cs2: use Vec3 instead of []float32 for vecs of length=3

pkg/demoinfocs/sendtables/propdecoder.go

@@ -100,14 +100,18 @@ type PropertyValue struct {
 	S2        bool
 }
 
+type Vec3 struct {
+	X, Y, Z float32
+}
+
 func (v PropertyValue) R3Vec() r3.Vector {
 	if v.S2 {
-		fs := v.Any.([]float32)
+		fs := v.Any.(Vec3)
 
 		return r3.Vector{
-			X: float64(fs[0]),
-			Y: float64(fs[1]),
-			Z: float64(fs[2]),
+			X: float64(fs.X),
+			Y: float64(fs.Y),
+			Z: float64(fs.Z),
 		}
 	}
 
@@ -120,12 +124,12 @@ func (v PropertyValue) R3VecOrNil() *r3.Vector {
 			return nil
 		}
 
-		fs := v.Any.([]float32)
+		fs := v.Any.(Vec3)
 
 		return &r3.Vector{
-			X: float64(fs[0]),
-			Y: float64(fs[1]),
-			Z: float64(fs[2]),
+			X: float64(fs.X),
+			Y: float64(fs.Y),
+			Z: float64(fs.Z),
 		}
 	}
 

pkg/demoinfocs/sendtables2/field_decoder.go

@@ -2,6 +2,8 @@ package sendtables2
 
 import (
 	"math"
+
+	"github.com/markus-wa/demoinfocs-golang/v4/pkg/demoinfocs/sendtables"
 )
 
 type fieldDecoder func(*reader) interface{}
@@ -260,6 +262,7 @@ func quantizedFactory(f *field) fieldDecoder {
 	}
 
 	qfd := newQuantizedFloatDecoder(f.bitCount, f.encodeFlags, f.lowValue, f.highValue)
+
 	return func(r *reader) interface{} {
 		return qfd.decode(r)
 	}
@@ -272,11 +275,24 @@ func vectorFactory(n int) fieldFactory {
 		}
 
 		d := floatFactory(f)
+
+		if n == 3 {
+			return func(r *reader) interface{} {
+				return sendtables.Vec3{
+					X: d(r).(float32),
+					Y: d(r).(float32),
+					Z: d(r).(float32),
+				}
+			}
+		}
+
 		return func(r *reader) interface{} {
 			x := make([]float32, n)
+
 			for i := 0; i < n; i++ {
 				x[i] = d(r).(float32)
 			}
+
 			return x
 		}
 	}
@@ -335,21 +351,22 @@ func readBitCoordPres(r *reader) float32 {
 }
 
 func qanglePreciseDecoder(r *reader) interface{} {
-	v := make([]float32, 3)
+	var v sendtables.Vec3
+
 	hasX := r.readBoolean()
 	hasY := r.readBoolean()
 	hasZ := r.readBoolean()
 
 	if hasX {
-		v[0] = readBitCoordPres(r)
+		v.X = readBitCoordPres(r)
 	}
 
 	if hasY {
-		v[1] = readBitCoordPres(r)
+		v.Y = readBitCoordPres(r)
 	}
 
 	if hasZ {
-		v[2] = readBitCoordPres(r)
+		v.Z = readBitCoordPres(r)
 	}
 
 	return v
@@ -362,29 +379,35 @@ func qangleFactory(f *field) fieldDecoder {
 
 	if f.bitCount != nil && *f.bitCount != 0 {
 		n := uint32(*f.bitCount)
+
 		return func(r *reader) interface{} {
-			return []float32{
-				r.readAngle(n),
-				r.readAngle(n),
-				r.readAngle(n),
+			return sendtables.Vec3{
+				X: r.readAngle(n),
+				Y: r.readAngle(n),
+				Z: r.readAngle(n),
 			}
 		}
 	}
 
 	return func(r *reader) interface{} {
-		ret := make([]float32, 3)
+		var ret sendtables.Vec3
+
 		rX := r.readBoolean()
 		rY := r.readBoolean()
 		rZ := r.readBoolean()
+
 		if rX {
-			ret[0] = r.readCoord()
+			ret.X = r.readCoord()
 		}
+
 		if rY {
-			ret[1] = r.readCoord()
+			ret.Y = r.readCoord()
 		}
+
 		if rZ {
-			ret[2] = r.readCoord()
+			ret.Z = r.readCoord()
 		}
+
 		return ret
 	}
 }

pkg/demoinfocs/sendtables2/field_path.go

@@ -271,13 +271,16 @@ func (fp *fieldPath) String() string {
 	for i := 0; i <= fp.last; i++ {
 		ss[i] = strconv.Itoa(fp.path[i])
 	}
+
 	return strings.Join(ss, "/")
 }
 
 // newFieldPath returns a new fieldPath ready for use
 func newFieldPath() *fieldPath {
 	fp := fpPool.Get().(*fieldPath)
+
 	fp.reset()
+
 	return fp
 }
 

pkg/demoinfocs/sendtables2/reader.go

@@ -4,6 +4,8 @@ import (
 	"encoding/binary"
 	"fmt"
 	"math"
+
+	"github.com/markus-wa/demoinfocs-golang/v4/pkg/demoinfocs/sendtables"
 )
 
 // reader performs read operations against a buffer
@@ -269,31 +271,31 @@ func (r *reader) readNormal() float32 {
 }
 
 // read3BitNormal reads a normalized float vector
-func (r *reader) read3BitNormal() []float32 {
-	ret := []float32{0.0, 0.0, 0.0}
+func (r *reader) read3BitNormal() sendtables.Vec3 {
+	var ret sendtables.Vec3
 
 	hasX := r.readBoolean()
 	haxY := r.readBoolean()
 
 	if hasX {
-		ret[0] = r.readNormal()
+		ret.X = r.readNormal()
 	}
 
 	if haxY {
-		ret[1] = r.readNormal()
+		ret.Y = r.readNormal()
 	}
 
 	negZ := r.readBoolean()
-	prodsum := ret[0]*ret[0] + ret[1]*ret[1]
+	prodsum := ret.X*ret.X + ret.Y*ret.Y
 
 	if prodsum < 1.0 {
-		ret[2] = float32(math.Sqrt(float64(1.0 - prodsum)))
+		ret.Z = float32(math.Sqrt(float64(1.0 - prodsum)))
 	} else {
-		ret[2] = 0.0
+		ret.Z = 0.0
 	}
 
 	if negZ {
-		ret[2] = -ret[2]
+		ret.Z = -ret.Z
 	}
 
 	return ret