NewXYZ funcs for Quat+github workflows

Get rid of pointer returns when creating new objects
2025-12-29 13:38:20 +00:00 · 2024-05-04 22:44:48 +04:00 · 2024-05-04 22:21:41 +04:00
18 changed files with 395 additions and 345 deletions
--- a/.github/workflows/test-gglm.yml
+++ b/.github/workflows/test-gglm.yml
@ -0,0 +1,21 @@
+name: test-gglm
+
+on:
+  create:
+  workflow_dispatch:
+
+jobs:
+  test-gglm:
+    runs-on: [windows-latest, macos-latest, ubuntu-latest]
+    steps:
+      - name: Install golang
+        uses: actions/setup-go@v3
+        with:
+          go-version: ">=1.17"
+
+      - name: Clone gglm
+        run: git clone https://github.com/bloeys/gglm
+
+      - name: Test gglm
+        working-directory: nmage
+        run: cd gglm && go test ./... -v
--- a/gglm/geometric.go
+++ b/gglm/geometric.go
@ -18,8 +18,8 @@ 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{
+func Cross(v1, v2 *Vec3) Vec3 {
+	return Vec3{
 		Data: [3]float32{
 			v1.Data[1]*v2.Data[2] - v1.Data[2]*v2.Data[1],
 			v1.Data[2]*v2.Data[0] - v1.Data[0]*v2.Data[2],
@ -81,12 +81,12 @@ func SqrDistVec4(v1, v2 *Vec4) float32 {
 // 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 {
+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{
+	return Vec2{
 		Data: [2]float32{
 			v.Data[0] - d*n.Data[0],
 			v.Data[1] - d*n.Data[1],
@ -97,12 +97,12 @@ func ReflectVec2(v, n *Vec2) *Vec2 {
 // 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 {
+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{
+	return Vec3{
 		Data: [3]float32{
 			v.Data[0] - d*n.Data[0],
 			v.Data[1] - d*n.Data[1],
--- a/gglm/geometric_test.go
+++ b/gglm/geometric_test.go
@ -9,8 +9,8 @@ import (
 var (
 	dotVec2Result, distVec2Result  float32
 	dotVec3Result, distVec3Result  float32
-	reflectVec2Result              *gglm.Vec2
-	crossResult, reflectVec3Result *gglm.Vec3
+	reflectVec2Result              gglm.Vec2
+	crossResult, reflectVec3Result gglm.Vec3
 )

 func TestDotVec2(t *testing.T) {
--- a/gglm/mat2.go
+++ b/gglm/mat2.go
@ -114,8 +114,8 @@ func (m *Mat2) Invert() *Mat2 {
 }

 // AddMat2 m3 = m1 + m2
-func AddMat2(m1, m2 *Mat2) *Mat2 {
-	return &Mat2{
+func AddMat2(m1, m2 *Mat2) Mat2 {
+	return Mat2{
 		Data: [2][2]float32{
 			{
 				m1.Data[0][0] + m2.Data[0][0],
@ -130,8 +130,8 @@ func AddMat2(m1, m2 *Mat2) *Mat2 {
 }

 // SubMat2 m3 = m1 - m2
-func SubMat2(m1, m2 *Mat2) *Mat2 {
-	return &Mat2{
+func SubMat2(m1, m2 *Mat2) Mat2 {
+	return Mat2{
 		Data: [2][2]float32{
 			{
 				m1.Data[0][0] - m2.Data[0][0],
@ -146,8 +146,8 @@ func SubMat2(m1, m2 *Mat2) *Mat2 {
 }

 // MulMat2 m3 = m1 * m2
-func MulMat2(m1, m2 *Mat2) *Mat2 {
-	return &Mat2{
+func MulMat2(m1, m2 *Mat2) Mat2 {
+	return Mat2{
 		Data: [2][2]float32{
 			{
 				m1.Data[0][0]*m2.Data[0][0] + m1.Data[1][0]*m2.Data[0][1],
@ -162,8 +162,8 @@ func MulMat2(m1, m2 *Mat2) *Mat2 {
 }

 // MulMat2Vec2 v2 = m1 * v1
-func MulMat2Vec2(m1 *Mat2, v1 *Vec2) *Vec2 {
-	return &Vec2{
+func MulMat2Vec2(m1 *Mat2, v1 *Vec2) Vec2 {
+	return Vec2{
 		Data: [2]float32{
 			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],
@ -172,8 +172,8 @@ func MulMat2Vec2(m1 *Mat2, v1 *Vec2) *Vec2 {
 }

 // NewMat2Id returns the 2x2 identity matrix
-func NewMat2Id() *Mat2 {
-	return &Mat2{
+func NewMat2Id() Mat2 {
+	return Mat2{
 		Data: [2][2]float32{
 			{1, 0},
 			{0, 1},
@ -181,8 +181,8 @@ func NewMat2Id() *Mat2 {
 	}
 }

-func NewMat2Diag(diagVal float32) *Mat2 {
-	return &Mat2{
+func NewMat2Diag(diagVal float32) Mat2 {
+	return Mat2{
 		Data: [2][2]float32{
 			{diagVal, 0},
 			{0, diagVal},
@ -190,8 +190,8 @@ func NewMat2Diag(diagVal float32) *Mat2 {
 	}
 }

-func NewMat2DiagArr(diag [2]float32) *Mat2 {
-	return &Mat2{
+func NewMat2DiagArr(diag [2]float32) Mat2 {
+	return Mat2{
 		Data: [2][2]float32{
 			{diag[0], 0},
 			{0, diag[1]},
@ -199,8 +199,8 @@ func NewMat2DiagArr(diag [2]float32) *Mat2 {
 	}
 }

-func NewMat2Vec2(col0, col1 *Vec2) *Mat2 {
-	return &Mat2{
+func NewMat2Vec2(col0, col1 *Vec2) Mat2 {
+	return Mat2{
 		Data: [2][2]float32{
 			col0.Data,
 			col1.Data,
@ -208,8 +208,8 @@ func NewMat2Vec2(col0, col1 *Vec2) *Mat2 {
 	}
 }

-func NewMat2Arr(col0, col1 [2]float32) *Mat2 {
-	return &Mat2{
+func NewMat2Arr(col0, col1 [2]float32) Mat2 {
+	return Mat2{
 		Data: [2][2]float32{
 			col0,
 			col1,
--- a/gglm/mat2_test.go
+++ b/gglm/mat2_test.go
@ -152,29 +152,25 @@ func TestTransposeMat2(t *testing.T) {
 	m := gglm.NewMat2Id()
 	ans := gglm.NewMat2Id()

-	if !m.Transpose().Transpose().Eq(ans) {
+	if !m.Transpose().Transpose().Eq(&ans) {
 		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
 	}

-	if !m.Transpose().Eq(ans) {
+	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},
-		},
+	m.Data = [2][2]float32{
+		{00, 01},
+		{10, 11},
 	}

-	ans = &gglm.Mat2{
-		Data: [2][2]float32{
-			{00, 10},
-			{01, 11},
-		},
+	ans.Data = [2][2]float32{
+		{00, 10},
+		{01, 11},
 	}

-	if !m.Transpose().Eq(ans) {
+	if !m.Transpose().Eq(&ans) {
 		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
 	}
 }
@ -188,11 +184,9 @@ func TestDeterminantMat2(t *testing.T) {
 		t.Errorf("Got: %f; Expected: %f", m.Determinant(), ans)
 	}

-	m = &gglm.Mat2{
-		Data: [2][2]float32{
-			{1, 8},
-			{5, 31},
-		},
+	m.Data = [2][2]float32{
+		{1, 8},
+		{5, 31},
 	}
 	ans = -9

@ -206,25 +200,21 @@ func TestInvertMat2(t *testing.T) {
 	m := gglm.NewMat2Id()
 	ans := gglm.NewMat2Id()

-	if !m.Invert().Eq(ans) {
+	if !m.Invert().Eq(&ans) {
 		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
 	}

-	m = &gglm.Mat2{
-		Data: [2][2]float32{
-			{1, 8},
-			{5, 31},
-		},
+	m.Data = [2][2]float32{
+		{1, 8},
+		{5, 31},
 	}

-	ans = &gglm.Mat2{
-		Data: [2][2]float32{
-			{-31 / 9.0, 8 / 9.0},
-			{5 / 9.0, -1 / 9.0},
-		},
+	ans.Data = [2][2]float32{
+		{-31 / 9.0, 8 / 9.0},
+		{5 / 9.0, -1 / 9.0},
 	}

-	if !m.Invert().Eq(ans) {
+	if !m.Invert().Eq(&ans) {
 		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
 	}
 }
@ -235,6 +225,6 @@ func BenchmarkMulMat2(b *testing.B) {
 	m2 := gglm.NewMat2Id()

 	for i := 0; i < b.N; i++ {
-		m1.Mul(m2)
+		m1.Mul(&m2)
 	}
 }
--- a/gglm/mat3.go
+++ b/gglm/mat3.go
@ -205,8 +205,8 @@ func (m *Mat3) ToMat2() Mat2 {
 }

 // AddMat3 m3 = m1 + m2
-func AddMat3(m1, m2 *Mat3) *Mat3 {
-	return &Mat3{
+func AddMat3(m1, m2 *Mat3) Mat3 {
+	return Mat3{
 		Data: [3][3]float32{
 			{
 				m1.Data[0][0] + m2.Data[0][0],
@ -228,8 +228,8 @@ func AddMat3(m1, m2 *Mat3) *Mat3 {
 }

 // SubMat3 m3 = m1 - m2
-func SubMat3(m1, m2 *Mat3) *Mat3 {
-	return &Mat3{
+func SubMat3(m1, m2 *Mat3) Mat3 {
+	return Mat3{
 		Data: [3][3]float32{
 			{
 				m1.Data[0][0] - m2.Data[0][0],
@ -251,7 +251,7 @@ func SubMat3(m1, m2 *Mat3) *Mat3 {
 }

 // MulMat3 m3 = m1 * m2
-func MulMat3(m1, m2 *Mat3) *Mat3 {
+func MulMat3(m1, m2 *Mat3) Mat3 {

 	m00 := m1.Data[0][0]
 	m01 := m1.Data[0][1]
@ -265,7 +265,7 @@ func MulMat3(m1, m2 *Mat3) *Mat3 {
 	m21 := m1.Data[2][1]
 	m22 := m1.Data[2][2]

-	return &Mat3{
+	return Mat3{
 		Data: [3][3]float32{
 			{
 				m00*m2.Data[0][0] + m10*m2.Data[0][1] + m20*m2.Data[0][2],
@ -287,8 +287,8 @@ func MulMat3(m1, m2 *Mat3) *Mat3 {
 }

 // MulMat3Vec3 v2 = m1 * v1
-func MulMat3Vec3(m1 *Mat3, v1 *Vec3) *Vec3 {
-	return &Vec3{
+func MulMat3Vec3(m1 *Mat3, v1 *Vec3) Vec3 {
+	return Vec3{
 		Data: [3]float32{
 			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],
@ -298,8 +298,8 @@ func MulMat3Vec3(m1 *Mat3, v1 *Vec3) *Vec3 {
 }

 // NewMat3Id returns the 3x3 identity matrix
-func NewMat3Id() *Mat3 {
-	return &Mat3{
+func NewMat3Id() Mat3 {
+	return Mat3{
 		Data: [3][3]float32{
 			{1, 0, 0},
 			{0, 1, 0},
@ -308,8 +308,8 @@ func NewMat3Id() *Mat3 {
 	}
 }

-func NewMat3Diag(diagVal float32) *Mat3 {
-	return &Mat3{
+func NewMat3Diag(diagVal float32) Mat3 {
+	return Mat3{
 		Data: [3][3]float32{
 			{diagVal, 0, 0},
 			{0, diagVal, 0},
@ -318,8 +318,8 @@ func NewMat3Diag(diagVal float32) *Mat3 {
 	}
 }

-func NewMat3DiagArr(diag [3]float32) *Mat3 {
-	return &Mat3{
+func NewMat3DiagArr(diag [3]float32) Mat3 {
+	return Mat3{
 		Data: [3][3]float32{
 			{diag[0], 0, 0},
 			{0, diag[1], 0},
@ -328,8 +328,8 @@ func NewMat3DiagArr(diag [3]float32) *Mat3 {
 	}
 }

-func NewMat3Vec3(col0, col1, col2 *Vec3) *Mat3 {
-	return &Mat3{
+func NewMat3Vec3(col0, col1, col2 *Vec3) Mat3 {
+	return Mat3{
 		Data: [3][3]float32{
 			col0.Data,
 			col1.Data,
@ -338,8 +338,8 @@ func NewMat3Vec3(col0, col1, col2 *Vec3) *Mat3 {
 	}
 }

-func NewMat3Arr(col0, col1, col2 [3]float32) *Mat3 {
-	return &Mat3{
+func NewMat3Arr(col0, col1, col2 [3]float32) Mat3 {
+	return Mat3{
 		Data: [3][3]float32{
 			col0,
 			col1,
--- a/gglm/mat3_test.go
+++ b/gglm/mat3_test.go
@ -167,31 +167,27 @@ func TestTransposeMat3(t *testing.T) {
 	m := gglm.NewMat3Id()
 	ans := gglm.NewMat3Id()

-	if !m.Transpose().Transpose().Eq(ans) {
+	if !m.Transpose().Transpose().Eq(&ans) {
 		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
 	}

-	if !m.Transpose().Eq(ans) {
+	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},
-		},
+	m.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},
-		},
+	ans.Data = [3][3]float32{
+		{00, 10, 20},
+		{01, 11, 21},
+		{02, 12, 22},
 	}

-	if !m.Transpose().Eq(ans) {
+	if !m.Transpose().Eq(&ans) {
 		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
 	}
 }
@ -205,12 +201,10 @@ func TestDeterminantMat3(t *testing.T) {
 		t.Errorf("Got: %f; Expected: %f", m.Determinant(), ans)
 	}

-	m = &gglm.Mat3{
-		Data: [3][3]float32{
-			{1, 8, 2},
-			{5, 3, 5},
-			{9, 6, 7},
-		},
+	m.Data = [3][3]float32{
+		{1, 8, 2},
+		{5, 3, 5},
+		{9, 6, 7},
 	}
 	ans = 77

@ -224,27 +218,23 @@ func TestInvertMat3(t *testing.T) {
 	m := gglm.NewMat3Id()
 	ans := gglm.NewMat3Id()

-	if !m.Invert().Eq(ans) {
+	if !m.Invert().Eq(&ans) {
 		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
 	}

-	m = &gglm.Mat3{
-		Data: [3][3]float32{
-			{1, 8, 2},
-			{5, 3, 5},
-			{9, 6, 7},
-		},
+	m.Data = [3][3]float32{
+		{1, 8, 2},
+		{5, 3, 5},
+		{9, 6, 7},
 	}

-	ans = &gglm.Mat3{
-		Data: [3][3]float32{
-			{-9 / 77.0, -4 / 7.0, 34 / 77.0},
-			{10 / 77.0, -1 / 7.0, 5 / 77.0},
-			{3 / 77.0, 6 / 7.0, -37 / 77.0},
-		},
+	ans.Data = [3][3]float32{
+		{-9 / 77.0, -4 / 7.0, 34 / 77.0},
+		{10 / 77.0, -1 / 7.0, 5 / 77.0},
+		{3 / 77.0, 6 / 7.0, -37 / 77.0},
 	}

-	if !m.Invert().Eq(ans) {
+	if !m.Invert().Eq(&ans) {
 		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
 	}
 }
@ -255,6 +245,6 @@ func BenchmarkMulMat3(b *testing.B) {
 	m2 := gglm.NewMat3Id()

 	for i := 0; i < b.N; i++ {
-		m1.Mul(m2)
+		m1.Mul(&m2)
 	}
 }
--- a/gglm/mat4.go
+++ b/gglm/mat4.go
@ -264,10 +264,10 @@ func (m *Mat4) Determinant() float32 {
 	signB := NewVec4(-1, +1, -1, +1)

 	inverse := NewMat4Arr(
-		inv0.ScaleVec(signA).Data,
-		inv1.ScaleVec(signB).Data,
-		inv2.ScaleVec(signA).Data,
-		inv3.ScaleVec(signB).Data,
+		inv0.ScaleVec(&signA).Data,
+		inv1.ScaleVec(&signB).Data,
+		inv2.ScaleVec(&signA).Data,
+		inv3.ScaleVec(&signB).Data,
 	)

 	row0 := NewVec4(inverse.Data[0][0], inverse.Data[1][0], inverse.Data[2][0], inverse.Data[3][0])
@ -353,10 +353,10 @@ func (m *Mat4) Invert() *Mat4 {
 	signB := NewVec4(-1, +1, -1, +1)

 	inverse := NewMat4Arr(
-		inv0.ScaleVec(signA).Data,
-		inv1.ScaleVec(signB).Data,
-		inv2.ScaleVec(signA).Data,
-		inv3.ScaleVec(signB).Data,
+		inv0.ScaleVec(&signA).Data,
+		inv1.ScaleVec(&signB).Data,
+		inv2.ScaleVec(&signA).Data,
+		inv3.ScaleVec(&signB).Data,
 	)

 	row0 := NewVec4(inverse.Data[0][0], inverse.Data[1][0], inverse.Data[2][0], inverse.Data[3][0])
@ -447,10 +447,10 @@ func (m *Mat4) InvertAndTranspose() *Mat4 {
 	signB := NewVec4(-1, +1, -1, +1)

 	inverse := NewMat4Arr(
-		inv0.ScaleVec(signA).Data,
-		inv1.ScaleVec(signB).Data,
-		inv2.ScaleVec(signA).Data,
-		inv3.ScaleVec(signB).Data,
+		inv0.ScaleVec(&signA).Data,
+		inv1.ScaleVec(&signB).Data,
+		inv2.ScaleVec(&signA).Data,
+		inv3.ScaleVec(&signB).Data,
 	)

 	row0 := NewVec4(inverse.Data[0][0], inverse.Data[1][0], inverse.Data[2][0], inverse.Data[3][0])
@ -495,8 +495,8 @@ func (m *Mat4) ToMat3() Mat3 {
 }

 // AddMat4 m3 = m1 + m2
-func AddMat4(m1, m2 *Mat4) *Mat4 {
-	return &Mat4{
+func AddMat4(m1, m2 *Mat4) Mat4 {
+	return Mat4{
 		Data: [4][4]float32{
 			{
 				m1.Data[0][0] + m2.Data[0][0],
@ -527,8 +527,8 @@ func AddMat4(m1, m2 *Mat4) *Mat4 {
 }

 // SubMat4 m3 = m1 - m2
-func SubMat4(m1, m2 *Mat4) *Mat4 {
-	return &Mat4{
+func SubMat4(m1, m2 *Mat4) Mat4 {
+	return Mat4{
 		Data: [4][4]float32{
 			{
 				m1.Data[0][0] - m2.Data[0][0],
@ -559,7 +559,7 @@ func SubMat4(m1, m2 *Mat4) *Mat4 {
 }

 // MulMat4 m3 = m1 * m2
-func MulMat4(m1, m2 *Mat4) *Mat4 {
+func MulMat4(m1, m2 *Mat4) Mat4 {

 	m00 := m1.Data[0][0]
 	m01 := m1.Data[0][1]
@ -581,7 +581,7 @@ func MulMat4(m1, m2 *Mat4) *Mat4 {
 	m32 := m1.Data[3][2]
 	m33 := m1.Data[3][3]

-	return &Mat4{
+	return Mat4{
 		Data: [4][4]float32{
 			{
 				m00*m2.Data[0][0] + m10*m2.Data[0][1] + m20*m2.Data[0][2] + m30*m2.Data[0][3],
@ -612,8 +612,8 @@ func MulMat4(m1, m2 *Mat4) *Mat4 {
 }

 // MulMat4Vec4 v2 = m1 * v1
-func MulMat4Vec4(m1 *Mat4, v1 *Vec4) *Vec4 {
-	return &Vec4{
+func MulMat4Vec4(m1 *Mat4, v1 *Vec4) Vec4 {
+	return Vec4{
 		Data: [4]float32{
 			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],
@ -624,8 +624,8 @@ func MulMat4Vec4(m1 *Mat4, v1 *Vec4) *Vec4 {
 }

 // NewMat4Id returns the 4x4 identity matrix
-func NewMat4Id() *Mat4 {
-	return &Mat4{
+func NewMat4Id() Mat4 {
+	return Mat4{
 		Data: [4][4]float32{
 			{1, 0, 0, 0},
 			{0, 1, 0, 0},
@ -635,8 +635,8 @@ func NewMat4Id() *Mat4 {
 	}
 }

-func NewMat4Diag(diagVal float32) *Mat4 {
-	return &Mat4{
+func NewMat4Diag(diagVal float32) Mat4 {
+	return Mat4{
 		Data: [4][4]float32{
 			{diagVal, 0, 0, 0},
 			{0, diagVal, 0, 0},
@ -646,8 +646,8 @@ func NewMat4Diag(diagVal float32) *Mat4 {
 	}
 }

-func NewMat4DiagArr(diag [4]float32) *Mat4 {
-	return &Mat4{
+func NewMat4DiagArr(diag [4]float32) Mat4 {
+	return Mat4{
 		Data: [4][4]float32{
 			{diag[0], 0, 0, 0},
 			{0, diag[1], 0, 0},
@ -657,8 +657,8 @@ func NewMat4DiagArr(diag [4]float32) *Mat4 {
 	}
 }

-func NewMat4Vec4(col0, col1, col2, col3 *Vec4) *Mat4 {
-	return &Mat4{
+func NewMat4Vec4(col0, col1, col2, col3 *Vec4) Mat4 {
+	return Mat4{
 		Data: [4][4]float32{
 			col0.Data,
 			col1.Data,
--- a/gglm/mat4_test.go
+++ b/gglm/mat4_test.go
@ -7,7 +7,7 @@ import (
 )

 var (
-	mulMat4Vec4Res *gglm.Vec4
+	mulMat4Vec4Res gglm.Vec4
 )

 func TestMat4GetSet(t *testing.T) {
@ -187,33 +187,29 @@ func TestTransposeMat4(t *testing.T) {
 	m := gglm.NewMat4Id()
 	ans := gglm.NewMat4Id()

-	if !m.Transpose().Transpose().Eq(ans) {
+	if !m.Transpose().Transpose().Eq(&ans) {
 		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
 	}

-	if !m.Transpose().Eq(ans) {
+	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},
-		},
+	m.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},
-		},
+	ans.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) {
+	if !m.Transpose().Eq(&ans) {
 		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
 	}
 }
@ -227,13 +223,11 @@ func TestDeterminantMat4(t *testing.T) {
 		t.Errorf("Got: %f; Expected: %f", m.Determinant(), ans)
 	}

-	m = &gglm.Mat4{
-		Data: [4][4]float32{
-			{1, 0, 2, 1},
-			{2, 1, 3, 0},
-			{3, 0, 4, 1},
-			{4, 1, 5, 1},
-		},
+	m.Data = [4][4]float32{
+		{1, 0, 2, 1},
+		{2, 1, 3, 0},
+		{3, 0, 4, 1},
+		{4, 1, 5, 1},
 	}
 	ans = -2

@ -247,29 +241,25 @@ func TestInvertMat4(t *testing.T) {
 	m := gglm.NewMat4Id()
 	ans := gglm.NewMat4Id()

-	if !m.Invert().Eq(ans) {
+	if !m.Invert().Eq(&ans) {
 		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
 	}

-	m = &gglm.Mat4{
-		Data: [4][4]float32{
-			{1, 0, 2, 1},
-			{2, 1, 3, 0},
-			{3, 0, 4, 1},
-			{4, 1, 5, 1},
-		},
+	m.Data = [4][4]float32{
+		{1, 0, 2, 1},
+		{2, 1, 3, 0},
+		{3, 0, 4, 1},
+		{4, 1, 5, 1},
 	}

-	ans = &gglm.Mat4{
-		Data: [4][4]float32{
-			{-1, -1, 0, 1},
-			{0.5, 0, -3 / 2.0, 1},
-			{0.5, 1, 0.5, -1},
-			{1, -1, -1, 1},
-		},
+	ans.Data = [4][4]float32{
+		{-1, -1, 0, 1},
+		{0.5, 0, -3 / 2.0, 1},
+		{0.5, 1, 0.5, -1},
+		{1, -1, -1, 1},
 	}

-	if !m.Invert().Eq(ans) {
+	if !m.Invert().Eq(&ans) {
 		t.Errorf("Got: %v\nExpected: %v;\n", m.String(), ans.String())
 	}
 }
@ -277,28 +267,25 @@ func TestInvertMat4(t *testing.T) {
 func TestInvertAndTransposeMat4(t *testing.T) {

 	m := gglm.NewMat4Id()
-	ans := gglm.NewMat4Id().Transpose()
+	ans := gglm.NewMat4Id()
+	ans.Transpose()

-	if !m.InvertAndTranspose().Eq(ans) {
+	if !m.InvertAndTranspose().Eq(&ans) {
 		t.Errorf("Got: %v; Expected: %v", m.String(), ans.String())
 	}

-	m = &gglm.Mat4{
-		Data: [4][4]float32{
-			{1, 0, 2, 1},
-			{2, 1, 3, 0},
-			{3, 0, 4, 1},
-			{4, 1, 5, 1},
-		},
+	m.Data = [4][4]float32{
+		{1, 0, 2, 1},
+		{2, 1, 3, 0},
+		{3, 0, 4, 1},
+		{4, 1, 5, 1},
 	}

-	ans = &gglm.Mat4{
-		Data: [4][4]float32{
-			{-1, -1, 0, 1},
-			{0.5, 0, -3 / 2.0, 1},
-			{0.5, 1, 0.5, -1},
-			{1, -1, -1, 1},
-		},
+	ans.Data = [4][4]float32{
+		{-1, -1, 0, 1},
+		{0.5, 0, -3 / 2.0, 1},
+		{0.5, 1, 0.5, -1},
+		{1, -1, -1, 1},
 	}

 	if !m.InvertAndTranspose().Eq(ans.Transpose()) {
@ -312,7 +299,7 @@ func BenchmarkMulMat4(b *testing.B) {
 	m2 := gglm.NewMat4Id()

 	for i := 0; i < b.N; i++ {
-		m1.Mul(m2)
+		m1.Mul(&m2)
 	}
 }

@ -322,6 +309,17 @@ func BenchmarkMulMat4Vec4(b *testing.B) {
 	v1 := gglm.Vec4{}

 	for i := 0; i < b.N; i++ {
-		mulMat4Vec4Res = gglm.MulMat4Vec4(m1, &v1)
+		mulMat4Vec4Res = gglm.MulMat4Vec4(&m1, &v1)
+	}
+}
+
+var mat4InvertRes *gglm.Mat4
+
+func BenchmarkMat4Invert(b *testing.B) {
+
+	m1 := gglm.NewMat4Id()
+
+	for i := 0; i < b.N; i++ {
+		mat4InvertRes = m1.Invert()
 	}
 }
--- a/gglm/quat.go
+++ b/gglm/quat.go
@ -32,51 +32,30 @@ func (q *Quat) Angle() float32 {
 }

 // Axis returns the rotation axis represented by this quaternion
-func (q *Quat) Axis() *Vec3 {
+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}}
+		return Vec3{Data: [3]float32{0, 0, 1}}
 	}

 	t = 1 / Sqrt32(t)
-	return &Vec3{Data: [3]float32{
+	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
+// NewQuatEulerVec 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,
-			},
-		},
-	}
+func NewQuatEulerVec(v *Vec3) Quat {
+	return NewQuatEuler(v.X(), v.Y(), v.Z())
 }

-// Euler takes rotations in radians and produces a rotation that
+// NewQuatEuler takes rotations in radians and produces a rotation that
 // rotates around the z-axis, y-axis and lastly x-axis.
-func NewQuatEulerXYZ(x, y, z float32) *Quat {
+func NewQuatEuler(x, y, z float32) Quat {

 	//Some other common terminology: x=roll, y=pitch, z=yaw
 	sinX, cosX := Sincos32(x * 0.5)
@ -89,7 +68,7 @@ func NewQuatEulerXYZ(x, y, z float32) *Quat {
 	//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{
+	return Quat{
 		Vec4: Vec4{
 			Data: [4]float32{
 				sinX*cosY*cosZ - cosX*sinY*sinZ,
@ -101,26 +80,55 @@ func NewQuatEulerXYZ(x, y, z float32) *Quat {
 	}
 }

+// NewQuatAngleAxisVec produces a quaternion thats rotates rotRad radians around the *normalized* vector rotAxisNorm
+func NewQuatAngleAxisVec(rotRad float32, rotAxisNorm *Vec3) Quat {
+	return NewQuatAngleAxis(rotRad, rotAxisNorm.X(), rotAxisNorm.Y(), rotAxisNorm.Z())
+}
+
 // NewQuatAngleAxis produces a quaternion thats rotates rotRad radians around the *normalized* vector rotAxisNorm
-func NewQuatAngleAxis(rotRad float32, rotAxisNorm *Vec3) *Quat {
+func NewQuatAngleAxis(rotRad float32, rotAxisNormX, rotAxisNormY, rotAxisNormZ float32) Quat {

 	s, c := Sincos32(rotRad * 0.5)
-	return &Quat{
+	return Quat{
 		Vec4: Vec4{
 			Data: [4]float32{
-				rotAxisNorm.Data[0] * s,
-				rotAxisNorm.Data[1] * s,
-				rotAxisNorm.Data[2] * s,
+				rotAxisNormX * s,
+				rotAxisNormY * s,
+				rotAxisNormZ * s,
 				c,
 			},
 		},
 	}
 }

-func NewQuatId() *Quat {
-	return &Quat{
+func NewQuatId() Quat {
+	return Quat{
 		Vec4: Vec4{
 			Data: [4]float32{0, 0, 0, 1},
 		},
 	}
 }
+
+func NewQuat(x, y, z, w float32) Quat {
+	return Quat{
+		Vec4: Vec4{
+			Data: [4]float32{x, y, z, w},
+		},
+	}
+}
+
+func NewQuatArr(arr [4]float32) Quat {
+	return Quat{
+		Vec4: Vec4{
+			Data: arr,
+		},
+	}
+}
+
+func NewQuatVec(v *Vec4) Quat {
+	return Quat{
+		Vec4: Vec4{
+			Data: v.Data,
+		},
+	}
+}
--- a/gglm/quat_test.go
+++ b/gglm/quat_test.go
@ -8,14 +8,16 @@ import (

 func TestNewQuatEuler(t *testing.T) {

-	q := gglm.NewQuatEuler(gglm.NewVec3(180, 180, 180).AsRad())
-	ans := &gglm.Quat{Vec4: *gglm.NewVec4(0, 0, 0, 1)}
+	degs := gglm.NewVec3(180, 180, 180)
+	degs.Data = degs.AsRad().Data
+	q := gglm.NewQuatEulerVec(&degs)
+	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())
 	}

-	q = gglm.NewQuatEulerXYZ(180*gglm.Deg2Rad, 180*gglm.Deg2Rad, 180*gglm.Deg2Rad)
+	q = gglm.NewQuatEuler(180*gglm.Deg2Rad, 180*gglm.Deg2Rad, 180*gglm.Deg2Rad)

 	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())
@ -24,8 +26,9 @@ func TestNewQuatEuler(t *testing.T) {

 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)}
+	rotAxis := gglm.NewVec3(0, 1, 0)
+	q := gglm.NewQuatAngleAxisVec(180*gglm.Deg2Rad, &rotAxis)
+	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())
@ -34,21 +37,27 @@ func TestNewQuatAngleAxis(t *testing.T) {

 func TestQuatAngle(t *testing.T) {

-	a := gglm.NewQuatAngleAxis(180*gglm.Deg2Rad, gglm.NewVec3(0, 1, 0)).Angle()
+	rotAxis := gglm.NewVec3(0, 1, 0)
+	quat := gglm.NewQuatAngleAxisVec(180*gglm.Deg2Rad, &rotAxis)
+	a := quat.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()
+	rotAxis = gglm.NewVec3(1, 1, 0)
+	quat = gglm.NewQuatAngleAxisVec(90*gglm.Deg2Rad, rotAxis.Normalize())
+	a = quat.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()
+	rotAxis = gglm.NewVec3(1, 1, 0)
+	quat = gglm.NewQuatAngleAxisVec(125*gglm.Deg2Rad, rotAxis.Normalize())
+	a = quat.Angle()
 	ans = 125 * gglm.Deg2Rad

 	if !gglm.EqF32(a, ans) {
@ -58,22 +67,30 @@ func TestQuatAngle(t *testing.T) {

 func TestQuatAxis(t *testing.T) {

-	a := gglm.NewQuatAngleAxis(1, gglm.NewVec3(0, 1, 0)).Axis()
+	rotAxis := gglm.NewVec3(0, 1, 0)
+	quat := gglm.NewQuatAngleAxisVec(1, &rotAxis)
+	a := quat.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()
+	rotAxis = gglm.NewVec3(1, 1, 0)
+	quat = gglm.NewQuatAngleAxisVec(1, rotAxis.Normalize())
+	a = quat.Axis()
+	ans = gglm.NewVec3(1, 1, 0)
+	ans.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()
+	rotAxis = gglm.NewVec3(67, 46, 32)
+	quat = gglm.NewQuatAngleAxisVec(1, rotAxis.Normalize())
+	a = quat.Axis()
+	ans = gglm.NewVec3(67, 46, 32)
+	ans.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/transform.go
+++ b/gglm/transform.go
@ -149,9 +149,11 @@ func NewRotMat(q *Quat) *TrMat {
 // Can be used to create the view matrix
 func LookAtRH(pos, targetPos, worldUp *Vec3) *TrMat {

-	forward := SubVec3(targetPos, pos).Normalize()
-	right := Cross(forward, worldUp).Normalize()
-	up := Cross(right, forward)
+	forward := SubVec3(targetPos, pos)
+	forward.Normalize()
+	right := Cross(&forward, worldUp)
+	right.Normalize()
+	up := Cross(&right, &forward)

 	return &TrMat{
 		Mat4: Mat4{
@ -159,7 +161,7 @@ func LookAtRH(pos, targetPos, worldUp *Vec3) *TrMat {
 				{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},
+				{-DotVec3(pos, &right), -DotVec3(pos, &up), DotVec3(pos, &forward), 1},
 			},
 		},
 	}
@ -169,9 +171,11 @@ func LookAtRH(pos, targetPos, worldUp *Vec3) *TrMat {
 // Can be used to create the view matrix
 func LookAtLH(pos, targetPos, worldUp *Vec3) *TrMat {

-	forward := SubVec3(targetPos, pos).Normalize()
-	right := Cross(worldUp, forward).Normalize()
-	up := Cross(forward, right)
+	forward := SubVec3(targetPos, pos)
+	forward.Normalize()
+	right := Cross(worldUp, &forward)
+	right.Normalize()
+	up := Cross(&forward, &right)

 	return &TrMat{
 		Mat4: Mat4{
@ -179,7 +183,7 @@ func LookAtLH(pos, targetPos, worldUp *Vec3) *TrMat {
 				{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},
+				{-DotVec3(pos, &right), -DotVec3(pos, &up), -DotVec3(pos, &forward), 1},
 			},
 		},
 	}
@ -212,8 +216,8 @@ func Ortho(left, right, top, bottom, nearClip, farClip float32) *TrMat {
 	}
 }

-func NewTrMatId() *TrMat {
-	return &TrMat{
-		Mat4: *NewMat4Id(),
+func NewTrMatId() TrMat {
+	return TrMat{
+		Mat4: NewMat4Id(),
 	}
 }
--- a/gglm/transform_test.go
+++ b/gglm/transform_test.go
@ -27,7 +27,8 @@ func TestNewTrMatId(t *testing.T) {

 func TestNewTranslationMat(t *testing.T) {

-	m := gglm.NewTranslationMat(gglm.NewVec3(1, 2, 3))
+	pos := gglm.NewVec3(1, 2, 3)
+	m := gglm.NewTranslationMat(&pos)
 	ans := &gglm.TrMat{
 		Mat4: gglm.Mat4{
 			Data: [4][4]float32{
@ -46,7 +47,8 @@ func TestNewTranslationMat(t *testing.T) {

 func TestNewScaleMat(t *testing.T) {

-	m := gglm.NewScaleMat(gglm.NewVec3(1, 2, 3))
+	pos := gglm.NewVec3(1, 2, 3)
+	m := gglm.NewScaleMat(&pos)
 	ans := &gglm.TrMat{
 		Mat4: gglm.Mat4{
 			Data: [4][4]float32{
@ -65,7 +67,8 @@ func TestNewScaleMat(t *testing.T) {

 func TestNewRotMat(t *testing.T) {

-	m := gglm.NewRotMat(gglm.NewQuatId())
+	quat := gglm.NewQuatId()
+	m := gglm.NewRotMat(&quat)
 	ans := &gglm.TrMat{
 		Mat4: gglm.Mat4{
 			Data: [4][4]float32{
--- a/gglm/vec2.go
+++ b/gglm/vec2.go
@ -151,8 +151,8 @@ func (v *Vec2) Clone() *Vec2 {
 }

 // AddVec2 v3 = v1 + v2
-func AddVec2(v1, v2 *Vec2) *Vec2 {
-	return &Vec2{
+func AddVec2(v1, v2 *Vec2) Vec2 {
+	return Vec2{
 		Data: [2]float32{
 			v1.X() + v2.X(),
 			v1.Y() + v2.Y(),
@ -161,8 +161,8 @@ func AddVec2(v1, v2 *Vec2) *Vec2 {
 }

 // SubVec2 v3 = v1 - v2
-func SubVec2(v1, v2 *Vec2) *Vec2 {
-	return &Vec2{
+func SubVec2(v1, v2 *Vec2) Vec2 {
+	return Vec2{
 		Data: [2]float32{
 			v1.X() - v2.X(),
 			v1.Y() - v2.Y(),
@ -170,8 +170,8 @@ func SubVec2(v1, v2 *Vec2) *Vec2 {
 	}
 }

-func NewVec2(x, y float32) *Vec2 {
-	return &Vec2{
+func NewVec2(x, y float32) Vec2 {
+	return Vec2{
 		[2]float32{
 			x,
 			y,
@ -179,8 +179,8 @@ func NewVec2(x, y float32) *Vec2 {
 	}
 }

-func NewVec2Arr(arr [2]float32) *Vec2 {
-	return &Vec2{
+func NewVec2Arr(arr [2]float32) Vec2 {
+	return Vec2{
 		Data: arr,
 	}
 }
--- a/gglm/vec3.go
+++ b/gglm/vec3.go
@ -213,11 +213,12 @@ func (v *Vec3) RotByQuat(q *Quat) *Vec3 {
 	// vprime = t1 + t2 + t3

 	u := NewVec3(q.X(), q.Y(), q.Z())
-	t1 := u.Clone().Scale(2 * DotVec3(u, v))
-	t2 := v.Clone().Scale(q.W()*q.W() - DotVec3(u, u))
-	t3 := Cross(u, v).Scale(2 * q.W())
+	t1 := u.Clone().Scale(2 * DotVec3(&u, v))
+	t2 := v.Clone().Scale(q.W()*q.W() - DotVec3(&u, &u))
+	t3 := Cross(&u, v)
+	t3.Scale(2 * q.W())

-	v.Data = t1.Add(t2).Add(t3).Data
+	v.Data = t1.Add(t2).Add(&t3).Data
 	return v
 }

@ -237,8 +238,8 @@ func (v *Vec3) AsRad() *Vec3 {
 }

 // AddVec3 v3 = v1 + v2
-func AddVec3(v1, v2 *Vec3) *Vec3 {
-	return &Vec3{
+func AddVec3(v1, v2 *Vec3) Vec3 {
+	return Vec3{
 		Data: [3]float32{
 			v1.X() + v2.X(),
 			v1.Y() + v2.Y(),
@ -248,8 +249,8 @@ func AddVec3(v1, v2 *Vec3) *Vec3 {
 }

 // SubVec3 v3 = v1 - v2
-func SubVec3(v1, v2 *Vec3) *Vec3 {
-	return &Vec3{
+func SubVec3(v1, v2 *Vec3) Vec3 {
+	return Vec3{
 		Data: [3]float32{
 			v1.X() - v2.X(),
 			v1.Y() - v2.Y(),
@ -258,8 +259,8 @@ func SubVec3(v1, v2 *Vec3) *Vec3 {
 	}
 }

-func NewVec3(x, y, z float32) *Vec3 {
-	return &Vec3{
+func NewVec3(x, y, z float32) Vec3 {
+	return Vec3{
 		[3]float32{
 			x,
 			y,
@ -268,8 +269,8 @@ func NewVec3(x, y, z float32) *Vec3 {
 	}
 }

-func NewVec3Arr(arr [3]float32) *Vec3 {
-	return &Vec3{
+func NewVec3Arr(arr [3]float32) Vec3 {
+	return Vec3{
 		Data: arr,
 	}
 }
--- a/gglm/vec4.go
+++ b/gglm/vec4.go
@ -262,8 +262,8 @@ func (v *Vec4) Clone() *Vec4 {
 }

 // AddVec4 v3 = v1 + v2
-func AddVec4(v1, v2 *Vec4) *Vec4 {
-	return &Vec4{
+func AddVec4(v1, v2 *Vec4) Vec4 {
+	return Vec4{
 		Data: [4]float32{
 			v1.X() + v2.X(),
 			v1.Y() + v2.Y(),
@ -274,8 +274,8 @@ func AddVec4(v1, v2 *Vec4) *Vec4 {
 }

 // SubVec4 v3 = v1 - v2
-func SubVec4(v1, v2 *Vec4) *Vec4 {
-	return &Vec4{
+func SubVec4(v1, v2 *Vec4) Vec4 {
+	return Vec4{
 		Data: [4]float32{
 			v1.X() - v2.X(),
 			v1.Y() - v2.Y(),
@ -285,8 +285,8 @@ func SubVec4(v1, v2 *Vec4) *Vec4 {
 	}
 }

-func NewVec4(x, y, z, w float32) *Vec4 {
-	return &Vec4{
+func NewVec4(x, y, z, w float32) Vec4 {
+	return Vec4{
 		[4]float32{
 			x,
 			y,
@ -296,8 +296,8 @@ func NewVec4(x, y, z, w float32) *Vec4 {
 	}
 }

-func NewVec4Arr(arr [4]float32) *Vec4 {
-	return &Vec4{
+func NewVec4Arr(arr [4]float32) Vec4 {
+	return Vec4{
 		Data: arr,
 	}
 }
--- a/gglm/vec_test.go
+++ b/gglm/vec_test.go
@ -107,7 +107,7 @@ func TestVecSwizzleSet(t *testing.T) {

 	v2.SetX(1)
 	v2.SetY(2)
-	if !v2.Eq(ans2) {
+	if !v2.Eq(&ans2) {
 		t.Errorf("Got: %v; Expected: %v", v2.String(), ans2.String())
 	}

@ -116,7 +116,7 @@ func TestVecSwizzleSet(t *testing.T) {

 	v2.SetR(11)
 	v2.SetG(22)
-	if !v2.Eq(ans2) {
+	if !v2.Eq(&ans2) {
 		t.Errorf("Got: %v; Expected: %v", v2.String(), ans2.String())
 	}

@ -124,7 +124,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	ans2 = gglm.NewVec2(1, 2)

 	v2.SetXY(1, 2)
-	if !v2.Eq(ans2) {
+	if !v2.Eq(&ans2) {
 		t.Errorf("Got: %v; Expected: %v", v2.String(), ans2.String())
 	}

@ -132,7 +132,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	ans2 = gglm.NewVec2(11, 22)

 	v2.SetRG(11, 22)
-	if !v2.Eq(ans2) {
+	if !v2.Eq(&ans2) {
 		t.Errorf("Got: %v; Expected: %v", v2.String(), ans2.String())
 	}

@ -144,7 +144,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	v3.SetY(2)
 	v3.SetZ(3)

-	if !v3.Eq(ans3) {
+	if !v3.Eq(&ans3) {
 		t.Errorf("Got: %v; Expected: %v", v3.String(), ans3.String())
 	}

@ -155,7 +155,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	v3.SetG(22)
 	v3.SetB(33)

-	if !v3.Eq(ans3) {
+	if !v3.Eq(&ans3) {
 		t.Errorf("Got: %v; Expected: %v", v3.String(), ans3.String())
 	}

@ -163,7 +163,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	ans3 = gglm.NewVec3(1, 2, 1)

 	v3.SetXY(1, 2)
-	if !v3.Eq(ans3) {
+	if !v3.Eq(&ans3) {
 		t.Errorf("Got: %v; Expected: %v", v3.String(), ans3.String())
 	}

@ -171,7 +171,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	ans3 = gglm.NewVec3(1, 2, 1)

 	v3.SetRG(1, 2)
-	if !v3.Eq(ans3) {
+	if !v3.Eq(&ans3) {
 		t.Errorf("Got: %v; Expected: %v", v3.String(), ans3.String())
 	}

@ -179,7 +179,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	ans3 = gglm.NewVec3(1, 2, 3)

 	v3.SetXYZ(1, 2, 3)
-	if !v3.Eq(ans3) {
+	if !v3.Eq(&ans3) {
 		t.Errorf("Got: %v; Expected: %v", v3.String(), ans3.String())
 	}

@ -187,7 +187,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	ans3 = gglm.NewVec3(1, 2, 3)

 	v3.SetRGB(1, 2, 3)
-	if !v3.Eq(ans3) {
+	if !v3.Eq(&ans3) {
 		t.Errorf("Got: %v; Expected: %v", v3.String(), ans3.String())
 	}

@ -195,21 +195,23 @@ func TestVecSwizzleSet(t *testing.T) {
 	v3 = gglm.NewVec3(1, 0, 0)
 	v32 := gglm.NewVec3(1, 0, 0)

-	angleV3 := gglm.AngleVec3(v3, v32) * gglm.Rad2Deg
+	angleV3 := gglm.AngleVec3(&v3, &v32) * gglm.Rad2Deg
 	if angleV3 != 0 {
 		t.Errorf("Got: %v; Expected: %v", v3.String(), 0)
 	}

 	v32.SetXY(0, 1)
-	angleV3 = gglm.AngleVec3(v3, v32) * gglm.Rad2Deg
+	angleV3 = gglm.AngleVec3(&v3, &v32) * gglm.Rad2Deg
 	if angleV3 != 90 {
 		t.Errorf("Got: %v; Expected: %v", v3.String(), 0)
 	}

 	// Test rot by quat
 	v32.SetXY(1, 0)
-	v32.RotByQuat(gglm.NewQuatAngleAxis(90*gglm.Deg2Rad, gglm.NewVec3(0, 1, 0)))
-	angleV3 = gglm.AngleVec3(v3, v32) * gglm.Rad2Deg
+	rotAxis := gglm.NewVec3(0, 1, 0)
+	quat := gglm.NewQuatAngleAxisVec(90*gglm.Deg2Rad, &rotAxis)
+	v32.RotByQuat(&quat)
+	angleV3 = gglm.AngleVec3(&v3, &v32) * gglm.Rad2Deg
 	if angleV3 != 90 {
 		t.Errorf("Got: %v; Expected: %v", v3.String(), 0)
 	}
@ -223,7 +225,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	v4.SetZ(3)
 	v4.SetW(4)

-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}

@ -235,7 +237,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	v4.SetB(33)
 	v4.SetA(44)

-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}

@ -243,7 +245,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	ans4 = gglm.NewVec4(1, 2, 1, 1)

 	v4.SetXY(1, 2)
-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}

@ -251,7 +253,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	ans4 = gglm.NewVec4(1, 2, 1, 1)

 	v4.SetRG(1, 2)
-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}

@ -259,7 +261,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	ans4 = gglm.NewVec4(1, 2, 3, 1)

 	v4.SetXYZ(1, 2, 3)
-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}

@ -267,7 +269,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	ans4 = gglm.NewVec4(1, 2, 3, 1)

 	v4.SetRGB(1, 2, 3)
-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}

@ -275,7 +277,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	ans4 = gglm.NewVec4(1, 2, 3, 4)

 	v4.SetXYZW(1, 2, 3, 4)
-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}

@ -283,7 +285,7 @@ func TestVecSwizzleSet(t *testing.T) {
 	ans4 = gglm.NewVec4(1, 2, 3, 4)

 	v4.SetRGBA(1, 2, 3, 4)
-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}
 }
@ -295,26 +297,26 @@ func TestVecSwizzleAdd(t *testing.T) {
 	ans2 := gglm.NewVec2(2, 3)
 	v2.AddX(1)
 	v2.AddY(2)
-	if !v2.Eq(ans2) {
+	if !v2.Eq(&ans2) {
 		t.Errorf("Got: %v; Expected: %v", v2.String(), ans2.String())
 	}

 	v2 = gglm.NewVec2(1, 1)
 	v2.AddR(1)
 	v2.AddG(2)
-	if !v2.Eq(ans2) {
+	if !v2.Eq(&ans2) {
 		t.Errorf("Got: %v; Expected: %v", v2.String(), ans2.String())
 	}

 	v2 = gglm.NewVec2(1, 1)
 	v2.AddXY(1, 2)
-	if !v2.Eq(ans2) {
+	if !v2.Eq(&ans2) {
 		t.Errorf("Got: %v; Expected: %v", v2.String(), ans2.String())
 	}

 	v2 = gglm.NewVec2(1, 1)
 	v2.AddRG(1, 2)
-	if !v2.Eq(ans2) {
+	if !v2.Eq(&ans2) {
 		t.Errorf("Got: %v; Expected: %v", v2.String(), ans2.String())
 	}

@ -324,7 +326,7 @@ func TestVecSwizzleAdd(t *testing.T) {
 	v3.AddX(1)
 	v3.AddY(2)
 	v3.AddZ(3)
-	if !v3.Eq(ans3) {
+	if !v3.Eq(&ans3) {
 		t.Errorf("Got: %v; Expected: %v", v3.String(), ans3.String())
 	}

@ -332,33 +334,33 @@ func TestVecSwizzleAdd(t *testing.T) {
 	v3.AddR(1)
 	v3.AddG(2)
 	v3.AddB(3)
-	if !v3.Eq(ans3) {
+	if !v3.Eq(&ans3) {
 		t.Errorf("Got: %v; Expected: %v", v3.String(), ans3.String())
 	}

 	v3 = gglm.NewVec3(1, 1, 1)
 	ans3 = gglm.NewVec3(2, 3, 1)
 	v3.AddXY(1, 2)
-	if !v3.Eq(ans3) {
+	if !v3.Eq(&ans3) {
 		t.Errorf("Got: %v; Expected: %v", v3.String(), ans3.String())
 	}

 	v3 = gglm.NewVec3(1, 1, 1)
 	v3.AddRG(1, 2)
-	if !v3.Eq(ans3) {
+	if !v3.Eq(&ans3) {
 		t.Errorf("Got: %v; Expected: %v", v3.String(), ans3.String())
 	}

 	v3 = gglm.NewVec3(1, 1, 1)
 	ans3 = gglm.NewVec3(2, 3, 4)
 	v3.AddXYZ(1, 2, 3)
-	if !v3.Eq(ans3) {
+	if !v3.Eq(&ans3) {
 		t.Errorf("Got: %v; Expected: %v", v3.String(), ans3.String())
 	}

 	v3 = gglm.NewVec3(1, 1, 1)
 	v3.AddRGB(1, 2, 3)
-	if !v3.Eq(ans3) {
+	if !v3.Eq(&ans3) {
 		t.Errorf("Got: %v; Expected: %v", v3.String(), ans3.String())
 	}

@ -369,7 +371,7 @@ func TestVecSwizzleAdd(t *testing.T) {
 	v4.AddY(2)
 	v4.AddZ(3)
 	v4.AddW(4)
-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}

@ -378,46 +380,46 @@ func TestVecSwizzleAdd(t *testing.T) {
 	v4.AddG(2)
 	v4.AddB(3)
 	v4.AddA(4)
-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}

 	v4 = gglm.NewVec4(1, 1, 1, 1)
 	ans4 = gglm.NewVec4(2, 3, 1, 1)
 	v4.AddXY(1, 2)
-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}

 	v4 = gglm.NewVec4(1, 1, 1, 1)
 	v4.AddRG(1, 2)
-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}

 	v4 = gglm.NewVec4(1, 1, 1, 1)
 	ans4 = gglm.NewVec4(2, 3, 4, 1)
 	v4.AddXYZ(1, 2, 3)
-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}

 	v4 = gglm.NewVec4(1, 1, 1, 1)
 	v4.AddRGB(1, 2, 3)
-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}

 	v4 = gglm.NewVec4(1, 1, 1, 1)
 	ans4 = gglm.NewVec4(2, 3, 4, 5)
 	v4.AddXYZW(1, 2, 3, 4)
-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}

 	v4 = gglm.NewVec4(1, 1, 1, 1)
 	v4.AddRGBA(1, 2, 3, 4)
-	if !v4.Eq(ans4) {
+	if !v4.Eq(&ans4) {
 		t.Errorf("Got: %v; Expected: %v", v4.String(), ans4.String())
 	}
 }
--- a/main.go
+++ b/main.go
@ -53,7 +53,7 @@ func main() {
 	m4.Mul(m5)
 	println(m4.String())
 	println(m6.String())
-	println(m4.Eq(m6))
+	println(m4.Eq(&m6))

 	// Vec2
 	v1 := &gglm.Vec2{Data: [2]float32{1, 2}}
@ -82,7 +82,9 @@ func main() {
 	println(v3.Eq(v4))

 	println(gglm.DotVec3(v3, v4))
-	println(gglm.Cross(v3, v4).String())
+
+	v3v4Cross := gglm.Cross(v3, v4)
+	println(v3v4Cross.String())

 	println("V3: " + v3.String())
 	v3.Normalize()
@ -117,7 +119,8 @@ func main() {
 	}

 	vec2A := gglm.Vec2{Data: [2]float32{1, 2}}
-	println(gglm.MulMat2Vec2(&mat2A, &vec2A).String())
+	mat2Vec2Mul := gglm.MulMat2Vec2(&mat2A, &vec2A)
+	println(mat2Vec2Mul.String())

 	// Mat3Vec3
 	mat3A := gglm.Mat3{
@ -140,18 +143,23 @@ func main() {

 	// Quaternion
 	vRot := &gglm.Vec3{Data: [3]float32{60, 30, 20}}
-	q := gglm.NewQuatEuler(vRot.AsRad())
+	q := gglm.NewQuatEulerVec(vRot.AsRad())
 	println("\n" + vRot.AsRad().String())
 	println(q.String(), "\n", q.Mag())

-	q = gglm.NewQuatAngleAxis(60*gglm.Deg2Rad, vRot.Normalize())
+	q = gglm.NewQuatAngleAxisVec(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))
+
+	rotDegs := gglm.NewVec3(60, 30, 20)
+	quat := gglm.NewQuatEulerVec(rotDegs.AsRad())
+	rotMat := gglm.NewRotMat(&quat)
+
+	scale := gglm.NewVec3(1, 1, 1)
+	scaleMat := gglm.NewScaleMat(&scale)

 	modelMat := gglm.NewTrMatId()
 	modelMat.Mul(translationMat.Mul(rotMat.Mul(scaleMat)))
@ -165,22 +173,30 @@ func main() {
 	println("\n\n", v2Orig.String(), "; ", v2Clone.String())

 	// Clone TrMat
-	trMatOrig := gglm.NewTranslationMat(gglm.NewVec3(1, 2, 3))
+	pos := gglm.NewVec3(1, 2, 3)
+	trMatOrig := gglm.NewTranslationMat(&pos)
 	trMatClone := trMatOrig.Clone()
-	trMatClone.Scale(gglm.NewVec3(2, 2, 2))
-	trMatClone.Translate(gglm.NewVec3(9, 0, 0))
+
+	trMatCloneScale := gglm.NewVec3(2, 2, 2)
+	trMatClone.Scale(&trMatCloneScale)
+
+	pos = gglm.NewVec3(9, 0, 0)
+	trMatClone.Translate(&pos)
 	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)
+	q1Degs := gglm.NewVec3(180*gglm.Deg2Rad, 0, 0)
+	q1 := gglm.NewQuatEulerVec(&q1Degs)
+
+	q2Degs := gglm.NewVec3(0, 180*gglm.Deg2Rad, 0)
+	q2 := gglm.NewQuatEulerVec(&q2Degs)
+	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.LookAtRH(camPos, targetPos, worldUp)
+	viewMat := gglm.LookAtRH(&camPos, &targetPos, &worldUp)
 	println(viewMat.String())

 	// Mat2Col
@ -200,5 +216,5 @@ func main() {
 		{2, 4},
 	}}

-	println(mc2.Mul(mc).String())
+	println(mc2.Mul(&mc).String())
 }
Author	SHA1	Message	Date
bloeys	5d2cfa0329	NewXYZ funcs for Quat+github workflows	2024-05-04 22:44:48 +04:00
bloeys	afb3bbfe75	Get rid of pointer returns when creating new objects	2024-05-04 22:21:41 +04:00