update

Author: hj

batch_table.go

@@ -106,18 +106,19 @@ func (h *BatchTable) Read(reader io.ReadSeeker, header Header, batchLength int)
 	if header.GetBatchTableJSONByteLength() <= 0 {
 		return nil
 	}
-	jsonb := make([]byte, header.GetBatchTableJSONByteLength())
+	jsonLen := header.GetBatchTableJSONByteLength()
 
-	if _, err := reader.Read(jsonb); err != nil {
-		return err
-	}
-
-	if batchLength == 0 {
+	if jsonLen == 0 {
 		h.Data = make(map[string]interface{})
 		h.Header = make(map[string]interface{})
 		return nil
 	}
 
+	jsonb := make([]byte, jsonLen)
+	if _, err := reader.Read(jsonb); err != nil {
+		return err
+	}
+
 	jsonr := bytes.NewReader(jsonb)
 	if err := h.readJSONHeader(jsonr); err != nil {
 		return err

go.mod

@@ -2,4 +2,7 @@ module github.com/flywave/go-3dtile
 
 go 1.16
 
-require github.com/qmuntal/gltf v0.20.3
+require (
+	github.com/flywave/go3d v0.0.0-20211208020909-d2697502845a
+	github.com/qmuntal/gltf v0.20.3
+)

go.sum

@@ -1,3 +1,5 @@
+github.com/flywave/go3d v0.0.0-20211208020909-d2697502845a h1:H6CwqyMjCgfXULAIG2zhCdkOgkeqluBuafjEuemuVJY=
+github.com/flywave/go3d v0.0.0-20211208020909-d2697502845a/go.mod h1:0/K6WtaMwhhVJb84xWStt+ALQl2EdvzW2oJqz+330GU=
 github.com/go-test/deep v1.0.1 h1:UQhStjbkDClarlmv0am7OXXO4/GaPdCGiUiMTvi28sg=
 github.com/go-test/deep v1.0.1/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
 github.com/qmuntal/gltf v0.20.3 h1:9oW6IAgHROZjwBcEVgkBhH1SR/7TLlVfSn6VDr/2h3E=

oct_encoded_normal.go

@@ -0,0 +1,102 @@
+package tile3d
+
+import "math"
+
+func clamp(val float32, minVal float32, maxVal float32) float32 {
+	if val < minVal {
+		return minVal
+	}
+
+	if val > maxVal {
+		return maxVal
+	}
+
+	return val
+}
+
+func clampUint8(val float32) uint16 {
+	return roundUint16(0.5 + float64(clamp(val, -1, 1)*0.5+0.5)*255.0)
+}
+
+func roundUint16(val float64) uint16 {
+	return uint16(val)
+}
+
+func signNotZero(val float32) float32 {
+	if val < 0.0 {
+		return -1.0
+	}
+	return 1.0
+}
+
+type OctEncodedNormal struct {
+	value uint16
+}
+
+func NewOctEncodedNormal(v [3]float32) *OctEncodedNormal {
+	return &OctEncodedNormal{value: encodeXYZ(v[0], v[1], v[2])}
+}
+
+func (n *OctEncodedNormal) Decode() [3]float32 {
+	return decodeValue(n.value)
+}
+
+func encodeXYZ(nx float32, ny float32, nz float32) uint16 {
+	denom := float32(math.Abs(float64(nx)) + math.Abs(float64(ny)) + math.Abs(float64(nz)))
+	rx := nx / denom
+	ry := ny / denom
+	if nz < 0 {
+		x := rx
+		y := ry
+		rx = (1 - float32(math.Abs(float64(y)))) * signNotZero(x)
+		ry = (1 - float32(math.Abs(float64(x)))) * signNotZero(y)
+	}
+	return clampUint8(rx) | clampUint8(ry)<<8
+}
+
+func decodeValue(val uint16) [3]float32 {
+	ex := float32(val & 0xff)
+	ey := float32(val >> 8)
+	ex = ex/255.0*2.0 - 1.0
+	ey = ey/255.0*2.0 - 1.0
+	ez := 1 - float32(math.Abs(float64(ex))+math.Abs(float64(ey)))
+	var n [3]float32
+
+	n[0] = ex
+	n[1] = ey
+	n[2] = ez
+
+	if n[2] < 0 {
+		x := n[0]
+		y := n[1]
+
+		n[0] = (1 - float32(math.Abs(float64(y)))) * signNotZero(x)
+		n[1] = (1 - float32(math.Abs(float64(x)))) * signNotZero(y)
+	}
+
+	n = normalizeInPlace(n)
+
+	return n
+}
+
+const smallMetricDistance = 1.0e-6
+
+func inverseMetricDistance(a float64) *float64 {
+	if math.Abs(a) <= smallMetricDistance {
+		return nil
+	}
+	dist := 1.0 / a
+	return &dist
+}
+
+func normalizeInPlace(n [3]float32) [3]float32 {
+	magnitude := math.Sqrt(float64(n[0]*n[0] + n[1]*n[1] + n[2]*n[2]))
+	a := inverseMetricDistance(magnitude)
+	if a == nil {
+		return n
+	}
+	n[0] *= float32(*a)
+	n[1] *= float32(*a)
+	n[2] *= float32(*a)
+	return n
+}

quantization.go

@@ -0,0 +1,97 @@
+package tile3d
+
+import (
+	"math"
+
+	"github.com/flywave/go3d/vec3"
+)
+
+const rangeScale16 = 0xffff
+const rangeScale8 = 0xff
+
+func computeScale(extent float32, rangeScale uint16) float32 {
+	if 0.0 == extent {
+		return extent
+	}
+	return float32(rangeScale) / extent
+}
+
+func isInRange(qpos uint16, rangeScale uint16) bool {
+	return qpos >= 0 && qpos < rangeScale+1
+}
+
+func Quantize(pos float32, origin float32, scale float32, rangeScale uint16) uint16 {
+	return uint16(math.Floor(math.Max(0.0, math.Min(float64(rangeScale), float64(0.5+(pos-origin)*scale)))))
+}
+
+func IsQuantizable(pos float32, origin float32, scale float32, rangeScale uint16) bool {
+	return isInRange(Quantize(pos, origin, scale, rangeScale), rangeScale16)
+}
+
+func UnQuantize(qpos uint16, origin float32, scale float32) float32 {
+	if 0.0 == scale {
+		return origin
+	}
+	return origin + float32(qpos)/scale
+}
+
+func IsQuantized(qpos uint16) bool {
+	return isInRange(qpos, rangeScale16) && qpos == uint16(math.Floor(float64(qpos)))
+}
+
+type QParams3d struct {
+	Origin [3]float32
+	Scale  [3]float32
+}
+
+func (p *QParams3d) SetFromRange(range_ *vec3.Box, rangeScale uint16) {
+	p.Origin[0] = range_.Min[0]
+	p.Origin[1] = range_.Min[1]
+	p.Origin[2] = range_.Min[2]
+
+	p.Scale[0] = computeScale(range_.Max[0]-range_.Min[0], rangeScale)
+	p.Scale[1] = computeScale(range_.Max[1]-range_.Min[1], rangeScale)
+	p.Scale[2] = computeScale(range_.Max[2]-range_.Min[2], rangeScale)
+}
+
+func (p *QParams3d) rangeDiagonal() [3]float32 {
+	var x float32
+	var y float32
+	var z float32
+
+	if p.Scale[0] == 0 {
+		x = 0
+	} else {
+		x = rangeScale16 / p.Scale[0]
+	}
+
+	if p.Scale[1] == 0 {
+		y = 0
+	} else {
+		y = rangeScale16 / p.Scale[1]
+	}
+
+	if p.Scale[2] == 0 {
+		z = 0
+	} else {
+		z = rangeScale16 / p.Scale[2]
+	}
+
+	return [3]float32{x, y, z}
+}
+
+func QuantizePoint3d(pos [3]float32, params *QParams3d) [3]uint16 {
+	var out [3]uint16
+	out[0] = Quantize(pos[0], params.Origin[0], params.Scale[0], rangeScale16)
+	out[1] = Quantize(pos[1], params.Origin[1], params.Scale[1], rangeScale16)
+	out[2] = Quantize(pos[2], params.Origin[2], params.Scale[2], rangeScale16)
+	return out
+}
+
+func UnQuantizePoint3d(qpos [3]uint16, params *QParams3d) [3]float32 {
+	var out [3]float32
+	out[0] = UnQuantize(qpos[0], params.Origin[0], params.Scale[0])
+	out[1] = UnQuantize(qpos[1], params.Origin[1], params.Scale[1])
+	out[2] = UnQuantize(qpos[2], params.Origin[2], params.Scale[2])
+	return out
+}