Quat axis and angle tests

README.md

@@ -1,6 +1,6 @@
 # gglm
 
-An OpenGL focused Go mathematics inspired by the C++ glm (OpenGL Mathematics) library
+Fast Go OpenGL Mathematics library inspired by the c++ library [glm](https://github.com/g-truc/glm).
 
 ## Notes
 

gglm/constants.go

@@ -0,0 +1,10 @@
+package gglm
+
+const (
+	Pi      float32 = 3.14159265359
+	Deg2Rad float32 = Pi / 180
+	Rad2Deg float32 = 180 / Pi
+
+	//CosHalf is Cos32(0.5)
+	CosHalf float32 = 0.87758256189
+)

gglm/geometric.go

@@ -14,6 +14,10 @@ func DotVec4(v1, v2 *Vec4) float32 {
 	return v1.X()*v2.X() + v1.Y()*v2.Y() + v1.Z()*v2.Z() + v1.W()*v2.W()
 }
 
+func DotQuat(q1, q2 *Quat) float32 {
+	return q1.X()*q2.X() + q1.Y()*q2.Y() + q1.Z()*q2.Z() + q1.W()*q2.W()
+}
+
 func Cross(v1, v2 *Vec3) *Vec3 {
 	return &Vec3{
 		Data: [3]float32{
@@ -73,3 +77,41 @@ func SqrDistVec4(v1, v2 *Vec4) float32 {
 	w := v1.Data[3] - v2.Data[3]
 	return x*x + y*y + z*z + w*w
 }
+
+//ReflectVec2 returns the reflected vector of the incoming vector 'v', and the surface normal 'n'.
+//
+//Note: n must be normalized or you will get wrong results
+func ReflectVec2(v, n *Vec2) *Vec2 {
+
+	//reflectedVec = v − 2*dot(v, norm)*norm
+	d := 2 * (v.Data[0]*n.Data[0] + v.Data[1]*n.Data[1])
+
+	return &Vec2{
+		Data: [2]float32{
+			v.Data[0] - d*n.Data[0],
+			v.Data[1] - d*n.Data[1],
+		},
+	}
+}
+
+//ReflectVec3 returns the reflected vector of the incoming vector 'v', and the surface normal 'n'.
+//
+//Note: n must be normalized or you will get wrong results
+func ReflectVec3(v, n *Vec3) *Vec3 {
+
+	//reflectedVec = v − 2*dot(v, norm)*norm
+	d := 2 * (v.Data[0]*n.Data[0] + v.Data[1]*n.Data[1] + v.Data[2]*n.Data[2])
+
+	return &Vec3{
+		Data: [3]float32{
+			v.Data[0] - d*n.Data[0],
+			v.Data[1] - d*n.Data[1],
+			v.Data[2] - d*n.Data[2],
+		},
+	}
+}
+
+//AngleQuat returns the angle between the two quaternions in radians
+func AngleQuat(q1, q2 *Quat) float32 {
+	return Acos32(DotQuat(q1, q2))
+}

gglm/geometric_test.go

@@ -0,0 +1,216 @@
+package gglm_test
+
+import (
+	"testing"
+
+	"github.com/bloeys/gglm/gglm"
+)
+
+var (
+	dotVec2Result, distVec2Result  float32
+	dotVec3Result, distVec3Result  float32
+	reflectVec2Result              *gglm.Vec2
+	crossResult, reflectVec3Result *gglm.Vec3
+)
+
+func TestDotVec2(t *testing.T) {
+
+	v1 := gglm.Vec2{Data: [2]float32{1, 2}}
+	v2 := gglm.Vec2{Data: [2]float32{3, 4}}
+	ans := float32(11)
+
+	res := gglm.DotVec2(&v1, &v2)
+	if res != ans {
+		t.Errorf("Got: %v; Expected: %v", res, ans)
+	}
+}
+
+func TestDotVec3(t *testing.T) {
+
+	v1 := gglm.Vec3{Data: [3]float32{1, 2, 3}}
+	v2 := gglm.Vec3{Data: [3]float32{4, 5, 6}}
+	ans := float32(32)
+
+	res := gglm.DotVec3(&v1, &v2)
+	if res != ans {
+		t.Errorf("Got: %v; Expected: %v", res, ans)
+	}
+}
+
+func TestDotVec4(t *testing.T) {
+
+	v1 := gglm.Vec4{Data: [4]float32{1, 2, 3, 4}}
+	v2 := gglm.Vec4{Data: [4]float32{5, 6, 7, 8}}
+	ans := float32(70)
+
+	res := gglm.DotVec4(&v1, &v2)
+	if res != ans {
+		t.Errorf("Got: %v; Expected: %v", res, ans)
+	}
+}
+
+func TestDistVec2(t *testing.T) {
+
+	v1 := gglm.Vec2{Data: [2]float32{1, 2}}
+	v2 := gglm.Vec2{Data: [2]float32{3, 4}}
+	ans := float32(2.828427)
+
+	res := gglm.DistVec2(&v1, &v2)
+	if res != ans {
+		t.Errorf("Got: %v; Expected: %v", res, ans)
+	}
+}
+
+func TestDistVec3(t *testing.T) {
+
+	v1 := gglm.Vec3{Data: [3]float32{1, 2, 3}}
+	v2 := gglm.Vec3{Data: [3]float32{4, 5, 6}}
+	ans := float32(5.196152)
+
+	res := gglm.DistVec3(&v1, &v2)
+	if res != ans {
+		t.Errorf("Got: %v; Expected: %v", res, ans)
+	}
+}
+
+func TestDistVec4(t *testing.T) {
+
+	v1 := gglm.Vec4{Data: [4]float32{1, 2, 3, 4}}
+	v2 := gglm.Vec4{Data: [4]float32{5, 6, 7, 8}}
+	ans := float32(8)
+
+	res := gglm.DistVec4(&v1, &v2)
+	if res != ans {
+		t.Errorf("Got: %v; Expected: %v", res, ans)
+	}
+}
+
+func TestSqrDistVec2(t *testing.T) {
+
+	v1 := gglm.Vec2{Data: [2]float32{1, 2}}
+	v2 := gglm.Vec2{Data: [2]float32{3, 4}}
+	ans := float32(8)
+
+	res := gglm.SqrDistVec2(&v1, &v2)
+	if res != ans {
+		t.Errorf("Got: %v; Expected: %v", res, ans)
+	}
+}
+
+func TestSqrDistVec3(t *testing.T) {
+
+	v1 := gglm.Vec3{Data: [3]float32{1, 2, 3}}
+	v2 := gglm.Vec3{Data: [3]float32{4, 5, 6}}
+	ans := float32(27)
+
+	res := gglm.SqrDistVec3(&v1, &v2)
+	if res != ans {
+		t.Errorf("Got: %v; Expected: %v", res, ans)
+	}
+}
+
+func TestSqrDistVec4(t *testing.T) {
+
+	v1 := gglm.Vec4{Data: [4]float32{1, 2, 3, 4}}
+	v2 := gglm.Vec4{Data: [4]float32{5, 6, 7, 8}}
+	ans := float32(64)
+
+	res := gglm.SqrDistVec4(&v1, &v2)
+	if res != ans {
+		t.Errorf("Got: %v; Expected: %v", res, ans)
+	}
+}
+
+func TestReflectVec2(t *testing.T) {
+
+	v1 := gglm.Vec2{Data: [2]float32{1, 2}}
+	n := gglm.Vec2{Data: [2]float32{0, 1}}
+	ans := gglm.Vec2{Data: [2]float32{1, -2}}
+
+	res := gglm.ReflectVec2(&v1, &n)
+	if !res.Eq(&ans) {
+		t.Errorf("Got: %v; Expected: %v", res, ans)
+	}
+}
+
+func TestReflectVec3(t *testing.T) {
+
+	v1 := gglm.Vec3{Data: [3]float32{1, 2, 3}}
+	n := gglm.Vec3{Data: [3]float32{0, 1, 0}}
+	ans := gglm.Vec3{Data: [3]float32{1, -2, 3}}
+
+	res := gglm.ReflectVec3(&v1, &n)
+	if !res.Eq(&ans) {
+		t.Errorf("Got: %v; Expected: %v", res, ans)
+	}
+}
+
+func BenchmarkDotVec2(b *testing.B) {
+
+	v1 := &gglm.Vec2{}
+	v2 := &gglm.Vec2{}
+
+	for i := 0; i < b.N; i++ {
+		dotVec2Result = gglm.DotVec2(v1, v2)
+	}
+}
+
+func BenchmarkDotVec3(b *testing.B) {
+
+	v1 := &gglm.Vec3{}
+	v2 := &gglm.Vec3{}
+
+	for i := 0; i < b.N; i++ {
+		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 BenchmarkDistVec2(b *testing.B) {
+
+	v1 := &gglm.Vec2{}
+	v2 := &gglm.Vec2{}
+
+	for i := 0; i < b.N; i++ {
+		distVec2Result = gglm.DistVec2(v1, v2)
+	}
+}
+
+func BenchmarkDistVec3(b *testing.B) {
+
+	v1 := &gglm.Vec3{}
+	v2 := &gglm.Vec3{}
+
+	for i := 0; i < b.N; i++ {
+		distVec3Result = gglm.DistVec3(v1, v2)
+	}
+}
+
+func BenchmarkReflectVec2(b *testing.B) {
+
+	v1 := &gglm.Vec2{}
+	v2 := &gglm.Vec2{}
+
+	for i := 0; i < b.N; i++ {
+		reflectVec2Result = gglm.ReflectVec2(v1, v2)
+	}
+}
+
+func BenchmarkReflectVec3(b *testing.B) {
+
+	v1 := &gglm.Vec3{}
+	v2 := &gglm.Vec3{}
+
+	for i := 0; i < b.N; i++ {
+		reflectVec3Result = gglm.ReflectVec3(v1, v2)
+	}
+}

gglm/mat2.go

@@ -8,15 +8,15 @@ var _ Mat = &Mat2{}
 var _ fmt.Stringer = &Mat2{}
 
 type Mat2 struct {
-	Data [4]float32
+	Data [2][2]float32
 }
 
 func (m *Mat2) Get(row, col int) float32 {
-	return m.Data[row*2+col]
+	return m.Data[col][row]
 }
 
 func (m *Mat2) Set(row, col int, val float32) {
-	m.Data[row*2+col] = val
+	m.Data[col][row] = val
 }
 
 func (m *Mat2) Size() MatSize {
@@ -25,42 +25,58 @@ func (m *Mat2) Size() MatSize {
 
 func (m *Mat2) String() string {
 	//+ always shows +/- sign; - means pad to the right; 9 means total of 9 digits (or padding if less); .3 means 3 decimals
-	return fmt.Sprintf("\n| %+-9.3f %+-9.3f |\n| %+-9.3f %+-9.3f |\n", m.Data[0], m.Data[1], m.Data[2], m.Data[3])
+	return fmt.Sprintf("\n| %+-9.3f %+-9.3f |\n| %+-9.3f %+-9.3f |\n", m.Data[0][0], m.Data[0][1], m.Data[1][0], m.Data[1][1])
+}
+
+func (m *Mat2) Col(c int) *Vec2 {
+	return &Vec2{Data: m.Data[c]}
 }
 
 //Add m += m2
-func (m *Mat2) Add(m2 *Mat2) {
-	m.Data[0] += m2.Data[0]
-	m.Data[1] += m2.Data[1]
-	m.Data[2] += m2.Data[2]
-	m.Data[3] += m2.Data[3]
+func (m *Mat2) Add(m2 *Mat2) *Mat2 {
+	m.Data[0][0] += m2.Data[0][0]
+	m.Data[0][1] += m2.Data[0][1]
+	m.Data[1][0] += m2.Data[1][0]
+	m.Data[1][1] += m2.Data[1][1]
+	return m
 }
 
 //Add m -= m2
-func (m *Mat2) Sub(m2 *Mat2) {
-	m.Data[0] -= m2.Data[0]
-	m.Data[1] -= m2.Data[1]
-	m.Data[2] -= m2.Data[2]
-	m.Data[3] -= m2.Data[3]
+func (m *Mat2) Sub(m2 *Mat2) *Mat2 {
+	m.Data[0][0] -= m2.Data[0][0]
+	m.Data[0][1] -= m2.Data[0][1]
+	m.Data[1][0] -= m2.Data[1][0]
+	m.Data[1][1] -= m2.Data[1][1]
+	return m
 }
 
 //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],
+func (m1 *Mat2) Mul(m2 *Mat2) *Mat2 {
+	m1.Data = [2][2]float32{
+		{
+			m1.Data[0][0]*m2.Data[0][0] + m1.Data[1][0]*m2.Data[0][1],
+			m1.Data[0][1]*m2.Data[0][0] + m1.Data[1][1]*m2.Data[0][1],
+		},
+		{
+			m1.Data[0][0]*m2.Data[1][0] + m1.Data[1][0]*m2.Data[1][1],
+			m1.Data[0][1]*m2.Data[1][0] + m1.Data[1][1]*m2.Data[1][1],
+		},
 	}
+
+	return m1
 }
 
 //Scale m *= x (element wise multiplication)
-func (m *Mat2) Scale(x float32) {
-	m.Data[0] *= x
-	m.Data[1] *= x
-	m.Data[2] *= x
-	m.Data[3] *= x
+func (m *Mat2) Scale(x float32) *Mat2 {
+	m.Data[0][0] *= x
+	m.Data[0][1] *= x
+	m.Data[1][0] *= x
+	m.Data[1][1] *= x
+	return m
+}
+
+func (v *Mat2) Clone() *Mat2 {
+	return &Mat2{Data: v.Data}
 }
 
 func (m *Mat2) Eq(m2 *Mat2) bool {
@@ -70,11 +86,15 @@ func (m *Mat2) Eq(m2 *Mat2) bool {
 //AddMat2 m3 = m1 + m2
 func AddMat2(m1, m2 *Mat2) *Mat2 {
 	return &Mat2{
-		Data: [4]float32{
-			m1.Data[0] + m2.Data[0],
-			m1.Data[1] + m2.Data[1],
-			m1.Data[2] + m2.Data[2],
-			m1.Data[3] + m2.Data[3],
+		Data: [2][2]float32{
+			{
+				m1.Data[0][0] + m2.Data[0][0],
+				m1.Data[0][1] + m2.Data[0][1],
+			},
+			{
+				m1.Data[1][0] + m2.Data[1][0],
+				m1.Data[1][1] + m2.Data[1][1],
+			},
 		},
 	}
 }
@@ -82,11 +102,15 @@ func AddMat2(m1, m2 *Mat2) *Mat2 {
 //SubMat2 m3 = m1 - m2
 func SubMat2(m1, m2 *Mat2) *Mat2 {
 	return &Mat2{
-		Data: [4]float32{
-			m1.Data[0] - m2.Data[0],
-			m1.Data[1] - m2.Data[1],
-			m1.Data[2] - m2.Data[2],
-			m1.Data[3] - m2.Data[3],
+		Data: [2][2]float32{
+			{
+				m1.Data[0][0] - m2.Data[0][0],
+				m1.Data[0][1] - m2.Data[0][1],
+			},
+			{
+				m1.Data[1][0] - m2.Data[1][0],
+				m1.Data[1][1] - m2.Data[1][1],
+			},
 		},
 	}
 }
@@ -94,12 +118,15 @@ 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],
+		Data: [2][2]float32{
+			{
+				m1.Data[0][0]*m2.Data[0][0] + m1.Data[1][0]*m2.Data[0][1],
+				m1.Data[0][1]*m2.Data[0][0] + m1.Data[1][1]*m2.Data[0][1],
+			},
+			{
+				m1.Data[0][0]*m2.Data[1][0] + m1.Data[1][0]*m2.Data[1][1],
+				m1.Data[0][1]*m2.Data[1][0] + m1.Data[1][1]*m2.Data[1][1],
+			},
 		},
 	}
 }
@@ -108,8 +135,8 @@ func MulMat2(m1, m2 *Mat2) *Mat2 {
 func MulMat2Vec2(m1 *Mat2, v1 *Vec2) *Vec2 {
 	return &Vec2{
 		Data: [2]float32{
-			m1.Data[0]*v1.Data[0] + m1.Data[1]*v1.Data[1],
-			m1.Data[2]*v1.Data[0] + m1.Data[3]*v1.Data[1],
+			m1.Data[0][0]*v1.Data[0] + m1.Data[1][0]*v1.Data[1],
+			m1.Data[0][1]*v1.Data[0] + m1.Data[1][1]*v1.Data[1],
 		},
 	}
 }
@@ -117,9 +144,9 @@ func MulMat2Vec2(m1 *Mat2, v1 *Vec2) *Vec2 {
 //NewMat2Id returns the 2x2 identity matrix
 func NewMat2Id() *Mat2 {
 	return &Mat2{
-		Data: [4]float32{
-			1, 0,
-			0, 1,
+		Data: [2][2]float32{
+			{1, 0},
+			{0, 1},
 		},
 	}
 }

gglm/mat2_test.go

@@ -25,9 +25,9 @@ func TestMat2GetSet(t *testing.T) {
 func TestMat2Id(t *testing.T) {
 
 	correctAns := gglm.Mat2{
-		Data: [4]float32{
-			1, 0,
-			0, 1,
+		Data: [2][2]float32{
+			{1, 0},
+			{0, 1},
 		}}
 
 	m1 := gglm.NewMat2Id()
@@ -39,20 +39,20 @@ func TestMat2Id(t *testing.T) {
 func TestSubMat2(t *testing.T) {
 
 	correctAns := gglm.Mat2{
-		Data: [4]float32{
-			-4, -4,
-			-4, -4,
+		Data: [2][2]float32{
+			{-4, -4},
+			{-4, -4},
 		}}
 
 	m1 := &gglm.Mat2{
-		Data: [4]float32{
-			1, 2,
-			3, 4,
+		Data: [2][2]float32{
+			{1, 3},
+			{2, 4},
 		}}
 	m2 := &gglm.Mat2{
-		Data: [4]float32{
-			5, 6,
-			7, 8,
+		Data: [2][2]float32{
+			{5, 7},
+			{6, 8},
 		}}
 
 	result := gglm.SubMat2(m1, m2)
@@ -70,20 +70,20 @@ func TestSubMat2(t *testing.T) {
 func TestAddMat2(t *testing.T) {
 
 	correctAns := gglm.Mat2{
-		Data: [4]float32{
-			6, 8,
-			10, 12,
+		Data: [2][2]float32{
+			{6, 10},
+			{8, 12},
 		}}
 
 	m1 := &gglm.Mat2{
-		Data: [4]float32{
-			1, 2,
-			3, 4,
+		Data: [2][2]float32{
+			{1, 3},
+			{2, 4},
 		}}
 	m2 := &gglm.Mat2{
-		Data: [4]float32{
-			5, 6,
-			7, 8,
+		Data: [2][2]float32{
+			{5, 7},
+			{6, 8},
 		}}
 
 	result := gglm.AddMat2(m1, m2)
@@ -101,20 +101,20 @@ func TestAddMat2(t *testing.T) {
 func TestMulMat2(t *testing.T) {
 
 	correctAns := gglm.Mat2{
-		Data: [4]float32{
-			19, 22,
-			43, 50,
+		Data: [2][2]float32{
+			{19, 43},
+			{22, 50},
 		}}
 
 	m1 := &gglm.Mat2{
-		Data: [4]float32{
-			1, 2,
-			3, 4,
+		Data: [2][2]float32{
+			{1, 3},
+			{2, 4},
 		}}
 	m2 := &gglm.Mat2{
-		Data: [4]float32{
-			5, 6,
-			7, 8,
+		Data: [2][2]float32{
+			{5, 7},
+			{6, 8},
 		}}
 
 	result := gglm.MulMat2(m1, m2)
@@ -134,9 +134,9 @@ func TestMulMat2Vec2(t *testing.T) {
 	correctAns := gglm.Vec2{Data: [2]float32{5, 11}}
 
 	m := &gglm.Mat2{
-		Data: [4]float32{
-			1, 2,
-			3, 4,
+		Data: [2][2]float32{
+			{1, 3},
+			{2, 4},
 		}}
 	v := &gglm.Vec2{Data: [2]float32{1, 2}}
 
@@ -146,3 +146,13 @@ func TestMulMat2Vec2(t *testing.T) {
 		t.Errorf("Got: %v; Expected: %v", result.String(), correctAns.String())
 	}
 }
+
+func BenchmarkMulMat2(b *testing.B) {
+
+	m1 := gglm.NewMat2Id()
+	m2 := gglm.NewMat2Id()
+
+	for i := 0; i < b.N; i++ {
+		m1.Mul(m2)
+	}
+}

gglm/mat3.go

@@ -8,15 +8,15 @@ var _ Mat = &Mat3{}
 var _ fmt.Stringer = &Mat3{}
 
 type Mat3 struct {
-	Data [9]float32
+	Data [3][3]float32
 }
 
 func (m *Mat3) Get(row, col int) float32 {
-	return m.Data[row*3+col]
+	return m.Data[col][row]
 }
 
 func (m *Mat3) Set(row, col int, val float32) {
-	m.Data[row*3+col] = val
+	m.Data[col][row] = val
 }
 
 func (m *Mat3) Size() MatSize {
@@ -25,81 +25,109 @@ func (m *Mat3) Size() MatSize {
 
 func (m *Mat3) String() string {
 	return fmt.Sprintf("\n| %+-9.3f %+-9.3f %+-9.3f |\n| %+-9.3f %+-9.3f %+-9.3f |\n| %+-9.3f %+-9.3f %+-9.3f |\n",
-		m.Data[0], m.Data[1], m.Data[2],
-		m.Data[3], m.Data[4], m.Data[5],
-		m.Data[6], m.Data[7], m.Data[8],
+		m.Data[0][0], m.Data[0][1], m.Data[0][2],
+		m.Data[1][0], m.Data[1][1], m.Data[1][2],
+		m.Data[2][0], m.Data[2][1], m.Data[2][2],
 	)
 }
 
+func (m *Mat3) Col(c int) *Vec3 {
+	return &Vec3{Data: m.Data[c]}
+}
+
 //Add m += m2
-func (m *Mat3) Add(m2 *Mat3) {
+func (m *Mat3) Add(m2 *Mat3) *Mat3 {
 
-	m.Data[0] += m2.Data[0]
-	m.Data[1] += m2.Data[1]
-	m.Data[2] += m2.Data[2]
+	m.Data[0][0] += m2.Data[0][0]
+	m.Data[0][1] += m2.Data[0][1]
+	m.Data[0][2] += m2.Data[0][2]
 
-	m.Data[3] += m2.Data[3]
-	m.Data[4] += m2.Data[4]
-	m.Data[5] += m2.Data[5]
+	m.Data[1][0] += m2.Data[1][0]
+	m.Data[1][1] += m2.Data[1][1]
+	m.Data[1][2] += m2.Data[1][2]
 
-	m.Data[6] += m2.Data[6]
-	m.Data[7] += m2.Data[7]
-	m.Data[8] += m2.Data[8]
+	m.Data[2][0] += m2.Data[2][0]
+	m.Data[2][1] += m2.Data[2][1]
+	m.Data[2][2] += m2.Data[2][2]
+	return m
 }
 
 //Add m -= m2
-func (m *Mat3) Sub(m2 *Mat3) {
+func (m *Mat3) Sub(m2 *Mat3) *Mat3 {
 
-	m.Data[0] -= m2.Data[0]
-	m.Data[1] -= m2.Data[1]
-	m.Data[2] -= m2.Data[2]
+	m.Data[0][0] -= m2.Data[0][0]
+	m.Data[0][1] -= m2.Data[0][1]
+	m.Data[0][2] -= m2.Data[0][2]
 
-	m.Data[3] -= m2.Data[3]
-	m.Data[4] -= m2.Data[4]
-	m.Data[5] -= m2.Data[5]
+	m.Data[1][0] -= m2.Data[1][0]
+	m.Data[1][1] -= m2.Data[1][1]
+	m.Data[1][2] -= m2.Data[1][2]
 
-	m.Data[6] -= m2.Data[6]
-	m.Data[7] -= m2.Data[7]
-	m.Data[8] -= m2.Data[8]
+	m.Data[2][0] -= m2.Data[2][0]
+	m.Data[2][1] -= m2.Data[2][1]
+	m.Data[2][2] -= m2.Data[2][2]
+	return m
 }
 
 //Mul m *= m2
-func (m *Mat3) Mul(m2 *Mat3) {
+func (m *Mat3) Mul(m2 *Mat3) *Mat3 {
 
-	//Indices:
-	// 0, 1, 2,
-	// 3, 4, 5,
-	// 6, 7, 8,
+	//Array indices:
+	// 00, 10, 20,
+	// 01, 11, 21,
+	// 02, 12, 22,
 
-	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],
+	m00 := m.Data[0][0]
+	m01 := m.Data[0][1]
+	m02 := m.Data[0][2]
 
-		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],
+	m10 := m.Data[1][0]
+	m11 := m.Data[1][1]
+	m12 := m.Data[1][2]
 
-		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],
+	m20 := m.Data[2][0]
+	m21 := m.Data[2][1]
+	m22 := m.Data[2][2]
+
+	m.Data = [3][3]float32{
+		{
+			m00*m2.Data[0][0] + m10*m2.Data[0][1] + m20*m2.Data[0][2],
+			m01*m2.Data[0][0] + m11*m2.Data[0][1] + m21*m2.Data[0][2],
+			m02*m2.Data[0][0] + m12*m2.Data[0][1] + m22*m2.Data[0][2],
+		},
+		{
+			m00*m2.Data[1][0] + m10*m2.Data[1][1] + m20*m2.Data[1][2],
+			m01*m2.Data[1][0] + m11*m2.Data[1][1] + m21*m2.Data[1][2],
+			m02*m2.Data[1][0] + m12*m2.Data[1][1] + m22*m2.Data[1][2],
+		},
+		{
+			m00*m2.Data[2][0] + m10*m2.Data[2][1] + m20*m2.Data[2][2],
+			m01*m2.Data[2][0] + m11*m2.Data[2][1] + m21*m2.Data[2][2],
+			m02*m2.Data[2][0] + m12*m2.Data[2][1] + m22*m2.Data[2][2],
+		},
 	}
+	return m
 }
 
 //Scale m *= x (element wise multiplication)
-func (m *Mat3) Scale(x float32) {
+func (m *Mat3) Scale(x float32) *Mat3 {
 
-	m.Data[0] *= x
-	m.Data[1] *= x
-	m.Data[2] *= x
+	m.Data[0][0] *= x
+	m.Data[0][1] *= x
+	m.Data[0][2] *= x
 
-	m.Data[3] *= x
-	m.Data[4] *= x
-	m.Data[5] *= x
+	m.Data[1][0] *= x
+	m.Data[1][1] *= x
+	m.Data[1][2] *= x
 
-	m.Data[6] *= x
-	m.Data[7] *= x
-	m.Data[8] *= x
+	m.Data[2][0] *= x
+	m.Data[2][1] *= x
+	m.Data[2][2] *= x
+	return m
+}
+
+func (v *Mat3) Clone() *Mat3 {
+	return &Mat3{Data: v.Data}
 }
 
 func (m *Mat3) Eq(m2 *Mat3) bool {
@@ -109,18 +137,22 @@ func (m *Mat3) Eq(m2 *Mat3) bool {
 //AddMat3 m3 = m1 + m2
 func AddMat3(m1, m2 *Mat3) *Mat3 {
 	return &Mat3{
-		Data: [9]float32{
-			m1.Data[0] + m2.Data[0],
-			m1.Data[1] + m2.Data[1],
-			m1.Data[2] + m2.Data[2],
-
-			m1.Data[3] + m2.Data[3],
-			m1.Data[4] + m2.Data[4],
-			m1.Data[5] + m2.Data[5],
-
-			m1.Data[6] + m2.Data[6],
-			m1.Data[7] + m2.Data[7],
-			m1.Data[8] + m2.Data[8],
+		Data: [3][3]float32{
+			{
+				m1.Data[0][0] + m2.Data[0][0],
+				m1.Data[0][1] + m2.Data[0][1],
+				m1.Data[0][2] + m2.Data[0][2],
+			},
+			{
+				m1.Data[1][0] + m2.Data[1][0],
+				m1.Data[1][1] + m2.Data[1][1],
+				m1.Data[1][2] + m2.Data[1][2],
+			},
+			{
+				m1.Data[2][0] + m2.Data[2][0],
+				m1.Data[2][1] + m2.Data[2][1],
+				m1.Data[2][2] + m2.Data[2][2],
+			},
 		},
 	}
 }
@@ -128,37 +160,58 @@ func AddMat3(m1, m2 *Mat3) *Mat3 {
 //SubMat3 m3 = m1 - m2
 func SubMat3(m1, m2 *Mat3) *Mat3 {
 	return &Mat3{
-		Data: [9]float32{
-			m1.Data[0] - m2.Data[0],
-			m1.Data[1] - m2.Data[1],
-			m1.Data[2] - m2.Data[2],
-
-			m1.Data[3] - m2.Data[3],
-			m1.Data[4] - m2.Data[4],
-			m1.Data[5] - m2.Data[5],
-
-			m1.Data[6] - m2.Data[6],
-			m1.Data[7] - m2.Data[7],
-			m1.Data[8] - m2.Data[8],
+		Data: [3][3]float32{
+			{
+				m1.Data[0][0] - m2.Data[0][0],
+				m1.Data[0][1] - m2.Data[0][1],
+				m1.Data[0][2] - m2.Data[0][2],
+			},
+			{
+				m1.Data[1][0] - m2.Data[1][0],
+				m1.Data[1][1] - m2.Data[1][1],
+				m1.Data[1][2] - m2.Data[1][2],
+			},
+			{
+				m1.Data[2][0] - m2.Data[2][0],
+				m1.Data[2][1] - m2.Data[2][1],
+				m1.Data[2][2] - m2.Data[2][2],
+			},
 		},
 	}
 }
 
 //MulMat3 m3 = m1 * m2
 func MulMat3(m1, m2 *Mat3) *Mat3 {
+
+	m00 := m1.Data[0][0]
+	m01 := m1.Data[0][1]
+	m02 := m1.Data[0][2]
+
+	m10 := m1.Data[1][0]
+	m11 := m1.Data[1][1]
+	m12 := m1.Data[1][2]
+
+	m20 := m1.Data[2][0]
+	m21 := m1.Data[2][1]
+	m22 := m1.Data[2][2]
+
 	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],
+		Data: [3][3]float32{
+			{
+				m00*m2.Data[0][0] + m10*m2.Data[0][1] + m20*m2.Data[0][2],
+				m01*m2.Data[0][0] + m11*m2.Data[0][1] + m21*m2.Data[0][2],
+				m02*m2.Data[0][0] + m12*m2.Data[0][1] + m22*m2.Data[0][2],
+			},
+			{
+				m00*m2.Data[1][0] + m10*m2.Data[1][1] + m20*m2.Data[1][2],
+				m01*m2.Data[1][0] + m11*m2.Data[1][1] + m21*m2.Data[1][2],
+				m02*m2.Data[1][0] + m12*m2.Data[1][1] + m22*m2.Data[1][2],
+			},
+			{
+				m00*m2.Data[2][0] + m10*m2.Data[2][1] + m20*m2.Data[2][2],
+				m01*m2.Data[2][0] + m11*m2.Data[2][1] + m21*m2.Data[2][2],
+				m02*m2.Data[2][0] + m12*m2.Data[2][1] + m22*m2.Data[2][2],
+			},
 		},
 	}
 }
@@ -167,9 +220,9 @@ func MulMat3(m1, m2 *Mat3) *Mat3 {
 func MulMat3Vec3(m1 *Mat3, v1 *Vec3) *Vec3 {
 	return &Vec3{
 		Data: [3]float32{
-			m1.Data[0]*v1.Data[0] + m1.Data[1]*v1.Data[1] + m1.Data[2]*v1.Data[2],
-			m1.Data[3]*v1.Data[0] + m1.Data[4]*v1.Data[1] + m1.Data[5]*v1.Data[2],
-			m1.Data[6]*v1.Data[0] + m1.Data[7]*v1.Data[1] + m1.Data[8]*v1.Data[2],
+			m1.Data[0][0]*v1.Data[0] + m1.Data[1][0]*v1.Data[1] + m1.Data[2][0]*v1.Data[2],
+			m1.Data[0][1]*v1.Data[0] + m1.Data[1][1]*v1.Data[1] + m1.Data[2][1]*v1.Data[2],
+			m1.Data[0][2]*v1.Data[0] + m1.Data[1][2]*v1.Data[1] + m1.Data[2][2]*v1.Data[2],
 		},
 	}
 }
@@ -177,10 +230,10 @@ func MulMat3Vec3(m1 *Mat3, v1 *Vec3) *Vec3 {
 //NewMat3Id returns the 3x3 identity matrix
 func NewMat3Id() *Mat3 {
 	return &Mat3{
-		Data: [9]float32{
-			1, 0, 0,
-			0, 1, 0,
-			0, 0, 1,
+		Data: [3][3]float32{
+			{1, 0, 0},
+			{0, 1, 0},
+			{0, 0, 1},
 		},
 	}
 }

gglm/mat3_test.go

@@ -30,10 +30,10 @@ func TestMat3GetSet(t *testing.T) {
 func TestMat3Id(t *testing.T) {
 
 	correctAns := gglm.Mat3{
-		Data: [9]float32{
-			1, 0, 0,
-			0, 1, 0,
-			0, 0, 1,
+		Data: [3][3]float32{
+			{1, 0, 0},
+			{0, 1, 0},
+			{0, 0, 1},
 		}}
 
 	m1 := gglm.NewMat3Id()
@@ -45,23 +45,23 @@ func TestMat3Id(t *testing.T) {
 func TestSubMat3(t *testing.T) {
 
 	correctAns := gglm.Mat3{
-		Data: [9]float32{
-			-9, -9, -9,
-			-9, -9, -9,
-			-9, -9, -9,
+		Data: [3][3]float32{
+			{-9, -9, -9},
+			{-9, -9, -9},
+			{-9, -9, -9},
 		}}
 
 	m1 := &gglm.Mat3{
-		Data: [9]float32{
-			1, 2, 3,
-			4, 5, 6,
-			7, 8, 9,
+		Data: [3][3]float32{
+			{1, 4, 7},
+			{2, 5, 8},
+			{3, 6, 9},
 		}}
 	m2 := &gglm.Mat3{
-		Data: [9]float32{
-			10, 11, 12,
-			13, 14, 15,
-			16, 17, 18,
+		Data: [3][3]float32{
+			{10, 13, 16},
+			{11, 14, 17},
+			{12, 15, 18},
 		}}
 
 	result := gglm.SubMat3(m1, m2)
@@ -79,23 +79,23 @@ func TestSubMat3(t *testing.T) {
 func TestAddMat3(t *testing.T) {
 
 	correctAns := gglm.Mat3{
-		Data: [9]float32{
-			11, 13, 15,
-			17, 19, 21,
-			23, 25, 27,
+		Data: [3][3]float32{
+			{11, 17, 23},
+			{13, 19, 25},
+			{15, 21, 27},
 		}}
 
 	m1 := &gglm.Mat3{
-		Data: [9]float32{
-			1, 2, 3,
-			4, 5, 6,
-			7, 8, 9,
+		Data: [3][3]float32{
+			{1, 4, 7},
+			{2, 5, 8},
+			{3, 6, 9},
 		}}
 	m2 := &gglm.Mat3{
-		Data: [9]float32{
-			10, 11, 12,
-			13, 14, 15,
-			16, 17, 18,
+		Data: [3][3]float32{
+			{10, 13, 16},
+			{11, 14, 17},
+			{12, 15, 18},
 		}}
 
 	result := gglm.AddMat3(m1, m2)
@@ -113,23 +113,23 @@ func TestAddMat3(t *testing.T) {
 func TestMulMat3(t *testing.T) {
 
 	correctAns := gglm.Mat3{
-		Data: [9]float32{
-			84, 90, 96,
-			201, 216, 231,
-			318, 342, 366,
+		Data: [3][3]float32{
+			{84, 201, 318},
+			{90, 216, 342},
+			{96, 231, 366},
 		}}
 
 	m1 := &gglm.Mat3{
-		Data: [9]float32{
-			1, 2, 3,
-			4, 5, 6,
-			7, 8, 9,
+		Data: [3][3]float32{
+			{1, 4, 7},
+			{2, 5, 8},
+			{3, 6, 9},
 		}}
 	m2 := &gglm.Mat3{
-		Data: [9]float32{
-			10, 11, 12,
-			13, 14, 15,
-			16, 17, 18,
+		Data: [3][3]float32{
+			{10, 13, 16},
+			{11, 14, 17},
+			{12, 15, 18},
 		}}
 
 	result := gglm.MulMat3(m1, m2)
@@ -147,10 +147,10 @@ func TestMulMat3(t *testing.T) {
 func TestMulMat3Vec3(t *testing.T) {
 
 	m := &gglm.Mat3{
-		Data: [9]float32{
-			1, 2, 3,
-			4, 5, 6,
-			7, 8, 9,
+		Data: [3][3]float32{
+			{1, 4, 7},
+			{2, 5, 8},
+			{3, 6, 9},
 		}}
 	v := &gglm.Vec3{Data: [3]float32{1, 2, 3}}
 
@@ -161,3 +161,13 @@ func TestMulMat3Vec3(t *testing.T) {
 		t.Errorf("Got: %v; Expected: %v", result.String(), correctAns.String())
 	}
 }
+
+func BenchmarkMulMat3(b *testing.B) {
+
+	m1 := gglm.NewMat3Id()
+	m2 := gglm.NewMat3Id()
+
+	for i := 0; i < b.N; i++ {
+		m1.Mul(m2)
+	}
+}

gglm/mat4.go

@@ -8,15 +8,15 @@ var _ Mat = &Mat4{}
 var _ fmt.Stringer = &Mat4{}
 
 type Mat4 struct {
-	Data [16]float32
+	Data [4][4]float32
 }
 
 func (m *Mat4) Get(row, col int) float32 {
-	return m.Data[row*4+col]
+	return m.Data[col][row]
 }
 
 func (m *Mat4) Set(row, col int, val float32) {
-	m.Data[row*4+col] = val
+	m.Data[col][row] = val
 }
 
 func (m *Mat4) Size() MatSize {
@@ -25,122 +25,155 @@ func (m *Mat4) Size() MatSize {
 
 func (m *Mat4) String() string {
 	return fmt.Sprintf("\n| %+-9.3f %+-9.3f %+-9.3f %+-9.3f |\n| %+-9.3f %+-9.3f %+-9.3f %+-9.3f |\n| %+-9.3f %+-9.3f %+-9.3f %+-9.3f |\n| %+-9.3f %+-9.3f %+-9.3f %+-9.3f |\n",
-		m.Data[0], m.Data[1], m.Data[2], m.Data[3],
-		m.Data[4], m.Data[5], m.Data[6], m.Data[7],
-		m.Data[8], m.Data[9], m.Data[10], m.Data[11],
-		m.Data[12], m.Data[13], m.Data[14], m.Data[15],
+		m.Data[0][0], m.Data[0][1], m.Data[0][2], m.Data[0][3],
+		m.Data[1][0], m.Data[1][1], m.Data[1][2], m.Data[1][3],
+		m.Data[2][0], m.Data[2][1], m.Data[2][2], m.Data[2][3],
+		m.Data[3][0], m.Data[3][1], m.Data[3][2], m.Data[3][3],
 	)
 }
 
+func (m *Mat4) Col(c int) *Vec4 {
+	return &Vec4{Data: m.Data[c]}
+}
+
 //Add m += m2
-func (m *Mat4) Add(m2 *Mat4) {
+func (m *Mat4) Add(m2 *Mat4) *Mat4 {
 
-	m.Data[0] += m2.Data[0]
-	m.Data[1] += m2.Data[1]
-	m.Data[2] += m2.Data[2]
-	m.Data[3] += m2.Data[3]
+	m.Data[0][0] += m2.Data[0][0]
+	m.Data[0][1] += m2.Data[0][1]
+	m.Data[0][2] += m2.Data[0][2]
+	m.Data[0][3] += m2.Data[0][3]
 
-	m.Data[4] += m2.Data[4]
-	m.Data[5] += m2.Data[5]
-	m.Data[6] += m2.Data[6]
-	m.Data[7] += m2.Data[7]
+	m.Data[1][0] += m2.Data[1][0]
+	m.Data[1][1] += m2.Data[1][1]
+	m.Data[1][2] += m2.Data[1][2]
+	m.Data[1][3] += m2.Data[1][3]
 
-	m.Data[8] += m2.Data[8]
-	m.Data[9] += m2.Data[9]
-	m.Data[10] += m2.Data[10]
-	m.Data[11] += m2.Data[11]
+	m.Data[2][0] += m2.Data[2][0]
+	m.Data[2][1] += m2.Data[2][1]
+	m.Data[2][2] += m2.Data[2][2]
+	m.Data[2][3] += m2.Data[2][3]
 
-	m.Data[12] += m2.Data[12]
-	m.Data[13] += m2.Data[13]
-	m.Data[14] += m2.Data[14]
-	m.Data[15] += m2.Data[15]
+	m.Data[3][0] += m2.Data[3][0]
+	m.Data[3][1] += m2.Data[3][1]
+	m.Data[3][2] += m2.Data[3][2]
+	m.Data[3][3] += m2.Data[3][3]
+
+	return m
 }
 
 //Add m -= m2
-func (m *Mat4) Sub(m2 *Mat4) {
+func (m *Mat4) Sub(m2 *Mat4) *Mat4 {
 
-	m.Data[0] -= m2.Data[0]
-	m.Data[1] -= m2.Data[1]
-	m.Data[2] -= m2.Data[2]
-	m.Data[3] -= m2.Data[3]
+	m.Data[0][0] -= m2.Data[0][0]
+	m.Data[0][1] -= m2.Data[0][1]
+	m.Data[0][2] -= m2.Data[0][2]
+	m.Data[0][3] -= m2.Data[0][3]
 
-	m.Data[4] -= m2.Data[4]
-	m.Data[5] -= m2.Data[5]
-	m.Data[6] -= m2.Data[6]
-	m.Data[7] -= m2.Data[7]
+	m.Data[1][0] -= m2.Data[1][0]
+	m.Data[1][1] -= m2.Data[1][1]
+	m.Data[1][2] -= m2.Data[1][2]
+	m.Data[1][3] -= m2.Data[1][3]
 
-	m.Data[8] -= m2.Data[8]
-	m.Data[9] -= m2.Data[9]
-	m.Data[10] -= m2.Data[10]
-	m.Data[11] -= m2.Data[11]
+	m.Data[2][0] -= m2.Data[2][0]
+	m.Data[2][1] -= m2.Data[2][1]
+	m.Data[2][2] -= m2.Data[2][2]
+	m.Data[2][3] -= m2.Data[2][3]
 
-	m.Data[12] -= m2.Data[12]
-	m.Data[13] -= m2.Data[13]
-	m.Data[14] -= m2.Data[14]
-	m.Data[15] -= m2.Data[15]
+	m.Data[3][0] -= m2.Data[3][0]
+	m.Data[3][1] -= m2.Data[3][1]
+	m.Data[3][2] -= m2.Data[3][2]
+	m.Data[3][3] -= m2.Data[3][3]
+	return m
 }
 
 //Mul m *= m2
-func (m *Mat4) Mul(m2 *Mat4) {
+func (m *Mat4) Mul(m2 *Mat4) *Mat4 {
 
-	//Indices:
-	// 00, 01, 02, 03,
-	// 04, 05, 06, 07,
-	// 08, 09, 10, 11,
-	// 12, 13, 14, 15,
+	//Array indices:
+	// 00, 10, 20, 30,
+	// 01, 11, 21, 31,
+	// 02, 12, 22, 32,
+	// 03, 13, 23, 33,
 
-	//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]
+	//Improves performance by ~8%
+	m00 := m.Data[0][0]
+	m01 := m.Data[0][1]
+	m02 := m.Data[0][2]
+	m03 := m.Data[0][3]
 
-	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],
+	m10 := m.Data[1][0]
+	m11 := m.Data[1][1]
+	m12 := m.Data[1][2]
+	m13 := m.Data[1][3]
 
-		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],
+	m20 := m.Data[2][0]
+	m21 := m.Data[2][1]
+	m22 := m.Data[2][2]
+	m23 := m.Data[2][3]
 
-		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],
+	m30 := m.Data[3][0]
+	m31 := m.Data[3][1]
+	m32 := m.Data[3][2]
+	m33 := m.Data[3][3]
 
-		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],
+	m.Data = [4][4]float32{
+		{
+			m00*m2.Data[0][0] + m10*m2.Data[0][1] + m20*m2.Data[0][2] + m30*m2.Data[0][3],
+			m01*m2.Data[0][0] + m11*m2.Data[0][1] + m21*m2.Data[0][2] + m31*m2.Data[0][3],
+			m02*m2.Data[0][0] + m12*m2.Data[0][1] + m22*m2.Data[0][2] + m32*m2.Data[0][3],
+			m03*m2.Data[0][0] + m13*m2.Data[0][1] + m23*m2.Data[0][2] + m33*m2.Data[0][3],
+		},
+		{
+			m00*m2.Data[1][0] + m10*m2.Data[1][1] + m20*m2.Data[1][2] + m30*m2.Data[1][3],
+			m01*m2.Data[1][0] + m11*m2.Data[1][1] + m21*m2.Data[1][2] + m31*m2.Data[1][3],
+			m02*m2.Data[1][0] + m12*m2.Data[1][1] + m22*m2.Data[1][2] + m32*m2.Data[1][3],
+			m03*m2.Data[1][0] + m13*m2.Data[1][1] + m23*m2.Data[1][2] + m33*m2.Data[1][3],
+		},
+		{
+			m00*m2.Data[2][0] + m10*m2.Data[2][1] + m20*m2.Data[2][2] + m30*m2.Data[2][3],
+			m01*m2.Data[2][0] + m11*m2.Data[2][1] + m21*m2.Data[2][2] + m31*m2.Data[2][3],
+			m02*m2.Data[2][0] + m12*m2.Data[2][1] + m22*m2.Data[2][2] + m32*m2.Data[2][3],
+			m03*m2.Data[2][0] + m13*m2.Data[2][1] + m23*m2.Data[2][2] + m33*m2.Data[2][3],
+		},
+		{
+			m00*m2.Data[3][0] + m10*m2.Data[3][1] + m20*m2.Data[3][2] + m30*m2.Data[3][3],
+			m01*m2.Data[3][0] + m11*m2.Data[3][1] + m21*m2.Data[3][2] + m31*m2.Data[3][3],
+			m02*m2.Data[3][0] + m12*m2.Data[3][1] + m22*m2.Data[3][2] + m32*m2.Data[3][3],
+			m03*m2.Data[3][0] + m13*m2.Data[3][1] + m23*m2.Data[3][2] + m33*m2.Data[3][3],
+		},
 	}
+
+	return m
 }
 
 //Scale m *= x (element wise multiplication)
-func (m *Mat4) Scale(x float32) {
+func (m *Mat4) Scale(x float32) *Mat4 {
 
-	m.Data[0] *= x
-	m.Data[1] *= x
-	m.Data[2] *= x
-	m.Data[3] *= x
+	m.Data[0][0] *= x
+	m.Data[0][1] *= x
+	m.Data[0][2] *= x
+	m.Data[0][3] *= x
 
-	m.Data[4] *= x
-	m.Data[5] *= x
-	m.Data[6] *= x
-	m.Data[7] *= x
+	m.Data[1][0] *= x
+	m.Data[1][1] *= x
+	m.Data[1][2] *= x
+	m.Data[1][3] *= x
 
-	m.Data[8] *= x
-	m.Data[9] *= x
-	m.Data[10] *= x
-	m.Data[11] *= x
+	m.Data[2][0] *= x
+	m.Data[2][1] *= x
+	m.Data[2][2] *= x
+	m.Data[2][3] *= x
 
-	m.Data[12] *= x
-	m.Data[13] *= x
-	m.Data[14] *= x
-	m.Data[15] *= x
+	m.Data[3][0] *= x
+	m.Data[3][1] *= x
+	m.Data[3][2] *= x
+	m.Data[3][3] *= x
+	return m
+}
+
+func (v *Mat4) Clone() *Mat4 {
+	return &Mat4{Data: v.Data}
 }
 
 func (m *Mat4) Eq(m2 *Mat4) bool {
@@ -150,26 +183,31 @@ func (m *Mat4) Eq(m2 *Mat4) bool {
 //AddMat4 m3 = m1 + m2
 func AddMat4(m1, m2 *Mat4) *Mat4 {
 	return &Mat4{
-		Data: [16]float32{
-			m1.Data[0] + m2.Data[0],
-			m1.Data[1] + m2.Data[1],
-			m1.Data[2] + m2.Data[2],
-			m1.Data[3] + m2.Data[3],
-
-			m1.Data[4] + m2.Data[4],
-			m1.Data[5] + m2.Data[5],
-			m1.Data[6] + m2.Data[6],
-			m1.Data[7] + m2.Data[7],
-
-			m1.Data[8] + m2.Data[8],
-			m1.Data[9] + m2.Data[9],
-			m1.Data[10] + m2.Data[10],
-			m1.Data[11] + m2.Data[11],
-
-			m1.Data[12] + m2.Data[12],
-			m1.Data[13] + m2.Data[13],
-			m1.Data[14] + m2.Data[14],
-			m1.Data[15] + m2.Data[15],
+		Data: [4][4]float32{
+			{
+				m1.Data[0][0] + m2.Data[0][0],
+				m1.Data[0][1] + m2.Data[0][1],
+				m1.Data[0][2] + m2.Data[0][2],
+				m1.Data[0][3] + m2.Data[0][3],
+			},
+			{
+				m1.Data[1][0] + m2.Data[1][0],
+				m1.Data[1][1] + m2.Data[1][1],
+				m1.Data[1][2] + m2.Data[1][2],
+				m1.Data[1][3] + m2.Data[1][3],
+			},
+			{
+				m1.Data[2][0] + m2.Data[2][0],
+				m1.Data[2][1] + m2.Data[2][1],
+				m1.Data[2][2] + m2.Data[2][2],
+				m1.Data[2][3] + m2.Data[2][3],
+			},
+			{
+				m1.Data[3][0] + m2.Data[3][0],
+				m1.Data[3][1] + m2.Data[3][1],
+				m1.Data[3][2] + m2.Data[3][2],
+				m1.Data[3][3] + m2.Data[3][3],
+			},
 		},
 	}
 }
@@ -177,26 +215,31 @@ func AddMat4(m1, m2 *Mat4) *Mat4 {
 //SubMat4 m3 = m1 - m2
 func SubMat4(m1, m2 *Mat4) *Mat4 {
 	return &Mat4{
-		Data: [16]float32{
-			m1.Data[0] - m2.Data[0],
-			m1.Data[1] - m2.Data[1],
-			m1.Data[2] - m2.Data[2],
-			m1.Data[3] - m2.Data[3],
-
-			m1.Data[4] - m2.Data[4],
-			m1.Data[5] - m2.Data[5],
-			m1.Data[6] - m2.Data[6],
-			m1.Data[7] - m2.Data[7],
-
-			m1.Data[8] - m2.Data[8],
-			m1.Data[9] - m2.Data[9],
-			m1.Data[10] - m2.Data[10],
-			m1.Data[11] - m2.Data[11],
-
-			m1.Data[12] - m2.Data[12],
-			m1.Data[13] - m2.Data[13],
-			m1.Data[14] - m2.Data[14],
-			m1.Data[15] - m2.Data[15],
+		Data: [4][4]float32{
+			{
+				m1.Data[0][0] - m2.Data[0][0],
+				m1.Data[0][1] - m2.Data[0][1],
+				m1.Data[0][2] - m2.Data[0][2],
+				m1.Data[0][3] - m2.Data[0][3],
+			},
+			{
+				m1.Data[1][0] - m2.Data[1][0],
+				m1.Data[1][1] - m2.Data[1][1],
+				m1.Data[1][2] - m2.Data[1][2],
+				m1.Data[1][3] - m2.Data[1][3],
+			},
+			{
+				m1.Data[2][0] - m2.Data[2][0],
+				m1.Data[2][1] - m2.Data[2][1],
+				m1.Data[2][2] - m2.Data[2][2],
+				m1.Data[2][3] - m2.Data[2][3],
+			},
+			{
+				m1.Data[3][0] - m2.Data[3][0],
+				m1.Data[3][1] - m2.Data[3][1],
+				m1.Data[3][2] - m2.Data[3][2],
+				m1.Data[3][3] - m2.Data[3][3],
+			},
 		},
 	}
 }
@@ -204,32 +247,52 @@ 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]
+	m00 := m1.Data[0][0]
+	m01 := m1.Data[0][1]
+	m02 := m1.Data[0][2]
+	m03 := m1.Data[0][3]
+
+	m10 := m1.Data[1][0]
+	m11 := m1.Data[1][1]
+	m12 := m1.Data[1][2]
+	m13 := m1.Data[1][3]
+
+	m20 := m1.Data[2][0]
+	m21 := m1.Data[2][1]
+	m22 := m1.Data[2][2]
+	m23 := m1.Data[2][3]
+
+	m30 := m1.Data[3][0]
+	m31 := m1.Data[3][1]
+	m32 := m1.Data[3][2]
+	m33 := m1.Data[3][3]
 
 	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],
+		Data: [4][4]float32{
+			{
+				m00*m2.Data[0][0] + m10*m2.Data[0][1] + m20*m2.Data[0][2] + m30*m2.Data[0][3],
+				m01*m2.Data[0][0] + m11*m2.Data[0][1] + m21*m2.Data[0][2] + m31*m2.Data[0][3],
+				m02*m2.Data[0][0] + m12*m2.Data[0][1] + m22*m2.Data[0][2] + m32*m2.Data[0][3],
+				m03*m2.Data[0][0] + m13*m2.Data[0][1] + m23*m2.Data[0][2] + m33*m2.Data[0][3],
+			},
+			{
+				m00*m2.Data[1][0] + m10*m2.Data[1][1] + m20*m2.Data[1][2] + m30*m2.Data[1][3],
+				m01*m2.Data[1][0] + m11*m2.Data[1][1] + m21*m2.Data[1][2] + m31*m2.Data[1][3],
+				m02*m2.Data[1][0] + m12*m2.Data[1][1] + m22*m2.Data[1][2] + m32*m2.Data[1][3],
+				m03*m2.Data[1][0] + m13*m2.Data[1][1] + m23*m2.Data[1][2] + m33*m2.Data[1][3],
+			},
+			{
+				m00*m2.Data[2][0] + m10*m2.Data[2][1] + m20*m2.Data[2][2] + m30*m2.Data[2][3],
+				m01*m2.Data[2][0] + m11*m2.Data[2][1] + m21*m2.Data[2][2] + m31*m2.Data[2][3],
+				m02*m2.Data[2][0] + m12*m2.Data[2][1] + m22*m2.Data[2][2] + m32*m2.Data[2][3],
+				m03*m2.Data[2][0] + m13*m2.Data[2][1] + m23*m2.Data[2][2] + m33*m2.Data[2][3],
+			},
+			{
+				m00*m2.Data[3][0] + m10*m2.Data[3][1] + m20*m2.Data[3][2] + m30*m2.Data[3][3],
+				m01*m2.Data[3][0] + m11*m2.Data[3][1] + m21*m2.Data[3][2] + m31*m2.Data[3][3],
+				m02*m2.Data[3][0] + m12*m2.Data[3][1] + m22*m2.Data[3][2] + m32*m2.Data[3][3],
+				m03*m2.Data[3][0] + m13*m2.Data[3][1] + m23*m2.Data[3][2] + m33*m2.Data[3][3],
+			},
 		},
 	}
 }
@@ -238,10 +301,10 @@ func MulMat4(m1, m2 *Mat4) *Mat4 {
 func MulMat4Vec4(m1 *Mat4, v1 *Vec4) *Vec4 {
 	return &Vec4{
 		Data: [4]float32{
-			m1.Data[0]*v1.Data[0] + m1.Data[1]*v1.Data[1] + m1.Data[2]*v1.Data[2] + m1.Data[3]*v1.Data[3],
-			m1.Data[4]*v1.Data[0] + m1.Data[5]*v1.Data[1] + m1.Data[6]*v1.Data[2] + m1.Data[7]*v1.Data[3],
-			m1.Data[8]*v1.Data[0] + m1.Data[9]*v1.Data[1] + m1.Data[10]*v1.Data[2] + m1.Data[11]*v1.Data[3],
-			m1.Data[12]*v1.Data[0] + m1.Data[13]*v1.Data[1] + m1.Data[14]*v1.Data[2] + m1.Data[15]*v1.Data[3],
+			m1.Data[0][0]*v1.Data[0] + m1.Data[1][0]*v1.Data[1] + m1.Data[2][0]*v1.Data[2] + m1.Data[3][0]*v1.Data[3],
+			m1.Data[0][1]*v1.Data[0] + m1.Data[1][1]*v1.Data[1] + m1.Data[2][1]*v1.Data[2] + m1.Data[3][1]*v1.Data[3],
+			m1.Data[0][2]*v1.Data[0] + m1.Data[1][2]*v1.Data[1] + m1.Data[2][2]*v1.Data[2] + m1.Data[3][2]*v1.Data[3],
+			m1.Data[0][3]*v1.Data[0] + m1.Data[1][3]*v1.Data[1] + m1.Data[2][3]*v1.Data[2] + m1.Data[3][3]*v1.Data[3],
 		},
 	}
 }
@@ -249,11 +312,11 @@ func MulMat4Vec4(m1 *Mat4, v1 *Vec4) *Vec4 {
 //NewMat4Id returns the 4x4 identity matrix
 func NewMat4Id() *Mat4 {
 	return &Mat4{
-		Data: [16]float32{
-			1, 0, 0, 0,
-			0, 1, 0, 0,
-			0, 0, 1, 0,
-			0, 0, 0, 1,
+		Data: [4][4]float32{
+			{1, 0, 0, 0},
+			{0, 1, 0, 0},
+			{0, 0, 1, 0},
+			{0, 0, 0, 1},
 		},
 	}
 }

gglm/mat4_test.go

@@ -6,6 +6,10 @@ import (
 	"github.com/bloeys/gglm/gglm"
 )
 
+var (
+	mulMat4Vec4Res *gglm.Vec4
+)
+
 func TestMat4GetSet(t *testing.T) {
 
 	m1 := gglm.Mat4{}
@@ -35,11 +39,11 @@ func TestMat4GetSet(t *testing.T) {
 func TestMat4Id(t *testing.T) {
 
 	correctAns := gglm.Mat4{
-		Data: [16]float32{
-			1, 0, 0, 0,
-			0, 1, 0, 0,
-			0, 0, 1, 0,
-			0, 0, 0, 1,
+		Data: [4][4]float32{
+			{1, 0, 0, 0},
+			{0, 1, 0, 0},
+			{0, 0, 1, 0},
+			{0, 0, 0, 1},
 		}}
 
 	m1 := gglm.NewMat4Id()
@@ -51,26 +55,26 @@ func TestMat4Id(t *testing.T) {
 func TestSubMat4(t *testing.T) {
 
 	correctAns := gglm.Mat4{
-		Data: [16]float32{
-			-16, -16, -16, -16,
-			-16, -16, -16, -16,
-			-16, -16, -16, -16,
-			-16, -16, -16, -16,
+		Data: [4][4]float32{
+			{-16, -16, -16, -16},
+			{-16, -16, -16, -16},
+			{-16, -16, -16, -16},
+			{-16, -16, -16, -16},
 		}}
 
 	m1 := &gglm.Mat4{
-		Data: [16]float32{
-			1, 2, 3, 4,
-			5, 6, 7, 8,
-			9, 10, 11, 12,
-			13, 14, 15, 16,
+		Data: [4][4]float32{
+			{1, 5, 9, 13},
+			{2, 6, 10, 14},
+			{3, 7, 11, 15},
+			{4, 8, 12, 16},
 		}}
 	m2 := &gglm.Mat4{
-		Data: [16]float32{
-			17, 18, 19, 20,
-			21, 22, 23, 24,
-			25, 26, 27, 28,
-			29, 30, 31, 32,
+		Data: [4][4]float32{
+			{17, 21, 25, 29},
+			{18, 22, 26, 30},
+			{19, 23, 27, 31},
+			{20, 24, 28, 32},
 		}}
 
 	result := gglm.SubMat4(m1, m2)
@@ -88,26 +92,26 @@ func TestSubMat4(t *testing.T) {
 func TestAddMat4(t *testing.T) {
 
 	correctAns := gglm.Mat4{
-		Data: [16]float32{
-			18, 20, 22, 24,
-			26, 28, 30, 32,
-			34, 36, 38, 40,
-			42, 44, 46, 48,
+		Data: [4][4]float32{
+			{18, 26, 34, 42},
+			{20, 28, 36, 44},
+			{22, 30, 38, 46},
+			{24, 32, 40, 48},
 		}}
 
 	m1 := &gglm.Mat4{
-		Data: [16]float32{
-			1, 2, 3, 4,
-			5, 6, 7, 8,
-			9, 10, 11, 12,
-			13, 14, 15, 16,
+		Data: [4][4]float32{
+			{1, 5, 9, 13},
+			{2, 6, 10, 14},
+			{3, 7, 11, 15},
+			{4, 8, 12, 16},
 		}}
 	m2 := &gglm.Mat4{
-		Data: [16]float32{
-			17, 18, 19, 20,
-			21, 22, 23, 24,
-			25, 26, 27, 28,
-			29, 30, 31, 32,
+		Data: [4][4]float32{
+			{17, 21, 25, 29},
+			{18, 22, 26, 30},
+			{19, 23, 27, 31},
+			{20, 24, 28, 32},
 		}}
 
 	result := gglm.AddMat4(m1, m2)
@@ -125,26 +129,26 @@ func TestAddMat4(t *testing.T) {
 func TestMulMat4(t *testing.T) {
 
 	correctAns := gglm.Mat4{
-		Data: [16]float32{
-			250, 260, 270, 280,
-			618, 644, 670, 696,
-			986, 1028, 1070, 1112,
-			1354, 1412, 1470, 1528,
+		Data: [4][4]float32{
+			{250, 618, 986, 1354},
+			{260, 644, 1028, 1412},
+			{270, 670, 1070, 1470},
+			{280, 696, 1112, 1528},
 		}}
 
 	m1 := &gglm.Mat4{
-		Data: [16]float32{
-			1, 2, 3, 4,
-			5, 6, 7, 8,
-			9, 10, 11, 12,
-			13, 14, 15, 16,
+		Data: [4][4]float32{
+			{1, 5, 9, 13},
+			{2, 6, 10, 14},
+			{3, 7, 11, 15},
+			{4, 8, 12, 16},
 		}}
 	m2 := &gglm.Mat4{
-		Data: [16]float32{
-			17, 18, 19, 20,
-			21, 22, 23, 24,
-			25, 26, 27, 28,
-			29, 30, 31, 32,
+		Data: [4][4]float32{
+			{17, 21, 25, 29},
+			{18, 22, 26, 30},
+			{19, 23, 27, 31},
+			{20, 24, 28, 32},
 		}}
 
 	result := gglm.MulMat4(m1, m2)
@@ -162,11 +166,11 @@ func TestMulMat4(t *testing.T) {
 func TestMulMat4Vec4(t *testing.T) {
 
 	m := &gglm.Mat4{
-		Data: [16]float32{
-			1, 2, 3, 4,
-			5, 6, 7, 8,
-			9, 10, 11, 12,
-			13, 14, 15, 16,
+		Data: [4][4]float32{
+			{1, 5, 9, 13},
+			{2, 6, 10, 14},
+			{3, 7, 11, 15},
+			{4, 8, 12, 16},
 		}}
 	v := &gglm.Vec4{Data: [4]float32{1, 2, 3, 4}}
 
@@ -177,3 +181,23 @@ func TestMulMat4Vec4(t *testing.T) {
 		t.Errorf("Got: %v; Expected: %v", result.String(), correctAns.String())
 	}
 }
+
+func BenchmarkMulMat4(b *testing.B) {
+
+	m1 := gglm.NewMat4Id()
+	m2 := gglm.NewMat4Id()
+
+	for i := 0; i < b.N; i++ {
+		m1.Mul(m2)
+	}
+}
+
+func BenchmarkMulMat4Vec4(b *testing.B) {
+
+	m1 := gglm.NewMat4Id()
+	v1 := gglm.Vec4{}
+
+	for i := 0; i < b.N; i++ {
+		mulMat4Vec4Res = gglm.MulMat4Vec4(m1, &v1)
+	}
+}

gglm/quat.go

@@ -0,0 +1,99 @@
+package gglm
+
+import (
+	"fmt"
+)
+
+var _ Swizzle4 = &Quat{}
+var _ fmt.Stringer = &Quat{}
+
+type Quat struct {
+	Vec4
+}
+
+//Eq checks for exact equality
+func (q *Quat) Eq(q2 *Quat) bool {
+	return q.Data == q2.Data
+}
+
+//Angle returns the angle represented by this quaternion
+func (q *Quat) Angle() float32 {
+
+	if Abs32(q.Data[3]) > CosHalf {
+
+		a := Asin32(Sqrt32(q.Data[0]*q.Data[0]+q.Data[1]*q.Data[1]+q.Data[2]*q.Data[2])) * 2
+		if q.Data[3] < 0 {
+			return Pi*2 - a
+		}
+		return a
+	}
+
+	return Acos32(q.Data[3]) * 2
+}
+
+//Axis returns the rotation axis represented by this quaternion
+func (q *Quat) Axis() *Vec3 {
+
+	var t float32 = 1 - q.Data[3]*q.Data[3]
+	if t <= 0 {
+		return &Vec3{Data: [3]float32{0, 0, 1}}
+	}
+
+	t = 1 / Sqrt32(t)
+	return &Vec3{Data: [3]float32{
+		q.Data[0] * t,
+		q.Data[1] * t,
+		q.Data[2] * t,
+	}}
+}
+
+//Euler takes rotations in radians and produces a rotation that
+//rotates around the z-axis, y-axis and lastly x-axis.
+func NewQuatEuler(v *Vec3) *Quat {
+
+	//Some other common terminology: x=roll, y=pitch, z=yaw
+	sinX, cosX := Sincos32(v.Data[0] * 0.5)
+	sinY, cosY := Sincos32(v.Data[1] * 0.5)
+	sinZ, cosZ := Sincos32(v.Data[2] * 0.5)
+
+	//This produces a z->y->x multiply order, but its written as XYZ.
+	//This is due to XYZ meaning independent rotation matrices, so Z is applied
+	//first, then Y matrix and lastly X.
+	//See this for more info: https://github.com/godotengine/godot/issues/6816#issuecomment-254592170
+	//
+	//Note: On most conversion tools putting the multiply order (e.g. ZYX for us) is required.
+	return &Quat{
+		Vec4: Vec4{
+			Data: [4]float32{
+				sinX*cosY*cosZ - cosX*sinY*sinZ,
+				cosX*sinY*cosZ + sinX*cosY*sinZ,
+				cosX*cosY*sinZ - sinX*sinY*cosZ,
+				cosX*cosY*cosZ + sinX*sinY*sinZ,
+			},
+		},
+	}
+}
+
+//AngleAxis rotates rotRad radians around the *normalized* vector rotAxisNorm
+func NewQuatAngleAxis(rotRad float32, rotAxisNorm *Vec3) *Quat {
+
+	s, c := Sincos32(rotRad * 0.5)
+	return &Quat{
+		Vec4: Vec4{
+			Data: [4]float32{
+				rotAxisNorm.Data[0] * s,
+				rotAxisNorm.Data[1] * s,
+				rotAxisNorm.Data[2] * s,
+				c,
+			},
+		},
+	}
+}
+
+func NewQuatId() *Quat {
+	return &Quat{
+		Vec4: Vec4{
+			Data: [4]float32{0, 0, 0, 1},
+		},
+	}
+}

gglm/quat_test.go

@@ -0,0 +1,75 @@
+package gglm_test
+
+import (
+	"testing"
+
+	"github.com/bloeys/gglm/gglm"
+)
+
+func TestNewQuatEuler(t *testing.T) {
+
+	q := gglm.NewQuatEuler(gglm.NewVec3(180, 180, 180).AsRad())
+	ans := &gglm.Quat{Vec4: *gglm.NewVec4(0, 0, 0, 1)}
+
+	if !gglm.EqF32(q.X(), ans.X()) || !gglm.EqF32(q.Y(), ans.Y()) || !gglm.EqF32(q.Z(), ans.Z()) || !gglm.EqF32(q.W(), ans.W()) {
+		t.Errorf("Got: %v; Expected: %v", q.String(), ans.String())
+	}
+}
+
+func TestNewQuatAngleAxis(t *testing.T) {
+
+	q := gglm.NewQuatAngleAxis(180*gglm.Deg2Rad, gglm.NewVec3(0, 1, 0))
+	ans := &gglm.Quat{Vec4: *gglm.NewVec4(0, 1, 0, 0)}
+
+	if !gglm.EqF32(q.X(), ans.X()) || !gglm.EqF32(q.Y(), ans.Y()) || !gglm.EqF32(q.Z(), ans.Z()) || !gglm.EqF32(q.W(), ans.W()) {
+		t.Errorf("Got: %v; Expected: %v", q.String(), ans.String())
+	}
+}
+
+func TestQuatAngle(t *testing.T) {
+
+	a := gglm.NewQuatAngleAxis(180*gglm.Deg2Rad, gglm.NewVec3(0, 1, 0)).Angle()
+	var ans float32 = 180.0 * gglm.Deg2Rad
+
+	if !gglm.EqF32(a, ans) {
+		t.Errorf("Got: %v; Expected: %v", a, ans)
+	}
+
+	a = gglm.NewQuatAngleAxis(90*gglm.Deg2Rad, gglm.NewVec3(1, 1, 0).Normalize()).Angle()
+	ans = 90 * gglm.Deg2Rad
+
+	if !gglm.EqF32(a, ans) {
+		t.Errorf("Got: %v; Expected: %v", a, ans)
+	}
+
+	a = gglm.NewQuatAngleAxis(125*gglm.Deg2Rad, gglm.NewVec3(1, 1, 0).Normalize()).Angle()
+	ans = 125 * gglm.Deg2Rad
+
+	if !gglm.EqF32(a, ans) {
+		t.Errorf("Got: %v; Expected: %v", a, ans)
+	}
+}
+
+func TestQuatAxis(t *testing.T) {
+
+	a := gglm.NewQuatAngleAxis(1, gglm.NewVec3(0, 1, 0)).Axis()
+	ans := gglm.NewVec3(0, 1, 0)
+
+	if !gglm.EqF32(a.X(), ans.X()) || !gglm.EqF32(a.Y(), ans.Y()) || !gglm.EqF32(a.Z(), ans.Z()) {
+		t.Errorf("Got: %v; Expected: %v", a.String(), ans.String())
+	}
+
+	a = gglm.NewQuatAngleAxis(1, gglm.NewVec3(1, 1, 0).Normalize()).Axis()
+	ans = gglm.NewVec3(1, 1, 0).Normalize()
+
+	if !gglm.EqF32(a.X(), ans.X()) || !gglm.EqF32(a.Y(), ans.Y()) || !gglm.EqF32(a.Z(), ans.Z()) {
+		t.Errorf("Got: %v; Expected: %v", a.String(), ans.String())
+	}
+
+	a = gglm.NewQuatAngleAxis(1, gglm.NewVec3(67, 46, 32).Normalize()).Axis()
+	ans = gglm.NewVec3(67, 46, 32).Normalize()
+
+	if !gglm.EqF32(a.X(), ans.X()) || !gglm.EqF32(a.Y(), ans.Y()) || !gglm.EqF32(a.Z(), ans.Z()) {
+		t.Errorf("Got: %v; Expected: %v", a.String(), ans.String())
+	}
+}

gglm/scalar.go

@@ -0,0 +1,45 @@
+package gglm
+
+import "math"
+
+//F32Epsilon = 0.0000005
+const F32Epsilon float32 = 1e-6
+
+//EqF32 true if abs(f1-f2) <= F32Epsilon
+func EqF32(f1, f2 float32) bool {
+	return math.Abs(float64(f1-f2)) <= float64(F32Epsilon)
+}
+
+//EqF32Epsilon true if abs(f1-f2) <= eps
+func EqF32Epsilon(f1, f2, eps float32) bool {
+	return math.Abs(float64(f1-f2)) <= float64(eps)
+}
+
+func Sin32(x float32) float32 {
+	return float32(math.Sin(float64(x)))
+}
+
+func Asin32(x float32) float32 {
+	return float32(math.Asin(float64(x)))
+}
+
+func Cos32(x float32) float32 {
+	return float32(math.Cos(float64(x)))
+}
+
+func Acos32(x float32) float32 {
+	return float32(math.Acos(float64(x)))
+}
+
+func Sincos32(x float32) (sinx, cosx float32) {
+	a, b := math.Sincos(float64(x))
+	return float32(a), float32(b)
+}
+
+func Abs32(x float32) float32 {
+	return float32(math.Abs(float64(x)))
+}
+
+func Sqrt32(x float32) float32 {
+	return float32(math.Sqrt(float64(x)))
+}

gglm/transform.go

@@ -0,0 +1,194 @@
+package gglm
+
+import (
+	"fmt"
+	"math"
+)
+
+var _ Mat = &TrMat{}
+var _ fmt.Stringer = &TrMat{}
+
+//TrMat represents a transformation matrix
+type TrMat struct {
+	Mat4
+}
+
+//Translate adds v to the translation components of the transformation matrix
+func (t *TrMat) Translate(v *Vec3) {
+	t.Data[3][0] += v.Data[0]
+	t.Data[3][1] += v.Data[1]
+	t.Data[3][2] += v.Data[2]
+}
+
+//Scale multiplies the scale components of the transformation matrix by v
+func (t *TrMat) Scale(v *Vec3) {
+	t.Data[0][0] *= v.Data[0]
+	t.Data[1][1] *= v.Data[1]
+	t.Data[2][2] *= v.Data[2]
+}
+
+//Rotate takes a *normalized* axis and angles in radians to rotate around the given axis
+func (t *TrMat) Rotate(rads float32, axis *Vec3) {
+
+	s := Sin32(rads)
+	c := Cos32(rads)
+
+	axis = axis.Normalize()
+	temp := axis.Clone().Scale(1 - c)
+
+	rotate := TrMat{}
+	rotate.Data[0][0] = c + temp.Data[0]*axis.Data[0]
+	rotate.Data[0][1] = temp.Data[0]*axis.Data[1] + s*axis.Data[2]
+	rotate.Data[0][2] = temp.Data[0]*axis.Data[2] - s*axis.Data[1]
+
+	rotate.Data[1][0] = temp.Data[1]*axis.Data[0] - s*axis.Data[2]
+	rotate.Data[1][1] = c + temp.Data[1]*axis.Data[1]
+	rotate.Data[1][2] = temp.Data[1]*axis.Data[2] + s*axis.Data[0]
+
+	rotate.Data[2][0] = temp.Data[2]*axis.Data[0] + s*axis.Data[1]
+	rotate.Data[2][1] = temp.Data[2]*axis.Data[1] - s*axis.Data[0]
+	rotate.Data[2][2] = c + temp.Data[2]*axis.Data[2]
+
+	result := &Mat4{}
+	result.Data[0] = t.Col(0).Scale(rotate.Data[0][0]).
+		Add(t.Col(1).Scale(rotate.Data[0][1])).
+		Add(t.Col(2).Scale(rotate.Data[0][2])).
+		Data
+
+	result.Data[1] = t.Col(0).Scale(rotate.Data[1][0]).
+		Add(t.Col(1).Scale(rotate.Data[1][1])).
+		Add(t.Col(2).Scale(rotate.Data[1][2])).
+		Data
+
+	result.Data[2] = t.Col(0).Scale(rotate.Data[2][0]).
+		Add(t.Col(1).Scale(rotate.Data[2][1])).
+		Add(t.Col(2).Scale(rotate.Data[2][2])).
+		Data
+
+	t.Data[0] = result.Data[0]
+	t.Data[1] = result.Data[1]
+	t.Data[2] = result.Data[2]
+}
+
+func (t *TrMat) Mul(m *TrMat) *TrMat {
+	t.Mat4.Mul(&m.Mat4)
+	return t
+}
+
+func (t *TrMat) Eq(m *TrMat) bool {
+	return t.Data == m.Data
+}
+
+func (t *TrMat) Clone() *TrMat {
+	return &TrMat{
+		Mat4: *t.Mat4.Clone(),
+	}
+}
+
+func NewTranslationMat(v *Vec3) *TrMat {
+	return &TrMat{
+		Mat4: Mat4{
+			Data: [4][4]float32{
+				{1, 0, 0, 0},
+				{0, 1, 0, 0},
+				{0, 0, 1, 0},
+				{v.Data[0], v.Data[1], v.Data[2], 1},
+			},
+		},
+	}
+}
+
+func NewScaleMat(v *Vec3) *TrMat {
+	return &TrMat{
+		Mat4: Mat4{
+			Data: [4][4]float32{
+				{v.Data[0], 0, 0, 0},
+				{0, v.Data[1], 0, 0},
+				{0, 0, v.Data[2], 0},
+				{0, 0, 0, 1},
+			},
+		},
+	}
+}
+
+func NewRotMat(q *Quat) *TrMat {
+
+	//Based on: https://www.weizmann.ac.il/sci-tea/benari/sites/sci-tea.benari/files/uploads/softwareAndLearningMaterials/quaternion-tutorial-2-0-1.pdf
+	//Note: in the reference p0,p1,p2,p3 == w,x,y,z
+
+	xx := q.Data[0] * q.Data[0]
+	yy := q.Data[1] * q.Data[1]
+	zz := q.Data[2] * q.Data[2]
+	ww := q.Data[3] * q.Data[3]
+
+	xy := q.Data[0] * q.Data[1]
+	xz := q.Data[0] * q.Data[2]
+	xw := q.Data[0] * q.Data[3]
+
+	yz := q.Data[1] * q.Data[2]
+	yw := q.Data[1] * q.Data[3]
+
+	zw := q.Data[2] * q.Data[3]
+
+	return &TrMat{
+		Mat4: Mat4{
+			Data: [4][4]float32{
+				{2*(ww+xx) - 1, 2 * (zw + xy), 2 * (xz - yw), 0},
+				{2 * (xy - zw), 2*(ww+yy) - 1, 2 * (xw + yz), 0},
+				{2 * (yw + xz), 2 * (yz - xw), 2*(ww+zz) - 1, 0},
+				{0, 0, 0, 1},
+			},
+		},
+	}
+}
+
+func LookAt(pos, targetPos, worldUp *Vec3) *TrMat {
+
+	forward := SubVec3(targetPos, pos).Normalize()
+	right := Cross(worldUp, forward).Normalize()
+	up := Cross(forward, right)
+
+	return &TrMat{
+		Mat4: Mat4{
+			Data: [4][4]float32{
+				{right.Data[0], up.Data[0], forward.Data[0], 0},
+				{right.Data[1], up.Data[1], forward.Data[1], 0},
+				{right.Data[2], up.Data[2], forward.Data[2], 0},
+				{-DotVec3(pos, right), -DotVec3(pos, up), DotVec3(pos, forward), 1},
+			},
+		},
+	}
+}
+
+//Perspective creates a perspective projection matrix
+func Perspective(fov, aspectRatio, nearClip, farClip float32) *Mat4 {
+	halfFovTan := float32(math.Tan(float64(fov * 0.5)))
+	return &Mat4{
+		Data: [4][4]float32{
+			{1 / (aspectRatio * halfFovTan), 0, 0, 0},
+			{0, 1 / halfFovTan, 0, 0},
+			{0, 0, -(nearClip + farClip) / (farClip - nearClip), -1},
+			{0, 0, -(2 * farClip * nearClip) / (farClip - nearClip), 0},
+		},
+	}
+}
+
+//Perspective creates an orthographic projection matrix
+func Ortho(left, right, top, bottom, nearClip, farClip float32) *TrMat {
+	return &TrMat{
+		Mat4: Mat4{
+			Data: [4][4]float32{
+				{2 / (right - left), 0, 0, 0},
+				{0, 2 / (top - bottom), 0, 0},
+				{0, 0, -2 / (farClip - nearClip), 0},
+				{-(right + left) / (right - left), -(top + bottom) / (top - bottom), -(farClip + nearClip) / (farClip - nearClip), 1},
+			},
+		},
+	}
+}
+
+func NewTrMatId() *TrMat {
+	return &TrMat{
+		Mat4: *NewMat4Id(),
+	}
+}

gglm/transform_test.go

@@ -0,0 +1,83 @@
+package gglm_test
+
+import (
+	"testing"
+
+	"github.com/bloeys/gglm/gglm"
+)
+
+func TestNewTrMatId(t *testing.T) {
+
+	m := gglm.NewTrMatId()
+	ans := &gglm.TrMat{
+		Mat4: gglm.Mat4{
+			Data: [4][4]float32{
+				{1, 0, 0, 0},
+				{0, 1, 0, 0},
+				{0, 0, 1, 0},
+				{0, 0, 0, 1},
+			},
+		},
+	}
+
+	if !m.Eq(ans) {
+		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
+	}
+}
+
+func TestNewTranslationMat(t *testing.T) {
+
+	m := gglm.NewTranslationMat(gglm.NewVec3(1, 2, 3))
+	ans := &gglm.TrMat{
+		Mat4: gglm.Mat4{
+			Data: [4][4]float32{
+				{1, 0, 0, 0},
+				{0, 1, 0, 0},
+				{0, 0, 1, 0},
+				{1, 2, 3, 1},
+			},
+		},
+	}
+
+	if !m.Eq(ans) {
+		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
+	}
+}
+
+func TestNewScaleMat(t *testing.T) {
+
+	m := gglm.NewScaleMat(gglm.NewVec3(1, 2, 3))
+	ans := &gglm.TrMat{
+		Mat4: gglm.Mat4{
+			Data: [4][4]float32{
+				{1, 0, 0, 0},
+				{0, 2, 0, 0},
+				{0, 0, 3, 0},
+				{0, 0, 0, 1},
+			},
+		},
+	}
+
+	if !m.Eq(ans) {
+		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
+	}
+}
+
+func TestNewRotMat(t *testing.T) {
+
+	m := gglm.NewRotMat(gglm.NewQuatId())
+	ans := &gglm.TrMat{
+		Mat4: gglm.Mat4{
+			Data: [4][4]float32{
+				{1, 0, 0, 0},
+				{0, 1, 0, 0},
+				{0, 0, 1, 0},
+				{0, 0, 0, 1},
+			},
+		},
+	}
+
+	if !m.Eq(ans) {
+		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
+	}
+}

gglm/vec2.go

@@ -51,21 +51,24 @@ func (v *Vec2) String() string {
 }
 
 //Scale v *= x (element wise multiplication)
-func (v *Vec2) Scale(x float32) {
+func (v *Vec2) Scale(x float32) *Vec2 {
 	v.Data[0] *= x
 	v.Data[1] *= x
+	return v
 }
 
 //Add v += v2
-func (v *Vec2) Add(v2 *Vec2) {
+func (v *Vec2) Add(v2 *Vec2) *Vec2 {
 	v.Data[0] += v2.X()
 	v.Data[1] += v2.Y()
+	return v
 }
 
 //SubVec2 v -= v2
-func (v *Vec2) Sub(v2 *Vec2) {
+func (v *Vec2) Sub(v2 *Vec2) *Vec2 {
 	v.Data[0] -= v2.X()
 	v.Data[1] -= v2.Y()
+	return v
 }
 
 //Mag returns the magnitude of the vector
@@ -93,6 +96,10 @@ func (v *Vec2) Normalize() {
 	v.Data[1] /= mag
 }
 
+func (v *Vec2) Clone() *Vec2 {
+	return &Vec2{Data: v.Data}
+}
+
 //AddVec2 v3 = v1 + v2
 func AddVec2(v1, v2 *Vec2) *Vec2 {
 	return &Vec2{
@@ -112,3 +119,12 @@ func SubVec2(v1, v2 *Vec2) *Vec2 {
 		},
 	}
 }
+
+func NewVec2(x, y float32) *Vec2 {
+	return &Vec2{
+		[2]float32{
+			x,
+			y,
+		},
+	}
+}

gglm/vec3.go

@@ -65,24 +65,27 @@ func (v *Vec3) String() string {
 }
 
 //Scale v *= x (element wise multiplication)
-func (v *Vec3) Scale(x float32) {
+func (v *Vec3) Scale(x float32) *Vec3 {
 	v.Data[0] *= x
 	v.Data[1] *= x
 	v.Data[2] *= x
+	return v
 }
 
-func (v *Vec3) Add(v2 *Vec3) {
+func (v *Vec3) Add(v2 *Vec3) *Vec3 {
 
 	v.Data[0] += v2.X()
 	v.Data[1] += v2.Y()
 	v.Data[2] += v2.Z()
+	return v
 }
 
 //SubVec3 v -= v2
-func (v *Vec3) Sub(v2 *Vec3) {
+func (v *Vec3) Sub(v2 *Vec3) *Vec3 {
 	v.Data[0] -= v2.X()
 	v.Data[1] -= v2.Y()
 	v.Data[2] -= v2.Z()
+	return v
 }
 
 //Mag returns the magnitude of the vector
@@ -105,11 +108,29 @@ func (v *Vec3) Set(x, y, z float32) {
 	v.Data[2] = z
 }
 
-func (v *Vec3) Normalize() {
+//Normalize normalizes this vector and returns it (doesn't copy)
+func (v *Vec3) Normalize() *Vec3 {
 	mag := float32(math.Sqrt(float64(v.X()*v.X() + v.Y()*v.Y() + v.Z()*v.Z())))
 	v.Data[0] /= mag
 	v.Data[1] /= mag
 	v.Data[2] /= mag
+
+	return v
+}
+
+func (v *Vec3) Clone() *Vec3 {
+	return &Vec3{Data: v.Data}
+}
+
+//AsRad returns a new vector with all values converted to Radians (i.e. multiplied by gglm.Deg2Rad)
+func (v *Vec3) AsRad() *Vec3 {
+	return &Vec3{
+		Data: [3]float32{
+			v.Data[0] * Deg2Rad,
+			v.Data[1] * Deg2Rad,
+			v.Data[2] * Deg2Rad,
+		},
+	}
 }
 
 //AddVec3 v3 = v1 + v2
@@ -133,3 +154,13 @@ func SubVec3(v1, v2 *Vec3) *Vec3 {
 		},
 	}
 }
+
+func NewVec3(x, y, z float32) *Vec3 {
+	return &Vec3{
+		[3]float32{
+			x,
+			y,
+			z,
+		},
+	}
+}

gglm/vec4.go

@@ -81,27 +81,29 @@ func (v *Vec4) String() string {
 }
 
 //Scale v *= x (element wise multiplication)
-func (v *Vec4) Scale(x float32) {
+func (v *Vec4) Scale(x float32) *Vec4 {
 	v.Data[0] *= x
 	v.Data[1] *= x
 	v.Data[2] *= x
 	v.Data[3] *= x
+	return v
 }
 
-func (v *Vec4) Add(v2 *Vec4) {
-
+func (v *Vec4) Add(v2 *Vec4) *Vec4 {
 	v.Data[0] += v2.X()
 	v.Data[1] += v2.Y()
 	v.Data[2] += v2.Z()
 	v.Data[3] += v2.W()
+	return v
 }
 
 //SubVec4 v -= v2
-func (v *Vec4) Sub(v2 *Vec4) {
+func (v *Vec4) Sub(v2 *Vec4) *Vec4 {
 	v.Data[0] -= v2.X()
 	v.Data[1] -= v2.Y()
 	v.Data[2] -= v2.Z()
 	v.Data[3] -= v2.W()
+	return v
 }
 
 //Mag returns the magnitude of the vector
@@ -133,6 +135,10 @@ func (v *Vec4) Normalize() {
 	v.Data[3] /= mag
 }
 
+func (v *Vec4) Clone() *Vec4 {
+	return &Vec4{Data: v.Data}
+}
+
 //AddVec4 v3 = v1 + v2
 func AddVec4(v1, v2 *Vec4) *Vec4 {
 	return &Vec4{
@@ -156,3 +162,14 @@ func SubVec4(v1, v2 *Vec4) *Vec4 {
 		},
 	}
 }
+
+func NewVec4(x, y, z, w float32) *Vec4 {
+	return &Vec4{
+		[4]float32{
+			x,
+			y,
+			z,
+			w,
+		},
+	}
+}

main.go

@@ -1,23 +1,27 @@
 package main
 
-import "github.com/bloeys/gglm/gglm"
+import (
+	"fmt"
+
+	"github.com/bloeys/gglm/gglm"
+)
 
 func main() {
 
 	//Mat3
 	m1 := &gglm.Mat3{
-		Data: [9]float32{
-			1, 2, 3,
-			4, 5, 6,
-			7, 8, 9,
+		Data: [3][3]float32{
+			{1, 4, 7},
+			{2, 5, 8},
+			{3, 6, 9},
 		},
 	}
 
 	m2 := &gglm.Mat3{
-		Data: [9]float32{
-			1, 2, 3,
-			1, 2, 3,
-			1, 2, 3,
+		Data: [3][3]float32{
+			{1, 1, 1},
+			{2, 2, 2},
+			{3, 3, 3},
 		},
 	}
 
@@ -28,20 +32,20 @@ func main() {
 
 	//Mat4
 	m4 := &gglm.Mat4{
-		Data: [16]float32{
-			1, 2, 3, 4,
-			5, 6, 7, 8,
-			9, 10, 11, 12,
-			13, 14, 15, 16,
+		Data: [4][4]float32{
+			{1, 5, 9, 13},
+			{2, 6, 10, 14},
+			{3, 7, 11, 15},
+			{4, 8, 12, 16},
 		},
 	}
 
 	m5 := &gglm.Mat4{
-		Data: [16]float32{
-			1, 2, 3, 4,
-			1, 2, 3, 4,
-			1, 2, 3, 4,
-			1, 2, 3, 4,
+		Data: [4][4]float32{
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
+			{1, 2, 3, 4},
 		},
 	}
 
@@ -96,4 +100,98 @@ func main() {
 	println("V6: " + v6.String())
 	v6.Normalize()
 	println("V6 Normal: " + v6.String())
+
+	//Mat2Vec2
+	mat2A := gglm.Mat2{
+		Data: [2][2]float32{
+			{1, 3},
+			{2, 4},
+		},
+	}
+
+	vec2A := gglm.Vec2{Data: [2]float32{1, 2}}
+	println(gglm.MulMat2Vec2(&mat2A, &vec2A).String())
+
+	//Mat3Vec3
+	mat3A := gglm.Mat3{
+		Data: [3][3]float32{
+			{1, 4, 7},
+			{2, 5, 8},
+			{3, 6, 9},
+		},
+	}
+
+	vec3A := gglm.Vec3{Data: [3]float32{1, 2, 3}}
+	mm3v3 := gglm.MulMat3Vec3(&mat3A, &vec3A)
+	println(mm3v3.String())
+
+	//ReflectVec2
+	vec2B := &gglm.Vec2{Data: [2]float32{4, 5}}
+	normA := &gglm.Vec2{Data: [2]float32{0, 1}}
+	rVec2A := gglm.ReflectVec2(vec2B, normA)
+	println(rVec2A.String())
+
+	//Quaternion
+	vRot := &gglm.Vec3{Data: [3]float32{60, 30, 20}}
+	q := gglm.NewQuatEuler(vRot.AsRad())
+	println("\n" + vRot.AsRad().String())
+	println(q.String(), "\n", q.Mag())
+
+	q = gglm.NewQuatAngleAxis(60*gglm.Deg2Rad, vRot.Normalize())
+	println("\n" + vRot.Normalize().String())
+	println(q.String())
+
+	//Transform
+	translationMat := gglm.NewTranslationMat(&gglm.Vec3{Data: [3]float32{1, 2, 3}})
+	rotMat := gglm.NewRotMat(gglm.NewQuatEuler(gglm.NewVec3(60, 30, 20).AsRad()))
+	scaleMat := gglm.NewScaleMat(gglm.NewVec3(1, 1, 1))
+
+	modelMat := gglm.NewTrMatId()
+	modelMat.Mul(translationMat.Mul(rotMat.Mul(scaleMat)))
+
+	println("\n\n\n", modelMat.String())
+
+	//Clone Vec2
+	v2Orig := gglm.Vec2{Data: [2]float32{1, 2}}
+	v2Clone := v2Orig.Clone()
+	v2Clone.SetX(99)
+	println("\n\n", v2Orig.String(), "; ", v2Clone.String())
+
+	//Clone TrMat
+	trMatOrig := gglm.NewTranslationMat(gglm.NewVec3(1, 2, 3))
+	trMatClone := trMatOrig.Clone()
+	trMatClone.Scale(gglm.NewVec3(2, 2, 2))
+	trMatClone.Translate(gglm.NewVec3(9, 0, 0))
+	println("\n\n", trMatOrig.String(), "; ", trMatClone.String())
+
+	//Quat geo
+	q1 := gglm.NewQuatEuler(gglm.NewVec3(180, 0, 0).AsRad())
+	q2 := gglm.NewQuatEuler(gglm.NewVec3(0, 180, 0).AsRad())
+	println(gglm.AngleQuat(q1, q2) * gglm.Rad2Deg)
+
+	//LookAt
+	camPos := gglm.NewVec3(0, 0, 3)
+	worldUp := gglm.NewVec3(0, 1, 0)
+	targetPos := gglm.NewVec3(0, 0, 0)
+	viewMat := gglm.LookAt(camPos, targetPos, worldUp)
+	println(viewMat.String())
+
+	//Mat2Col
+	mc := gglm.NewMat2Id()
+	println("===============================")
+	println(mc.String())
+
+	mc.Data = [2][2]float32{
+		{1, 3},
+		{2, 4},
+	}
+	println(mc.String())
+	fmt.Printf("Arr: %v", mc.Data)
+
+	mc2 := gglm.Mat2{Data: [2][2]float32{
+		{1, 3},
+		{2, 4},
+	}}
+
+	println(mc2.Mul(mc).String())
 }

main_test.go

@@ -1,73 +0,0 @@
-package main
-
-import (
-	"testing"
-
-	"github.com/bloeys/gglm/gglm"
-)
-
-var (
-	dotVec2Result float32 = 0
-	dotVec3Result float32 = 0
-	crossResult   *gglm.Vec3
-)
-
-func BenchmarkDotVec2(b *testing.B) {
-
-	v1 := &gglm.Vec2{}
-	v2 := &gglm.Vec2{}
-
-	for i := 0; i < b.N; i++ {
-		dotVec2Result = gglm.DotVec2(v1, v2)
-	}
-}
-
-func BenchmarkDotVec3(b *testing.B) {
-
-	v1 := &gglm.Vec3{}
-	v2 := &gglm.Vec3{}
-
-	for i := 0; i < b.N; i++ {
-		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)
-	}
-}