From f5c4671bfbad96bf346bd7e9a21fc4317b4959df Mon Sep 17 00:00:00 2001
From: Indrajith K L
Date: Sat, 3 Dec 2022 17:00:20 +0530
Subject: Adds most of the tools

---
 v_windows/v/old/vlib/gg/m4/graphic.v | 110 +++++++
 v_windows/v/old/vlib/gg/m4/m4_test.v | 235 ++++++++++++++
 v_windows/v/old/vlib/gg/m4/matrix.v  | 595 +++++++++++++++++++++++++++++++++++
 v_windows/v/old/vlib/gg/m4/vector.v  | 230 ++++++++++++++
 4 files changed, 1170 insertions(+)
 create mode 100644 v_windows/v/old/vlib/gg/m4/graphic.v
 create mode 100644 v_windows/v/old/vlib/gg/m4/m4_test.v
 create mode 100644 v_windows/v/old/vlib/gg/m4/matrix.v
 create mode 100644 v_windows/v/old/vlib/gg/m4/vector.v

(limited to 'v_windows/v/old/vlib/gg/m4')

diff --git a/v_windows/v/old/vlib/gg/m4/graphic.v b/v_windows/v/old/vlib/gg/m4/graphic.v
new file mode 100644
index 0000000..e134e80
--- /dev/null
+++ b/v_windows/v/old/vlib/gg/m4/graphic.v
@@ -0,0 +1,110 @@
+/**********************************************************************
+*
+* Simply vector/matrix graphic utility
+*
+* Copyright (c) 2021 Dario Deledda. All rights reserved.
+* Use of this source code is governed by an MIT license
+* that can be found in the LICENSE file.
+*
+* TODO:
+**********************************************************************/
+module m4
+
+import math
+
+// Translate degrees to radians
+[inline]
+pub fn rad(deg f32) f32 {
+	return (math.pi / 180.0) * deg
+}
+
+// Translate radians to degrees
+[inline]
+pub fn deg(grad f32) f32 {
+	return (180.0 / math.pi) * grad
+}
+
+// calculate the Orthographic projection matrix
+pub fn ortho(left f32, right f32, bottom f32, top f32, z_near f32, z_far f32) Mat4 {
+	rml := right - left
+	rpl := right + left
+	tmb := top - bottom
+	tpb := top + bottom
+	fmn := z_far - z_near
+	fpn := z_far + z_near
+	if fmn != 0 {
+		return Mat4{ e: [
+				2 / rml, 0      ,       0, -(rpl / rml),
+				0      , 2 / tmb,       0, -(tpb / tmb),
+				0      ,       0, 2 / fmn, -(fpn / fmn),
+				0      ,       0,       0,            1,
+			]!
+		}
+	} 
+	return Mat4{ e: [
+			2 / rml, 0      ,       0, -(rpl / rml),
+			0      , 2 / tmb,       0, -(tpb / tmb),
+			0      ,       0,       0,            0,
+			0      ,       0,       0,            1,
+		]!
+	}
+}
+
+// Calculate the perspective matrix using (fov:fov, ar:aspect_ratio ,n:near_pane, f:far_plane) as parameters
+pub fn perspective(fov f32, ar f32, n f32, f f32) Mat4 {
+	ctan := f32(1.0 / math.tan(fov * (f32(math.pi) / 360.0))) // for the FOV we use 360 instead 180
+	return Mat4{ e: [
+		  ctan / ar, 	  0,		                   0, 							0,
+			0,		     ctan, 	                     0, 							0,
+			0,		        0,		   (n + f) / (n - f), 			     -1.0,
+			0,		        0, (2.0 * n * f) / (n - f), 	            0,
+		]!
+	}
+}
+
+// Calculate the look-at matrix
+pub fn look_at(eye Vec4, center Vec4, up Vec4) Mat4 {
+	f := (center - eye).normalize3()
+	s := (f % up).normalize3()
+	u := (s % f)
+
+	return Mat4{ e: [
+			/* [0][0] */ s.e[0],
+			/* [0][1] */ u.e[0],
+			/* [0][2] */ - f.e[0],
+			/* [0][3] */ 0,
+
+			/* [1][1] */ s.e[1],
+			/* [1][1] */ u.e[1],
+			/* [1][2] */ - f.e[1],
+			/* [1][3] */ 0,
+
+			/* [2][0] */ s.e[2],
+			/* [2][1] */ u.e[2],
+			/* [2][2] */ - f.e[2],
+			/* [2][3] */ 0,
+
+			/* [3][0] */ - (s * eye),
+			/* [3][1] */ - (u * eye),
+			/* [3][2] */ f * eye,
+			/* [3][3] */ 1,
+		]!
+	}
+}
+
+
+// Get the complete transformation matrix for GLSL demos
+pub fn calc_tr_matrices(w f32, h f32, rx f32, ry f32, in_scale f32) Mat4 {
+	proj := perspective(60, w / h, 0.01, 10.0)
+	view := look_at(Vec4{ e: [f32(0.0), 1.5, 6, 0]! }, Vec4{ e: [f32(0), 0, 0, 0]! }, Vec4{ e: [f32(0), 1.0, 0, 0]! })
+	view_proj := view * proj
+
+	rxm := rotate(rad(rx), Vec4{ e: [f32(1), 0, 0, 0]! })
+	rym := rotate(rad(ry), Vec4{ e: [f32(0), 1, 0, 0]! })
+
+	model := rym * rxm
+	scale_m := scale(Vec4{ e: [in_scale, in_scale, in_scale, 1]! })
+
+	res := (scale_m * model) * view_proj
+	return res
+}
diff --git a/v_windows/v/old/vlib/gg/m4/m4_test.v b/v_windows/v/old/vlib/gg/m4/m4_test.v
new file mode 100644
index 0000000..90b4640
--- /dev/null
+++ b/v_windows/v/old/vlib/gg/m4/m4_test.v
@@ -0,0 +1,235 @@
+import gg.m4
+
+pub fn test_m4() {
+	unsafe {
+		// Test Mat4
+		mut a := m4.Mat4{ e: [
+			f32(0),	1,	2,	3,
+				4,	5,	6,	7,
+				8,	9,	10,	11,
+				12,	13,	14,	15,
+				]!
+		}
+		mut b := m4.Mat4{}
+		mut c := m4.Mat4{}
+
+		// equal test
+		assert a.e == [
+			f32(0),	1,	2,	3,
+				4,	5,	6,	7,
+				8,	9,	10,	11,
+				12,	13,	14,	15,
+				]!
+
+		// copy test
+		b.copy(a)
+		assert a.e == b.e
+
+		// test: transpose, scale
+		assert b.transpose().mul_scalar(2.0).mul_scalar(0.5).transpose().e == a.e
+		assert b.sum_all() == 120.0
+
+		// test rows/columns set/get
+		for i in 0 .. 4 {
+			b = m4.zero_m4()
+			b.set_row(i, m4.Vec4{ e: [f32(1.0), 2, 3, 4]! })
+			assert b.get_f(0, i) == 1.0
+			assert b.get_f(1, i) == 2.0
+			assert b.get_f(2, i) == 3.0
+			assert b.get_f(3, i) == 4.0
+			// println(b)
+			c = m4.zero_m4()
+			c.set_col(i, m4.Vec4{ e: [f32(1.0), 2, 3, 4]! })
+			assert c.get_f(i, 0) == 1.0
+			assert c.get_f(i, 1) == 2.0
+			assert c.get_f(i, 2) == 3.0
+			assert c.get_f(i, 3) == 4.0
+			// println(c)
+		}
+	}
+}
+
+fn test_swap_col_row() {
+	unsafe {
+		// swap_col / swap_row
+		b := m4.Mat4{ e: [
+			f32(1),	2,	3,	4,
+				5,	6,	7,	8,
+				9,	10,	11,	12,
+				13,	14,	15,	16,
+				]!
+		}
+		b.swap_col(0, 2)
+		assert b.e == [
+			f32(3),	2,	1,	4,
+				7,	6,	5,	8,
+				11,	10,	9,	12,
+				15,	14,	13,	16,
+				]!
+		b = m4.Mat4{ e: [
+			f32(1),	2,	3,	4,
+				5,	6,	7,	8,
+				9,	10,	11,	12,
+				13,	14,	15,	16,
+				]!
+		}
+		b.swap_row(0, 2)
+		assert b.e == [
+			f32(9),	10,	11,	12,
+				5,	6,	7,	8,
+				1,	2,	3,	4,
+				13,	14,	15,	16,
+				]!
+	}
+}
+
+fn test_sum_sub() {
+	unsafe {
+		// test sum/sub
+		b := m4.unit_m4()
+		c := m4.unit_m4()
+		assert m4.sub(m4.add(b, c), b).e == m4.unit_m4().e
+		assert (b + c - b).e == m4.unit_m4().e
+	}
+}
+
+fn test_transpose() {
+	unsafe {
+		b := m4.Mat4{ e: [
+			f32(0),	1,	2,	3,
+				4,	5,	6,	7,
+				8,	9,	10,	11,
+				12,	13,	14,	15,
+				]!
+		}
+		assert b.transpose().transpose().e == b.e
+	}
+}
+
+fn test_multiplication() {
+	unsafe {
+		b := m4.Mat4{ e: [
+			f32(1),	0,	0,	0,
+				0,	2,	0,	0,
+				0,	0,	3,	0,
+				0,	0,	0,	4,
+				]!
+		}
+		c := m4.Mat4{ e: [
+			f32(1),	2,	3,	4,
+				5,	6,	7,	8,
+				9,	10,	11,	12,
+				13,	14,	15,	16,
+				]!
+		}
+
+		assert (c * c).e == [
+			f32(90),100,110,120,
+				202,228,254,280,
+				314,356,398,440,
+				426,484,542,600,
+				]!
+
+		assert m4.mul(c, c).e == [
+			f32(90),100,110,120,
+				202,228,254,280,
+				314,356,398,440,
+				426,484,542,600,
+		]!
+
+		assert m4.mul(b, c).e == [
+			f32(1),	2,	3,	4,
+				10,	12,	14,	16,
+				27,	30,	33,	36,
+				52,	56,	60,	64,
+				]!
+
+		assert (b * c).e == [
+			f32(1),	2,	3,	4,
+				10,	12,	14,	16,
+				27,	30,	33,	36,
+				52,	56,	60,	64,
+				]!
+
+		assert m4.det(b) == 24
+	}
+}
+
+fn test_det() {
+	unsafe {
+		b := m4.Mat4{ e: [
+			f32(5),	6,	6,	8,
+				2,	2,	2,	8,
+				6,	6,	2,	8,
+				2,	3,	6,	7,
+				]!
+		}
+		assert m4.det(b) == -8
+
+		c := m4.Mat4{ e: [
+			f32(1),	8,	2,	3,
+				8,	2,	3,	1,
+				2,	3,	3,	2,
+				3,	1,	2,	4,
+				]!
+		}
+		// println("*** INVERSE ****")
+		// println(m4.mul(b.inverse(),b))
+		// println(m4.clean_small(m4.mul(c.inverse(),c)))
+		// println("****************")
+		assert m4.mul(b.inverse(), b).e == m4.unit_m4().e
+		assert m4.mul(c.inverse(), c).is_equal(m4.unit_m4())
+	}
+}
+
+fn test_vec4() {
+	// Test Vec4
+	// println("*** Vector4 ****")
+	assert m4.vec3(1,2,3) == m4.Vec4{[f32(1), 2, 3, 1]!}
+	mut v := m4.Vec4{[f32(1), 2, 3, 4]!}
+	assert v * v.inv() == 4
+	assert v.mul_scalar(1.0 / v.mod()).mod() == 1
+	assert v + m4.Vec4{ e: [f32(5), 6, 7, 8]! } == m4.Vec4{ e: [f32(6), 8, 10, 12]! }
+	assert v - m4.Vec4{ e: [f32(1), 2, 3, 4]! } == m4.Vec4{ e: [f32(0), 0, 0, 0]! }
+	assert v.mul_vec4(m4.Vec4{ e: [f32(2), 2, 2, 2]! }) == m4.Vec4{	e: [f32(2), 4, 6, 8]! }
+	assert f32_abs(v.normalize().mod() - 1) < m4.precision
+	v = m4.Vec4{[f32(1), 2, 3, 0]!}
+	assert f32_abs(v.normalize3().mod3() - 1) < m4.precision
+	assert f32_abs(v.normalize3().mod() - 1) < m4.precision
+	// cross product
+	// x y z
+	// 1 2 3 ==> -3 6 -3 0
+	// 4 5 6
+	// println(m4.Vec4{[f32(1),2,3,2]!} % m4.Vec4{[f32(4),5,6,2]!})
+	assert m4.Vec4{[f32(1), 2, 3, 0]!} % m4.Vec4{[f32(4), 5, 6, 0]!} == m4.Vec4{[ f32(-3),	6,	-3,	0, ]!}
+	assert m4.Vec4{[f32(1), 2, 3, 13]!} % m4.Vec4{[f32(4), 5, 6, 11]!} == m4.Vec4{[	f32(-3), 6,	-3,	0, ]!}
+	// matrix * vector
+	a := m4.Mat4{ e: [
+		f32(1),2,3,4
+		5,6,7,8
+		9,10,11,12
+		13,14,15,16
+		]!
+	}
+	assert m4.mul_vec(a, m4.Vec4{[f32(1), 2, 3, 4]!}) == m4.Vec4{[ f32(30),	70,	110,150, ]!}
+	// Rotation
+	// println("*** Rotation ****")
+	rotx := m4.rotate(m4.rad(-90), m4.Vec4{	e: [f32(1.0), 0, 0, 0]!	}).clean()
+	roty := m4.rotate(m4.rad(-90), m4.Vec4{	e: [f32(0), 1.0, 0, 0]! }).clean()
+	rotz := m4.rotate(m4.rad(-90), m4.Vec4{	e: [f32(0), 0, 1, 0]!	}).clean()
+	// println( rotx )
+	// println( roty )
+	// println( rotz )
+	// println( m4.mul_vec(rotx, m4.Vec4{e:[f32(0),0,1,0]!}).clean())
+	assert m4.mul_vec(roty, m4.Vec4{ e: [f32(1.0), 0.0, 0, 0]! }).clean() == m4.Vec4{ e: [f32(0), 0.0, -1, 0]! }
+	assert m4.mul_vec(rotz, m4.Vec4{ e: [f32(1.0), 0.0, 0, 0]! }).clean() == m4.Vec4{ e: [f32(0), 1, 0, 0]! }
+	assert m4.mul_vec(rotx, m4.Vec4{ e: [f32(0), 0, 1, 0]! }).clean() == m4.Vec4{ e: [f32(0), -1, 0, 0]! }
+	// println("****************")
+}
+
+fn test_proj() {
+	ort := m4.ortho(0,300,0,200,0,0)
+	assert m4.mul_vec(ort, m4.Vec4{[ f32(150),	100,	0, 1]!}) == m4.Vec4{[ f32(0),	0,	0, 1]!}
+	assert m4.mul_vec(ort, m4.Vec4{[ f32(0),	0,	0, 1]!}) == m4.Vec4{[ f32(-1),	-1,	0, 1]!}
+	assert m4.mul_vec(ort, m4.Vec4{[ f32(300),	200,	0, 1]!}) == m4.Vec4{[ f32(1),	1,	0, 1]!}
+}
diff --git a/v_windows/v/old/vlib/gg/m4/matrix.v b/v_windows/v/old/vlib/gg/m4/matrix.v
new file mode 100644
index 0000000..c839b9d
--- /dev/null
+++ b/v_windows/v/old/vlib/gg/m4/matrix.v
@@ -0,0 +1,595 @@
+/**********************************************************************
+*
+* Simply vector/matrix utility
+*
+* Copyright (c) 2021 Dario Deledda. All rights reserved.
+* Use of this source code is governed by an MIT license
+* that can be found in the LICENSE file.
+*
+* TODO:
+**********************************************************************/
+module m4
+
+import math
+
+pub union Mat4 {
+pub mut:
+	e [16]f32
+	f [4][4]f32
+}
+
+pub const precision = f32(10e-7)
+
+// default precision for the module
+
+/*********************************************************************
+*
+* Utility
+*
+*********************************************************************/
+// String representation of the matrix
+pub fn (x Mat4) str() string {
+	unsafe {
+		return '|${x.e[0]:-6.3},${x.e[1]:-6.3},${x.e[2]:-6.3},${x.e[3]:-6.3}|\n' +
+			'|${x.e[4]:-6.3},${x.e[5]:-6.3},${x.e[6]:-6.3},${x.e[7]:-6.3}|\n' +
+			'|${x.e[8]:-6.3},${x.e[9]:-6.3},${x.e[10]:-6.3},${x.e[11]:-6.3}|\n' +
+			'|${x.e[12]:-6.3},${x.e[13]:-6.3},${x.e[14]:-6.3},${x.e[15]:-6.3}|'
+	}
+}
+
+// Remove all the raw zeros
+[direct_array_access]
+pub fn (a Mat4) clean() Mat4 {
+	unsafe {
+		x := Mat4{}
+		for c, value in a.e {
+			if f32_abs(value) < m4.precision {
+				x.e[c] = 0
+			} else {
+				x.e[c] = value
+			}
+		}
+		return x
+	}
+}
+
+// Sum all the elements of the matrix
+pub fn (x Mat4) sum_all() f32 {
+	mut res := f32(0)
+	for v in unsafe { x.e } {
+		res += v
+	}
+	return res
+}
+
+// Check if two matrix are equal using module precision
+[direct_array_access]
+pub fn (x Mat4) is_equal(y Mat4) bool {
+	unsafe {
+		for c, value in x.e {
+			if f32_abs(value - y.e[c]) > m4.precision {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+//-------------------------------------
+// Set/Get values
+//-------------------------------------
+// Get an element of the matrix using [0..15] indexes, one dimension
+pub fn (x Mat4) get_e(elem_index int) f32 {
+	unsafe {
+		return x.e[elem_index]
+	}
+}
+
+// Get an element of the matrix using [0..3][0..3] indexes, two dimension
+pub fn (x Mat4) get_f(index_col int, index_row int) f32 {
+	unsafe {
+		return x.e[(index_row << 2) + index_col]
+	}
+}
+
+// Set an element of the matrix using [0..15] indexes, one dimension
+pub fn (mut x Mat4) set_e(index int, value f32) {
+	unsafe {
+		x.e[index] = value
+	}
+}
+
+// Set an element of the matrix using [0..3][0..3] indexes, two dimension
+pub fn (mut x Mat4) set_f(index_col int, index_row int, value f32) {
+	unsafe {
+		x.e[(index_row << 2) + index_col] = value
+	}
+}
+
+// Copy a matrix elements from another matrix
+pub fn (mut x Mat4) copy(y Mat4) {
+	unsafe {
+		x.e = [
+			y.e[0 ], y.e[1 ], y.e[2 ], y.e[3 ],
+			y.e[4 ], y.e[5 ], y.e[6 ], y.e[7 ],
+			y.e[8 ], y.e[9 ], y.e[10], y.e[11],
+			y.e[12], y.e[13], y.e[14], y.e[15],
+		]!
+	}
+}
+
+// Set the trace of the matrix using a vec4
+pub fn (mut x Mat4) set_trace(v3 Vec4) {
+	unsafe {
+		x.e[0 ] = v3.e[0]
+		x.e[5 ] = v3.e[1]
+		x.e[10] = v3.e[2]
+		x.e[15] = v3.e[3]
+	}
+}
+
+// Get the trace of the matrix
+pub fn (x Mat4) get_trace() Vec4 {
+	unsafe {
+		return Vec4{ e: [ x.e[0], x.e[5], x.e[10], x.e[15],	]! }
+	}
+}
+
+// Set all the matrix elements to value
+pub fn (mut x Mat4) set_f32(value f32) {
+	unsafe {
+		x.e = [
+			value, value, value, value,
+			value, value, value, value,
+			value, value, value, value,
+			value, value, value, value,
+		]!
+	}
+}
+
+//-------------------------------------
+// Rows/Column access
+//-------------------------------------
+// Set the row as the input vec4
+[direct_array_access]
+[unsafe]
+pub fn (mut x Mat4) set_row(row int, v3 Vec4) {
+	unsafe {
+		x.e[row * 4 + 0] = v3.e[0]
+		x.e[row * 4 + 1] = v3.e[1]
+		x.e[row * 4 + 2] = v3.e[2]
+		x.e[row * 4 + 3] = v3.e[3]
+	}
+}
+
+// Get a row from a matrix
+[direct_array_access]
+[unsafe]
+pub fn (x Mat4) get_row(row int) Vec4 {
+	unsafe {
+		return Vec4{
+			e: [
+				x.e[row * 4 + 0],
+				x.e[row * 4 + 1],
+				x.e[row * 4 + 2],
+				x.e[row * 4 + 3],
+			]!
+		}
+	}
+}
+
+// Set the column as the input vec4
+[direct_array_access]
+[unsafe]
+pub fn (mut x Mat4) set_col(col int, v3 Vec4) {
+	unsafe {
+		x.e[col] = v3.e[0]
+		x.e[col + 4 ] = v3.e[1]
+		x.e[col + 8 ] = v3.e[2]
+		x.e[col + 12] = v3.e[3]
+	}
+}
+
+// Get a column from a matrix
+[direct_array_access]
+[unsafe]
+pub fn (x Mat4) get_col(col int) Vec4 {
+	unsafe {
+		return Vec4{
+			e: [
+				x.e[col],
+				x.e[col + 4 ],
+				x.e[col + 8 ],
+				x.e[col + 12],
+			]!
+		}
+	}
+}
+
+// Swap two columns in the matrix
+[direct_array_access]
+[unsafe]
+pub fn (mut x Mat4) swap_col(col1 int, col2 int) {
+	unsafe {
+		v0 := x.e[col1]
+		v1 := x.e[col1 + 4 ]
+		v2 := x.e[col1 + 8 ]
+		v3 := x.e[col1 + 12]
+
+		x.e[col1] = x.e[col2]
+		x.e[col1 + 4 ] = x.e[col2 + 4 ]
+		x.e[col1 + 8 ] = x.e[col2 + 8 ]
+		x.e[col1 + 12] = x.e[col2 + 12]
+
+		x.e[col2] = v0
+		x.e[col2 + 4 ] = v1
+		x.e[col2 + 8 ] = v2
+		x.e[col2 + 12] = v3
+	}
+}
+
+// Swap two rows in the matrix
+[direct_array_access]
+[unsafe]
+pub fn (mut x Mat4) swap_row(row1 int, row2 int) {
+	unsafe {
+		v0 := x.e[row1 * 4 + 0]
+		v1 := x.e[row1 * 4 + 1]
+		v2 := x.e[row1 * 4 + 2]
+		v3 := x.e[row1 * 4 + 3]
+
+		x.e[row1 * 4 + 0] = x.e[row2 * 4 + 0]
+		x.e[row1 * 4 + 1] = x.e[row2 * 4 + 1]
+		x.e[row1 * 4 + 2] = x.e[row2 * 4 + 2]
+		x.e[row1 * 4 + 3] = x.e[row2 * 4 + 3]
+
+		x.e[row2 * 4 + 0] = v0
+		x.e[row2 * 4 + 1] = v1
+		x.e[row2 * 4 + 2] = v2
+		x.e[row2 * 4 + 3] = v3
+	}
+}
+
+//-------------------------------------
+// Modify data
+//-------------------------------------
+// Transpose the matrix
+pub fn (x Mat4) transpose() Mat4 {
+	unsafe {
+		return Mat4{ e: [
+				x.e[0 ], x.e[4 ], x.e[8 ], x.e[12],
+				x.e[1 ], x.e[5 ], x.e[9 ], x.e[13],
+				x.e[2 ], x.e[6 ], x.e[10], x.e[14],
+				x.e[3 ], x.e[7 ], x.e[11], x.e[15],
+			]!
+		}
+	}
+}
+
+// Multiply the all the elements of the matrix by a scalar
+pub fn (x Mat4) mul_scalar(s f32) Mat4 {
+	unsafe {
+		return Mat4{ e: [
+				x.e[0 ] * s, x.e[1 ] * s, x.e[2 ] * s, x.e[3 ] * s,
+				x.e[4 ] * s, x.e[5 ] * s, x.e[6 ] * s, x.e[7 ] * s,
+				x.e[8 ] * s, x.e[9 ] * s, x.e[10] * s, x.e[11] * s,
+				x.e[12] * s, x.e[13] * s, x.e[14] * s, x.e[15] * s,
+			]!
+		}
+	}
+}
+
+/*********************************************************************
+*
+* Init/set
+*
+*********************************************************************/
+// Return a zero matrix
+pub fn zero_m4() Mat4 {
+	return Mat4{ e: [
+		f32(0),	0,	0,	0,
+			0,	0,	0,	0,
+			0,	0,	0,	0,
+			0,	0,	0,	0,
+			]!
+	}
+}
+
+// Return a unity matrix
+pub fn unit_m4() Mat4 {
+	return Mat4{ e: [
+			f32(1),	0,	0,	0,
+				0,	1,	0,	0,
+				0,	0,	1,	0,
+				0,	0,	0,	1,
+				]!
+	}
+}
+
+// Return a matrix initialized with value
+pub fn set_m4(value f32) Mat4 {
+	return Mat4{ e: [
+			value, value, value, value,
+			value, value, value, value,
+			value, value, value, value,
+			value, value, value, value,
+			]!
+	}
+}
+
+/*********************************************************************
+*
+* Math
+*
+*********************************************************************/
+
+// Sum of matrix, operator +
+pub fn (a Mat4) + (b Mat4) Mat4 {
+	unsafe {
+		return Mat4{ e: [
+				a.e[0 ] + b.e[0 ], 	a.e[1 ] + b.e[1 ], 	a.e[2 ] + b.e[2 ],	a.e[3 ] + b.e[3 ],
+				a.e[4 ] + b.e[4 ],	a.e[5 ] + b.e[5 ],	a.e[6 ] + b.e[6 ],	a.e[7 ] + b.e[7 ],
+				a.e[8 ] + b.e[8 ],	a.e[9 ] + b.e[9 ],	a.e[10] + b.e[10],	a.e[11] + b.e[11],
+				a.e[12] + b.e[12],	a.e[13] + b.e[13],	a.e[14] + b.e[14],	a.e[15] + b.e[15],
+			]!
+		}
+	}
+}
+
+// Subtraction of matrix, operator -
+pub fn (a Mat4) - (b Mat4) Mat4 {
+	unsafe {
+		return Mat4{ e: [
+				a.e[0 ] - b.e[0 ], 	a.e[1 ] - b.e[1 ],	a.e[2 ] - b.e[2 ],	a.e[3 ] - b.e[3 ],
+				a.e[4 ] - b.e[4 ],	a.e[5 ] - b.e[5 ],	a.e[6 ] - b.e[6 ],	a.e[7 ] - b.e[7 ],
+				a.e[8 ] - b.e[8 ],	a.e[9 ] - b.e[9 ],	a.e[10] - b.e[10],	a.e[11] - b.e[11],
+				a.e[12] - b.e[12],	a.e[13] - b.e[13],	a.e[14] - b.e[14],	a.e[15] - b.e[15],
+			]!
+		}
+	}
+}
+
+// Multiplication of matrix, operator *
+pub fn (a Mat4) * (b Mat4) Mat4 {
+	unsafe {
+		return Mat4{
+			e: [
+				/* [0][0] */  a.f[0][0] * b.f[0][0] + a.f[0][1] * b.f[1][0] + a.f[0][2] * b.f[2][0] + a.f[0][3] * b.f[3][0]
+				/* [0][1] */, a.f[0][0] * b.f[0][1] + a.f[0][1] * b.f[1][1] + a.f[0][2] * b.f[2][1] + a.f[0][3] * b.f[3][1]
+				/* [0][2] */, a.f[0][0] * b.f[0][2] + a.f[0][1] * b.f[1][2] + a.f[0][2] * b.f[2][2] + a.f[0][3] * b.f[3][2]
+				/* [0][3] */, a.f[0][0] * b.f[0][3] + a.f[0][1] * b.f[1][3] + a.f[0][2] * b.f[2][3] + a.f[0][3] * b.f[3][3]
+
+				/* [1][0] */, a.f[1][0] * b.f[0][0] + a.f[1][1] * b.f[1][0] + a.f[1][2] * b.f[2][0] + a.f[1][3] * b.f[3][0]
+				/* [1][1] */, a.f[1][0] * b.f[0][1] + a.f[1][1] * b.f[1][1] + a.f[1][2] * b.f[2][1] + a.f[1][3] * b.f[3][1]
+				/* [1][2] */, a.f[1][0] * b.f[0][2] + a.f[1][1] * b.f[1][2] + a.f[1][2] * b.f[2][2] + a.f[1][3] * b.f[3][2]
+				/* [1][3] */, a.f[1][0] * b.f[0][3] + a.f[1][1] * b.f[1][3] + a.f[1][2] * b.f[2][3] + a.f[1][3] * b.f[3][3]
+
+				/* [2][0] */, a.f[2][0] * b.f[0][0] + a.f[2][1] * b.f[1][0] + a.f[2][2] * b.f[2][0] + a.f[2][3] * b.f[3][0]
+				/* [2][1] */, a.f[2][0] * b.f[0][1] + a.f[2][1] * b.f[1][1] + a.f[2][2] * b.f[2][1] + a.f[2][3] * b.f[3][1]
+				/* [2][2] */, a.f[2][0] * b.f[0][2] + a.f[2][1] * b.f[1][2] + a.f[2][2] * b.f[2][2] + a.f[2][3] * b.f[3][2]
+				/* [2][3] */, a.f[2][0] * b.f[0][3] + a.f[2][1] * b.f[1][3] + a.f[2][2] * b.f[2][3] + a.f[2][3] * b.f[3][3]
+
+				/* [3][0] */, a.f[3][0] * b.f[0][0] + a.f[3][1] * b.f[1][0] + a.f[3][2] * b.f[2][0] + a.f[3][3] * b.f[3][0]
+				/* [3][1] */, a.f[3][0] * b.f[0][1] + a.f[3][1] * b.f[1][1] + a.f[3][2] * b.f[2][1] + a.f[3][3] * b.f[3][1]
+				/* [3][2] */, a.f[3][0] * b.f[0][2] + a.f[3][1] * b.f[1][2] + a.f[3][2] * b.f[2][2] + a.f[3][3] * b.f[3][2]
+				/* [3][3] */, a.f[3][0] * b.f[0][3] + a.f[3][1] * b.f[1][3] + a.f[3][2] * b.f[2][3] + a.f[3][3] * b.f[3][3],
+			]!
+		}
+	}
+}
+
+// Sum of matrix function
+pub fn add(a Mat4, b Mat4) Mat4 {
+	unsafe {
+		return a + b
+	}
+}
+
+// Subtraction of matrix function
+pub fn sub(a Mat4, b Mat4) Mat4 {
+	unsafe {
+		return a - b
+	}
+}
+
+// Multiplication of matrix function
+pub fn mul(a Mat4, b Mat4) Mat4 {
+	unsafe {
+		return a * b
+	}
+}
+
+// Multiply a Matrix by a vector
+pub fn mul_vec(a Mat4, v Vec4) Vec4 {
+	unsafe {
+		return Vec4{ e: [
+				a.e[0 ] * v.e[0] + a.e[1 ] * v.e[1] + a.e[2 ] * v.e[2] + a.e[3 ] * v.e[3],
+				a.e[4 ] * v.e[0] + a.e[5 ] * v.e[1] + a.e[6 ] * v.e[2] + a.e[7 ] * v.e[3],
+				a.e[8 ] * v.e[0] + a.e[9 ] * v.e[1] + a.e[10] * v.e[2] + a.e[11] * v.e[3],
+				a.e[12] * v.e[0] + a.e[13] * v.e[1] + a.e[14] * v.e[2] + a.e[15] * v.e[3],
+				]!
+		}
+	}
+}
+
+// Calculate the determinant of the Matrix
+pub fn det(x Mat4) f32 {
+	unsafe {
+		mut t := [6]f32{}
+		x00 := x.f[0][0]
+		x10 := x.f[1][0]
+		x20 := x.f[2][0]
+		x30 := x.f[3][0]
+		x01 := x.f[0][1]
+		x11 := x.f[1][1]
+		x21 := x.f[2][1]
+		x31 := x.f[3][1]
+		x02 := x.f[0][2]
+		x12 := x.f[1][2]
+		x22 := x.f[2][2]
+		x32 := x.f[3][2]
+		x03 := x.f[0][3]
+		x13 := x.f[1][3]
+		x23 := x.f[2][3]
+		x33 := x.f[3][3]
+
+		t[0] = x22 * x33 - x23 * x32
+		t[1] = x12 * x33 - x13 * x32
+		t[2] = x12 * x23 - x13 * x22
+		t[3] = x02 * x33 - x03 * x32
+		t[4] = x02 * x23 - x03 * x22
+		t[5] = x02 * x13 - x03 * x12
+
+		return 0.0 +
+			x00 * (x11 * t[0] - x21 * t[1] + x31 * t[2]) -
+			x10 * (x01 * t[0] - x21 * t[3] + x31 * t[4]) +
+			x20 * (x01 * t[1] - x11 * t[3] + x31 * t[5]) -
+			x30 * (x01 * t[2] - x11 * t[4] + x21 * t[5])
+	}
+}
+
+// Calculate the inverse of the Matrix
+pub fn (x Mat4) inverse() Mat4 {
+	unsafe {
+		mut t := [6]f32{}
+		mut det := f32(0)
+
+		a := x.f[0][0]
+		b := x.f[1][0]
+		c := x.f[2][0]
+		d := x.f[3][0]
+		e := x.f[0][1]
+		f := x.f[1][1]
+		g := x.f[2][1]
+		h := x.f[3][1]
+		i := x.f[0][2]
+		j := x.f[1][2]
+		k := x.f[2][2]
+		l := x.f[3][2]
+		m := x.f[0][3]
+		n := x.f[1][3]
+		o := x.f[2][3]
+		p := x.f[3][3]
+
+		t[0] = k * p - o * l
+		t[1] = j * p - n * l
+		t[2] = j * o - n * k
+		t[3] = i * p - m * l
+		t[4] = i * o - m * k
+		t[5] = i * n - m * j
+
+		mut dest := Mat4{}
+		dest.f[0][0] = f * t[0] - g * t[1] + h * t[2]
+		dest.f[0][1] = -(e * t[0] - g * t[3] + h * t[4])
+		dest.f[0][2] = e * t[1] - f * t[3] + h * t[5]
+		dest.f[0][3] = -(e * t[2] - f * t[4] + g * t[5])
+
+		dest.f[1][0] = -(b * t[0] - c * t[1] + d * t[2])
+		dest.f[1][1] = a * t[0] - c * t[3] + d * t[4]
+		dest.f[1][2] = -(a * t[1] - b * t[3] + d * t[5])
+		dest.f[1][3] = a * t[2] - b * t[4] + c * t[5]
+
+		t[0] = g * p - o * h
+		t[1] = f * p - n * h
+		t[2] = f * o - n * g
+		t[3] = e * p - m * h
+		t[4] = e * o - m * g
+		t[5] = e * n - m * f
+
+		dest.f[2][0] = b * t[0] - c * t[1] + d * t[2]
+		dest.f[2][1] = -(a * t[0] - c * t[3] + d * t[4])
+		dest.f[2][2] = a * t[1] - b * t[3] + d * t[5]
+		dest.f[2][3] = -(a * t[2] - b * t[4] + c * t[5])
+
+		t[0] = g * l - k * h
+		t[1] = f * l - j * h
+		t[2] = f * k - j * g
+		t[3] = e * l - i * h
+		t[4] = e * k - i * g
+		t[5] = e * j - i * f
+
+		dest.f[3][0] = -(b * t[0] - c * t[1] + d * t[2])
+		dest.f[3][1] = a * t[0] - c * t[3] + d * t[4]
+		dest.f[3][2] = -(a * t[1] - b * t[3] + d * t[5])
+		dest.f[3][3] = a * t[2] - b * t[4] + c * t[5]
+
+		tmp := (a * dest.f[0][0] + b * dest.f[0][1] + c * dest.f[0][2] + d * dest.f[0][3])
+		if tmp != 0 {
+			det = f32(1.0) / tmp
+		}
+		return dest.mul_scalar(det)
+	}
+}
+
+/*********************************************************************
+*
+* Transformations
+*
+*********************************************************************/
+
+// Get a rotation matrix using w as rotation axis vector, the angle is in radians
+pub fn rotate(angle f32, w Vec4) Mat4 {
+	cs := f32(math.cos(angle))
+	sn := f32(math.sin(angle))
+	cv := f32(1.0) - cs
+	axis := w.normalize3()
+	unsafe {
+		ax := axis.e[0]
+		ay := axis.e[1]
+		az := axis.e[2]
+
+		return Mat4{ e: [
+				/* [0][0] */  (ax * ax * cv) + cs
+				/* [0][1] */, (ax * ay * cv) + az * sn
+				/* [0][2] */, (ax * az * cv) - ay * sn
+				/* [0][3] */, 0
+
+				/* [1][0] */, (ay * ax * cv) - az * sn
+				/* [1][1] */, (ay * ay * cv) + cs
+				/* [1][2] */, (ay * az * cv) + ax * sn
+				/* [1][3] */, 0
+
+				/* [2][0] */, (az * ax * cv) + ay * sn
+				/* [2][1] */, (az * ay * cv) - ax * sn
+				/* [2][2] */, (az * az * cv) + cs
+				/* [2][3] */, 0
+
+				/* [3][0] */, 0
+				/* [3][1] */, 0
+				/* [3][2] */, 0
+				/* [3][3] */, 1,
+			]!
+		}
+	}
+}
+
+/*********************************************************************
+*
+* Graphic
+*
+*********************************************************************/
+// Get a matrix translated by a vector w
+pub fn (x Mat4) translate(w Vec4) Mat4 {
+	unsafe {
+		return Mat4{ e: [
+				x.e[0],	x.e[1], x.e[2 ], 	x.e[3 ] ,
+				x.e[4], x.e[5],	x.e[6 ], 	x.e[7 ] ,
+				x.e[8], x.e[9], x.e[10], 	x.e[11] ,
+				x.e[12] + w.e[0], 	x.e[13] + w.e[1], x.e[14] + w.e[2], x.e[15],
+				]!
+		}
+	}
+}
+
+// Get a scale matrix, the scale vector is w, only xyz are evaluated.
+pub fn scale(w Vec4) Mat4 {
+	unsafe {
+		return Mat4{ e: [
+				w.e[0], 	0,			0,			0,
+				0,			w.e[1],		0,			0,
+				0,			0,			w.e[2],		0,
+				0,			0,			0,			1,
+				]!
+		}
+	}
+}
diff --git a/v_windows/v/old/vlib/gg/m4/vector.v b/v_windows/v/old/vlib/gg/m4/vector.v
new file mode 100644
index 0000000..52e4c78
--- /dev/null
+++ b/v_windows/v/old/vlib/gg/m4/vector.v
@@ -0,0 +1,230 @@
+/**********************************************************************
+*
+* Simply vector/matrix utility
+*
+* Copyright (c) 2021 Dario Deledda. All rights reserved.
+* Use of this source code is governed by an MIT license
+* that can be found in the LICENSE file.
+*
+* TODO:
+**********************************************************************/
+module m4
+
+import math
+
+pub struct Vec4 {
+pub mut:
+	e [4]f32
+}
+
+/*********************************************************************
+*
+* Utility
+*
+*********************************************************************/
+pub fn (x Vec4) str() string {
+	return '|${x.e[0]:-6.3},${x.e[1]:-6.3},${x.e[2]:-6.3},${x.e[3]:-6.3}|'
+}
+
+// create a Vec4 function passing x,y,z as parameteres. w is set to 1
+pub fn vec3(x f32, y f32, z f32) Vec4 {
+	return Vec4{
+		e: [x, y, z, 1]!
+	}
+}
+
+// Remove all the raw zeros
+[direct_array_access]
+pub fn (a Vec4) clean() Vec4 {
+	mut x := Vec4{}
+	for c, value in a.e {
+		if f32_abs(value) < precision {
+			x.e[c] = 0
+		} else {
+			x.e[c] = value
+		}
+	}
+	return x
+}
+
+// Set all elements to value
+pub fn (mut x Vec4) copy(value f32) {
+	x.e = [value, value, value, value]!
+}
+
+// Scale the vector using a scalar
+pub fn (x Vec4) mul_scalar(value f32) Vec4 {
+	return Vec4{
+		e: [x.e[0] * value, x.e[1] * value, x.e[2] * value, x.e[3] * value]!
+	}
+}
+
+// Reciprocal of the vector
+pub fn (x Vec4) inv() Vec4 {
+	return Vec4{
+		e: [
+			if x.e[0] != 0 { 1.0 / x.e[0] } else { f32(0) },
+			if x.e[1] != 0 { 1.0 / x.e[1] } else { f32(0) },
+			if x.e[2] != 0 { 1.0 / x.e[2] } else { f32(0) },
+			if x.e[3] != 0 { 1.0 / x.e[3] } else { f32(0) },
+		]!
+	}
+}
+
+// Normalize the vector
+pub fn (x Vec4) normalize() Vec4 {
+	m := x.mod()
+	if m == 0 {
+		return zero_v4()
+	}
+	return Vec4{
+		e: [
+			x.e[0] * (1 / m),
+			x.e[1] * (1 / m),
+			x.e[2] * (1 / m),
+			x.e[3] * (1 / m),
+		]!
+	}
+}
+
+// Normalize only xyz, w set to 0
+pub fn (x Vec4) normalize3() Vec4 {
+	m := x.mod3()
+	if m == 0 {
+		return zero_v4()
+	}
+	return Vec4{
+		e: [
+			x.e[0] * (1 / m),
+			x.e[1] * (1 / m),
+			x.e[2] * (1 / m),
+			0,
+		]!
+	}
+}
+
+// Module of the vector xyzw
+pub fn (x Vec4) mod() f32 {
+	return f32(math.sqrt(x.e[0] * x.e[0] + x.e[1] * x.e[1] + x.e[2] * x.e[2] + x.e[3] * x.e[3]))
+}
+
+// Module for 3d vector xyz, w ignored
+pub fn (x Vec4) mod3() f32 {
+	return f32(math.sqrt(x.e[0] * x.e[0] + x.e[1] * x.e[1] + x.e[2] * x.e[2]))
+}
+
+/*********************************************************************
+*
+* Math
+*
+*********************************************************************/
+// Return a zero vector
+pub fn zero_v4() Vec4 {
+	return Vec4{
+		e: [
+			f32(0),
+			0,
+			0,
+			0,
+		]!
+	}
+}
+
+// Return all one vector
+pub fn one_v4() Vec4 {
+	return Vec4{
+		e: [
+			f32(1),
+			1,
+			1,
+			1,
+		]!
+	}
+}
+
+// Return a blank vector
+pub fn blank_v4() Vec4 {
+	return Vec4{
+		e: [
+			f32(0),
+			0,
+			0,
+			1,
+		]!
+	}
+}
+
+// Set all elements to value
+pub fn set_v4(value f32) Vec4 {
+	return Vec4{
+		e: [
+			value,
+			value,
+			value,
+			value,
+		]!
+	}
+}
+
+// Sum of all the elements
+pub fn (x Vec4) sum() f32 {
+	return x.e[0] + x.e[1] + x.e[2] + x.e[3]
+}
+
+/*********************************************************************
+*
+* Operators
+*
+*********************************************************************/
+// Addition
+pub fn (a Vec4) + (b Vec4) Vec4 {
+	return Vec4{
+		e: [
+			a.e[0] + b.e[0],
+			a.e[1] + b.e[1],
+			a.e[2] + b.e[2],
+			a.e[3] + b.e[3],
+		]!
+	}
+}
+
+// Subtraction
+pub fn (a Vec4) - (b Vec4) Vec4 {
+	return Vec4{
+		e: [
+			a.e[0] - b.e[0],
+			a.e[1] - b.e[1],
+			a.e[2] - b.e[2],
+			a.e[3] - b.e[3],
+		]!
+	}
+}
+
+// Dot product
+pub fn (a Vec4) * (b Vec4) f32 {
+	return a.e[0] * b.e[0] + a.e[1] * b.e[1] + a.e[2] * b.e[2] + a.e[3] * b.e[3]
+}
+
+// Cross product
+pub fn (a Vec4) % (b Vec4) Vec4 {
+	return Vec4{
+		e: [
+			(a.e[1] * b.e[2]) - (a.e[2] * b.e[1]),
+			(a.e[2] * b.e[0]) - (a.e[0] * b.e[2]),
+			(a.e[0] * b.e[1]) - (a.e[1] * b.e[0]),
+			0,
+		]!
+	}
+}
+
+// Components multiplication
+pub fn (x Vec4) mul_vec4(y Vec4) Vec4 {
+	return Vec4{
+		e: [
+			x.e[0] * y.e[0],
+			x.e[1] * y.e[1],
+			x.e[2] * y.e[2],
+			x.e[3] * y.e[3],
+		]!
+	}
+}
-- 
cgit v1.2.3