summaryrefslogtreecommitdiff
path: root/src/core/shader.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/shader.c')
-rw-r--r--src/core/shader.c261
1 files changed, 257 insertions, 4 deletions
diff --git a/src/core/shader.c b/src/core/shader.c
index fe25408..b5d8407 100644
--- a/src/core/shader.c
+++ b/src/core/shader.c
@@ -1,8 +1,226 @@
+#include "../math/math.h"
#include "shader.h"
#include "vert.h"
#include "device.h"
-void ssrS_bcpcolor(Vec3* bc, Color A, Color B, Color C, Color* out) {
+float* reg_num_00;
+float* reg_num_01;
+float* reg_num_02;
+float* reg_num_03;
+
+Vec2* reg_v2_00;
+Vec2* reg_v2_01;
+Vec2* reg_v2_02;
+Vec2* reg_v2_03;
+Vec2* reg_v2_04;
+Vec2* reg_v2_05;
+
+Vec3* reg_v3_00;
+Vec3* reg_v3_01;
+Vec3* reg_v3_02;
+Vec3* reg_v3_03;
+Vec3* reg_v3_04;
+Vec3* reg_v3_05;
+Vec3* reg_v3_06;
+Vec3* reg_v3_07;
+
+Vec4* reg_v4_00;
+Vec4* reg_v4_01;
+Vec4* reg_v4_02;
+Vec4* reg_v4_03;
+Vec4* reg_v4_04;
+Vec4* reg_v4_05;
+
+Register reg_num[4] = {
+ { 0, REGTYPE_NUM, NULL },
+ { 0, REGTYPE_NUM, NULL },
+ { 0, REGTYPE_NUM, NULL },
+ { 0, REGTYPE_NUM, NULL },
+};
+
+Register reg_v2[6] = {
+ { 0, REGTYPE_VEC2, NULL },
+ { 0, REGTYPE_VEC2, NULL },
+ { 0, REGTYPE_VEC2, NULL },
+ { 0, REGTYPE_VEC2, NULL },
+ { 0, REGTYPE_VEC2, NULL },
+ { 0, REGTYPE_VEC2, NULL },
+};
+
+Register reg_v3[8] = {
+ { 0, REGTYPE_VEC3, NULL },
+ { 0, REGTYPE_VEC3, NULL },
+ { 0, REGTYPE_VEC3, NULL },
+ { 0, REGTYPE_VEC3, NULL },
+ { 0, REGTYPE_VEC3, NULL },
+ { 0, REGTYPE_VEC3, NULL },
+ { 0, REGTYPE_VEC3, NULL },
+ { 0, REGTYPE_VEC3, NULL },
+};
+
+Register reg_v4[6] = {
+ { 0, REGTYPE_VEC4, NULL },
+ { 0, REGTYPE_VEC4, NULL },
+ { 0, REGTYPE_VEC4, NULL },
+ { 0, REGTYPE_VEC4, NULL },
+ { 0, REGTYPE_VEC4, NULL },
+ { 0, REGTYPE_VEC4, NULL },
+};
+
+void ssrS_setregisters(uint flag, int capacity) {
+#define reg_scale_num(i) \
+if (flag & VARYING_NUM_##i) ssrM_rescalevector(float, reg_num[##i].num, reg_num[##i].length, capacity, FALSE)
+
+#define reg_scale_v2(i) \
+if (flag & VARYING_V2_##i) ssrM_rescalevector(float, reg_v2[##i].v2, reg_v2[##i].length, capacity, FALSE)
+
+#define reg_scale_v3(i) \
+if (flag & VARYING_V3_##i) ssrM_rescalevector(float, reg_v3[##i].v3, reg_v3[##i].length, capacity, FALSE)
+
+#define reg_scale_v4(i) \
+if (flag & VARYING_V4_##i) ssrM_rescalevector(float, reg_v4[##i].v4, reg_v4[##i].length, capacity, FALSE)
+
+ if (!(flag & VARYING_EXTRA))
+ return;
+ if (flag & VARYING_NUM) {
+ reg_scale_num(00);
+ reg_scale_num(01);
+ reg_scale_num(02);
+ reg_scale_num(03);
+ }
+ if (flag & VARYING_V2) {
+ reg_scale_v2(00);
+ reg_scale_v2(01);
+ reg_scale_v2(02);
+ reg_scale_v2(03);
+ reg_scale_v2(04);
+ reg_scale_v2(05);
+ }
+ if (flag & VARYING_V3) {
+ reg_scale_v3(00);
+ reg_scale_v3(01);
+ reg_scale_v3(02);
+ reg_scale_v3(03);
+ reg_scale_v3(04);
+ reg_scale_v3(05);
+ reg_scale_v3(06);
+ reg_scale_v3(07);
+ }
+ if (flag & VARYING_V4) {
+ reg_scale_v4(00);
+ reg_scale_v4(01);
+ reg_scale_v4(02);
+ reg_scale_v4(03);
+ reg_scale_v4(04);
+ reg_scale_v4(05);
+ }
+}
+
+void ssrS_setupregisterpoints(uint extra_varying_flag, int idx) {
+#define set_reg_num_pointer(i)\
+ if (extra_varying_flag & VARYING_NUM_##i) reg_num_##i = &reg_num[##i].num[idx];
+
+#define set_reg_v2_pointer(i)\
+ if (extra_varying_flag & VARYING_V2_##i) reg_v2_##i = &reg_v2[##i].v2[idx];
+
+#define set_reg_v3_pointer(i)\
+ if (extra_varying_flag & VARYING_V3_##i) reg_v3_##i = &reg_v3[##i].v3[idx];
+
+#define set_reg_v4_pointer(i)\
+ if (extra_varying_flag & VARYING_V4_##i) reg_v4_##i = &reg_v4[##i].v4[idx];
+
+ if (!(extra_varying_flag & VARYING_EXTRA))
+ return;
+ if (extra_varying_flag & VARYING_NUM) {
+ set_reg_num_pointer(00);
+ set_reg_num_pointer(01);
+ set_reg_num_pointer(02);
+ set_reg_num_pointer(03);
+ }
+ if (extra_varying_flag & VARYING_V2) {
+ set_reg_v2_pointer(00);
+ set_reg_v2_pointer(01);
+ set_reg_v2_pointer(02);
+ set_reg_v2_pointer(03);
+ set_reg_v2_pointer(04);
+ set_reg_v2_pointer(05);
+ }
+ if (extra_varying_flag & VARYING_V3) {
+ set_reg_v3_pointer(00);
+ set_reg_v3_pointer(01);
+ set_reg_v3_pointer(02);
+ set_reg_v3_pointer(03);
+ set_reg_v3_pointer(04);
+ set_reg_v3_pointer(05);
+ set_reg_v3_pointer(06);
+ set_reg_v3_pointer(07);
+ }
+ if (extra_varying_flag & VARYING_V4) {
+ set_reg_v4_pointer(00);
+ set_reg_v4_pointer(01);
+ set_reg_v4_pointer(02);
+ set_reg_v4_pointer(03);
+ set_reg_v4_pointer(04);
+ set_reg_v4_pointer(05);
+ }
+}
+
+void ssrS_setregtofragin(uint extra_varying_flag, FragmentShaderIn* frag_in){
+#define set_reg_num_pointer_to_fragin(i)\
+ if (extra_varying_flag & VARYING_NUM_##i) reg_num_##i = &frag_in->num[##i];
+
+#define set_reg_v2_pointer_to_fragin(i)\
+ if (extra_varying_flag & VARYING_V2_##i) reg_v2_##i = &frag_in->v2[##i];
+
+#define set_reg_v3_pointer_to_fragin(i)\
+ if (extra_varying_flag & VARYING_V3_##i) reg_v3_##i = &frag_in->v3[##i];
+
+#define set_reg_v4_pointer_to_fragin(i)\
+ if (extra_varying_flag & VARYING_V4_##i) reg_v4_##i = &frag_in->v4[##i];
+
+ if (!(extra_varying_flag & VARYING_EXTRA))
+ return;
+ if (extra_varying_flag & VARYING_NUM) {
+ set_reg_num_pointer_to_fragin(00);
+ set_reg_num_pointer_to_fragin(01);
+ set_reg_num_pointer_to_fragin(02);
+ set_reg_num_pointer_to_fragin(03);
+ }
+ if (extra_varying_flag & VARYING_V2) {
+ set_reg_v2_pointer_to_fragin(00);
+ set_reg_v2_pointer_to_fragin(01);
+ set_reg_v2_pointer_to_fragin(02);
+ set_reg_v2_pointer_to_fragin(03);
+ set_reg_v2_pointer_to_fragin(04);
+ set_reg_v2_pointer_to_fragin(05);
+ }
+ if (extra_varying_flag & VARYING_V3) {
+ set_reg_v3_pointer_to_fragin(00);
+ set_reg_v3_pointer_to_fragin(01);
+ set_reg_v3_pointer_to_fragin(02);
+ set_reg_v3_pointer_to_fragin(03);
+ set_reg_v3_pointer_to_fragin(04);
+ set_reg_v3_pointer_to_fragin(05);
+ set_reg_v3_pointer_to_fragin(06);
+ set_reg_v3_pointer_to_fragin(07);
+ }
+ if (extra_varying_flag & VARYING_V4) {
+ set_reg_v4_pointer_to_fragin(00);
+ set_reg_v4_pointer_to_fragin(01);
+ set_reg_v4_pointer_to_fragin(02);
+ set_reg_v4_pointer_to_fragin(03);
+ set_reg_v4_pointer_to_fragin(04);
+ set_reg_v4_pointer_to_fragin(05);
+ }
+}
+
+float* ssrS_bcpnum(Vec3* bc, float A, float B, float C, float* out) {
+ ssr_assert(bc && out);
+ *out = bc->A * A + bc->B * B + bc->C * C;
+ return out;
+}
+
+Color* ssrS_bcpcolor(Vec3* bc, Color A, Color B, Color C, Color* out) {
ssr_assert(bc && out);
*out = ssr_color(
bc->A * COLOR_R(A) + bc->B * COLOR_R(B) + bc->C * COLOR_R(C),
@@ -10,25 +228,60 @@ void ssrS_bcpcolor(Vec3* bc, Color A, Color B, Color C, Color* out) {
bc->A * COLOR_B(A) + bc->B * COLOR_B(B) + bc->C * COLOR_B(C),
bc->A * COLOR_A(A) + bc->B * COLOR_A(B) + bc->C * COLOR_A(C)
);
+ return out;
}
-void ssrS_bcpvec2(Vec3* bc, Vec2* A, Vec2* B, Vec2* C, Vec2* out) {
+Vec2* ssrS_bcpvec2(Vec3* bc, Vec2* A, Vec2* B, Vec2* C, Vec2* out) {
ssr_assert(bc && A && B && C && out);
out->x = bc->A * A->x + bc->B * B->x + bc->C * C->x;
out->y = bc->A * A->y + bc->B * B->y + bc->C * C->y;
+ return out;
}
-void ssrS_bcpvec3(Vec3* bc, Vec3* A, Vec3* B, Vec3* C, Vec3* out) {
+Vec3* ssrS_bcpvec3(Vec3* bc, Vec3* A, Vec3* B, Vec3* C, Vec3* out) {
ssr_assert(bc && A && B && C && out);
out->x = bc->A * A->x + bc->B * B->x + bc->C * C->x;
out->y = bc->A * A->y + bc->B * B->y + bc->C * C->y;
out->z = bc->A * A->z + bc->B * B->z + bc->C * C->z;
+ return out;
}
-void ssrS_bcpvec4(Vec3* bc, Vec4* A, Vec4* B, Vec4* C, Vec4* out) {
+Vec4* ssrS_bcpvec4(Vec3* bc, Vec4* A, Vec4* B, Vec4* C, Vec4* out) {
ssr_assert(bc && A && B && C && out);
out->x = bc->A * A->x + bc->B * B->x + bc->C * C->x;
out->y = bc->A * A->y + bc->B * B->y + bc->C * C->y;
out->z = bc->A * A->z + bc->B * B->z + bc->C * C->z;
out->w = bc->A * A->w + bc->B * B->w + bc->C * C->w;
+ return out;
+}
+
+void ssrS_lerpnum(float t, float A, float B, float* out) {
+ *out = lerp(A, B, t);
+}
+
+void ssrS_lerpcolor(float t, Color A, Color B, Color* out) {
+ *out = ssr_color(
+ lerp(COLOR_R(A), COLOR_R(B), t),
+ lerp(COLOR_G(A), COLOR_G(B), t),
+ lerp(COLOR_B(A), COLOR_B(B), t),
+ lerp(COLOR_A(A), COLOR_A(B), t)
+ );
+}
+
+void ssrS_lerpvec2(float t, Vec2* A, Vec2* B, Vec2* out) {
+ out->x = lerp(A->x, B->x, t);
+ out->y = lerp(A->y, B->y, t);
+}
+
+void ssrS_lerpvec3(float t, Vec3* A, Vec3* B, Vec3* out) {
+ out->x = lerp(A->x, B->x, t);
+ out->y = lerp(A->y, B->y, t);
+ out->z = lerp(A->z, B->z, t);
+}
+
+void ssrS_lerpvec4(float t, Vec4* A, Vec4* B, Vec4* out) {
+ out->x = lerp(A->x, B->x, t);
+ out->y = lerp(A->y, B->y, t);
+ out->z = lerp(A->z, B->z, t);
+ out->w = lerp(A->w, B->w, t);
}
generated by cgit v1.1-26-g67d0 at 2025-05-18 17:56:34 +0000