X/Y/Z/W setters/getters

gglm/geometric.go

@@ -8,6 +8,10 @@ func DotVec3(v1, v2 *Vec3) float32 {
 	return v1.X()*v2.X() + v1.Y()*v2.Y() + v1.Z()*v2.Z()
 }
 
+func DotVec4(v1, v2 *Vec4) float32 {
+	return v1.X()*v2.X() + v1.Y()*v2.Y() + v1.Z()*v2.Z() + v1.W()*v2.W()
+}
+
 func Cross(v1, v2 *Vec3) *Vec3 {
 	return &Vec3{
 		Data: [3]float32{
@@ -17,3 +21,57 @@ func Cross(v1, v2 *Vec3) *Vec3 {
 		},
 	}
 }
+
+//DistVec2 returns euclidean distance between v1 and v2
+func DistVec2(v1, v2 *Vec2) float32 {
+
+	diff := Vec2{
+		Data: [2]float32{
+			v1.X() - v2.X(),
+			v1.Y() - v2.Y(),
+		},
+	}
+
+	return diff.Mag()
+}
+
+//DistVec3 returns euclidean distance between v1 and v2
+func DistVec3(v1, v2 *Vec3) float32 {
+
+	diff := Vec3{
+		Data: [3]float32{
+			v1.X() - v2.X(),
+			v1.Y() - v2.Y(),
+			v1.Z() - v2.Z(),
+		},
+	}
+
+	return diff.Mag()
+}
+
+//DistVec2 returns the squared euclidean distance between v1 and v2 (avoids a sqrt)
+func SqrDistVec2(v1, v2 *Vec2) float32 {
+
+	diff := Vec2{
+		Data: [2]float32{
+			v1.X() - v2.X(),
+			v1.Y() - v2.Y(),
+		},
+	}
+
+	return diff.SqrMag()
+}
+
+//DistVec3 returns the squared euclidean distance between v1 and v2 (avoids a sqrt)
+func SqrDistVec3(v1, v2 *Vec3) float32 {
+
+	diff := Vec3{
+		Data: [3]float32{
+			v1.X() - v2.X(),
+			v1.Y() - v2.Y(),
+			v1.Z() - v2.Z(),
+		},
+	}
+
+	return diff.SqrMag()
+}

gglm/mat.go

@@ -29,7 +29,7 @@ func (ms MatSize) String() string {
 }
 
 type Mat interface {
-	At(row, col int) float32
+	Get(row, col int) float32
 	Set(row, col int, val float32)
 	Size() MatSize
 }

gglm/mat2.go

@@ -11,7 +11,7 @@ type Mat2 struct {
 	Data [4]float32
 }
 
-func (m *Mat2) At(row, col int) float32 {
+func (m *Mat2) Get(row, col int) float32 {
 	return m.Data[row*2+col]
 }
 
@@ -44,6 +44,17 @@ func (m *Mat2) Sub(m2 *Mat2) {
 	m.Data[3] -= m2.Data[3]
 }
 
+//Mul m *= m2
+func (m *Mat2) Mul(m2 *Mat2) {
+	m.Data = [4]float32{
+		m.Data[0]*m2.Data[0] + m.Data[1]*m2.Data[2],
+		m.Data[0]*m2.Data[1] + m.Data[1]*m2.Data[3],
+
+		m.Data[2]*m2.Data[0] + m.Data[3]*m2.Data[2],
+		m.Data[2]*m2.Data[1] + m.Data[3]*m2.Data[3],
+	}
+}
+
 //Scale m *= x (element wise multiplication)
 func (m *Mat2) Scale(x float32) {
 	m.Data[0] *= x
@@ -52,6 +63,10 @@ func (m *Mat2) Scale(x float32) {
 	m.Data[3] *= x
 }
 
+func (m *Mat2) Eq(m2 *Mat2) bool {
+	return m.Data == m2.Data
+}
+
 //AddMat2 m3 = m1 + m2
 func AddMat2(m1, m2 *Mat2) *Mat2 {
 	return &Mat2{
@@ -76,6 +91,19 @@ func SubMat2(m1, m2 *Mat2) *Mat2 {
 	}
 }
 
+//MulMat2 m3 = m1 * m2
+func MulMat2(m1, m2 *Mat2) *Mat2 {
+	return &Mat2{
+		Data: [4]float32{
+			m1.Data[0]*m2.Data[0] + m1.Data[1]*m2.Data[2],
+			m1.Data[0]*m2.Data[1] + m1.Data[1]*m2.Data[3],
+
+			m1.Data[2]*m2.Data[0] + m1.Data[3]*m2.Data[2],
+			m1.Data[2]*m2.Data[1] + m1.Data[3]*m2.Data[3],
+		},
+	}
+}
+
 //NewMat2Id returns the 2x2 identity matrix
 func NewMat2Id() *Mat2 {
 	return &Mat2{

gglm/mat3.go

@@ -11,7 +11,7 @@ type Mat3 struct {
 	Data [9]float32
 }
 
-func (m *Mat3) At(row, col int) float32 {
+func (m *Mat3) Get(row, col int) float32 {
 	return m.Data[row*3+col]
 }
 
@@ -63,6 +63,29 @@ func (m *Mat3) Sub(m2 *Mat3) {
 	m.Data[8] -= m2.Data[8]
 }
 
+//Mul m *= m2
+func (m *Mat3) Mul(m2 *Mat3) {
+
+	//Indices:
+	// 0, 1, 2,
+	// 3, 4, 5,
+	// 6, 7, 8,
+
+	m.Data = [9]float32{
+		m.Data[0]*m2.Data[0] + m.Data[1]*m2.Data[3] + m.Data[2]*m2.Data[6],
+		m.Data[0]*m2.Data[1] + m.Data[1]*m2.Data[4] + m.Data[2]*m2.Data[7],
+		m.Data[0]*m2.Data[2] + m.Data[1]*m2.Data[5] + m.Data[2]*m2.Data[8],
+
+		m.Data[3]*m2.Data[0] + m.Data[4]*m2.Data[3] + m.Data[5]*m2.Data[6],
+		m.Data[3]*m2.Data[1] + m.Data[4]*m2.Data[4] + m.Data[5]*m2.Data[7],
+		m.Data[3]*m2.Data[2] + m.Data[4]*m2.Data[5] + m.Data[5]*m2.Data[8],
+
+		m.Data[6]*m2.Data[0] + m.Data[7]*m2.Data[3] + m.Data[8]*m2.Data[6],
+		m.Data[6]*m2.Data[1] + m.Data[7]*m2.Data[4] + m.Data[8]*m2.Data[7],
+		m.Data[6]*m2.Data[2] + m.Data[7]*m2.Data[5] + m.Data[8]*m2.Data[8],
+	}
+}
+
 //Scale m *= x (element wise multiplication)
 func (m *Mat3) Scale(x float32) {
 
@@ -79,6 +102,10 @@ func (m *Mat3) Scale(x float32) {
 	m.Data[8] *= x
 }
 
+func (m *Mat3) Eq(m2 *Mat3) bool {
+	return m.Data == m2.Data
+}
+
 //AddMat3 m3 = m1 + m2
 func AddMat3(m1, m2 *Mat3) *Mat3 {
 	return &Mat3{
@@ -117,6 +144,25 @@ func SubMat3(m1, m2 *Mat3) *Mat3 {
 	}
 }
 
+//MulMat3 m3 = m1 * m2
+func MulMat3(m1, m2 *Mat3) *Mat3 {
+	return &Mat3{
+		Data: [9]float32{
+			m1.Data[0]*m2.Data[0] + m1.Data[1]*m2.Data[3] + m1.Data[2]*m2.Data[6],
+			m1.Data[0]*m2.Data[1] + m1.Data[1]*m2.Data[4] + m1.Data[2]*m2.Data[7],
+			m1.Data[0]*m2.Data[2] + m1.Data[1]*m2.Data[5] + m1.Data[2]*m2.Data[8],
+
+			m1.Data[3]*m2.Data[0] + m1.Data[4]*m2.Data[3] + m1.Data[5]*m2.Data[6],
+			m1.Data[3]*m2.Data[1] + m1.Data[4]*m2.Data[4] + m1.Data[5]*m2.Data[7],
+			m1.Data[3]*m2.Data[2] + m1.Data[4]*m2.Data[5] + m1.Data[5]*m2.Data[8],
+
+			m1.Data[6]*m2.Data[0] + m1.Data[7]*m2.Data[3] + m1.Data[8]*m2.Data[6],
+			m1.Data[6]*m2.Data[1] + m1.Data[7]*m2.Data[4] + m1.Data[8]*m2.Data[7],
+			m1.Data[6]*m2.Data[2] + m1.Data[7]*m2.Data[5] + m1.Data[8]*m2.Data[8],
+		},
+	}
+}
+
 //NewMat3Id returns the 3x3 identity matrix
 func NewMat3Id() *Mat3 {
 	return &Mat3{

gglm/mat4.go

@@ -11,7 +11,7 @@ type Mat4 struct {
 	Data [16]float32
 }
 
-func (m *Mat4) At(row, col int) float32 {
+func (m *Mat4) Get(row, col int) float32 {
 	return m.Data[row*4+col]
 }
 
@@ -80,6 +80,45 @@ func (m *Mat4) Sub(m2 *Mat4) {
 	m.Data[15] -= m2.Data[15]
 }
 
+//Mul m *= m2
+func (m *Mat4) Mul(m2 *Mat4) {
+
+	//Indices:
+	// 00, 01, 02, 03,
+	// 04, 05, 06, 07,
+	// 08, 09, 10, 11,
+	// 12, 13, 14, 15,
+
+	//Seems to improve performance by ~5% (18ns/op -> 17ns/op).
+	//Works by improving cache usage by putting 0,4,8,12 together instead of faraway in the array?
+	a := m2.Data[0]
+	b := m2.Data[4]
+	c := m2.Data[8]
+	d := m2.Data[12]
+
+	m.Data = [16]float32{
+		m.Data[0]*a + m.Data[1]*b + m.Data[2]*c + m.Data[3]*d,
+		m.Data[0]*m2.Data[1] + m.Data[1]*m2.Data[5] + m.Data[2]*m2.Data[9] + m.Data[3]*m2.Data[13],
+		m.Data[0]*m2.Data[2] + m.Data[1]*m2.Data[6] + m.Data[2]*m2.Data[10] + m.Data[3]*m2.Data[14],
+		m.Data[0]*m2.Data[3] + m.Data[1]*m2.Data[7] + m.Data[2]*m2.Data[11] + m.Data[3]*m2.Data[15],
+
+		m.Data[4]*a + m.Data[5]*b + m.Data[6]*c + m.Data[7]*d,
+		m.Data[4]*m2.Data[1] + m.Data[5]*m2.Data[5] + m.Data[6]*m2.Data[9] + m.Data[7]*m2.Data[13],
+		m.Data[4]*m2.Data[2] + m.Data[5]*m2.Data[6] + m.Data[6]*m2.Data[10] + m.Data[7]*m2.Data[14],
+		m.Data[4]*m2.Data[3] + m.Data[5]*m2.Data[7] + m.Data[6]*m2.Data[11] + m.Data[7]*m2.Data[15],
+
+		m.Data[8]*a + m.Data[9]*b + m.Data[10]*c + m.Data[11]*d,
+		m.Data[8]*m2.Data[1] + m.Data[9]*m2.Data[5] + m.Data[10]*m2.Data[9] + m.Data[11]*m2.Data[13],
+		m.Data[8]*m2.Data[2] + m.Data[9]*m2.Data[6] + m.Data[10]*m2.Data[10] + m.Data[11]*m2.Data[14],
+		m.Data[8]*m2.Data[3] + m.Data[9]*m2.Data[7] + m.Data[10]*m2.Data[11] + m.Data[11]*m2.Data[15],
+
+		m.Data[12]*a + m.Data[13]*b + m.Data[14]*c + m.Data[15]*d,
+		m.Data[12]*m2.Data[1] + m.Data[13]*m2.Data[5] + m.Data[14]*m2.Data[9] + m.Data[15]*m2.Data[13],
+		m.Data[12]*m2.Data[2] + m.Data[13]*m2.Data[6] + m.Data[14]*m2.Data[10] + m.Data[15]*m2.Data[14],
+		m.Data[12]*m2.Data[3] + m.Data[13]*m2.Data[7] + m.Data[14]*m2.Data[11] + m.Data[15]*m2.Data[15],
+	}
+}
+
 //Scale m *= x (element wise multiplication)
 func (m *Mat4) Scale(x float32) {
 
@@ -104,6 +143,10 @@ func (m *Mat4) Scale(x float32) {
 	m.Data[15] *= x
 }
 
+func (m *Mat4) Eq(m2 *Mat4) bool {
+	return m.Data == m2.Data
+}
+
 //AddMat4 m3 = m1 + m2
 func AddMat4(m1, m2 *Mat4) *Mat4 {
 	return &Mat4{
@@ -158,6 +201,39 @@ func SubMat4(m1, m2 *Mat4) *Mat4 {
 	}
 }
 
+//MulMat4 m3 = m1 * m2
+func MulMat4(m1, m2 *Mat4) *Mat4 {
+
+	a := m2.Data[0]
+	b := m2.Data[4]
+	c := m2.Data[8]
+	d := m2.Data[12]
+
+	return &Mat4{
+		Data: [16]float32{
+			m1.Data[0]*a + m1.Data[1]*b + m1.Data[2]*c + m1.Data[3]*d,
+			m1.Data[0]*m2.Data[1] + m1.Data[1]*m2.Data[5] + m1.Data[2]*m2.Data[9] + m1.Data[3]*m2.Data[13],
+			m1.Data[0]*m2.Data[2] + m1.Data[1]*m2.Data[6] + m1.Data[2]*m2.Data[10] + m1.Data[3]*m2.Data[14],
+			m1.Data[0]*m2.Data[3] + m1.Data[1]*m2.Data[7] + m1.Data[2]*m2.Data[11] + m1.Data[3]*m2.Data[15],
+
+			m1.Data[4]*a + m1.Data[5]*b + m1.Data[6]*c + m1.Data[7]*d,
+			m1.Data[4]*m2.Data[1] + m1.Data[5]*m2.Data[5] + m1.Data[6]*m2.Data[9] + m1.Data[7]*m2.Data[13],
+			m1.Data[4]*m2.Data[2] + m1.Data[5]*m2.Data[6] + m1.Data[6]*m2.Data[10] + m1.Data[7]*m2.Data[14],
+			m1.Data[4]*m2.Data[3] + m1.Data[5]*m2.Data[7] + m1.Data[6]*m2.Data[11] + m1.Data[7]*m2.Data[15],
+
+			m1.Data[8]*a + m1.Data[9]*b + m1.Data[10]*c + m1.Data[11]*d,
+			m1.Data[8]*m2.Data[1] + m1.Data[9]*m2.Data[5] + m1.Data[10]*m2.Data[9] + m1.Data[11]*m2.Data[13],
+			m1.Data[8]*m2.Data[2] + m1.Data[9]*m2.Data[6] + m1.Data[10]*m2.Data[10] + m1.Data[11]*m2.Data[14],
+			m1.Data[8]*m2.Data[3] + m1.Data[9]*m2.Data[7] + m1.Data[10]*m2.Data[11] + m1.Data[11]*m2.Data[15],
+
+			m1.Data[12]*a + m1.Data[13]*b + m1.Data[14]*c + m1.Data[15]*d,
+			m1.Data[12]*m2.Data[1] + m1.Data[13]*m2.Data[5] + m1.Data[14]*m2.Data[9] + m1.Data[15]*m2.Data[13],
+			m1.Data[12]*m2.Data[2] + m1.Data[13]*m2.Data[6] + m1.Data[14]*m2.Data[10] + m1.Data[15]*m2.Data[14],
+			m1.Data[12]*m2.Data[3] + m1.Data[13]*m2.Data[7] + m1.Data[14]*m2.Data[11] + m1.Data[15]*m2.Data[15],
+		},
+	}
+}
+
 //NewMat4Id returns the 4x4 identity matrix
 func NewMat4Id() *Mat4 {
 	return &Mat4{

gglm/swizzle.go

@@ -3,12 +3,18 @@ package gglm
 type Swizzle1 interface {
 	X() float32
 	R() float32
+
+	SetX(float32)
+	SetR(float32)
 }
 
 type Swizzle2 interface {
 	Swizzle1
 	Y() float32
 	G() float32
+
+	SetY(float32)
+	SetG(float32)
 }
 
 type Swizzle3 interface {
@@ -16,10 +22,15 @@ type Swizzle3 interface {
 	Z() float32
 	B() float32
 
-	// XYZ
-	// YXZ
-	// XZY
-	// YZX
-	// ZXY
-	// ZYX
+	SetZ(float32)
+	SetB(float32)
+}
+
+type Swizzle4 interface {
+	Swizzle3
+	W() float32
+	A() float32
+
+	SetW(float32)
+	SetA(float32)
 }

gglm/vec2.go

@@ -30,6 +30,22 @@ func (v *Vec2) G() float32 {
 	return v.Data[1]
 }
 
+func (v *Vec2) SetX(f float32) {
+	v.Data[0] = f
+}
+
+func (v *Vec2) SetR(f float32) {
+	v.Data[0] = f
+}
+
+func (v *Vec2) SetY(f float32) {
+	v.Data[1] = f
+}
+
+func (v *Vec2) SetG(f float32) {
+	v.Data[1] = f
+}
+
 func (v *Vec2) String() string {
 	return fmt.Sprintf("(%f, %f)", v.X(), v.Y())
 }
@@ -62,6 +78,15 @@ func (v *Vec2) SqrMag() float32 {
 	return v.X()*v.X() + v.Y()*v.Y()
 }
 
+func (v *Vec2) Eq(v2 *Vec2) bool {
+	return v.Data == v2.Data
+}
+
+func (v *Vec2) Set(x, y float32) {
+	v.Data[0] = x
+	v.Data[1] = y
+}
+
 //AddVec2 v3 = v1 + v2
 func AddVec2(v1, v2 *Vec2) *Vec2 {
 	return &Vec2{

gglm/vec3.go

@@ -36,6 +36,30 @@ func (v *Vec3) B() float32 {
 	return v.Data[2]
 }
 
+func (v *Vec3) SetX(f float32) {
+	v.Data[0] = f
+}
+
+func (v *Vec3) SetR(f float32) {
+	v.Data[0] = f
+}
+
+func (v *Vec3) SetY(f float32) {
+	v.Data[1] = f
+}
+
+func (v *Vec3) SetG(f float32) {
+	v.Data[1] = f
+}
+
+func (v *Vec3) SetZ(f float32) {
+	v.Data[2] = f
+}
+
+func (v *Vec3) SetB(f float32) {
+	v.Data[2] = f
+}
+
 func (v *Vec3) String() string {
 	return fmt.Sprintf("(%f, %f, %f)", v.X(), v.Y(), v.Z())
 }
@@ -71,6 +95,16 @@ func (v *Vec3) SqrMag() float32 {
 	return v.X()*v.X() + v.Y()*v.Y() + v.Z()*v.Z()
 }
 
+func (v *Vec3) Eq(v2 *Vec3) bool {
+	return v.Data == v2.Data
+}
+
+func (v *Vec3) Set(x, y, z float32) {
+	v.Data[0] = x
+	v.Data[1] = y
+	v.Data[2] = z
+}
+
 //AddVec3 v3 = v1 + v2
 func AddVec3(v1, v2 *Vec3) *Vec3 {
 	return &Vec3{

gglm/vec4.go

@@ -0,0 +1,150 @@
+package gglm
+
+import (
+	"fmt"
+	"math"
+)
+
+var _ Swizzle4 = &Vec4{}
+var _ fmt.Stringer = &Vec4{}
+
+type Vec4 struct {
+	Data [4]float32
+}
+
+func (v *Vec4) X() float32 {
+	return v.Data[0]
+}
+
+func (v *Vec4) Y() float32 {
+	return v.Data[1]
+}
+
+func (v *Vec4) Z() float32 {
+	return v.Data[2]
+}
+
+func (v *Vec4) W() float32 {
+	return v.Data[3]
+}
+
+func (v *Vec4) R() float32 {
+	return v.Data[0]
+}
+
+func (v *Vec4) G() float32 {
+	return v.Data[1]
+}
+
+func (v *Vec4) B() float32 {
+	return v.Data[2]
+}
+
+func (v *Vec4) A() float32 {
+	return v.Data[3]
+}
+
+func (v *Vec4) SetX(f float32) {
+	v.Data[0] = f
+}
+
+func (v *Vec4) SetR(f float32) {
+	v.Data[0] = f
+}
+
+func (v *Vec4) SetY(f float32) {
+	v.Data[1] = f
+}
+
+func (v *Vec4) SetG(f float32) {
+	v.Data[1] = f
+}
+
+func (v *Vec4) SetZ(f float32) {
+	v.Data[2] = f
+}
+
+func (v *Vec4) SetB(f float32) {
+	v.Data[2] = f
+}
+
+func (v *Vec4) SetW(f float32) {
+	v.Data[3] = f
+}
+
+func (v *Vec4) SetA(f float32) {
+	v.Data[3] = f
+}
+
+func (v *Vec4) String() string {
+	return fmt.Sprintf("(%f, %f, %f, %f)", v.X(), v.Y(), v.Z(), v.W())
+}
+
+//Scale v *= x (element wise multiplication)
+func (v *Vec4) Scale(x float32) {
+	v.Data[0] *= x
+	v.Data[1] *= x
+	v.Data[2] *= x
+	v.Data[3] *= x
+}
+
+func (v *Vec4) Add(v2 *Vec4) {
+
+	v.Data[0] += v2.X()
+	v.Data[1] += v2.Y()
+	v.Data[2] += v2.Z()
+	v.Data[3] += v2.W()
+}
+
+//SubVec4 v -= v2
+func (v *Vec4) Sub(v2 *Vec4) {
+	v.Data[0] -= v2.X()
+	v.Data[1] -= v2.Y()
+	v.Data[2] -= v2.Z()
+	v.Data[3] -= v2.W()
+}
+
+//Mag returns the magnitude of the vector
+func (v *Vec4) Mag() float32 {
+	return float32(math.Sqrt(float64(v.X()*v.X() + v.Y()*v.Y() + v.Z()*v.Z() + v.W()*v.W())))
+}
+
+//Mag returns the squared magnitude of the vector
+func (v *Vec4) SqrMag() float32 {
+	return v.X()*v.X() + v.Y()*v.Y() + v.Z()*v.Z() + v.Z()*v.Z()
+}
+
+func (v *Vec4) Eq(v2 *Vec4) bool {
+	return v.Data == v2.Data
+}
+
+func (v *Vec4) Set(x, y, z, w float32) {
+	v.Data[0] = x
+	v.Data[1] = y
+	v.Data[2] = z
+	v.Data[3] = w
+}
+
+//AddVec4 v3 = v1 + v2
+func AddVec4(v1, v2 *Vec4) *Vec4 {
+	return &Vec4{
+		Data: [4]float32{
+			v1.X() + v2.X(),
+			v1.Y() + v2.Y(),
+			v1.Z() + v2.Z(),
+			v1.W() + v2.W(),
+		},
+	}
+}
+
+//SubVec4 v3 = v1 - v2
+func SubVec4(v1, v2 *Vec4) *Vec4 {
+	return &Vec4{
+		Data: [4]float32{
+			v1.X() - v2.X(),
+			v1.Y() - v2.Y(),
+			v1.Z() - v2.Z(),
+			v1.W() - v2.W(),
+		},
+	}
+}

main.go

@@ -1,29 +1,62 @@
 package main
 
-import (
-	"github.com/bloeys/gglm/gglm"
-)
+import "github.com/bloeys/gglm/gglm"
 
 func main() {
 
-	// v1 := gglm.NewVec2([]float32{4, 5})
-	// v2 := gglm.NewVec2([]float32{1, 1})
-	// println(v1.Mag())
-	// println(v1.SqrMag())
-	// v1 := gglm.NewVec2(nil)
-	// v2 := gglm.NewVec2(nil)
-	// v1.Add(v2)
-
-	m1 := &gglm.Mat4{}
-	m2 := &gglm.Mat4{
-		Data: [16]float32{
-			-10, 0, 100, 0,
-			0, 0, 0, 0,
-			0, 0, 0, 0,
-			0, 0, 0, 0,
+	//Mat3
+	m1 := &gglm.Mat3{
+		Data: [9]float32{
+			1, 2, 3,
+			4, 5, 6,
+			7, 8, 9,
 		},
 	}
 
-	m3 := gglm.AddMat4(m1, m2)
-	m2.Add(m3)
+	m2 := &gglm.Mat3{
+		Data: [9]float32{
+			1, 2, 3,
+			1, 2, 3,
+			1, 2, 3,
+		},
+	}
+
+	m3 := gglm.MulMat3(m1, m2)
+	m1.Mul(m2)
+	println(m1.String())
+	println(m3.String())
+
+	//Mat4
+	m4 := &gglm.Mat4{
+		Data: [16]float32{
+			1, 2, 3, 4,
+			5, 6, 7, 8,
+			9, 10, 11, 12,
+			13, 14, 15, 16,
+		},
+	}
+
+	m5 := &gglm.Mat4{
+		Data: [16]float32{
+			1, 2, 3, 4,
+			1, 2, 3, 4,
+			1, 2, 3, 4,
+			1, 2, 3, 4,
+		},
+	}
+
+	m6 := gglm.MulMat4(m4, m5)
+	m4.Mul(m5)
+	println(m4.String())
+	println(m6.String())
+	println(m4.Eq(m6))
+
+	v1 := &gglm.Vec2{Data: [2]float32{1, 2}}
+	v2 := &gglm.Vec2{Data: [2]float32{3, 4}}
+	println(gglm.DistVec2(v1, v2))
+	println(gglm.SqrDistVec2(v2, v1))
+
+	println(v1.Eq(v2))
+	v2.Set(1, 2)
+	println(v1.Eq(v2))
 }

main_test.go

@@ -6,22 +6,68 @@ import (
 	"github.com/bloeys/gglm/gglm"
 )
 
-func BenchmarkVec3Add(b *testing.B) {
+var (
+	dotVec2Result float32 = 0
+	dotVec3Result float32 = 0
+	crossResult   *gglm.Vec3
+)
 
-	v1 := gglm.NewMat4Id()
-	v2 := gglm.NewMat4Id()
+func BenchmarkDotVec2(b *testing.B) {
+
+	v1 := &gglm.Vec2{}
+	v2 := &gglm.Vec2{}
 
 	for i := 0; i < b.N; i++ {
-		gglm.AddMat4(v1, v2)
+		dotVec2Result = gglm.DotVec2(v1, v2)
 	}
 }
 
-func BenchmarkVec3Add2(b *testing.B) {
+func BenchmarkDotVec3(b *testing.B) {
 
-	v1 := gglm.NewMat4Id()
-	v2 := gglm.NewMat4Id()
+	v1 := &gglm.Vec3{}
+	v2 := &gglm.Vec3{}
 
 	for i := 0; i < b.N; i++ {
-		v1.Add(v2)
+		dotVec3Result = gglm.DotVec3(v1, v2)
+	}
+}
+
+func BenchmarkCross(b *testing.B) {
+
+	v1 := &gglm.Vec3{}
+	v2 := &gglm.Vec3{}
+
+	for i := 0; i < b.N; i++ {
+		crossResult = gglm.Cross(v1, v2)
+	}
+}
+
+func BenchmarkMulMat2(b *testing.B) {
+
+	m1 := gglm.NewMat2Id()
+	m2 := gglm.NewMat2Id()
+
+	for i := 0; i < b.N; i++ {
+		m1.Mul(m2)
+	}
+}
+
+func BenchmarkMulMat3(b *testing.B) {
+
+	m1 := gglm.NewMat3Id()
+	m2 := gglm.NewMat3Id()
+
+	for i := 0; i < b.N; i++ {
+		m1.Mul(m2)
+	}
+}
+
+func BenchmarkMulMat4(b *testing.B) {
+
+	m1 := gglm.NewMat4Id()
+	m2 := gglm.NewMat4Id()
+
+	for i := 0; i < b.N; i++ {
+		m1.Mul(m2)
 	}
 }