*光源

9 files changed, 66 insertions, 100 deletions

diff --git a/src/core/clip.c b/src/core/clip.c
index 8fe1eeb..071b14b 100644
--- a/src/core/clip.c
+++ b/src/core/clip.c
@@ -1,6 +1,8 @@
 #include "clip.h"
 #include "shader.h"
 
+/*from mesa3d*/
+
 typedef enum {
 	POSITIVE_W,
 	POSITIVE_X,
@@ -151,31 +153,31 @@ bool clip_triangle(Vec4* c0, Vec4* c1, Vec4* c2, Vert* v0, Vert* v1, Vert* v2, u
 	static ClippedBuffer temp;
 
 	/*copy vert data to temp*/
-	temp.count = 3; 
+	temp.count = 3;
 #define INIT_CLIP_VERT(idx) \
 	temp.vertices[idx].clip_coord = *c##idx;												 	 \
 	temp.vertices[idx].vertex = *v##idx;														 	 \
 	if (varying_flag & VARYING_EXTRA) {															 	 \
 		int i = 0;																										 	 \
-		if(varying_flag && VARYING_NUM) {															 	 \
+		if(varying_flag & VARYING_NUM) {															 	 \
 			for (i = 0; i < REG_NUM_COUNT; ++i) {													 \
 				if (varying_flag & (VARYING_NUM_00 << i))										 \
 					temp.vertices[idx].num[i] = reg_num[i].num[v##idx->index]; \
 			}																															 \
 		}																															 	 \
-		if(varying_flag && VARYING_V2) {															 	 \
+		if(varying_flag & VARYING_V2) {															 	 \
 			for (i = 0; i < REG_V2_COUNT; ++i) {													 \
 				if (varying_flag & (VARYING_V2_00 << i))										 \
 					temp.vertices[idx].v2[i] = reg_v2[i].v2[v##idx->index];		 \
 			}																															 \
 		}																																 \
-		if(varying_flag && VARYING_V3) {															 	 \
+		if(varying_flag & VARYING_V3) {															 	 \
 			for (i = 0; i < REG_V3_COUNT; ++i) {													 \
 				if (varying_flag & (VARYING_V3_00 << i))										 \
 					temp.vertices[idx].v3[i] = reg_v3[i].v3[v##idx->index];		 \
 			}																															 \
 		}																																 \
-		if(varying_flag && VARYING_V4) {															 	 \
+		if(varying_flag & VARYING_V4) {															 	 \
 			for (i = 0; i < REG_V4_COUNT; ++i) {													 \
 				if (varying_flag & (VARYING_V4_00 << i))										 \
 					temp.vertices[idx].v4[i] = reg_v4[i].v4[v##idx->index];		 \
diff --git a/src/core/device.c b/src/core/device.c
index f6b1a4e..b9c024c 100644
--- a/src/core/device.c
+++ b/src/core/device.c
@@ -289,7 +289,7 @@ void ssr_draw(ssr_PrimitiveType primitive) {
 	state.uniforms.mv         = &mv;
 
 	uint varying_flag = state.program->varying_flag;
-	bool use_extra_varyings = varying_flag & VARYING_EXTRA;
+	bool use_extra_varyings = (varying_flag & VARYING_EXTRA) != 0;
 
 	/*prepare registers if necessary*/
 	if (use_extra_varyings) {
@@ -362,7 +362,7 @@ void ssr_draw(ssr_PrimitiveType primitive) {
 			} else {
 				if (clipped_buffer.count >= 3) {
 					ClippedVert* vt0 = &clipped_buffer.vertices[0], *vt1, *vt2;
-					for (int i = 1; i <= clipped_buffer.count - 2; ++i) { /*0->i->i+1*/
+					for (int i = 1; i <= clipped_buffer.count - 2; ++i) {
 						vt1 = &clipped_buffer.vertices[i];
 						vt2 = &clipped_buffer.vertices[i + 1];
 						h0 = &vt0->clip_coord; h1 = &vt1->clip_coord; h2 = &vt2->clip_coord;
diff --git a/src/core/rasterizer.c b/src/core/rasterizer.c
index 5503e69..d39e246 100644
--- a/src/core/rasterizer.c
+++ b/src/core/rasterizer.c
@@ -84,7 +84,14 @@ static void puttriangle(Vec2* A, Vec2* B, Vec2* C, Color c) {
 
 extern FragmentShaderIn ssr_frag_in;
 
-void ssrR_triangle(Vec4* CA, Vec4* CB, Vec4* CC, Vert* A, Vert* B, Vert* C, bool from_reg, ClippedVert* CVA, ClippedVert* CVB, ClippedVert* CVC, Program* program, UniformCollection* uniforms) {
+void ssrR_triangle(
+	Vec4* CA, Vec4* CB, Vec4* CC, 
+	Vert* A, Vert* B, Vert* C, 
+	bool from_reg, 
+	ClippedVert* CVA, ClippedVert* CVB, ClippedVert* CVC, 
+	Program* program, 
+	UniformCollection* uniforms
+) {
 	ssr_assert(CA && CB && CC && program);
 
 	static Vec3 SA, SB, SC;
@@ -97,11 +104,11 @@ void ssrR_triangle(Vec4* CA, Vec4* CB, Vec4* CC, Vert* A, Vert* B, Vert* C, bool
 	puttriangle(&SA, &SB, &SC, 0xffff0000);
 	return;
 */
-	Vec3 *sa = &SA, *sb = &SB, *sc = &SC, *tmp; Vec4* v4tmp; Vert* vtemp;
+	Vec3 *sa = &SA, *sb = &SB, *sc = &SC, *tmp; Vec4* v4tmp; Vert* vtemp; ClippedVert* cvtmp;
 #define swap(t, a, b) {t = a; a = b; b = t;} /*sort in y axis*/
-	if (sb->y < sa->y) { swap(tmp, sa, sb); swap(v4tmp, CA, CB); swap(vtemp, A, B); }
-	if (sc->y < sb->y) { swap(tmp, sb, sc); swap(v4tmp, CB, CC); swap(vtemp, B, C); }
-	if (sb->y < sa->y) { swap(tmp, sa, sb); swap(v4tmp, CA, CB); swap(vtemp, A, B); }
+	if (sb->y < sa->y) { swap(tmp, sa, sb); swap(v4tmp, CA, CB); swap(vtemp, A, B); if (!from_reg) swap(cvtmp, CVA, CVB); }
+	if (sc->y < sb->y) { swap(tmp, sb, sc); swap(v4tmp, CB, CC); swap(vtemp, B, C); if (!from_reg) swap(cvtmp, CVC, CVB); }
+	if (sb->y < sa->y) { swap(tmp, sa, sb); swap(v4tmp, CA, CB); swap(vtemp, A, B); if (!from_reg) swap(cvtmp, CVA, CVB); }
 #undef swap
 
 	Vec2 AB = {sb->x - sa->x, sb->y - sa->y}, AC = { sc->x - sa->x, sc->y - sa->y };
@@ -131,13 +138,13 @@ void ssrR_triangle(Vec4* CA, Vec4* CB, Vec4* CC, Vert* A, Vert* B, Vert* C, bool
 	}																																																																													 \
 	if (from_reg) { /*extra varying*/																																																													 \
 		uint i_a = A->index, i_b = B->index, i_c = C->index;																																																		 \
-		if (varying_flag && VARYING_NUM) {																																																											 \
+		if (varying_flag & VARYING_NUM) {																																																											 \
 			if (varying_flag & VARYING_NUM_00) reg_num_00 = ssrS_bcpnum(&bcp, reg_num[0].num[i_a], reg_num[0].num[i_b], reg_num[0].num[i_c], &ssr_frag_in.num[0]); \
 			if (varying_flag & VARYING_NUM_01) reg_num_01 = ssrS_bcpnum(&bcp, reg_num[1].num[i_a], reg_num[1].num[i_b], reg_num[1].num[i_c], &ssr_frag_in.num[1]); \
 			if (varying_flag & VARYING_NUM_02) reg_num_02 = ssrS_bcpnum(&bcp, reg_num[2].num[i_a], reg_num[2].num[i_b], reg_num[2].num[i_c], &ssr_frag_in.num[2]); \
 			if (varying_flag & VARYING_NUM_03) reg_num_03 = ssrS_bcpnum(&bcp, reg_num[3].num[i_a], reg_num[3].num[i_b], reg_num[3].num[i_c], &ssr_frag_in.num[3]); \
 		}																																																																												 \
-		if (varying_flag && VARYING_V2) {																																																												 \
+		if (varying_flag & VARYING_V2) {																																																												 \
 			if (varying_flag & VARYING_V2_00) reg_v2_00 = ssrS_bcpvec2(&bcp, &reg_v2[0].v2[i_a], &reg_v2[0].v2[i_b], &reg_v2[0].v2[i_c], &ssr_frag_in.v2[0]);			 \
 			if (varying_flag & VARYING_V2_01) reg_v2_01 = ssrS_bcpvec2(&bcp, &reg_v2[1].v2[i_a], &reg_v2[1].v2[i_b], &reg_v2[1].v2[i_c], &ssr_frag_in.v2[1]);			 \
 			if (varying_flag & VARYING_V2_02) reg_v2_02 = ssrS_bcpvec2(&bcp, &reg_v2[2].v2[i_a], &reg_v2[2].v2[i_b], &reg_v2[2].v2[i_c], &ssr_frag_in.v2[2]);			 \
@@ -145,7 +152,7 @@ void ssrR_triangle(Vec4* CA, Vec4* CB, Vec4* CC, Vert* A, Vert* B, Vert* C, bool
 			if (varying_flag & VARYING_V2_04) reg_v2_04 = ssrS_bcpvec2(&bcp, &reg_v2[4].v2[i_a], &reg_v2[4].v2[i_b], &reg_v2[4].v2[i_c], &ssr_frag_in.v2[4]);			 \
 			if (varying_flag & VARYING_V2_05) reg_v2_05 = ssrS_bcpvec2(&bcp, &reg_v2[5].v2[i_a], &reg_v2[5].v2[i_b], &reg_v2[5].v2[i_c], &ssr_frag_in.v2[5]);			 \
 		}																																																																												 \
-		if (varying_flag && VARYING_V3) {																																																												 \
+		if (varying_flag & VARYING_V3) {																																																												 \
 			if (varying_flag & VARYING_V3_00) reg_v3_00 = ssrS_bcpvec3(&bcp, &reg_v3[0].v3[i_a], &reg_v3[0].v3[i_b], &reg_v3[0].v3[i_c], &ssr_frag_in.v3[0]);			 \
 			if (varying_flag & VARYING_V3_01) reg_v3_01 = ssrS_bcpvec3(&bcp, &reg_v3[1].v3[i_a], &reg_v3[1].v3[i_b], &reg_v3[1].v3[i_c], &ssr_frag_in.v3[1]);			 \
 			if (varying_flag & VARYING_V3_02) reg_v3_02 = ssrS_bcpvec3(&bcp, &reg_v3[2].v3[i_a], &reg_v3[2].v3[i_b], &reg_v3[2].v3[i_c], &ssr_frag_in.v3[2]);			 \
@@ -155,7 +162,7 @@ void ssrR_triangle(Vec4* CA, Vec4* CB, Vec4* CC, Vert* A, Vert* B, Vert* C, bool
 			if (varying_flag & VARYING_V3_06) reg_v3_06 = ssrS_bcpvec3(&bcp, &reg_v3[6].v3[i_a], &reg_v3[6].v3[i_b], &reg_v3[6].v3[i_c], &ssr_frag_in.v3[6]);			 \
 			if (varying_flag & VARYING_V3_07) reg_v3_07 = ssrS_bcpvec3(&bcp, &reg_v3[7].v3[i_a], &reg_v3[7].v3[i_b], &reg_v3[7].v3[i_c], &ssr_frag_in.v3[7]);			 \
 		}																																																																												 \
-		if (varying_flag && VARYING_V4) {																																																												 \
+		if (varying_flag & VARYING_V4) {																																																												 \
 			if (varying_flag & VARYING_V4_00) reg_v4_00 = ssrS_bcpvec4(&bcp, &reg_v4[0].v4[i_a], &reg_v4[0].v4[i_b], &reg_v4[0].v4[i_c], &ssr_frag_in.v4[0]);			 \
 			if (varying_flag & VARYING_V4_01) reg_v4_01 = ssrS_bcpvec4(&bcp, &reg_v4[1].v4[i_a], &reg_v4[1].v4[i_b], &reg_v4[1].v4[i_c], &ssr_frag_in.v4[1]);			 \
 			if (varying_flag & VARYING_V4_02) reg_v4_02 = ssrS_bcpvec4(&bcp, &reg_v4[2].v4[i_a], &reg_v4[2].v4[i_b], &reg_v4[2].v4[i_c], &ssr_frag_in.v4[2]);			 \
@@ -164,13 +171,13 @@ void ssrR_triangle(Vec4* CA, Vec4* CB, Vec4* CC, Vert* A, Vert* B, Vert* C, bool
 			if (varying_flag & VARYING_V4_05) reg_v4_05 = ssrS_bcpvec4(&bcp, &reg_v4[5].v4[i_a], &reg_v4[5].v4[i_b], &reg_v4[5].v4[i_c], &ssr_frag_in.v4[5]);			 \
 		}																																																																												 \
 	} else {																																																																									 \
-		if (varying_flag && VARYING_NUM) {																																																											 \
+		if (varying_flag & VARYING_NUM) {																																																											 \
 			if (varying_flag & VARYING_NUM_00) reg_num_00 = ssrS_bcpnum(&bcp, CVA->num[0], CVB->num[0], CVC->num[0], &ssr_frag_in.num[0]);												 \
 			if (varying_flag & VARYING_NUM_01) reg_num_01 = ssrS_bcpnum(&bcp, CVA->num[1], CVB->num[1], CVC->num[1], &ssr_frag_in.num[1]);												 \
 			if (varying_flag & VARYING_NUM_02) reg_num_02 = ssrS_bcpnum(&bcp, CVA->num[2], CVB->num[2], CVC->num[2], &ssr_frag_in.num[2]);												 \
 			if (varying_flag & VARYING_NUM_03) reg_num_03 = ssrS_bcpnum(&bcp, CVA->num[3], CVB->num[3], CVC->num[3], &ssr_frag_in.num[3]);												 \
 		}																																																																												 \
-		if (varying_flag && VARYING_V2) {																																																												 \
+		if (varying_flag & VARYING_V2) {																																																												 \
 			if (varying_flag & VARYING_V2_00) reg_v2_00 = ssrS_bcpvec2(&bcp, &CVA->v2[0], &CVB->v2[0], &CVC->v2[0], &ssr_frag_in.v2[0]);													 \
 			if (varying_flag & VARYING_V2_01) reg_v2_01 = ssrS_bcpvec2(&bcp, &CVA->v2[1], &CVB->v2[1], &CVC->v2[1], &ssr_frag_in.v2[1]);													 \
 			if (varying_flag & VARYING_V2_02) reg_v2_02 = ssrS_bcpvec2(&bcp, &CVA->v2[2], &CVB->v2[2], &CVC->v2[2], &ssr_frag_in.v2[2]);													 \
@@ -178,7 +185,7 @@ void ssrR_triangle(Vec4* CA, Vec4* CB, Vec4* CC, Vert* A, Vert* B, Vert* C, bool
 			if (varying_flag & VARYING_V2_04) reg_v2_04 = ssrS_bcpvec2(&bcp, &CVA->v2[4], &CVB->v2[4], &CVC->v2[4], &ssr_frag_in.v2[4]);													 \
 			if (varying_flag & VARYING_V2_05) reg_v2_05 = ssrS_bcpvec2(&bcp, &CVA->v2[5], &CVB->v2[5], &CVC->v2[5], &ssr_frag_in.v2[5]);													 \
 		}																																																																												 \
-		if (varying_flag && VARYING_V3) {																																																												 \
+		if (varying_flag & VARYING_V3) {																																																												 \
 			if (varying_flag & VARYING_V3_00) reg_v3_00 = ssrS_bcpvec3(&bcp, &CVA->v3[0], &CVB->v3[0], &CVC->v3[0], &ssr_frag_in.v3[0]);													 \
 			if (varying_flag & VARYING_V3_01) reg_v3_01 = ssrS_bcpvec3(&bcp, &CVA->v3[1], &CVB->v3[1], &CVC->v3[1], &ssr_frag_in.v3[1]);													 \
 			if (varying_flag & VARYING_V3_02) reg_v3_02 = ssrS_bcpvec3(&bcp, &CVA->v3[2], &CVB->v3[2], &CVC->v3[2], &ssr_frag_in.v3[2]);													 \
@@ -188,7 +195,7 @@ void ssrR_triangle(Vec4* CA, Vec4* CB, Vec4* CC, Vert* A, Vert* B, Vert* C, bool
 			if (varying_flag & VARYING_V3_06) reg_v3_06 = ssrS_bcpvec3(&bcp, &CVA->v3[6], &CVB->v3[6], &CVC->v3[6], &ssr_frag_in.v3[6]);													 \
 			if (varying_flag & VARYING_V3_07) reg_v3_07 = ssrS_bcpvec3(&bcp, &CVA->v3[7], &CVB->v3[7], &CVC->v3[7], &ssr_frag_in.v3[7]);													 \
 		}																																																																												 \
-		if (varying_flag && VARYING_V4) {																																																												 \
+		if (varying_flag & VARYING_V4) {																																																												 \
 			if (varying_flag & VARYING_V4_00) reg_v4_00 = ssrS_bcpvec4(&bcp, &CVA->v4[0], &CVB->v4[0], &CVC->v4[0], &ssr_frag_in.v4[0]);													 \
 			if (varying_flag & VARYING_V4_01) reg_v4_01 = ssrS_bcpvec4(&bcp, &CVA->v4[1], &CVB->v4[1], &CVC->v4[1], &ssr_frag_in.v4[1]);													 \
 			if (varying_flag & VARYING_V4_02) reg_v4_02 = ssrS_bcpvec4(&bcp, &CVA->v4[2], &CVB->v4[2], &CVC->v4[2], &ssr_frag_in.v4[2]);													 \
@@ -262,62 +269,6 @@ void ssrR_triangle(Vec4* CA, Vec4* CB, Vec4* CC, Vert* A, Vert* B, Vert* C, bool
 #undef RENDER_TRIANGLE
 }
 
-/*deprecated*/
-/*
-static Vec2 bboxmin, bboxmax; 
-void ssrR_triangle(Vec4* CA, Vec4* CB, Vec4* CC, Vert* A, Vert* B, Vert* C, Program* program, UniformCollection* uniforms) {
-	ssr_assert(CA && CB && CC && program && A && B && C && uniforms);
-
-	vec4_dividew(CA, &SA); ssrU_viewport(&SA, &SA);
-	vec4_dividew(CB, &SB); ssrU_viewport(&SB, &SB);
-	vec4_dividew(CC, &SC); ssrU_viewport(&SC, &SC);
-
-	bboxmin.x = (int)min(SA.x, min(SB.x, SC.x));
-	bboxmax.x = (int)max(SA.x, max(SB.x, SC.x));
-	bboxmin.y = (int)min(SA.y, min(SB.y, SC.y));
-	bboxmax.y = (int)max(SA.y, max(SB.y, SC.y));
-
-	float CAw = 1.f / CA->w, CBw = 1.f / CB->w, CCw = 1.f / CC->w;
-	float depth; Vec3 cdepth = { SA.z, SB.z, SC.z };
-	FragmentShaderIn in = { A, B, C, 0 };
-	Vec2 p;	
-	Color color; 
-	Vec3 s[2], u;
-	s[0].x = SC.x - SA.x; s[0].y = SB.x - SA.x;
-	s[1].x = SC.y - SA.y; s[1].y = SB.y - SA.y;
-	bool dontdiscad;
-	for (p.y = bboxmin.y; p.y <= bboxmax.y; ++p.y) {
-		s[1].z = SA.y - p.y;
-		for (p.x = bboxmin.x; p.x <= bboxmax.x; ++p.x) {
-			s[0].z = SA.x - p.x;
-			vec3_cross(&s[0], &s[1], &u);
-
-			discardif(compare(u.z, 0));
-
-			u.z = 1.f / u.z;
-			bcp.x = 1.f - (u.x + u.y) * u.z;
-			bcp.y = u.y * u.z;
-			bcp.z = u.x * u.z;
-
-			discardif(bcp.x < 0 || bcp.y < 0 || bcp.z < 0);
-
-			bcp.x *= CAw; bcp.y *= CBw; bcp.z *= CCw;
-			vec3_scale(&bcp, 1.f / (bcp.x + bcp.y + bcp.z), &bcp);
-
-			if (ssr_isenable(ENABLEMASK_DEPTHTEST)) {
-				depth = vec3_dot(&bcp, &cdepth) * 0.5f + 0.5f;
-				discardif(!ssr_testdepthf(p.x, p.y, depth));
-			}
-
-			in.bc = &bcp;
-			dontdiscad = program->fragmentshader(uniforms, &in, &color);
-			if (dontdiscad)
-				ssr_putpoint(p.x, p.y, color);
-		}
-	}
-}
-*/
-
 void ssrR_line(Vec4* CA, Vec4* CB, Vert* A, Vert* B, Program* program, UniformCollection* uniforms) {
 	ssr_assert(CA && CB && program && A && B && uniforms);
 
diff --git a/src/core/shader.c b/src/core/shader.c
index b5d8407..89daa36 100644
--- a/src/core/shader.c
+++ b/src/core/shader.c
@@ -72,16 +72,17 @@ void ssrS_setregisters(uint flag, int capacity) {
 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)
+if (flag & VARYING_V2_##i) ssrM_rescalevector(Vec2, 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)
+if (flag & VARYING_V3_##i) ssrM_rescalevector(Vec3, 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_V4_##i) ssrM_rescalevector(Vec4, 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);
diff --git a/src/core/shader.h b/src/core/shader.h
index 3024a0d..224ebb4 100644
--- a/src/core/shader.h
+++ b/src/core/shader.h
@@ -107,7 +107,7 @@ typedef struct Program {
 
 #define VARYING_V4       (VARYING_V4_00 | VARYING_V4_01 | VARYING_V4_02 | VARYING_V4_03 | VARYING_V4_04 | VARYING_V4_05)
 
-#define VARYING_EXTRA    (~VARYING_BASIC)
+#define VARYING_EXTRA    (VARYING_NUM | VARYING_V2 | VARYING_V3 | VARYING_V4)
 
 float* ssrS_bcpnum(Vec3* bc, float A, float B, float C, float* out);
 Color* ssrS_bcpcolor(Vec3* bc, Color A, Color B, Color C, Color* out);
@@ -140,8 +140,8 @@ typedef struct Register {
 	union {
 		float* num;
 		Vec2* v2;
-		Vec4* v4;
 		Vec3* v3;
+		Vec4* v4;
 	};
 } Register;
 
diff --git a/src/example/03_texture.c b/src/example/03_texture.c
index fb5f0f2..395acfb 100644
--- a/src/example/03_texture.c
+++ b/src/example/03_texture.c
@@ -10,18 +10,20 @@ static int cube[] = {
 };
 
 static Vert verts[] = {
-	{0, {1, 1, 1}, zerovec3, zerovec3, zerovec2, 0xffff0000},
-	{1, {-1, 1, 1}, zerovec3, zerovec3, zerovec2,0xff00ff00},
-	{2, {-1, -1, 1}, zerovec3, zerovec3, zerovec2, 0xff0000ff},
-	{3, {1, -1, 1}, zerovec3, zerovec3, zerovec2, 0xffff00ff},
-	{4, {1, 1, -1}, zerovec3, zerovec3, zerovec2, 0xffaa28aa},
-	{5, {-1, 1, -1}, zerovec3, zerovec3, zerovec2,0xffFFC58E},
-	{6, {-1, -1, -1}, zerovec3, zerovec3, zerovec2, 0xffA100FF},
-	{7, {1, -1, -1}, zerovec3, zerovec3, zerovec2, 0xffFAFF00},
+	{0, {1, 1, 1}, {1, 1, 1}, zerovec3, zerovec2, 0xffff0000},
+	{1, {-1, 1, 1}, {-1, 1, 1}, zerovec3, zerovec2,0xff00ff00},
+	{2, {-1, -1, 1}, {-1, -1, 1}, zerovec3, zerovec2, 0xff0000ff},
+	{3, {1, -1, 1}, {1, -1, 1}, zerovec3, zerovec2, 0xffff00ff},
+	{4, {1, 1, -1}, {1, 1, -1}, zerovec3, zerovec2, 0xffaa28aa},
+	{5, {-1, 1, -1}, {-1, 1, -1}, zerovec3, zerovec2,0xffFFC58E},
+	{6, {-1, -1, -1}, {-1, -1, -1}, zerovec3, zerovec2, 0xffA100FF},
+	{7, {1, -1, -1}, {1, -1, -1}, zerovec3, zerovec2, 0xffFAFF00},
 };
 
 extern Program ssr_built_in_shader_unlit;
 
+static Vec3 light = {-1, -1, -1};
+
 void onloadtexture(void* data) {
 	ssr_matrixmode(MATRIX_PROJECTION);
 	ssr_loadidentity();
@@ -43,13 +45,19 @@ void oneventtexture(void* data) {
 }
 
 static float _t = 0;
+static Quat q;
 
 void onupdatetexture(void*data) {
 	uint dt = *(uint*)data;
 	ssr_matrixmode(MATRIX_MODEL);
 	ssr_loadidentity();
-	ssr_translate(0, 0, -2);
-	ssr_rotate(_t -= dt / 50.f, 1, 1, 1);
+	ssr_translate(0, 0, -3);
+	ssr_rotate(_t -= dt / 50.f, 1, 0.3, 1);
+
+	Vec3 rot = { 1,1,0 }; vec3_normalize(&rot, &rot);
+	quat_fromaxisangle(&rot, 10, &q);
+	quat_applytovec3(&q, &light, &light);
+	ssr_setuniformvec3(0, &light); /*set light direction*/
 }
 
 void ondrawtexture(void*data) {
diff --git a/src/math/vec3.c b/src/math/vec3.c
index 1deb52e..917c4d1 100644
--- a/src/math/vec3.c
+++ b/src/math/vec3.c
@@ -97,8 +97,8 @@ void vec3_multiply(Vec3* v1, Vec3* v2, Quat* out) {
 
 void vec3_normalize(Vec3* v, Vec3* out) {
 	ssr_assert(v && out);
-	float mag = rsqrt(v->x * v->x + v->y * v->y + v->z * v->z);
-	//float mag = 1.f / vec3_magnitude(v);
+	//float mag = rsqrt(v->x * v->x + v->y * v->y + v->z * v->z);
+	float mag = 1.f / vec3_magnitude(v);
 	out->x = v->x * mag;
 	out->y = v->y * mag;
 	out->z = v->z * mag;
diff --git a/src/shaders/common_header.h b/src/shaders/common_header.h
index 848fe98..9741a36 100644
--- a/src/shaders/common_header.h
+++ b/src/shaders/common_header.h
@@ -3,5 +3,6 @@
 
 #include "../core/shader.h"
 
+extern void ssrR_putline(int x0, int y0, int x1, int y1, Color color);
 
 #endif
\ No newline at end of file
diff --git a/src/shaders/unlit.c b/src/shaders/unlit.c
index ec6949f..ab060cd 100644
--- a/src/shaders/unlit.c
+++ b/src/shaders/unlit.c
@@ -1,23 +1,26 @@
 #include "common_header.h"
 
-#define model_matrix UM4(0)
+#define light UV3(0)
 
-#define world_normal reg_v3_00
-#define vcolor  reg_v4_00
+#define vert_color reg_v4_00
 
 static void vert(UniformCollection* uniforms, VertexShaderIn* in, Vec4* clipcoord) {
 	static Vec4 p; p.xyz = in->vertex->position; p.w = 1;
 	mat4_applytovec4(uniforms->mvp, &p, clipcoord);
-	model_matrix;
+	color_tocolor32(in->vertex->color, vert_color);
 }
 
 static bool frag(UniformCollection* uniforms, FragmentShaderIn* in, Color* color) {
-	*color = in->color;
-	world_normal;
+	vec3_normalize(light, light);
+	vec3_normalize(&in->normal, &in->normal);
+	float strongness = vec3_dot(light, &in->normal);
+	vec3_scale(vert_color, 1 - clamp(strongness, 0, 1), vert_color);
+	*color = color32_tocolor(vert_color);
+	
 	return 1;
 }
 
 Program ssr_built_in_shader_unlit = { 
 	vert, frag,
-	VARYING_COLOR
+	VARYING_NORMAL | VARYING_V4_00
 };