1 files changed, 66 insertions, 66 deletions

diff --git a/src/test/test_mat4.c b/src/test/test_mat4.c
index e7a65fc..3ad56a4 100644
--- a/src/test/test_mat4.c
+++ b/src/test/test_mat4.c
@@ -19,8 +19,8 @@ Mat4 m2 = {
 static void test_multiply() {
 	print("test_multiply\n");
 	Mat4 res;
-	mat4_multiply(&m1, &m2, &res);
-	mat4_print(&res);
+	internal_mat4_multiply(&m1, &m2, &res);
+	internal_mat4_print(&res);
 }
 
 static void test_invert() {
@@ -32,11 +32,11 @@ static void test_invert() {
 		6, 0, 2, 1,
 	};
 	Mat4 res, res2;
-	mat4_invertfull(&m, &res);
-	mat4_print(&res);
-	mat4_multiply(&m1, &m, &res2);
-	mat4_multiply(&res2, &res, &res2);
-	mat4_print(&res2);
+	internal_mat4_invertfull(&m, &res);
+	internal_mat4_print(&res);
+	internal_mat4_multiply(&m1, &m, &res2);
+	internal_mat4_multiply(&res2, &res, &res2);
+	internal_mat4_print(&res2);
 	/*
 	-0.250    0.333    1.667   -1.833
 	0.083    0.000   -0.667    0.833
@@ -48,68 +48,68 @@ static void test_invert() {
 static void test_transpose() {
 	print("test_transpose\n");
 	Mat4 res;
-	mat4_transpose(&m1, &res);
-	mat4_print(&res);
+	internal_mat4_transpose(&m1, &res);
+	internal_mat4_print(&res);
 }
 
 static void test_scale() {
 	print("test_scale\n");
 	Mat4 scale;
-	mat4_setscale(1, 2, 3, &scale);
+	internal_mat4_setscale(1, 2, 3, &scale);
 	Mat4 res;
-	mat4_multiply(&scale, &m1, &res);
-	mat4_print(&scale);
+	internal_mat4_multiply(&scale, &m1, &res);
+	internal_mat4_print(&scale);
 }
 
 static void test_position() {
 	print("test_position\n");
 	Mat4 pos;
-	mat4_setposition(1, 2, 3, &pos);
-	mat4_print(&pos);
+	internal_mat4_setposition(1, 2, 3, &pos);
+	internal_mat4_print(&pos);
 }
 
 static void test_rotation() {
 	print("test_rotation\n");
 	Mat4 i;
-	mat4_setidentity(&i);
+	internal_mat4_setidentity(&i);
 	Vec3 axis = { 0, 0, 1 };
-	mat4_rotate(&i, 90, &axis, &i);
-	mat4_print(&i);
+	internal_mat4_rotate(&i, 90, &axis, &i);
+	internal_mat4_print(&i);
 }
 
 static void test_invertgeneral3d() {
 	print("test_invertgeneral3d\n");
 	Mat4 trans;
-	mat4_setidentity(&trans);
-	print("original matrix"); mat4_print(&m1);
+	internal_mat4_setidentity(&trans);
+	print("original matrix"); internal_mat4_print(&m1);
 	Vec3 v;
-	v.x = 1; v.y = 3.3; v.z = 0; mat4_translate(&trans, &v, &trans);
-	v.x = 1; v.y = 0; v.z = 0; mat4_rotate(&trans, 23, &v, &trans);
-	v.x = 1; v.y = 1.2; v.z = 1; mat4_scale(&trans, &v, &trans);
-	v.x = 1; v.y = 3; v.z = 0; mat4_rotate(&trans, 23, &v, &trans);
-	v.x = 2; v.y = 3.3; v.z = 0; mat4_translate(&trans, &v, &trans);
-	print("transform matrix"); mat4_print(&trans);
+	v.x = 1; v.y = 3.3; v.z = 0; internal_mat4_translate(&trans, &v, &trans);
+	v.x = 1; v.y = 0; v.z = 0; internal_mat4_rotate(&trans, 23, &v, &trans);
+	v.x = 1; v.y = 1.2; v.z = 1; internal_mat4_scale(&trans, &v, &trans);
+	v.x = 1; v.y = 3; v.z = 0; internal_mat4_rotate(&trans, 23, &v, &trans);
+	v.x = 2; v.y = 3.3; v.z = 0; internal_mat4_translate(&trans, &v, &trans);
+	print("transform matrix"); internal_mat4_print(&trans);
 	Mat4 res;
-	mat4_multiply(&trans, &m1, &res);
-	mat4_invertgeneral3d(&trans, &trans);
-	print("inverse transform matrix");	mat4_print(&trans);
-	mat4_multiply(&trans, &res, &res);
-	print("inverted result");	mat4_print(&res);
+	internal_mat4_multiply(&trans, &m1, &res);
+	internal_mat4_invertgeneral3d(&trans, &trans);
+	print("inverse transform matrix");	internal_mat4_print(&trans);
+	internal_mat4_multiply(&trans, &res, &res);
+	print("inverted result");	internal_mat4_print(&res);
 }
 
 void test_invertrot() {
 	print("test_invertrot\n");
-	print("original matrix"); mat4_print(&m1);
-	Mat4 rot; mat4_setidentity(&rot);
-	Vec3 axis = { 1,2,3 }; mat4_rotate(&rot, 90, &axis, &rot);
-	print("rotation matrix"); mat4_print(&rot);
+	print("original matrix"); internal_mat4_print(&m1);
+	Mat4 rot; internal_mat4_setidentity(&rot);
+	Vec3 axis = { 1,2,3 }; internal_mat4_rotate(&rot, 90, &axis, &rot);
+	print("rotation matrix"); internal_mat4_print(&rot);
 	Mat4 res;
-	mat4_multiply(&rot, &m1, &res);
-	print("result matrix"); mat4_print(&res);
-	mat4_invertgeneral3d(&rot, &rot);
-	print("inverse rotation matrix"); mat4_print(&rot);
-	mat4_multiply(&rot, &res, &res);
-	print("result matrix"); mat4_print(&res);
+	internal_mat4_multiply(&rot, &m1, &res);
+	print("result matrix"); internal_mat4_print(&res);
+	internal_mat4_invertgeneral3d(&rot, &rot);
+	print("inverse rotation matrix"); internal_mat4_print(&rot);
+	internal_mat4_multiply(&rot, &res, &res);
+	print("result matrix"); internal_mat4_print(&res);
 }
 
 TEST(test_orthogonalize)
@@ -121,55 +121,55 @@ TEST(test_orthogonalize)
 	);
 	Mat4 A;
 
-	TIME_STAMP("mat4_orthogonalize time used")
+	TIME_STAMP("internal_mat4_orthogonalize time used")
 	for (int i = 0; i < 1000000; ++i) {
-		mat4_orthogonalize(&A0, &A);
+		internal_mat4_orthogonalize(&A0, &A);
 	}
 	TIME_STAMP_END
 
-	TIME_STAMP("mat4_isorthogonal time used")
+	TIME_STAMP("internal_mat4_isorthogonal time used")
 	for (int i = 0; i < 1000000; ++i) {
-		mat4_isorthogonal(&A0);
+		internal_mat4_isorthogonal(&A0);
 	}
 	TIME_STAMP_END
 
-	mat4_print(&A);
-	float res = vec3_dot(&A.basis.y, &A.basis.x);
+	internal_mat4_print(&A);
+	float res = internal_vec3_dot(&A.basis.y, &A.basis.x);
 	printf("%f\n", res);
-	printf("%d\n", mat4_isorthogonal(&A));
+	printf("%d\n", internal_mat4_isorthogonal(&A));
 	Mat4 rev;
-	mat4_transpose(&A, &rev);
-	mat4_multiply(&A, &rev, &rev);
-	mat4_print(&rev);
+	internal_mat4_transpose(&A, &rev);
+	internal_mat4_multiply(&A, &rev, &rev);
+	internal_mat4_print(&rev);
 END
 
 TEST(test_toeuler)
 	Euler euler = { 90, 0, 33 };
 	Quat rot;
-	quat_fromeuler(&euler, &rot);
+	internal_quat_fromeuler(&euler, &rot);
 	Mat4 m;
-	quat_tomat4(&rot, &m);
+	internal_quat_tomat4(&rot, &m);
 	Euler res;
-	quat_toeuler(&rot, &res);
-	euler_print(&res);
+	internal_quat_toeuler(&rot, &res);
+	internal_euler_print(&res);
 END
 
 TEST(test_rotatematrix)
 	Euler euler = { 10, 20, 30 };
 	Quat rot;
-	quat_fromeuler(&euler, &rot);
+	internal_quat_fromeuler(&euler, &rot);
 	Mat4 m;
-	quat_tomat4(&rot, &m);
-	mat4_print(&m);
+	internal_quat_tomat4(&rot, &m);
+	internal_mat4_print(&m);
 	Mat4 mz, mx, my;
-	mat4_setrotatez(30, &mz);
-	mat4_setrotatex(10, &mx);
-	mat4_setrotatey(20, &my);
-	mat4_multiply(&mx, &mz, &mx);
-	mat4_multiply(&my, &mx, &m);
-	mat4_print(&m);
-	mat4_setrotate(10, 20, 30, &m);
-	mat4_print(&m);
+	internal_mat4_setrotatez(30, &mz);
+	internal_mat4_setrotatex(10, &mx);
+	internal_mat4_setrotatey(20, &my);
+	internal_mat4_multiply(&mx, &mz, &mx);
+	internal_mat4_multiply(&my, &mx, &m);
+	internal_mat4_print(&m);
+	internal_mat4_setrotate(10, 20, 30, &m);
+	internal_mat4_print(&m);
 END
 
 TEST(test_isidentity)
@@ -181,7 +181,7 @@ TEST(test_isidentity)
 	)
 	bool res;
 	TIME_STAMP_1000000("test is isidentity")
-	res = mat4_isidentity(&mat);
+	res = internal_mat4_isidentity(&mat);
 	TIME_STAMP_END
 	printf("%d\n", res);
 END