summaryrefslogtreecommitdiff
path: root/src/test
diff options
context:
space:
mode:
Diffstat (limited to 'src/test')
-rw-r--r--src/test/test_mat4.c132
-rw-r--r--src/test/test_quat.c60
2 files changed, 96 insertions, 96 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
diff --git a/src/test/test_quat.c b/src/test/test_quat.c
index 5d86842..1b85361 100644
--- a/src/test/test_quat.c
+++ b/src/test/test_quat.c
@@ -6,25 +6,25 @@ TEST(test_euler)
Euler e = {90, 90, 0};
Vec3 p = {2,3,4}, res;
Quat qut;
-quat_fromeuler(&e, &qut);
-quat_applytovec3(&qut, &p, &res);
-vec3_print(&res);
+internal_quat_fromeuler(&e, &qut);
+internal_quat_applytovec3(&qut, &p, &res);
+internal_vec3_print(&res);
/*ÓÃÖá½Ç¶¨Òå*/
Vec3 axis = { 1, 0,0 };
Quat qut2;
-quat_fromaxisangle(&axis, 90, &qut2);
-quat_applytovec3(&qut, &p, &res);
-vec3_print(&res);
+internal_quat_fromaxisangle(&axis, 90, &qut2);
+internal_quat_applytovec3(&qut, &p, &res);
+internal_vec3_print(&res);
Mat4 mat;
-quat_tomat4(&qut, &mat);
-mat4_print(&mat);
+internal_quat_tomat4(&qut, &mat);
+internal_mat4_print(&mat);
Vec4 p2 = { 2,3,4,1 };
Vec4 res2;
-mat4_mulvec4(&mat, &p2, &res2);
-vec4_print(&res2);
+internal_mat4_mulvec4(&mat, &p2, &res2);
+internal_vec4_print(&res2);
END
@@ -32,46 +32,46 @@ TEST(test_quat2euler)
Euler e = { 10, 20, 30};
Quat q;
-euler_toquat(&e, &q);
-euler_deg2rad(&e, &e);
-quat_print(&q);
-euler_print(&e);
+internal_euler_toquat(&e, &q);
+internal_euler_deg2rad(&e, &e);
+internal_quat_print(&q);
+internal_euler_print(&e);
Euler res;
-quat_toeuler(&q, &res);
+internal_quat_toeuler(&q, &res);
-euler_print(&res);
+internal_euler_print(&res);
-quat_fromeuler(&res, &q);
-quat_print(&q);
+internal_quat_fromeuler(&res, &q);
+internal_quat_print(&q);
END
TEST(test_conjugate)
Quat rot;
Vec3 axis = {2,3,4};
-vec3_normalize(&axis, &axis);
-quat_fromaxisangle(&axis, 46, &rot);
+internal_vec3_normalize(&axis, &axis);
+internal_quat_fromaxisangle(&axis, 46, &rot);
Vec3 p = {12, 3, 55};
-vec3_print(&p);
+internal_vec3_print(&p);
Vec3 res;
-quat_applytovec3(&rot, &p, &res);
-vec3_print(&res);
+internal_quat_applytovec3(&rot, &p, &res);
+internal_vec3_print(&res);
Quat rev;
-quat_invert(&rot, &rev);
-quat_applytovec3(&rev, &res, &res);
-vec3_print(&res);
+internal_quat_invert(&rot, &rev);
+internal_quat_applytovec3(&rev, &res, &res);
+internal_vec3_print(&res);
END
TEST(test_lookrotation)
Vec3 view = {1, 0, 0};
Vec3 up = {0, 1, 0};
Quat rot;
-quat_setlookrotation(&view, &up, &rot);
-quat_print(&rot);
+internal_quat_setlookrotation(&view, &up, &rot);
+internal_quat_print(&rot);
Euler euler;
-quat_toeuler(&rot, &euler);
-euler_print(&euler);
+internal_quat_toeuler(&rot, &euler);
+internal_euler_print(&euler);
END
void test_quat() {
generated by cgit v1.1-26-g67d0 at 2025-05-28 19:48:41 +0000