*鍔爄nternal鍓嶇紑

3 files changed, 32 insertions, 32 deletions

diff --git a/src/core/device.c b/src/core/device.c
index 6b2bb7c..ac055c9 100644
--- a/src/core/device.c
+++ b/src/core/device.c
@@ -151,7 +151,7 @@ void ssr_matrixmode(ssr_MatrixMode mode) {
 }
 
 void ssr_loadidentity() {
-	mat4_setidentity(&MATRIX);
+	internal_mat4_setidentity(&MATRIX);
 }
 
 void ssr_pushmatrix() {
@@ -168,34 +168,34 @@ void ssr_popmatrix() {
 void ssr_lookat(Vec3* pos, Vec3* target, Vec3* up) {
 	ssr_assert(pos && target && up);
 	Vec3 z;
-	vec3_minus(pos, target, &z); vec3_normalize(&z, &z); /*去除缩放影响*/
+	internal_vec3_minus(pos, target, &z); internal_vec3_normalize(&z, &z); /*去除缩放影响*/
 	Vec3 x;
-	vec3_cross(up, &z, &x); vec3_normalize(&x, &x);
+	internal_vec3_cross(up, &z, &x); internal_vec3_normalize(&x, &x);
 	Vec3 y;
-	vec3_cross(&z, &x, &y); vec3_normalize(&y, &y);
+	internal_vec3_cross(&z, &x, &y); internal_vec3_normalize(&y, &y);
 	Mat4 m = { /*注意这里是列主序*/
 		x.x,                 y.x,                 z.x,                0,
 		x.y,                 y.y,                 z.y,                0,
 		x.z,                 y.z,                 z.z,                0,
-		-vec3_dot(&x, pos),  -vec3_dot(&y, pos),  -vec3_dot(&z, pos), 1
+		-internal_vec3_dot(&x, pos),  -internal_vec3_dot(&y, pos),  -internal_vec3_dot(&z, pos), 1
 	};
-	mat4_multiply(&MATRIX, &m, &MATRIX);
+	internal_mat4_multiply(&MATRIX, &m, &MATRIX);
 }
 
 void ssr_scale(float sx, float sy, float sz) {
 	Vec3 scale = { sx, sy, sz };
-	mat4_scale(&MATRIX, &scale, &MATRIX);
+	internal_mat4_scale(&MATRIX, &scale, &MATRIX);
 }
 
 void ssr_rotate(float angle, float x, float y, float z) {
 	Vec3 axis = { x, y, z };
-	vec3_normalize(&axis, &axis);
-	mat4_rotate(&MATRIX, angle, &axis, &MATRIX);
+	internal_vec3_normalize(&axis, &axis);
+	internal_mat4_rotate(&MATRIX, angle, &axis, &MATRIX);
 }
 
 void ssr_translate(float x, float y, float z) {
 	Vec3 trans = { x, y, z };
-	mat4_translate(&MATRIX, &trans, &MATRIX);
+	internal_mat4_translate(&MATRIX, &trans, &MATRIX);
 }
 
 void ssr_loadmatrix(Mat4* m) {
@@ -205,13 +205,13 @@ void ssr_loadmatrix(Mat4* m) {
 
 void ssr_multmatrix(Mat4* m) {
 	ssr_assert(m);
-	mat4_multiply(&MATRIX, m, &MATRIX);
+	internal_mat4_multiply(&MATRIX, m, &MATRIX);
 }
 
 void ssr_getmvp(Mat4* out) {
 	ssr_assert(out);
-	mat4_multiply(&GETMATRIX(MATRIX_VIEW), &GETMATRIX(MATRIX_MODEL), out);
-	mat4_multiply(&GETMATRIX(MATRIX_PROJECTION), out, out);
+	internal_mat4_multiply(&GETMATRIX(MATRIX_VIEW), &GETMATRIX(MATRIX_MODEL), out);
+	internal_mat4_multiply(&GETMATRIX(MATRIX_PROJECTION), out, out);
 }
 
 void ssr_getm(Mat4* out) {
@@ -221,7 +221,7 @@ void ssr_getm(Mat4* out) {
 
 void ssr_getmv(Mat4* out) {
 	ssr_assert(out);
-	mat4_multiply(&GETMATRIX(MATRIX_VIEW), &GETMATRIX(MATRIX_MODEL), out);
+	internal_mat4_multiply(&GETMATRIX(MATRIX_VIEW), &GETMATRIX(MATRIX_MODEL), out);
 }
 
 void ssr_enable(uint mask) {
@@ -245,22 +245,22 @@ void ssr_viewport(float l, float r, float b, float t) {
 
 void ssr_ortho(float l, float r, float b, float t, float n, float f) {
 	Mat4 m;
-	mat4_setortho(l, r, b, t, n, f, &m);
-	mat4_multiply(&MATRIX, &m, &MATRIX);
+	internal_mat4_setortho(l, r, b, t, n, f, &m);
+	internal_mat4_multiply(&MATRIX, &m, &MATRIX);
 }
 
 void ssr_frustum(float l, float r, float b, float t, float n, float f) {
 	ssr_assert(n > 0 && f > 0 && f > n);
 	Mat4 m;
-	mat4_setfrustum(l, r, b, t, n, f, &m);
-	mat4_multiply(&MATRIX, &m, &MATRIX);
+	internal_mat4_setfrustum(l, r, b, t, n, f, &m);
+	internal_mat4_multiply(&MATRIX, &m, &MATRIX);
 }
 
 void ssr_perspective(float fov, float aspect, float n, float f) {
 	ssr_assert(n > 0 && f > 0 && f > n);
 	Mat4 m;
-	mat4_setperspective(fov, aspect, n, f, &m);
-	mat4_multiply(&MATRIX, &m, &MATRIX);
+	internal_mat4_setperspective(fov, aspect, n, f, &m);
+	internal_mat4_multiply(&MATRIX, &m, &MATRIX);
 }
 
 void ssr_present() {
diff --git a/src/core/rasterizer.c b/src/core/rasterizer.c
index d926cb0..0c78893 100644
--- a/src/core/rasterizer.c
+++ b/src/core/rasterizer.c
@@ -50,7 +50,7 @@ bool ssrR_barycentric(Vec2* A, Vec2* B, Vec2* C, Vec2* p, Vec3* out) {
 	Vec3 s[2], u;
 	s[0].x = C->x - A->x; s[0].y = B->x - A->x; s[0].z = A->x - p->x;
 	s[1].x = C->y - A->y; s[1].y = B->y - A->y; s[1].z = A->y - p->y;
-	vec3_cross(&s[0], &s[1], &u);
+	internal_vec3_cross(&s[0], &s[1], &u);
 	if (compare(u.z, 0)) {
 		return 0;
 	} else {
@@ -93,9 +93,9 @@ void ssrR_triangle(
 	ssr_assert(CA && CB && CC && program);
 
 	Vec4 SA, SB, SC;
-	vec4_dividewnoz(CA, &SA); ssrU_viewport(&SA, &SA);
-	vec4_dividewnoz(CB, &SB); ssrU_viewport(&SB, &SB);
-	vec4_dividewnoz(CC, &SC); ssrU_viewport(&SC, &SC);
+	internal_vec4_dividewnoz(CA, &SA); ssrU_viewport(&SA, &SA);
+	internal_vec4_dividewnoz(CB, &SB); ssrU_viewport(&SB, &SB);
+	internal_vec4_dividewnoz(CC, &SC); ssrU_viewport(&SC, &SC);
 
 /*
 	puttriangle(&SA, &SB, &SC, 0xffff0000);
@@ -151,7 +151,7 @@ void ssrR_triangle(
 		for (p.x = from; order * (p.x - to) <= 0; p.x += order) {	          \
 			/*calculate barycentric coordinate*/															\
 			s[0].z = sa->x - p.x;																		          \
-			vec3_cross(&s[0], &s[1], &u);													            \
+			internal_vec3_cross(&s[0], &s[1], &u);													            \
 			discardif(compare(u.z, 0));														            \
 			u.z = 1.f / u.z;																			            \
 			bc.x = 1.f - (u.x + u.y) * u.z;											              \
@@ -160,7 +160,7 @@ void ssrR_triangle(
 			discardif(bc.x < 0 || bc.y < 0 || bc.z < 0);				              \
 			/*perspective correction*/																	      \
 			bc.x *= CAw; bc.y *= CBw; bc.z *= CCw;							              \
-			vec3_scale(&bc, 1.f / (bc.x + bc.y + bc.z), &bc);                 \
+			internal_vec3_scale(&bc, 1.f / (bc.x + bc.y + bc.z), &bc);                 \
 			/*early depth testing*/																			      \
 			if(depth_test){											                              \
 				depth = bc.x*sa->z + bc.y*sb->z + bc.z*sc->z;										\
@@ -238,8 +238,8 @@ void ssrR_line(
 	ssr_assert(CA && CB && program && uniforms);
 
 	Vec4 SA, SB;
-	vec4_dividewnoz(CA, &SA); ssrU_viewport(&SA, &SA);
-	vec4_dividewnoz(CB, &SB); ssrU_viewport(&SB, &SB);
+	internal_vec4_dividewnoz(CA, &SA); ssrU_viewport(&SA, &SA);
+	internal_vec4_dividewnoz(CB, &SB); ssrU_viewport(&SB, &SB);
 
 	FragmentShader frag_shader = program->fragmentshader;
 	
@@ -329,7 +329,7 @@ void ssrR_point(Vec4* CA, uint IA, Program* program, UniformCollection* uniforms
 	FragmentShader frag_shader = program->fragmentshader;
 
 	Vec3 SA; 
-	vec4_dividew(CA, &SA); ssrU_viewport(&SA, &SA);
+	internal_vec4_dividew(CA, &SA); ssrU_viewport(&SA, &SA);
 
 	bool depth_test = ssr_isenable(ENABLE_DEPTHTEST);
 	bool blend = ssr_isenable(ENABLE_BLEND);
diff --git a/src/core/texture.c b/src/core/texture.c
index bb33bae..ecde0f4 100644
--- a/src/core/texture.c
+++ b/src/core/texture.c
@@ -107,9 +107,9 @@ Color32 texture_sampling(Texture* tex, float x01, float y01) {
 		bl = sampling(tex, wrap_mode, x_min, y_max);
 		br = sampling(tex, wrap_mode, x_max, y_max);
 
-		vec4_lerp(&tl, &tr, x - x_min, &t);
-		vec4_lerp(&bl, &br, x - x_min, &b);
-		vec4_lerp(&t, &b, y - y_min, &out);
+		internal_vec4_lerp(&tl, &tr, x - x_min, &t);
+		internal_vec4_lerp(&bl, &br, x - x_min, &b);
+		internal_vec4_lerp(&t, &b, y - y_min, &out);
 
 		return out;
 	}