summaryrefslogtreecommitdiff
path: root/src/math/quat.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/math/quat.c')
-rw-r--r--src/math/quat.c120
1 files changed, 60 insertions, 60 deletions
diff --git a/src/math/quat.c b/src/math/quat.c
index 8f7274d..07215d2 100644
--- a/src/math/quat.c
+++ b/src/math/quat.c
@@ -35,59 +35,59 @@ sharedEuler = *v;\
v = &sharedEuler;\
}while(0)
-void quat_tostring(Quat* v, char buf[]) {
+void internal_quat_tostring(Quat* v, char buf[]) {
ssr_assert(v);
sprintf(buf, "%8.3f %8.3f %8.3f", v->x, v->y, v->z);
}
-void quat_print(Quat* q) {
+void internal_quat_print(Quat* q) {
ssr_assert(q);
- quat_tostring(q, printbuffer);
+ internal_quat_tostring(q, printbuffer);
printf("\n%s\n", printbuffer);
}
-void euler_tostring(Euler* v, char buf[]) {
+void internal_euler_tostring(Euler* v, char buf[]) {
sprintf(buf, "%8.3f %8.3f %8.3f", v->x, v->y, v->z);
}
-void euler_print(Euler* v) {
- euler_tostring(v, printbuffer);
+void internal_euler_print(Euler* v) {
+ internal_euler_tostring(v, printbuffer);
printf("\n%s\n", printbuffer);
}
-void euler_deg2rad(Euler* in, Euler* out) {
+void internal_euler_deg2rad(Euler* in, Euler* out) {
ssr_assert(in && out);
out->x = radians(in->x);
out->y = radians(in->y);
out->z = radians(in->z);
}
-void euler_rad2deg(Euler* in, Euler* out) {
+void internal_euler_rad2deg(Euler* in, Euler* out) {
ssr_assert(in && out);
out->x = degree(in->x);
out->y = degree(in->y);
out->z = degree(in->z);
}
-Quat quat_make(float rx, float ry, float rz) {
+Quat internal_quat_make(float rx, float ry, float rz) {
Quat rot;
Euler euler = {rx, ry, rz};
- quat_fromeuler(&euler, &rot);
+ internal_quat_fromeuler(&euler, &rot);
return rot;
}
-void euler_toquat(Euler* euler, Quat* out) {
+void internal_euler_toquat(Euler* euler, Quat* out) {
ssr_assert(euler && out);
- quat_fromeuler(euler, out);
+ internal_quat_fromeuler(euler, out);
}
/*这里精度不对*/
-bool quat_isidentity(Quat* q) {
- return compare(quat_magnitude(q), 1.f);
+bool internal_quat_isidentity(Quat* q) {
+ return compare(internal_quat_magnitude(q), 1.f);
}
-void quat_fromaxisangle(Vec3* axis, float angle, Quat* out) {
- ssr_assert(compare(vec3_magnitude2(axis), 1.f));
+void internal_quat_fromaxisangle(Vec3* axis, float angle, Quat* out) {
+ ssr_assert(compare(internal_vec3_magnitude2(axis), 1.f));
angle = radians(angle);
float half = angle * 0.5;
float s = sin(half);
@@ -97,10 +97,10 @@ void quat_fromaxisangle(Vec3* axis, float angle, Quat* out) {
out->z = s * axis->z;
}
-void quat_fromeuler(Euler* el, Quat* out) {
+void internal_quat_fromeuler(Euler* el, Quat* out) {
ssr_assert(el && out);
Euler euler;
- euler_deg2rad(el, &euler);
+ internal_euler_deg2rad(el, &euler);
float cx = cos(euler.x * 0.5f);
float sx = sin(euler.x * 0.5f);
float cy = cos(euler.y * 0.5f);
@@ -111,15 +111,15 @@ void quat_fromeuler(Euler* el, Quat* out) {
Quat qy = {0, sy, 0,cy};
Quat qz = {0, 0,sz,cz};
/*按ZXY顺序*/
- quat_multiply(&qx, &qz, &qx);
- quat_multiply(&qy, &qx, out);
- ssr_assert(quat_isidentity(out));
+ internal_quat_multiply(&qx, &qz, &qx);
+ internal_quat_multiply(&qy, &qx, out);
+ ssr_assert(internal_quat_isidentity(out));
}
/*
** 四元数直接对向量进行旋转和先转成矩阵形式再旋转计算量一样
*/
-void quat_applytovec3(Quat* q, Vec3* v, Vec3* out) {
+void internal_quat_applytovec3(Quat* q, Vec3* v, Vec3* out) {
ssr_assert(q && v && out);
if (v == out) {
shrvec3(v);
@@ -145,13 +145,13 @@ void quat_applytovec3(Quat* q, Vec3* v, Vec3* out) {
out->z = (xz - wy) * v->x + (yz + wx) * v->y + (1.0f - (xx + yy)) * v->z;
}
-void quat_tomat4(Quat* q, Mat4* out) {
+void internal_quat_tomat4(Quat* q, Mat4* out) {
ssr_assert(q && out);
- ssr_assert(quat_isidentity(q));
+ ssr_assert(internal_quat_isidentity(q));
- mat4_setidentity(out);
+ internal_mat4_setidentity(out);
- float x = q->x * 2.0F; /*从quat_applytovec3能得到矩阵形式*/
+ float x = q->x * 2.0F; /*从internal_quat_applytovec3能得到矩阵形式*/
float y = q->y * 2.0F;
float z = q->z * 2.0F;
float xx = q->x * x;
@@ -164,7 +164,7 @@ void quat_tomat4(Quat* q, Mat4* out) {
float wy = q->w * y;
float wz = q->w * z;
- /*和mat4_setaxisangle实际上结果一样*/
+ /*和internal_mat4_setaxisangle实际上结果一样*/
out->l[0] = 1.0f - (yy + zz);
out->l[1] = xy + wz;
out->l[2] = xz - wy;
@@ -178,20 +178,20 @@ void quat_tomat4(Quat* q, Mat4* out) {
out->l[10] = 1.0f - (xx + yy);
}
-void quat_toeuler(Quat* q, Euler* out) {
+void internal_quat_toeuler(Quat* q, Euler* out) {
ssr_assert(q && out);
Mat4 mat;
- quat_tomat4(q, &mat); /*计算变换矩阵*/
- mat4_toeuler(&mat, out); /*mat是按照RyRxRz顺序(z->y->x)的旋转矩阵*/
+ internal_quat_tomat4(q, &mat); /*计算变换矩阵*/
+ internal_mat4_toeuler(&mat, out); /*mat是按照RyRxRz顺序(z->y->x)的旋转矩阵*/
}
-void quat_normalize(Quat* q, Quat* out) {
+void internal_quat_normalize(Quat* q, Quat* out) {
ssr_assert(q && out);
- float mag = quat_magnitude(q);
- quat_scale(q, 1.f/mag, out);
+ float mag = internal_quat_magnitude(q);
+ internal_quat_scale(q, 1.f/mag, out);
}
-void quat_scale(Quat* q, float scale, Quat* out) {
+void internal_quat_scale(Quat* q, float scale, Quat* out) {
ssr_assert(q && out);
out->x = q->x * scale;
out->y = q->y * scale;
@@ -199,7 +199,7 @@ void quat_scale(Quat* q, float scale, Quat* out) {
out->w = q->w * scale;
}
-void quat_negtive(Quat* in, Quat* out) {
+void internal_quat_negtive(Quat* in, Quat* out) {
ssr_assert(in && out);
out->w = -in->w;
out->x = -in->x;
@@ -207,7 +207,7 @@ void quat_negtive(Quat* in, Quat* out) {
out->z = -in->z;
}
-void quat_devide(Quat* q, float k, Quat* out) {
+void internal_quat_devide(Quat* q, float k, Quat* out) {
ssr_assert(q && out);
k = 1 / k;
out->w = q->w * k;
@@ -216,31 +216,31 @@ void quat_devide(Quat* q, float k, Quat* out) {
out->z = q->z * k;
}
-void quat_invert(Quat* q, Quat* out) {
+void internal_quat_invert(Quat* q, Quat* out) {
ssr_assert(q && out);
- float mag2 = quat_magnitude2(q);
- quat_conjugate(q, out);
- quat_devide(out, mag2, out);
+ float mag2 = internal_quat_magnitude2(q);
+ internal_quat_conjugate(q, out);
+ internal_quat_devide(out, mag2, out);
/*实际上如果是单位四元数，共轭就是逆*/
}
-bool quat_setlookrotation(Vec3* view, Vec3* up, Quat* out) {
+bool internal_quat_setlookrotation(Vec3* view, Vec3* up, Quat* out) {
ssr_assert(view && up && out);
Mat4 m;
- mat4_setlookrotation(view, up, &m); /*先以view为准构建正交矩阵*/
- mat4_toquat(&m, out);
+ internal_mat4_setlookrotation(view, up, &m); /*先以view为准构建正交矩阵*/
+ internal_mat4_toquat(&m, out);
return 1;
}
/*q1 * q2^-1*/
-void quat_minus(Quat* q1, Quat* q2, Quat* out) {
+void internal_quat_minus(Quat* q1, Quat* q2, Quat* out) {
ssr_assert(q1 && q2 && out);
- Quat q2i; quat_invert(q2, &q2i);
- quat_multiply(q1, &q2i, out);
+ Quat q2i; internal_quat_invert(q2, &q2i);
+ internal_quat_multiply(q1, &q2i, out);
}
/*q1*q2*/
-void quat_multiply(Quat* q1, Quat* q2, Quat* out) {
+void internal_quat_multiply(Quat* q1, Quat* q2, Quat* out) {
ssr_assert(q1 && q2 && out);
float w1 = q1->w, x1 = q1->x, y1 = q1->y, z1 = q1->z,
@@ -254,7 +254,7 @@ void quat_multiply(Quat* q1, Quat* q2, Quat* out) {
/*
** 共轭的几何意义是颠倒旋转轴方向，代表了和q相反的角位移
*/
-void quat_conjugate(Quat* in, Quat* out) {
+void internal_quat_conjugate(Quat* in, Quat* out) {
ssr_assert(in && out);
out->w = in->w;
out->x = -in->x;
@@ -262,25 +262,25 @@ void quat_conjugate(Quat* in, Quat* out) {
out->z = -in->z;
}
-float quat_dot(Quat* q1, Quat* q2) {
+float internal_quat_dot(Quat* q1, Quat* q2) {
ssr_assert(q1 && q2);
return (q1->x*q2->x + q1->y*q2->y + q1->z*q2->z + q1->w*q2->w);
}
-float quat_magnitude(Quat* q) {
+float internal_quat_magnitude(Quat* q) {
ssr_assert(q);
- return sqrt(quat_dot(q, q));
+ return sqrt(internal_quat_dot(q, q));
}
-float quat_magnitude2(Quat* q) {
+float internal_quat_magnitude2(Quat* q) {
ssr_assert(q);
- return quat_dot(q, q);
+ return internal_quat_dot(q, q);
}
-void quat_slerp(Quat* q1, Quat* q2, float t, Quat* out) {
+void internal_quat_slerp(Quat* q1, Quat* q2, float t, Quat* out) {
ssr_assert(q1 && q2 && out);
- ssr_assert(quat_isidentity(q1) && quat_isidentity(q2)); /*适用于单位四元数*/
- float dot = quat_dot(q1, q2);
+ ssr_assert(internal_quat_isidentity(q1) && internal_quat_isidentity(q2)); /*适用于单位四元数*/
+ float dot = internal_quat_dot(q1, q2);
Quat temp;
if (dot < 0.0f) {
dot = -dot;
@@ -302,14 +302,14 @@ void quat_slerp(Quat* q1, Quat* q2, float t, Quat* out) {
out->z = (q1->z*sinaomt + temp.z*sinat)*sinadiv;
out->w = (q1->w*sinaomt + temp.w*sinat)*sinadiv;
} else { /*小范围时使用lerp*/
- quat_lerp(q1, &temp, t, out);
+ internal_quat_lerp(q1, &temp, t, out);
}
}
-void quat_lerp(Quat* q1, Quat* q2, float t, Quat* out) {
+void internal_quat_lerp(Quat* q1, Quat* q2, float t, Quat* out) {
ssr_assert(q1 && q2 && out);
float t2 = 1 - t;
- if (quat_dot(q1, q2) < 0.f) { /*点乘不能是负的，翻转一个四元数的符号，使得落回360°*/
+ if (internal_quat_dot(q1, q2) < 0.f) { /*点乘不能是负的，翻转一个四元数的符号，使得落回360°*/
out->x = q1->x * t2 - t * q2->x;
out->y = q1->y * t2 - t * q2->y;
out->z = q1->z * t2 - t * q2->z;
@@ -320,5 +320,5 @@ void quat_lerp(Quat* q1, Quat* q2, float t, Quat* out) {
out->z = q1->z * t2 + t * q2->z;
out->w = q1->w * t2 + t * q2->w;
}
- quat_normalize(out, out);
+ internal_quat_normalize(out, out);
}
generated by cgit v1.1-26-g67d0 at 2025-05-23 21:39:04 +0000