*misc

11 files changed, 289 insertions, 211 deletions

diff --git a/src/core/clip.c b/src/core/clip.c
index 51321a8..23e18ce 100644
--- a/src/core/clip.c
+++ b/src/core/clip.c
@@ -2,6 +2,122 @@
 #include "shader.h"
 #include "../util/type.h"
 
+static LinearInterpolator clip_interpolator[REG_TOTAL] = {
+	ssrS_lerpnum,
+	ssrS_lerpnum,
+	ssrS_lerpnum,
+	ssrS_lerpnum,
+	ssrS_lerpvec2,
+	ssrS_lerpvec2,
+	ssrS_lerpvec2,
+	ssrS_lerpvec2,
+	ssrS_lerpvec2,
+	ssrS_lerpvec2,
+	ssrS_lerpvec2,
+	ssrS_lerpvec2,
+	ssrS_lerpvec3,
+	ssrS_lerpvec3,
+	ssrS_lerpvec3,
+	ssrS_lerpvec3,
+	ssrS_lerpvec3,
+	ssrS_lerpvec3,
+	ssrS_lerpvec3,
+	ssrS_lerpvec3,
+	ssrS_lerpvec3,
+	ssrS_lerpvec3,
+	ssrS_lerpvec3,
+	ssrS_lerpvec3,
+	ssrS_lerpvec4,
+	ssrS_lerpvec4,
+	ssrS_lerpvec4,
+	ssrS_lerpvec4,
+	ssrS_lerpvec4,
+	ssrS_lerpvec4,
+	ssrS_lerpvec4,
+	ssrS_lerpvec4,
+};
+
+uint clip_element_size[REG_TOTAL] = {
+	4,4,4,4, /*float*/
+	8, 8, 8, 8,8, 8, 8, 8, /*Vec2*/
+	12,12,12,12,12,12,12,12,12,12,12,12, /*Vec3*/
+	16,16,16,16,16,16,16,16 /*Vec4*/
+};
+
+/*用来访问临时寄存器*/
+byte* clip_buffer_data[REG_TOTAL] =
+{
+	clip_buffer.temp_reg_num[0],
+	clip_buffer.temp_reg_num[1],
+	clip_buffer.temp_reg_num[2],
+	clip_buffer.temp_reg_num[3],
+	clip_buffer.temp_reg_v2[0],
+	clip_buffer.temp_reg_v2[1],
+	clip_buffer.temp_reg_v2[2],
+	clip_buffer.temp_reg_v2[3],
+	clip_buffer.temp_reg_v2[4],
+	clip_buffer.temp_reg_v2[5],
+	clip_buffer.temp_reg_v2[6],
+	clip_buffer.temp_reg_v2[7],
+	clip_buffer.temp_reg_v3[0],
+	clip_buffer.temp_reg_v3[1],
+	clip_buffer.temp_reg_v3[2],
+	clip_buffer.temp_reg_v3[3],
+	clip_buffer.temp_reg_v3[4],
+	clip_buffer.temp_reg_v3[5],
+	clip_buffer.temp_reg_v3[6],
+	clip_buffer.temp_reg_v3[7],
+	clip_buffer.temp_reg_v3[8],
+	clip_buffer.temp_reg_v3[9],
+	clip_buffer.temp_reg_v3[10],
+	clip_buffer.temp_reg_v3[11],
+	clip_buffer.temp_reg_v4[0],
+	clip_buffer.temp_reg_v4[1],
+	clip_buffer.temp_reg_v4[2],
+	clip_buffer.temp_reg_v4[3],
+	clip_buffer.temp_reg_v4[4],
+	clip_buffer.temp_reg_v4[5],
+	clip_buffer.temp_reg_v4[6],
+	clip_buffer.temp_reg_v4[7],
+};
+
+/*用来访问临时寄存器*/
+byte* temp_clip_buffer_data[REG_TOTAL] =
+{
+	temp_clip_buffer.temp_reg_num[0],
+	temp_clip_buffer.temp_reg_num[1],
+	temp_clip_buffer.temp_reg_num[2],
+	temp_clip_buffer.temp_reg_num[3],
+	temp_clip_buffer.temp_reg_v2[0],
+	temp_clip_buffer.temp_reg_v2[1],
+	temp_clip_buffer.temp_reg_v2[2],
+	temp_clip_buffer.temp_reg_v2[3],
+	temp_clip_buffer.temp_reg_v2[4],
+	temp_clip_buffer.temp_reg_v2[5],
+	temp_clip_buffer.temp_reg_v2[6],
+	temp_clip_buffer.temp_reg_v2[7],
+	temp_clip_buffer.temp_reg_v3[0],
+	temp_clip_buffer.temp_reg_v3[1],
+	temp_clip_buffer.temp_reg_v3[2],
+	temp_clip_buffer.temp_reg_v3[3],
+	temp_clip_buffer.temp_reg_v3[4],
+	temp_clip_buffer.temp_reg_v3[5],
+	temp_clip_buffer.temp_reg_v3[6],
+	temp_clip_buffer.temp_reg_v3[7],
+	temp_clip_buffer.temp_reg_v3[8],
+	temp_clip_buffer.temp_reg_v3[9],
+	temp_clip_buffer.temp_reg_v3[10],
+	temp_clip_buffer.temp_reg_v3[11],
+	temp_clip_buffer.temp_reg_v4[0],
+	temp_clip_buffer.temp_reg_v4[1],
+	temp_clip_buffer.temp_reg_v4[2],
+	temp_clip_buffer.temp_reg_v4[3],
+	temp_clip_buffer.temp_reg_v4[4],
+	temp_clip_buffer.temp_reg_v4[5],
+	temp_clip_buffer.temp_reg_v4[6],
+	temp_clip_buffer.temp_reg_v4[7],
+};
+
 typedef enum {
 	POSITIVE_W,
 	POSITIVE_X,
@@ -61,169 +177,124 @@ static float get_intersect_ratio(Vec4* prev, Vec4* curr, Plane plane) {
 		return 0;
 	}
 }
-//
-//static bool clip_against_plane(Plane plane, uint varying_flag, ClippedBuffer* src_buffer, ClippedBuffer* dst_buffer) {
-//	int idx = 0;
-//	for (int i = 0; i < src_buffer->count; ++i) {
-//		ClippedVert* prev = &src_buffer->vertices[(i - 1 + src_buffer->count) % src_buffer->count];
-//		ClippedVert* curr = &src_buffer->vertices[i];
-//
-//		bool prev_inside = is_inside_plane(&prev->clip_coord, plane);
-//		bool curr_inside = is_inside_plane(&curr->clip_coord, plane);
-//
-//		if (prev_inside != curr_inside) {
-//			ClippedVert* dst = &dst_buffer->vertices[idx];
-//			float t = get_intersect_ratio(&prev->clip_coord, &curr->clip_coord, plane);
-//			ssrS_lerpvec4(t, &prev->clip_coord, &curr->clip_coord, &dst->clip_coord);
-//			/*set varying varibles*/
-//			if (varying_flag & VARYING_BASIC) {
-//				if (varying_flag & VARYING_POSITION) ssrS_lerpvec3(t, &prev->vertex.position, &curr->vertex.position, &dst->vertex.position);
-//				if (varying_flag & VARYING_NORMAL) ssrS_lerpvec3(t, &prev->vertex.normal, &curr->vertex.normal, &dst->vertex.normal);
-//				if (varying_flag & VARYING_TANGENT) ssrS_lerpvec3(t, &prev->vertex.tangent, &curr->vertex.tangent, &dst->vertex.tangent);
-//				if (varying_flag & VARYING_TEXCOORD) ssrS_lerpvec2(t, &prev->vertex.texcoord, &curr->vertex.texcoord, &dst->vertex.texcoord);
-//				if (varying_flag & VARYING_COLOR) ssrS_lerpcolor(t, prev->vertex.color, curr->vertex.color, &dst->vertex.color);
-///*
-//				if (varying_flag & VARYING_JOINT) ssrS_lerpvec4(t, &prev->vertex.joint, &curr->vertex.joint, &dst->vertex.joint);
-//				if (varying_flag & VARYING_WEIGHT) ssrS_lerpvec4(t, &prev->vertex.weight, &curr->vertex.weight, &dst->vertex.weight);
-//*/
-//			}
-//			if (varying_flag & VARYING_ANY) {
-//				int j = 0;
-//				if (varying_flag & VARYING_NUM) {
-//					for (j = 0; j < REG_NUM_COUNT; ++j) {
-//						if (varying_flag & (VARYING_NUM_00 << j)) {
-//							ssrS_lerpnum(t, prev->num[j], curr->num[j], &dst->num[j]);
-//						}
-//					}
-//				}
-//				if (varying_flag & VARYING_V2) {
-//					for (j = 0; j < REG_V2_COUNT; ++j) {
-//						if (varying_flag & (VARYING_V2_00 << j)) {
-//							ssrS_lerpvec2(t, &prev->v2[j], &curr->v2[j], &dst->v2[j]);
-//						}
-//					}
-//				}
-//				if (varying_flag & VARYING_V3) {
-//					for (j = 0; j < REG_V3_COUNT; ++j) {
-//						if (varying_flag & (VARYING_V3_00 << j)) {
-//							ssrS_lerpvec3(t, &prev->v3[j], &curr->v3[j], &dst->v3[j]);
-//						}
-//					}
-//				}
-//				if (varying_flag & VARYING_V4) {
-//					for (j = 0; j < REG_V4_COUNT; ++j) {
-//						if (varying_flag & (VARYING_V4_00 << j)) {
-//							ssrS_lerpvec4(t, &prev->v4[j], &curr->v4[j], &dst->v4[j]);
-//						}
-//					}
-//				}
-//			}
-//			++idx;
-//		}
-//
-//		if (curr_inside) {
-//			ClippedVert* dst = &dst_buffer->vertices[idx];
-//			*dst = *curr;
-//			++idx;
-//		}
-//	}
-//	dst_buffer->count = idx;
-//	return idx < 3;
-//}
-
-#define CLIP(plane, from, to) \
-do {																					             \
-	if (clip_against_plane(plane, varying_flag, from, to)) { \
-		buffer->count = 0;/*cull this triangle*/		           \
-		return 1;																		           \
-	}																							           \
-}while(0)
 
-ClippedBuffer clip_buffer;
+static bool clip_against_plane(
+	  Plane plane
+	, uint varying_flag
+	, ClippedBuffer* src_buffer
+	, ClippedBuffer* dst_buffer
+	, byte* src_data[]
+	, byte* dst_data[]
+) {
+	bool varying = varying_flag & VARYING_ANY;
+	int idx = 0; /*顶点索引*/
+	ClippedVert *prev, *curr;
+	uint previ, curri;
+	bool prev_inside, curr_inside;
+	int i, j, regi, size;
+	float t;
+	ClippedVert* dst;
+	for (i = 0; i < src_buffer->count; ++i) {
+		prev = &src_buffer->vertices[(i - 1 + src_buffer->count) % src_buffer->count];
+		curr = &src_buffer->vertices[i];
 
-byte* clip_buffer_data[REG_TOTAL] =
-{
-	&clip_buffer.temp_reg_num[0],
-	&clip_buffer.temp_reg_num[1],
-	&clip_buffer.temp_reg_num[2],
-	&clip_buffer.temp_reg_num[3],
-	&clip_buffer.temp_reg_v2[0],
-	&clip_buffer.temp_reg_v2[1],
-	&clip_buffer.temp_reg_v2[2],
-	&clip_buffer.temp_reg_v2[3],
-	&clip_buffer.temp_reg_v2[4],
-	&clip_buffer.temp_reg_v2[5],
-	&clip_buffer.temp_reg_v3[0],
-	&clip_buffer.temp_reg_v3[1],
-	&clip_buffer.temp_reg_v3[2],
-	&clip_buffer.temp_reg_v3[3],
-	&clip_buffer.temp_reg_v3[4],
-	&clip_buffer.temp_reg_v3[5],
-	&clip_buffer.temp_reg_v3[6],
-	&clip_buffer.temp_reg_v3[7],
-	&clip_buffer.temp_reg_v4[0],
-	&clip_buffer.temp_reg_v4[1],
-	&clip_buffer.temp_reg_v4[2],
-	&clip_buffer.temp_reg_v4[3],
-	&clip_buffer.temp_reg_v4[4],
-	&clip_buffer.temp_reg_v4[5],
-};
+		previ = prev->vertex.index;
+		curri = curr->vertex.index;
+
+		prev_inside = is_inside_plane(&prev->clip_coord, plane);
+		curr_inside = is_inside_plane(&curr->clip_coord, plane);
 
-bool clip_triangle(Vec4* c0, Vec4* c1, Vec4* c2, Vert* v0, Vert* v1, Vert* v2, uint varying_flag, ClippedBuffer* buffer) {
+		if (prev_inside != curr_inside) {
+			t = get_intersect_ratio(&prev->clip_coord, &curr->clip_coord, plane);
+			dst = &dst_buffer->vertices[idx];
+			ssrS_lerpvec4(t, &prev->clip_coord, &curr->clip_coord, &dst->clip_coord);
+			dst->vertex.index = idx;
+			/*set varying variables*/
+			if (varying) {
+				for (j = 0; j < REG_TOTAL; ++j) {
+					regi = open_regsi[j];
+					if (regi == -1) break;
+					size = clip_element_size[regi];
+					clip_interpolator[regi](t, &src_data[regi][previ * size], &src_data[regi][curri * size], &dst_data[regi][idx * size]);
+				}
+			}
+			++idx;
+		}
+
+		if (curr_inside) {
+			dst = &dst_buffer->vertices[idx];
+			*dst = *curr;
+			dst->vertex.index = idx;
+			/*copy varying variables*/
+			if (varying) {
+				for (j = 0; j < REG_TOTAL; ++j) {
+					regi = open_regsi[j];
+					if (regi == -1) break;
+					size = clip_element_size[regi];
+					ssrM_copy(&dst_data[regi][idx*size], &src_data[regi][curri*size], size);
+				}
+			}
+			++idx;
+		}
+	}
+	dst_buffer->count = idx;
+	return idx < 3;
+}
+
+#define CLIP(plane, from, to, from_data, to_data) \
+	if (clip_against_plane(plane, varying_flag, from, to, from_data, to_data)) { \
+		buffer->count = 0;/*cull this triangle*/		           										 \
+		return 1;																		           										 \
+	}
+
+ClippedBuffer clip_buffer;
+ClippedBuffer temp_clip_buffer;
+
+bool clip_triangle(
+	Vec4* c0, Vec4* c1, Vec4* c2
+	, Vert* v0, Vert* v1, Vert* v2
+	, uint varying_flag
+	, ClippedBuffer* buffer
+) {
 	bool is_visible = is_vertex_visible(c0)
 	&& is_vertex_visible(c1)
 	&& is_vertex_visible(c2);
 
-	if (is_visible) {
+	if (is_visible)
 		return 0; /*no need to clip*/
+
+	ssr_assert(buffer == &clip_buffer);
+
+	/*copy vert data to temp_clip_buffer*/
+	temp_clip_buffer.count = 3;
+#define COPY_VERT(i) \
+	temp_clip_buffer.vertices[i].clip_coord = *c##i; \
+	temp_clip_buffer.vertices[i].vertex = *v##i;     \
+	temp_clip_buffer.vertices[i].vertex.index = ##i; \
+
+	COPY_VERT(0);
+	COPY_VERT(1);
+	COPY_VERT(2);
+
+#undef COPY_VERT
+
+	int i, index, size;
+	for (i = 0; i < REG_TOTAL; ++i) {
+		index = open_regsi[i];
+		if (index == -1) break;
+		size = registers[index].element_size;
+		ssrM_copy(&temp_clip_buffer_data[index][0], &registers[index].data[v0->index*size], size);
+		ssrM_copy(&temp_clip_buffer_data[index][size], &registers[index].data[v1->index*size], size);
+		ssrM_copy(&temp_clip_buffer_data[index][2*size], &registers[index].data[v2->index*size], size);
 	}
-//
-//	/*clipping it*/
-//
-//	/*copy vert data to clip_buffer*/
-//	clip_buffer.count = 3;
-//#define INIT_CLIP_VERT(idx) \
-//	clip_buffer.vertices[idx].clip_coord = *c##idx;												 	 \
-//	clip_buffer.vertices[idx].vertex = *v##idx;														 	 \
-//	if (varying_flag & VARYING_ANY) {															 	 \
-//		int i = 0;																										 	 \
-//		if(varying_flag & VARYING_NUM) {															 	 \
-//			for (i = 0; i < REG_NUM_COUNT; ++i) {													 \
-//				if (varying_flag & (VARYING_NUM_00 << i))										 \
-//					clip_buffer.vertices[idx].num[i] = reg_num[i].num[v##idx->index]; \
-//			}																															 \
-//		}																															 	 \
-//		if(varying_flag & VARYING_V2) {															 	 \
-//			for (i = 0; i < REG_V2_COUNT; ++i) {													 \
-//				if (varying_flag & (VARYING_V2_00 << i))										 \
-//					clip_buffer.vertices[idx].v2[i] = reg_v2[i].v2[v##idx->index];		 \
-//			}																															 \
-//		}																																 \
-//		if(varying_flag & VARYING_V3) {															 	 \
-//			for (i = 0; i < REG_V3_COUNT; ++i) {													 \
-//				if (varying_flag & (VARYING_V3_00 << i))										 \
-//					clip_buffer.vertices[idx].v3[i] = reg_v3[i].v3[v##idx->index];		 \
-//			}																															 \
-//		}																																 \
-//		if(varying_flag & VARYING_V4) {															 	 \
-//			for (i = 0; i < REG_V4_COUNT; ++i) {													 \
-//				if (varying_flag & (VARYING_V4_00 << i))										 \
-//					clip_buffer.vertices[idx].v4[i] = reg_v4[i].v4[v##idx->index];		 \
-//			}																															 \
-//		}																																 \
-//	}
-//	INIT_CLIP_VERT(0);
-//	INIT_CLIP_VERT(1);
-//	INIT_CLIP_VERT(2);
-//#undef INIT_CLIP_VERT
-//
-//	CLIP(POSITIVE_W, &clip_buffer, buffer);
-//	CLIP(POSITIVE_X, buffer, &clip_buffer);
-//	CLIP(NEGATIVE_X, &clip_buffer, buffer);
-//	CLIP(POSITIVE_Y, buffer, &clip_buffer);
-//	CLIP(NEGATIVE_Y, &clip_buffer, buffer);
-//	CLIP(POSITIVE_Z, buffer, &clip_buffer);
-//	CLIP(NEGATIVE_Z, &clip_buffer, buffer);
-//
-//	return 1;
+
+	CLIP(POSITIVE_W, &temp_clip_buffer, buffer, temp_clip_buffer_data, clip_buffer_data);
+	CLIP(POSITIVE_X, buffer, &temp_clip_buffer, clip_buffer_data, temp_clip_buffer_data);
+	CLIP(NEGATIVE_X, &temp_clip_buffer, buffer, temp_clip_buffer_data, clip_buffer_data);
+	CLIP(POSITIVE_Y, buffer, &temp_clip_buffer, clip_buffer_data, temp_clip_buffer_data);
+	CLIP(NEGATIVE_Y, &temp_clip_buffer, buffer, temp_clip_buffer_data, clip_buffer_data);
+	CLIP(POSITIVE_Z, buffer, &temp_clip_buffer, clip_buffer_data, temp_clip_buffer_data);
+	CLIP(NEGATIVE_Z, &temp_clip_buffer, buffer, temp_clip_buffer_data, clip_buffer_data);
+
+	return 1;
 }
diff --git a/src/core/clip.h b/src/core/clip.h
index 2ac733d..c1bb7b6 100644
--- a/src/core/clip.h
+++ b/src/core/clip.h
@@ -26,7 +26,8 @@ typedef struct {
 	Vec4 temp_reg_v4[REG_V4_COUNT][CLIP_BUFFER_SIZE];
 } ClippedBuffer;
 
-ClippedBuffer clip_buffer;
+ClippedBuffer clip_buffer; /*clipping result*/
+ClippedBuffer temp_clip_buffer; 
 
 bool clip_triangle(Vec4* c0, Vec4* c1, Vec4* c2, Vert* v0, Vert* v1, Vert* v2, uint varying_flag, ClippedBuffer* clipped);
 
diff --git a/src/core/device.c b/src/core/device.c
index 92a893f..b5468cd 100644
--- a/src/core/device.c
+++ b/src/core/device.c
@@ -422,7 +422,7 @@ static struct {
 	uint length;
 } clip_coords;
 
-static ClippedBuffer clipped_buffer; /*clipping result*/
+extern ClippedBuffer clip_buffer; /*clipping result*/
 
 void ssr_draw(ssr_PrimitiveType primitive) {
 	ssr_assert(state.verts && state.indices);
@@ -480,6 +480,7 @@ void ssr_draw(ssr_PrimitiveType primitive) {
 		uint i0, i1, i2;
 		Vec4 *h0, *h1, *h2;
 		Vert *v0, *v1, *v2;
+		bool reset_active_reg = FALSE;
 		for (int i = 0; i < state.nprims; ++i) {
 			i0 = state.indices[i * 3];
 			i1 = state.indices[i * 3 + 1];
@@ -507,19 +508,25 @@ void ssr_draw(ssr_PrimitiveType primitive) {
 			}
 
 			/*clipping*/
-			bool clipped = clip_triangle(h0, h1, h2, v0, v1, v2, varying_flag, &clipped_buffer);
+			bool clipped = clip_triangle(h0, h1, h2, v0, v1, v2, varying_flag, &clip_buffer);
 
 			/*rasterization*/
 			if (!clipped) {
-				/*ssrS_setactiveregr();*/
+				if (reset_active_reg) {
+					reset_active_reg = FALSE;
+					ssrS_setactiveregr();
+				}
 				ssrR_triangle(h0, h1, h2, v0, v1, v2, state.program, &state.uniforms);
 			} else {
-				ssrS_setactiveregc();
-				if (clipped_buffer.count >= 3) {
-					ClippedVert* vt0 = &clipped_buffer.vertices[0], *vt1, *vt2;
-					for (int i = 1; i <= clipped_buffer.count - 2; ++i) {
-						vt1 = &clipped_buffer.vertices[i];
-						vt2 = &clipped_buffer.vertices[i + 1];
+				if (!reset_active_reg) {
+					reset_active_reg = TRUE;
+					ssrS_setactiveregc();
+				}
+				if (clip_buffer.count >= 3) {
+					ClippedVert* vt0 = &clip_buffer.vertices[0], *vt1, *vt2;
+					for (int i = 1; i <= clip_buffer.count - 2; ++i) {
+						vt1 = &clip_buffer.vertices[i];
+						vt2 = &clip_buffer.vertices[i + 1];
 						h0 = &vt0->clip_coord; h1 = &vt1->clip_coord; h2 = &vt2->clip_coord;
 						v0 = &vt0->vertex;     v1 = &vt1->vertex;     v2 = &vt2->vertex;
 						ssrR_triangle(h0, h1, h2, v0, v1, v2, state.program, &state.uniforms);
@@ -563,3 +570,7 @@ void ssr_setuniformtex(uint idx, Texture* tex) {
 	if (idx < 0 || idx > 11) return;
 	state.uniforms.var_tex[idx] = tex;
 }
+
+void ssr_setuniformu(void* userdata) {
+	state.uniforms.userdata = userdata;
+}
diff --git a/src/core/device.h b/src/core/device.h
index 066d399..6dc8143 100644
--- a/src/core/device.h
+++ b/src/core/device.h
@@ -98,6 +98,7 @@ void ssr_setuniformvec4(uint idx, Vec4* src);
 void ssr_setuniformvec3(uint idx, Vec3* src);
 void ssr_setuniformvec2(uint idx, Vec2* src);
 void ssr_setuniformtex(uint idx, Texture* tex);
+void ssr_setuniformu(void* userdata);
 
 void ssr_draw(ssr_PrimitiveType primitive);
 void ssr_clearcolor(Color color);
diff --git a/src/core/rasterizer.c b/src/core/rasterizer.c
index ba88161..2319d44 100644
--- a/src/core/rasterizer.c
+++ b/src/core/rasterizer.c
@@ -153,9 +153,6 @@ void ssrR_triangle( Vec4* CA, Vec4* CB, Vec4* CC, Vert* A, Vert* B, Vert* C, Pro
 			ssrS_solveregs(&bc, A->index, B->index, C->index);             \
 			/*enter fragment shader*/																			 \
 			if(program->fragmentshader(uniforms, &ssr_frag_in, &color))	{	 \
-				/*MSAA*/																										 \
-				if(multi_sample) {																					 \
-				}																														 \
 				/*blend*/																										 \
 				if(blend) {																									 \
 					Color32 dst; dst = ssr_getfbocolor(p.x, p.y);							 \
diff --git a/src/core/shader.c b/src/core/shader.c
index a56cde5..aa271ed 100644
--- a/src/core/shader.c
+++ b/src/core/shader.c
@@ -140,26 +140,26 @@ void ssrS_openregs(uint varying_flag) {
 }
 
 void ssrS_setactiveregr() { /*set active reg data from registers*/
-	int index = 0;
+	int regi = 0;
 	ActiveReg* reg;
 	for (int i = 0; i < REG_TOTAL; ++i) {
-		index = open_regsi[i];
-		if (index == -1) break;
-		reg = &active_regs[index];
-		reg->data = registers[index].data;
+		regi = open_regsi[i];
+		if (regi == -1) break;
+		reg = &active_regs[regi];
+		reg->data = registers[regi].data;
 	}
 }
 
 extern byte* clip_buffer_data[REG_TOTAL];
 
 void ssrS_setactiveregc() { /*set active reg data from clipping buffer*/
-	int index = 0;
+	int regi = 0;
 	ActiveReg* reg;
 	for (int i = 0; i < REG_TOTAL; ++i) {
-		index = open_regsi[i];
-		if (index == -1) break;
-		reg = &active_regs[index];
-		reg->data = clip_buffer_data[index];
+		regi = open_regsi[i];
+		if (regi == -1) break;
+		reg = &active_regs[regi];
+		reg->data = clip_buffer_data[regi];
 	}
 }
 
@@ -269,8 +269,8 @@ Vec4* ssrS_bcpvec4(Vec3* bc, Vec4* A, Vec4* B, Vec4* C, Vec4* out) {
 	return out;
 }
 
-void ssrS_lerpnum(float t, float A, float B, float* out) {
-	*out = lerp(A, B, t);
+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) {
diff --git a/src/core/shader.h b/src/core/shader.h
index 05fd738..15edf4c 100644
--- a/src/core/shader.h
+++ b/src/core/shader.h
@@ -112,8 +112,8 @@ Vec2*  ssrS_bcpvec2(Vec3* bc, Vec2* A, Vec2* B, Vec2* C, Vec2* out);
 Vec3* ssrS_bcpvec3(Vec3* bc, Vec3* A, Vec3* B, Vec3* C, Vec3* out);
 Vec4* ssrS_bcpvec4(Vec3* bc, Vec4* A, Vec4* B, Vec4* C, Vec4* out);
 
-void ssrS_lerpnum(float t, float A, float B, float* out);
 void ssrS_lerpcolor(float t, Color A, Color B, Color* out);
+void ssrS_lerpnum(float t, float* A, float* B, float* out);
 void ssrS_lerpvec2(float t, Vec2* A, Vec2* B, Vec2* out);
 void ssrS_lerpvec3(float t, Vec3* A, Vec3* B, Vec3* out);
 void ssrS_lerpvec4(float t, Vec4* A, Vec4* B, Vec4* out);
@@ -144,7 +144,7 @@ typedef struct {
 } Register;
 
 typedef void* (*BcpInterpolator)(Vec3* bc, void* a, void* b, void* c, void* out);
-typedef void* (*LinearInterpolator)(float t, void* a, void* b, void* c, void* out);
+typedef void* (*LinearInterpolator)(float t, void* a, void* b, void* out);
 
 typedef struct {
 	uint element_size;
@@ -156,6 +156,7 @@ typedef struct {
 
 Register registers[REG_TOTAL];
 ActiveReg active_regs[REG_TOTAL];
+
 int open_regsi[REG_TOTAL]; /*draw call用到的寄存器，可以索引到registers和active_regs*/
 
 /*寄存器指针accessor，指向寄存器中的某个值，用于在shader里快速访问，使用错误可能会出现野指针*/
@@ -177,6 +178,6 @@ void ssrS_setupregisterpointers(int idx);
 void ssrS_setregtofragin();
 
 #define tex2d(tex, uv) \
-texture_sampling(tex, ssr_getfiltermode(), ssr_getwrapmode(), (uv).x, (uv).y)
+texture_sampling(tex, ssr_getfiltermode(), ssr_getwrapmode(), (uv)->x, (uv)->y)
 
 #endif
\ No newline at end of file
diff --git a/src/core/vert.h b/src/core/vert.h
index d594442..faf027e 100644
--- a/src/core/vert.h
+++ b/src/core/vert.h
@@ -29,6 +29,7 @@ typedef struct Vert {
 	Vec2 texcoord;
 	Color color;
 /*
+	Vec2 texcoord1;
 	Vec4 joint;
 	Vec4 weight;
 */
diff --git a/src/example/03_texture.c b/src/example/03_texture.c
index 781bf6b..0e48fcb 100644
--- a/src/example/03_texture.c
+++ b/src/example/03_texture.c
@@ -79,7 +79,7 @@ void onupdatetexture(void*data) {
 
 	ssr_matrixmode(MATRIX_VIEW);
 	ssr_loadidentity();
-	float distance = 700;
+	float distance = 800;
 	Vec3 p = { distance * sin(_t), 300, distance * cos(_t) }, target = { 0, 0, 0 };
 	//Vec3 p = { 0, 0, 700}, target = { 0, 0, 0 };
 	ssr_lookat(&p, &target, &vec3up);
@@ -94,8 +94,8 @@ void onupdatetexture(void*data) {
 
 	Mat4 world2object;
 	ssr_getm(&world2object);
-	mat4_invertgeneral3d(&world2object, &world2object);
-	mat4_transpose(&world2object, &world2object); // transpose it
+	//mat4_invertgeneral3d(&world2object, &world2object);
+	//mat4_transpose(&world2object, &world2object); // transpose it
 
 	ssr_setuniformmat4(0, &world2object);
 }
diff --git a/src/main.c b/src/main.c
index a6f3bbc..4cf83e5 100644
--- a/src/main.c
+++ b/src/main.c
@@ -11,11 +11,6 @@ SDL_Surface* suf;
 #define SCREEN_WIDTH 600
 #define SCREEN_HEIGHT 480
 
-//
-//#define SCREEN_WIDTH 800
-//#define SCREEN_HEIGHT 600
-//
-
 typedef void(*F)(void*);
 F onload;
 F onupdate;
diff --git a/src/shaders/pbr.c b/src/shaders/pbr.c
index ce56419..bd78c8b 100644
--- a/src/shaders/pbr.c
+++ b/src/shaders/pbr.c
@@ -1,24 +1,24 @@
 #include "common.h"
 
 /*uniforms*/
-#define object2world     UM4(0)
-#define light            UV3(0)
+#define _object2world     UM4(0)
+#define _light            UV3(0)
 
-#define albedo_tex       UTEX(0)
-#define noraml_tex       UTEX(1)
-#define roughness_tex    UTEX(2)
-#define metalness_tex    UTEX(3)
+#define _albedo_tex       UTEX(0) 
+#define _noraml_tex       UTEX(1) 
+#define _roughness_tex    UTEX(2) 
+#define _metalness_tex    UTEX(3)
 
 /*varyings*/
-#define uv               reg_v2_00
-#define vnormal          reg_v3_05
-#define rough            reg_num_00
-#define world_pos        reg_v3_00
-#define depth_pos        reg_v3_01
-#define clip_pos         reg_v4_00
-#define world_normal     reg_v3_02 
-#define world_tangent    reg_v3_03
-#define world_bitangent  reg_v3_04
+#define _texcoord         reg_v2_00
+#define _normal           reg_v3_05
+#define _rough            reg_num_00
+#define _world_pos        reg_v3_00
+#define _depth_pos        reg_v3_01
+#define _clip_pos         reg_v4_00
+#define _world_normal     reg_v3_02 
+#define _world_tangent    reg_v3_03
+#define _world_bitangent  reg_v3_04
 
 static void vert(UniformCollection* uniforms, VertexShaderIn* in, Vec4* clipcoord) {
 	static Vec4 p; p.xyz = in->vertex->position; p.w = 1;
@@ -29,11 +29,11 @@ static void vert(UniformCollection* uniforms, VertexShaderIn* in, Vec4* clipcoor
 		in->vertex->normal.z,
 		1
 	};
-	Vec4 worldnormal; mat4_mulvec4(object2world, &normal, &worldnormal);
-	vec3_normalize(light, light);
+	Vec4 worldnormal; mat4_mulvec4(_object2world, &normal, &worldnormal);
+	vec3_normalize(_light, _light);
 	//*rough = 1 - vec3_dot(&worldnormal, light);
 	//*vnormal = in->vertex->normal;
-	*uv = in->vertex->texcoord;
+	*_texcoord = in->vertex->texcoord;
 }
 
 static bool frag(UniformCollection* uniforms, FragmentShaderIn* in, Color32* color) {
@@ -46,7 +46,7 @@ static bool frag(UniformCollection* uniforms, FragmentShaderIn* in, Color32* col
 	//(*color).a = 1;
 	//return 1;
 	//float rough = 1- vec3_dot(&in->normal, light);
-	Color32 c = tex2d(albedo_tex, *uv);
+	Color32 c = tex2d(_albedo_tex, _texcoord);
 	//Color32 nc = tex2d(noramltex, in->texcoord);
 	//vec3_scale(&c, roughness, &c);
 	color32_saturate(&c);