Matrix transpose

README.md

@@ -4,6 +4,7 @@ Fast OpenGL/Graphics focused Mathematics library in Go inspired by the c++ libra
 
 gglm currently has the following:
 
+- Matrices are stored column major
 - `Vec2`, `Vec3` and `Vec4` structs that implement vector (x,y,z,w) operations
 - `Mat2`, `Mat3`, `Mat4` structs that implement square matrix operations
 - `Quat` struct that implements quaternion operations

gglm/mat2.go

@@ -75,14 +75,24 @@ func (m *Mat2) Scale(x float32) *Mat2 {
 	return m
 }
 
-func (v *Mat2) Clone() *Mat2 {
+func (m *Mat2) Clone() *Mat2 {
-	return &Mat2{Data: v.Data}
+	return &Mat2{Data: m.Data}
 }
 
 func (m *Mat2) Eq(m2 *Mat2) bool {
 	return m.Data == m2.Data
 }
 
+func (m *Mat2) Transpose() *Mat2 {
+
+	m.Data = [2][2]float32{
+		{m.Data[0][0], m.Data[1][0]},
+		{m.Data[0][1], m.Data[1][1]},
+	}
+
+	return m
+}
+
 // AddMat2 m3 = m1 + m2
 func AddMat2(m1, m2 *Mat2) *Mat2 {
 	return &Mat2{

gglm/mat2_test.go

@@ -147,6 +147,38 @@ func TestMulMat2Vec2(t *testing.T) {
 	}
 }
 
+func TestTransposeMat2(t *testing.T) {
+
+	m := gglm.NewMat2Id()
+	ans := gglm.NewMat2Id()
+
+	if !m.Transpose().Transpose().Eq(ans) {
+		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
+	}
+
+	if !m.Transpose().Eq(ans) {
+		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
+	}
+
+	m = &gglm.Mat2{
+		Data: [2][2]float32{
+			{00, 01},
+			{10, 11},
+		},
+	}
+
+	ans = &gglm.Mat2{
+		Data: [2][2]float32{
+			{00, 10},
+			{01, 11},
+		},
+	}
+
+	if !m.Transpose().Eq(ans) {
+		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
+	}
+}
+
 func BenchmarkMulMat2(b *testing.B) {
 
 	m1 := gglm.NewMat2Id()

gglm/mat3.go

@@ -126,14 +126,25 @@ func (m *Mat3) Scale(x float32) *Mat3 {
 	return m
 }
 
-func (v *Mat3) Clone() *Mat3 {
+func (m *Mat3) Clone() *Mat3 {
-	return &Mat3{Data: v.Data}
+	return &Mat3{Data: m.Data}
 }
 
 func (m *Mat3) Eq(m2 *Mat3) bool {
 	return m.Data == m2.Data
 }
 
+func (m *Mat3) Transpose() *Mat3 {
+
+	m.Data = [3][3]float32{
+		{m.Data[0][0], m.Data[1][0], m.Data[2][0]},
+		{m.Data[0][1], m.Data[1][1], m.Data[2][1]},
+		{m.Data[0][2], m.Data[1][2], m.Data[2][2]},
+	}
+
+	return m
+}
+
 // AddMat3 m3 = m1 + m2
 func AddMat3(m1, m2 *Mat3) *Mat3 {
 	return &Mat3{

gglm/mat3_test.go

@@ -162,6 +162,40 @@ func TestMulMat3Vec3(t *testing.T) {
 	}
 }
 
+func TestTransposeMat3(t *testing.T) {
+
+	m := gglm.NewMat3Id()
+	ans := gglm.NewMat3Id()
+
+	if !m.Transpose().Transpose().Eq(ans) {
+		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
+	}
+
+	if !m.Transpose().Eq(ans) {
+		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
+	}
+
+	m = &gglm.Mat3{
+		Data: [3][3]float32{
+			{00, 01, 02},
+			{10, 11, 12},
+			{20, 21, 22},
+		},
+	}
+
+	ans = &gglm.Mat3{
+		Data: [3][3]float32{
+			{00, 10, 20},
+			{01, 11, 21},
+			{02, 12, 22},
+		},
+	}
+
+	if !m.Transpose().Eq(ans) {
+		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
+	}
+}
+
 func BenchmarkMulMat3(b *testing.B) {
 
 	m1 := gglm.NewMat3Id()

gglm/mat4.go

@@ -180,6 +180,18 @@ func (m *Mat4) Eq(m2 *Mat4) bool {
 	return m.Data == m2.Data
 }
 
+func (m *Mat4) Transpose() *Mat4 {
+
+	m.Data = [4][4]float32{
+		{m.Data[0][0], m.Data[1][0], m.Data[2][0], m.Data[3][0]},
+		{m.Data[0][1], m.Data[1][1], m.Data[2][1], m.Data[3][1]},
+		{m.Data[0][2], m.Data[1][2], m.Data[2][2], m.Data[3][2]},
+		{m.Data[0][3], m.Data[1][3], m.Data[2][3], m.Data[3][3]},
+	}
+
+	return m
+}
+
 // AddMat4 m3 = m1 + m2
 func AddMat4(m1, m2 *Mat4) *Mat4 {
 	return &Mat4{

gglm/mat4_test.go

@@ -182,6 +182,42 @@ func TestMulMat4Vec4(t *testing.T) {
 	}
 }
 
+func TestTransposeMat4(t *testing.T) {
+
+	m := gglm.NewMat4Id()
+	ans := gglm.NewMat4Id()
+
+	if !m.Transpose().Transpose().Eq(ans) {
+		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
+	}
+
+	if !m.Transpose().Eq(ans) {
+		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
+	}
+
+	m = &gglm.Mat4{
+		Data: [4][4]float32{
+			{00, 01, 02, 03},
+			{10, 11, 12, 13},
+			{20, 21, 22, 23},
+			{30, 31, 32, 33},
+		},
+	}
+
+	ans = &gglm.Mat4{
+		Data: [4][4]float32{
+			{00, 10, 20, 30},
+			{01, 11, 21, 31},
+			{02, 12, 22, 32},
+			{03, 13, 23, 33},
+		},
+	}
+
+	if !m.Transpose().Eq(ans) {
+		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
+	}
+}
+
 func BenchmarkMulMat4(b *testing.B) {
 
 	m1 := gglm.NewMat4Id()