WebSVN – Kolibri OS – Diff – /programs/develop/libraries/TinyGL/asm_fork/vertex.asm


align 4
proc glopNormal uses ecx esi edi, context:dword, p:dword
	mov esi,[p]
	add esi,4
	mov edi,[context]
	add edi,offs_cont_current_normal
	mov ecx,3
	rep movsd
	mov dword[edi],0.0 ;context.current_normal.W = 0.0
	ret
endp
 
align 4
proc glopTexCoord uses ecx esi edi, context:dword, p:dword
	mov esi,[p]
	add esi,4
	mov edi,[context]
	add edi,offs_cont_current_tex_coord
	mov ecx,4
	rep movsd
	ret
endp
 
align 4
proc glopEdgeFlag uses eax ebx, context:dword, p:dword
	mov eax,[context]
	mov ebx,[p]
	mov ebx,[ebx+4] ;ebx = p[1]
	mov dword[eax+offs_cont_current_edge_flag],ebx
	ret
endp
 
align 4
proc glopColor uses eax ecx esi edi, context:dword, p:dword
locals
	q rd 7
endl
	;current_color[3] = p[1-4]
	;longcurrent_color[2] = p[5-7]
	mov esi,[p]
	add esi,4
	mov edi,[context]
	add edi,offs_cont_current_color
	mov ecx,7
	rep movsd
 
	mov eax,[context]
	cmp dword[eax+offs_cont_color_material_enabled],0
	je @f
		mov dword[q],OP_Material
		mov ecx,[eax+offs_cont_current_color_material_mode]
		mov dword[q+4],ecx
		mov ecx,[eax+offs_cont_current_color_material_type]
		mov dword[q+8],ecx
		mov esi,[p]
		add esi,4
		mov edi,ebp
		sub edi,16 ;edi = &q[3]
		mov ecx,4
		rep movsd
		stdcall glopMaterial, eax,[q]
	@@:
	ret
endp
 
align 4
proc gl_eval_viewport uses eax, context:dword
locals
	zsize dd ? ;float
endl
	mov eax,[context]
	add eax,offs_cont_viewport ;eax = (GLViewport*) v
 
	mov dword[zsize],(1 shl (ZB_Z_BITS + ZB_POINT_Z_FRAC_BITS))
	fild dword[zsize]
	fstp dword[zsize]
 
	fld1
	fld1
	fadd st1,st0 ;st1 = 2.0
	fdiv st0,st1 ;st0 = 0.5
 
	fild dword[eax+offs_vpor_xsize]
	fsub st0,st1
	fdiv st0,st2
	fst dword[eax+offs_vpor_scale+offs_X]
	fiadd dword[eax+offs_vpor_xmin]
	fstp dword[eax+offs_vpor_trans+offs_X]
 
	fild dword[eax+offs_vpor_ysize]
	fsub st0,st1
	fdiv st0,st2
	fchs
	fst dword[eax+offs_vpor_scale+offs_Y]
	fchs
	fiadd dword[eax+offs_vpor_ymin]
	fstp dword[eax+offs_vpor_trans+offs_Y]
 
	fld dword[zsize]
	fsub st0,st1
	fdiv st0,st2
	fchs
	fst dword[eax+offs_vpor_scale+offs_Z]
	fchs
	mov dword[zsize],(1 shl ZB_POINT_Z_FRAC_BITS) / 2
	fiadd dword[zsize]
	fstp dword[eax+offs_vpor_trans+offs_Z]
if DEBUG ;gl_eval_viewport
	stdcall dbg_print,f_ev,txt_nl
	add eax,offs_vpor_scale
	stdcall gl_print_matrix,eax,1
	add eax,8
	stdcall gl_print_matrix,eax,1
end if
	ret
endp
 
 
align 4
proc glopBegin uses eax ebx ecx edx, context:dword, p:dword
locals
	tmp M4
endl
;    assert(c->in_begin == 0);
 
	mov edx,[context]
	mov ebx,[p]
	mov ebx,[ebx+4] ;ebx = p[1]
	mov [edx+offs_cont_begin_type],ebx
	mov dword[edx+offs_cont_in_begin],1
	mov dword[edx+offs_cont_vertex_n],0
	mov dword[edx+offs_cont_vertex_cnt],0
 
	bt dword[edx+offs_cont_matrix_model_projection_updated],0
	jnc .end_mmpu
 
	cmp dword[edx+offs_cont_lighting_enabled],0 ;if(context.lighting_enabled)
	je @f
if DEBUG ;context.matrix_stack_ptr[0]
	stdcall gl_print_matrix,dword[edx+offs_cont_matrix_stack_ptr],4
end if
		; precompute inverse modelview
		mov ebx,ebp
		sub ebx,64
		stdcall gl_M4_Inv, ebx,dword[edx+offs_cont_matrix_stack_ptr]
if DEBUG ;tmp
	stdcall dbg_print,txt_sp,txt_nl
	stdcall gl_print_matrix,ebx,4
end if
		push ebx
		mov ebx,edx
		add ebx,offs_cont_matrix_model_view_inv
		stdcall gl_M4_Transpose, ebx
if DEBUG ;context.matrix_model_view_inv
	stdcall dbg_print,txt_sp,txt_nl
	stdcall gl_print_matrix,ebx,4
end if
		jmp .end_if_0
	@@:
		mov ecx,edx
		add ecx,offs_cont_matrix_model_projection
		; precompute projection matrix
		stdcall gl_M4_Mul, ecx,dword[edx+offs_cont_matrix_stack_ptr+4],dword[edx+offs_cont_matrix_stack_ptr]
 
		; test to accelerate computation
		mov dword[edx+offs_cont_matrix_model_projection_no_w_transform],0
		fldz
		fld dword[ecx+12*4]
		fcomp st1
		fstsw ax
		sahf
		jne .end_if_0
		fld dword[ecx+13*4]
		fcomp st1
		fstsw ax
		sahf
		jne .end_if_0
		fld dword[ecx+14*4]
		fcomp st1
		fstsw ax
		sahf
		jne .end_if_0
			mov dword[edx+offs_cont_matrix_model_projection_no_w_transform],1
	.end_if_0:
 
		; test if the texture matrix is not Identity
		mov eax,edx
		add eax,offs_cont_matrix_stack_ptr+8
		stdcall gl_M4_IsId,eax
		xor eax,1
		mov dword[edx+offs_cont_apply_texture_matrix],eax
 
		mov dword[edx+offs_cont_matrix_model_projection_updated],0
	.end_mmpu:
 
	; viewport
	cmp dword[edx+offs_cont_viewport+offs_vpor_updated],0 ;if (context.viewport.updated)
	je @f
		stdcall gl_eval_viewport,edx
		mov dword[edx+offs_cont_viewport+offs_vpor_updated],0
	@@:
	; triangle drawing functions
	cmp dword[edx+offs_cont_render_mode],GL_SELECT
	jne @f
		mov dword[edx+offs_cont_draw_triangle_front],gl_draw_triangle_select
		mov dword[edx+offs_cont_draw_triangle_back],gl_draw_triangle_select
		jmp .end_if_2
	@@:
 
	cmp dword[edx+offs_cont_polygon_mode_front],GL_POINT
	jne @f
		mov dword[edx+offs_cont_draw_triangle_front],gl_draw_triangle_point
		jmp .end_if_1
	@@:
	cmp dword[edx+offs_cont_polygon_mode_front],GL_LINE
	jne @f
		mov dword[edx+offs_cont_draw_triangle_front],gl_draw_triangle_line
		jmp .end_if_1
	@@: ;default:
		mov dword[edx+offs_cont_draw_triangle_front],gl_draw_triangle_fill
	.end_if_1:
 
	cmp dword[edx+offs_cont_polygon_mode_back],GL_POINT
	jne @f
		mov dword[edx+offs_cont_draw_triangle_back],gl_draw_triangle_point
		jmp .end_if_2
	@@:
	cmp dword[edx+offs_cont_polygon_mode_back],GL_LINE
	jne @f
		mov dword[edx+offs_cont_draw_triangle_back],gl_draw_triangle_line
		jmp .end_if_2
	@@: ;default:
	    mov dword[edx+offs_cont_draw_triangle_back],gl_draw_triangle_fill
	.end_if_2:
	ret
endp
 
; coords, tranformation , clip code and projection
; TODO : handle all cases
align 4
proc gl_vertex_transform, context:dword, v:dword
pushad
	mov eax,[context]
	mov edx,[v]
	cmp dword[eax+offs_cont_lighting_enabled],0 ;if (context.lighting_enabled)
	je .els_0
		; eye coordinates needed for lighting
		mov ebx,dword[eax+offs_cont_matrix_stack_ptr]
		finit
		fld dword[edx+offs_vert_coord+offs_X]
		fld dword[edx+offs_vert_coord+offs_Y]
		fld dword[edx+offs_vert_coord+offs_Z]
 
		mov ecx,4
		.cycle_0:
			fld dword[ebx]     ;st0 = m[0]
			fmul st0,st3       ;st0 *= v.coord.X
			fld dword[ebx+4]   ;st0 = m[1]
			fmul st0,st3       ;st0 *= v.coord.Y
			fld dword[ebx+8]   ;st0 = m[2]
			fmul st0,st3       ;st0 *= v.coord.Z
			fadd dword[ebx+12] ;st0 += m[3]
			faddp              ;st0 += v.coord.Z * m[2] 
			faddp              ;st0 += v.coord.Y * m[1] 
			fstp dword[edx+offs_vert_ec] ;v.ec.X = v.coord.X * m[0] + v.coord.Y * m[1] + v.coord.Z * m[2] + m[3]
			add ebx,16 ;следущая строка матрицы
			add edx,4  ;следущая координата вектора
		loop .cycle_0
		ffree st0
		fincstp
		ffree st0
		fincstp
		ffree st0
		fincstp
 
		; projection coordinates
		mov ebx,dword[eax+offs_cont_matrix_stack_ptr+4]
		mov edx,[v]
 
		fld dword[edx+offs_vert_ec+offs_X]
		fld dword[edx+offs_vert_ec+offs_Y]
		fld dword[edx+offs_vert_ec+offs_Z]
 
		mov ecx,4
		.cycle_1:
			fld dword[ebx]     ;st0 = m[0]
			fmul st0,st3       ;st0 *= v.ec.X
			fld dword[ebx+4]   ;st0 = m[1]
			fmul st0,st3       ;st0 *= v.ec.Y
			fld dword[ebx+8]   ;st0 = m[2]
			fmul st0,st3       ;st0 *= v.ec.Z
			fadd dword[ebx+12] ;st0 += m[3]
			faddp              ;st0 += v.ec.Z * m[2]
			faddp              ;st0 += v.ec.Y * m[1]
			fstp dword[edx+offs_vert_pc] ;v.pc.X = v.ec.X * m[0] + v.ec.Y * m[1] + v.ec.Z * m[2] + m[3]
			add ebx,16 ;следущая строка матрицы
			add edx,4  ;следущая координата вектора
		loop .cycle_1
		ffree st0
		fincstp
		ffree st0
		fincstp
		ffree st0
		fincstp
 
		mov ebx,eax
		add ebx,offs_cont_matrix_model_view_inv
		mov edi,eax
		add edi,offs_cont_current_normal
		mov edx,[v]
 
		fld dword[edi] ;edi = &n
		fld dword[edi+offs_Y]
		fld dword[edi+offs_Z]
 
		mov ecx,3
		.cycle_2:
			fld dword[ebx]   ;st0 = m[0]
			fmul st0,st3     ;st0 *= n.X
			fld dword[ebx+4] ;st0 = m[1]
			fmul st0,st3     ;st0 *= n.Y
			fld dword[ebx+8] ;st0 = m[2]
			fmul st0,st3     ;st0 *= n.Z
			faddp            ;st0 += n.Z * m[2]
			faddp            ;st0 += n.Y * m[1]
			fstp dword[edx+offs_vert_normal] ;v.normal.X = n.X * m[0] + n.Y * m[1] + n.Z * m[2]
			add ebx,16 ;следущая строка матрицы
			add edx,4  ;следущая координата вектора
		loop .cycle_2
 
		cmp dword[eax+offs_cont_normalize_enabled],0
		je .end_els
			mov edx,[v]
			add edx,offs_vert_normal
			stdcall gl_V3_Norm,edx
		jmp .end_els
	.els_0:
		; no eye coordinates needed, no normal
		; NOTE: W = 1 is assumed
		mov ebx,eax
		add ebx,offs_cont_matrix_model_projection
 
		finit
		fld dword[edx+offs_vert_coord+offs_X]
		fld dword[edx+offs_vert_coord+offs_Y]
		fld dword[edx+offs_vert_coord+offs_Z]
 
		mov esi,edx
		add esi,offs_vert_pc
 
		fld dword[ebx]     ;st0 = m[0]
		fmul st0,st3       ;st0 *= v.coord.X
		fld dword[ebx+4]   ;st0 = m[1]
		fmul st0,st3       ;st0 *= v.coord.Y
		fld dword[ebx+8]   ;st0 = m[2]
		fmul st0,st3       ;st0 *= v.coord.Z
		fadd dword[ebx+12] ;st0 += m[3]
		faddp              ;st0 += v.coord.Z * m[2]
		faddp              ;st0 += v.coord.Y * m[1]
		fstp dword[esi]    ;v.pc.X = v.coord.X * m[0] + v.coord.Y * m[1] + v.coord.Z * m[2] + m[3]
 
		fld dword[ebx+16]  ;st0 = m[4]
		fmul st0,st3       ;st0 *= v.coord.X
		fld dword[ebx+20]  ;st0 = m[5]
		fmul st0,st3       ;st0 *= v.coord.Y
		fld dword[ebx+24]  ;st0 = m[6]
		fmul st0,st3       ;st0 *= v.coord.Z
		fadd dword[ebx+28] ;st0 += m[7]
		faddp              ;st0 += v.coord.Z * m[6]
		faddp              ;st0 += v.coord.Y * m[5]
		fstp dword[esi+4]  ;v.pc.X = v.coord.X * m[4] + v.coord.Y * m[5] + v.coord.Z * m[6] + m[7]
 
		fld dword[ebx+32]  ;st0 = m[8]
		fmul st0,st3       ;st0 *= v.coord.X
		fld dword[ebx+36]  ;st0 = m[9]
		fmul st0,st3       ;st0 *= v.coord.Y
		fld dword[ebx+40]  ;st0 = m[10]
		fmul st0,st3       ;st0 *= v.coord.Z
		fadd dword[ebx+44] ;st0 += m[11]
		faddp              ;st0 += v.coord.Z * m[10]
		faddp              ;st0 += v.coord.Y * m[9]
		fstp dword[esi+8]  ;v.pc.X = v.coord.X * m[8] + v.coord.Y * m[9] + v.coord.Z * m[10] + m[11]
 
		cmp dword[eax+offs_cont_matrix_model_projection_no_w_transform],0
		je .els_1
			;if (context.matrix_model_projection_no_w_transform)
			mov ebx,dword[ebx+60] ;ebx = m[15]
			mov dword[esi+12],ebx ;v.pc.W = m[15]
			jmp .end_els
		.els_1:
			fld dword[ebx+48]  ;st0 = m[12]
			fmul st0,st3       ;st0 *= v.coord.X
			fld dword[ebx+52]  ;st0 = m[13]
			fmul st0,st3       ;st0 *= v.coord.Y
			fld dword[ebx+56]  ;st0 = m[14]
			fmul st0,st3       ;st0 *= v.coord.Z
			fadd dword[ebx+60] ;st0 += m[15]
			faddp              ;st0 += v.coord.Z * m[14] 
			faddp              ;st0 += v.coord.Y * m[13] 
			fstp dword[esi+12] ;v.pc.W = v.coord.X * m[12] + v.coord.Y * m[13] + v.coord.Z * m[14] + m[15]
	.end_els:
	ffree st0
	fincstp
	ffree st0
	fincstp
	ffree st0
	fincstp
 
if DEBUG ;gl_vertex_transform
	stdcall dbg_print,f_vt,txt_nl
	mov edx,[v]
	add edx,offs_vert_pc
	stdcall gl_print_matrix,edx,1
end if
	mov edx,[v]
	stdcall gl_clipcode, dword[edx+offs_vert_pc+offs_X], dword[edx+offs_vert_pc+offs_Y],\
		dword[edx+offs_vert_pc+offs_Z], dword[edx+offs_vert_pc+offs_W]
	mov dword[edx+offs_vert_clip_code],eax
popad
	ret
endp
 
align 4
proc glopVertex, context:dword, p:dword
locals
	;ebx = GLVertex * v
	n dd ? ;ebp-4
endl
pushad
	mov edx,[context]
 
;    assert(c->in_begin != 0);
 
	mov ecx,[edx+offs_cont_vertex_n]
	mov [n],ecx
	inc dword[edx+offs_cont_vertex_cnt]
 
	; quick fix to avoid crashes on large polygons
	mov ecx,[edx+offs_cont_vertex_max]
	cmp dword[n],ecx
	jl @f
		shl dword[edx+offs_cont_vertex_max],1 ; just double size
		imul ecx,2*sizeof.GLVertex
		stdcall gl_malloc,ecx
		cmp eax,0
		jne .no_err
;gl_fatal_error("unable to allocate GLVertex array.\n");
		.no_err:
		mov edi,eax
		mov ebx,eax
		mov esi,[edx+offs_cont_vertex]
		mov ecx,[n]
		imul ecx,(sizeof.GLVertex)/4 ;((...)/4) что-бы использовать movsd вместо movsb
		rep movsd
		stdcall gl_free,dword[edx+offs_cont_vertex]
		mov dword[edx+offs_cont_vertex],ebx
	@@:
	; new vertex entry
	mov ebx,[n]
	imul ebx,sizeof.GLVertex
	add ebx,[edx+offs_cont_vertex]
	inc dword[n]
 
	mov esi,[p]
	add esi,4
	mov edi,ebx
	add edi,offs_vert_coord ;edi = &v.coord
	mov ecx,4
	rep movsd
 
	stdcall gl_vertex_transform, edx, ebx
 
	; color
	cmp dword[edx+offs_cont_lighting_enabled],0
 
	je .els_0
		stdcall gl_shade_vertex, edx,ebx
		jmp @f
	.els_0:
		mov eax,[edx+offs_cont_current_color]
		mov [ebx+offs_vert_color],eax
		mov eax,[edx+offs_cont_current_color+4]
		mov [ebx+offs_vert_color+4],eax
		mov eax,[edx+offs_cont_current_color+8]
		mov [ebx+offs_vert_color+8],eax
	@@:
 
	; tex coords
	cmp dword[edx+offs_cont_texture_2d_enabled],0
	je @f
		cmp dword[edx+offs_cont_apply_texture_matrix],0
		je .els_1
;           gl_M4_MulV4(&v->tex_coord, c->matrix_stack_ptr[2], &c->current_tex_coord);
			jmp @f
		.els_1:
			mov eax,[edx+offs_cont_current_tex_coord]
			mov [ebx+offs_vert_tex_coord],eax
	@@:
 
	; precompute the mapping to the viewport
	cmp dword[ebx+offs_vert_clip_code],0
	jne @f
		stdcall gl_transform_to_viewport, edx,ebx
	@@:
 
	; edge flag
	mov eax,[edx+offs_cont_current_edge_flag]
	mov dword[ebx+offs_vert_edge_flag],eax ;v.edge_flag = context.current_edge_flag
 
	cmp dword[edx+offs_cont_begin_type],GL_POINTS
	jne @f
		stdcall gl_draw_point, edx, dword[edx+offs_cont_vertex] ;dword[edx+...] = &context.vertex[0]
		mov dword[n],0
		jmp .end_f
	@@:
	cmp dword[edx+offs_cont_begin_type],GL_LINES
	jne @f
		cmp dword[n],2
		jne .end_f
			mov eax,[edx+offs_cont_vertex]
			push eax
			add eax,sizeof.GLVertex
			stdcall gl_draw_line, edx, eax
			xor eax,eax
			mov dword[n],eax
		jmp .end_f
	@@:
	cmp dword[edx+offs_cont_begin_type],GL_LINE_STRIP
	je .li_loop
	cmp dword[edx+offs_cont_begin_type],GL_LINE_LOOP
	jne @f
		.li_loop:
		cmp dword[n],1
		jne .els_2
			mov esi,[edx+offs_cont_vertex]
			mov edi,esi
			add edi,2*sizeof.GLVertex
			mov ecx,(sizeof.GLVertex)/4 ;((...)/4) что-бы использовать movsd вместо movsb
			rep movsd ;context.vertex[2] = context.vertex[0]
			jmp .end_f
		.els_2:
		cmp dword[n],2
		jne .end_f ;else if (n == 2)
			mov eax,[edx+offs_cont_vertex]
			push eax
			mov edi,eax
			add eax,sizeof.GLVertex
			mov esi,eax
			stdcall gl_draw_line, edx, eax
			mov ecx,(sizeof.GLVertex)/4 ;((...)/4) что-бы использовать movsd вместо movsb
			rep movsd ;context.vertex[0] = context.vertex[1]
			mov dword[n],1
		jmp .end_f
	@@:
	cmp dword[edx+offs_cont_begin_type],GL_TRIANGLES
	jne @f
		cmp dword[n],3
		jne .end_f
			mov eax,[edx+offs_cont_vertex]
			mov [esp-4],eax
			add eax,sizeof.GLVertex
			mov [esp-8],eax
			add eax,sizeof.GLVertex
			mov [esp-12],eax
			sub esp,12
			stdcall gl_draw_triangle, edx
			xor eax,eax
			mov dword[n],eax
		jmp .end_f
	@@:
	cmp dword[edx+offs_cont_begin_type],GL_TRIANGLE_STRIP
	jne @f
;       if (c->vertex_cnt >= 3) {
;           if (n == 3)
;               n = 0;
;            /* needed to respect triangle orientation */
;            switch(c->vertex_cnt & 1) {
;            case 0:
;               gl_draw_triangle(c,&c->vertex[2],&c->vertex[1],&c->vertex[0]);
;               break;
;            default:
;            case 1:
;               gl_draw_triangle(c,&c->vertex[0],&c->vertex[1],&c->vertex[2]);
;               break;
;            }
;       }
		jmp .end_f
	@@:
	cmp dword[edx+offs_cont_begin_type],GL_TRIANGLE_FAN
	jne @f
		cmp dword[n],3
		jne .end_f
			mov eax,[edx+offs_cont_vertex]
			mov [esp-4],eax
			add eax,sizeof.GLVertex
			mov [esp-8],eax
			mov edi,eax
			add eax,sizeof.GLVertex
			mov [esp-12],eax
			mov esi,eax
			sub esp,12
			stdcall gl_draw_triangle, edx
			mov ecx,(sizeof.GLVertex)/4 ;((...)/4) что-бы использовать movsd вместо movsb
			rep movsd ;context.vertex[1] = context.vertex[2]
			mov dword[n],2
		jmp .end_f
	@@:
	cmp dword[edx+offs_cont_begin_type],GL_QUADS
	jne @f
		cmp dword[n],4
		jne .end_f
			mov eax,[edx+offs_cont_vertex]
			add eax,2*sizeof.GLVertex
			mov dword[eax+offs_vert_edge_flag],0 ;context.vertex[2].edge_flag = 0
			push eax
			sub eax,sizeof.GLVertex
			push eax
			sub eax,sizeof.GLVertex
			stdcall gl_draw_triangle, edx,eax ;v0,v1,v2
			mov dword[eax+offs_vert_edge_flag],0 ;context.vertex[0].edge_flag = 0
			add eax,2*sizeof.GLVertex
			mov dword[eax+offs_vert_edge_flag],1 ;context.vertex[2].edge_flag = 1
			add eax,sizeof.GLVertex
			push eax
			sub eax,sizeof.GLVertex
			push eax
			sub eax,2*sizeof.GLVertex
			stdcall gl_draw_triangle, edx,eax ;v0,v2,v3
			xor eax,eax
			mov dword[n],eax
		jmp .end_f
	@@:
	cmp dword[edx+offs_cont_begin_type],GL_QUAD_STRIP
	jne @f
		cmp dword[n],4
		jne .end_f
			mov eax,[edx+offs_cont_vertex]
			mov [esp-4],eax
			mov edi,eax
			add eax,sizeof.GLVertex
			mov [esp-8],eax
			add eax,sizeof.GLVertex
			mov [esp-12],eax
			mov esi,eax
			sub esp,12
			stdcall gl_draw_triangle, edx ;v0,v1,v2
			mov [esp-12],eax
			add eax,sizeof.GLVertex
			mov [esp-8],eax
			sub eax,2*sizeof.GLVertex
			mov [esp-4],eax
			sub esp,12
			stdcall gl_draw_triangle, edx ;v1,v3,v2
			mov ecx,(sizeof.GLVertex)/2 ;((...)/2) копируем 2 вершины
			rep movsd ;context.vertex[0] = context.vertex[2], context.vertex[1] = context.vertex[3]
			mov dword[n],2
		jmp .end_f
	@@:
	cmp dword[edx+offs_cont_begin_type],GL_POLYGON
	je .end_f
;    default:
;       gl_fatal_error("glBegin: type %x not handled\n", c->begin_type);
;    }
	.end_f:
 
	mov ecx,[n]
	mov [edx+offs_cont_vertex_n],ecx
popad
	ret
endp
 
align 4
proc glopEnd uses eax ebx ecx, context:dword, p:dword
	mov eax,[context]
;    assert(c->in_begin == 1);
 
	cmp dword[eax+offs_cont_begin_type],GL_LINE_LOOP
	jne .else_i
		cmp dword[eax+offs_cont_vertex_cnt],3
		jl .end_i
			mov ebx,[eax+offs_cont_vertex]
			push ebx
			add ebx,2*sizeof.GLVertex
			push ebx
			stdcall gl_draw_line, eax
		jmp .end_i
	.else_i:
	cmp dword[eax+offs_cont_begin_type],GL_POLYGON
	jne .end_i
		mov ebx,dword[eax+offs_cont_vertex_cnt]
		@@: ;while (ebx >= 3)
		cmp ebx,3
		jl .end_i
			dec ebx
			mov ecx,ebx
			imul ecx,sizeof.GLVertex
			add ecx,[eax+offs_cont_vertex]
			push ecx ;ecx = &context.vertex[i]
			sub ecx,sizeof.GLVertex
			push ecx ;ecx = &context.vertex[i-1]
			stdcall gl_draw_triangle, eax,[eax+offs_cont_vertex]
		jmp @b
	.end_i:
	mov dword[eax+offs_cont_in_begin],0
	ret
endp

Rev 5218	Rev 5256
1	align 4	1	align 4
2	proc glopNormal uses ecx esi edi, context:dword, p:dword	2	proc glopNormal uses ecx esi edi, context:dword, p:dword
3	mov esi,[p]	3	mov esi,[p]
4	add esi,4	4	add esi,4
5	mov edi,[context]	5	mov edi,[context]
6	add edi,offs_cont_current_normal	6	add edi,offs_cont_current_normal
7	mov ecx,3	7	mov ecx,3
8	rep movsd	8	rep movsd
9	mov dword[edi],0.0 ;context.current_normal.W = 0.0	9	mov dword[edi],0.0 ;context.current_normal.W = 0.0
10	ret	10	ret
11	endp	11	endp
12		12
13	align 4	13	align 4
14	proc glopTexCoord uses ecx esi edi, context:dword, p:dword	14	proc glopTexCoord uses ecx esi edi, context:dword, p:dword
15	mov esi,[p]	15	mov esi,[p]
16	add esi,4	16	add esi,4
17	mov edi,[context]	17	mov edi,[context]
18	add edi,offs_cont_current_tex_coord	18	add edi,offs_cont_current_tex_coord
19	mov ecx,4	19	mov ecx,4
20	rep movsd	20	rep movsd
21	ret	21	ret
22	endp	22	endp
23		23
24	align 4	24	align 4
25	proc glopEdgeFlag uses eax ebx, context:dword, p:dword	25	proc glopEdgeFlag uses eax ebx, context:dword, p:dword
26	mov eax,[context]	26	mov eax,[context]
27	mov ebx,[p]	27	mov ebx,[p]
28	mov ebx,[ebx+4] ;ebx = p[1]	28	mov ebx,[ebx+4] ;ebx = p[1]
29	mov dword[eax+offs_cont_current_edge_flag],ebx	29	mov dword[eax+offs_cont_current_edge_flag],ebx
30	ret	30	ret
31	endp	31	endp
32		32
33	align 4	33	align 4
34	proc glopColor uses eax ecx esi edi, context:dword, p:dword	34	proc glopColor uses eax ecx esi edi, context:dword, p:dword
35	locals	35	locals
36	q rd 7	36	q rd 7
37	endl	37	endl
38	;current_color[3] = p[1-4]	38	;current_color[3] = p[1-4]
39	;longcurrent_color[2] = p[5-7]	39	;longcurrent_color[2] = p[5-7]
40	mov esi,[p]	40	mov esi,[p]
41	add esi,4	41	add esi,4
42	mov edi,[context]	42	mov edi,[context]
43	add edi,offs_cont_current_color	43	add edi,offs_cont_current_color
44	mov ecx,7	44	mov ecx,7
45	rep movsd	45	rep movsd
46		46
47	mov eax,[context]	47	mov eax,[context]
48	cmp dword[eax+offs_cont_color_material_enabled],0	48	cmp dword[eax+offs_cont_color_material_enabled],0
49	je @f	49	je @f
50	mov dword[q],OP_Material	50	mov dword[q],OP_Material
51	mov ecx,[eax+offs_cont_current_color_material_mode]	51	mov ecx,[eax+offs_cont_current_color_material_mode]
52	mov dword[q+4],ecx	52	mov dword[q+4],ecx
53	mov ecx,[eax+offs_cont_current_color_material_type]	53	mov ecx,[eax+offs_cont_current_color_material_type]
54	mov dword[q+8],ecx	54	mov dword[q+8],ecx
55	mov esi,[p]	55	mov esi,[p]
56	add esi,4	56	add esi,4
57	mov edi,ebp	57	mov edi,ebp
58	sub edi,16 ;edi = &q[3]	58	sub edi,16 ;edi = &q[3]
59	mov ecx,4	59	mov ecx,4
60	rep movsd	60	rep movsd
61	stdcall glopMaterial, eax,[q]	61	stdcall glopMaterial, eax,[q]
62	@@:	62	@@:
63	ret	63	ret
64	endp	64	endp
65		65
66	align 4	66	align 4
67	proc gl_eval_viewport uses eax, context:dword	67	proc gl_eval_viewport uses eax, context:dword
68	locals	68	locals
69	zsize dd ? ;float	69	zsize dd ? ;float
70	endl	70	endl
71	mov eax,[context]	71	mov eax,[context]
72	add eax,offs_cont_viewport ;eax = (GLViewport*) v	72	add eax,offs_cont_viewport ;eax = (GLViewport*) v
73		73
74	mov dword[zsize],(1 shl (ZB_Z_BITS + ZB_POINT_Z_FRAC_BITS))	74	mov dword[zsize],(1 shl (ZB_Z_BITS + ZB_POINT_Z_FRAC_BITS))
75	fild dword[zsize]	75	fild dword[zsize]
76	fstp dword[zsize]	76	fstp dword[zsize]
77		77
78	fld1	78	fld1
79	fld1	79	fld1
80	fadd st1,st0 ;st1 = 2.0	80	fadd st1,st0 ;st1 = 2.0
81	fdiv st0,st1 ;st0 = 0.5	81	fdiv st0,st1 ;st0 = 0.5
82		82
83	fild dword[eax+offs_vpor_xsize]	83	fild dword[eax+offs_vpor_xsize]
84	fsub st0,st1	84	fsub st0,st1
85	fdiv st0,st2	85	fdiv st0,st2
86	fst dword[eax+offs_vpor_scale+offs_X]	86	fst dword[eax+offs_vpor_scale+offs_X]
87	fiadd dword[eax+offs_vpor_xmin]	87	fiadd dword[eax+offs_vpor_xmin]
88	fstp dword[eax+offs_vpor_trans+offs_X]	88	fstp dword[eax+offs_vpor_trans+offs_X]
89		89
90	fild dword[eax+offs_vpor_ysize]	90	fild dword[eax+offs_vpor_ysize]
91	fsub st0,st1	91	fsub st0,st1
92	fdiv st0,st2	92	fdiv st0,st2
93	fchs	93	fchs
94	fst dword[eax+offs_vpor_scale+offs_Y]	94	fst dword[eax+offs_vpor_scale+offs_Y]
95	fchs	95	fchs
96	fiadd dword[eax+offs_vpor_ymin]	96	fiadd dword[eax+offs_vpor_ymin]
97	fstp dword[eax+offs_vpor_trans+offs_Y]	97	fstp dword[eax+offs_vpor_trans+offs_Y]
98		98
99	fld dword[zsize]	99	fld dword[zsize]
100	fsub st0,st1	100	fsub st0,st1
101	fdiv st0,st2	101	fdiv st0,st2
102	fchs	102	fchs
103	fst dword[eax+offs_vpor_scale+offs_Z]	103	fst dword[eax+offs_vpor_scale+offs_Z]
104	fchs	104	fchs
105	mov dword[zsize],(1 shl ZB_POINT_Z_FRAC_BITS) / 2	105	mov dword[zsize],(1 shl ZB_POINT_Z_FRAC_BITS) / 2
106	fiadd dword[zsize]	106	fiadd dword[zsize]
107	fstp dword[eax+offs_vpor_trans+offs_Z]	107	fstp dword[eax+offs_vpor_trans+offs_Z]
108	if DEBUG ;gl_eval_viewport	108	if DEBUG ;gl_eval_viewport
109	stdcall dbg_print,f_ev,txt_nl	109	stdcall dbg_print,f_ev,txt_nl
110	add eax,offs_vpor_scale	110	add eax,offs_vpor_scale
111	stdcall gl_print_matrix,eax,1	111	stdcall gl_print_matrix,eax,1
112	add eax,8	112	add eax,8
113	stdcall gl_print_matrix,eax,1	113	stdcall gl_print_matrix,eax,1
114	end if	114	end if
115	ret	115	ret
116	endp	116	endp
117		117
118		118
119	align 4	119	align 4
120	proc glopBegin uses eax ebx ecx edx, context:dword, p:dword	120	proc glopBegin uses eax ebx ecx edx, context:dword, p:dword
121	locals	121	locals
122	tmp M4	122	tmp M4
123	endl	123	endl
124	; assert(c->in_begin == 0);	124	; assert(c->in_begin == 0);
125		125
126	mov edx,[context]	126	mov edx,[context]
127	mov ebx,[p]	127	mov ebx,[p]
128	mov ebx,[ebx+4] ;ebx = p[1]	128	mov ebx,[ebx+4] ;ebx = p[1]
129	mov [edx+offs_cont_begin_type],ebx	129	mov [edx+offs_cont_begin_type],ebx
130	mov dword[edx+offs_cont_in_begin],1	130	mov dword[edx+offs_cont_in_begin],1
131	mov dword[edx+offs_cont_vertex_n],0	131	mov dword[edx+offs_cont_vertex_n],0
132	mov dword[edx+offs_cont_vertex_cnt],0	132	mov dword[edx+offs_cont_vertex_cnt],0
133		133
134	bt dword[edx+offs_cont_matrix_model_projection_updated],0	134	bt dword[edx+offs_cont_matrix_model_projection_updated],0
135	jnc .end_mmpu	135	jnc .end_mmpu
136		136
137	cmp dword[edx+offs_cont_lighting_enabled],0 ;if(context.lighting_enabled)	137	cmp dword[edx+offs_cont_lighting_enabled],0 ;if(context.lighting_enabled)
138	je @f	138	je @f
139	; precompute inverse modelview	139	if DEBUG ;context.matrix_stack_ptr[0]
-		140	stdcall gl_print_matrix,dword[edx+offs_cont_matrix_stack_ptr],4
-		141	end if
-		142	; precompute inverse modelview
140	mov ebx,ebp	143	mov ebx,ebp
141	sub ebx,64	144	sub ebx,64
142	stdcall gl_M4_Inv, ebx, edx+offs_cont_matrix_stack_ptr	145	stdcall gl_M4_Inv, ebx,dword[edx+offs_cont_matrix_stack_ptr]
143	stdcall gl_M4_Transpose, edx+offs_cont_matrix_model_view_inv, ebx	146	if DEBUG ;tmp
-		147	stdcall dbg_print,txt_sp,txt_nl
-		148	stdcall gl_print_matrix,ebx,4
-		149	end if
-		150	push ebx
-		151	mov ebx,edx
-		152	add ebx,offs_cont_matrix_model_view_inv
144	jmp .end_if_0	153	stdcall gl_M4_Transpose, ebx
-		154	if DEBUG ;context.matrix_model_view_inv
-		155	stdcall dbg_print,txt_sp,txt_nl
-		156	stdcall gl_print_matrix,ebx,4
-		157	end if
-		158	jmp .end_if_0
145	@@:	159	@@:
146	mov ecx,edx	160	mov ecx,edx
147	add ecx,offs_cont_matrix_model_projection	161	add ecx,offs_cont_matrix_model_projection
148	; precompute projection matrix	162	; precompute projection matrix
149	stdcall gl_M4_Mul, ecx,dword[edx+offs_cont_matrix_stack_ptr+4],dword[edx+offs_cont_matrix_stack_ptr]	163	stdcall gl_M4_Mul, ecx,dword[edx+offs_cont_matrix_stack_ptr+4],dword[edx+offs_cont_matrix_stack_ptr]
150		164
151	; test to accelerate computation	165	; test to accelerate computation
152	mov dword[edx+offs_cont_matrix_model_projection_no_w_transform],0	166	mov dword[edx+offs_cont_matrix_model_projection_no_w_transform],0
153	fldz	167	fldz
154	fld dword[ecx+12*4]	168	fld dword[ecx+12*4]
155	fcomp st1	169	fcomp st1
156	fstsw ax	170	fstsw ax
157	sahf	171	sahf
158	jne .end_if_0	172	jne .end_if_0
159	fld dword[ecx+13*4]	173	fld dword[ecx+13*4]
160	fcomp st1	174	fcomp st1
161	fstsw ax	175	fstsw ax
162	sahf	176	sahf
163	jne .end_if_0	177	jne .end_if_0
164	fld dword[ecx+14*4]	178	fld dword[ecx+14*4]
165	fcomp st1	179	fcomp st1
166	fstsw ax	180	fstsw ax
167	sahf	181	sahf
168	jne .end_if_0	182	jne .end_if_0
169	mov dword[edx+offs_cont_matrix_model_projection_no_w_transform],1	183	mov dword[edx+offs_cont_matrix_model_projection_no_w_transform],1
170	.end_if_0:	184	.end_if_0:
171		185
172	; test if the texture matrix is not Identity	186	; test if the texture matrix is not Identity
173	mov eax,edx	187	mov eax,edx
174	add eax,offs_cont_matrix_stack_ptr+8	188	add eax,offs_cont_matrix_stack_ptr+8
175	stdcall gl_M4_IsId,eax	189	stdcall gl_M4_IsId,eax
176	xor eax,1	190	xor eax,1
177	mov dword[edx+offs_cont_apply_texture_matrix],eax	191	mov dword[edx+offs_cont_apply_texture_matrix],eax
178		192
179	mov dword[edx+offs_cont_matrix_model_projection_updated],0	193	mov dword[edx+offs_cont_matrix_model_projection_updated],0
180	.end_mmpu:	194	.end_mmpu:
181		195
182	; viewport	196	; viewport
183	cmp dword[edx+offs_cont_viewport+offs_vpor_updated],0 ;if (context.viewport.updated)	197	cmp dword[edx+offs_cont_viewport+offs_vpor_updated],0 ;if (context.viewport.updated)
184	je @f	198	je @f
185	stdcall gl_eval_viewport,edx	199	stdcall gl_eval_viewport,edx
186	mov dword[edx+offs_cont_viewport+offs_vpor_updated],0	200	mov dword[edx+offs_cont_viewport+offs_vpor_updated],0
187	@@:	201	@@:
188	; triangle drawing functions	202	; triangle drawing functions
189	cmp dword[edx+offs_cont_render_mode],GL_SELECT	203	cmp dword[edx+offs_cont_render_mode],GL_SELECT
190	jne @f	204	jne @f
191	mov dword[edx+offs_cont_draw_triangle_front],gl_draw_triangle_select	205	mov dword[edx+offs_cont_draw_triangle_front],gl_draw_triangle_select
192	mov dword[edx+offs_cont_draw_triangle_back],gl_draw_triangle_select	206	mov dword[edx+offs_cont_draw_triangle_back],gl_draw_triangle_select
193	jmp .end_if_2	207	jmp .end_if_2
194	@@:	208	@@:
195		209
196	cmp dword[edx+offs_cont_polygon_mode_front],GL_POINT	210	cmp dword[edx+offs_cont_polygon_mode_front],GL_POINT
197	jne @f	211	jne @f
198	mov dword[edx+offs_cont_draw_triangle_front],gl_draw_triangle_point	212	mov dword[edx+offs_cont_draw_triangle_front],gl_draw_triangle_point
199	jmp .end_if_1	213	jmp .end_if_1
200	@@:	214	@@:
201	cmp dword[edx+offs_cont_polygon_mode_front],GL_LINE	215	cmp dword[edx+offs_cont_polygon_mode_front],GL_LINE
202	jne @f	216	jne @f
203	mov dword[edx+offs_cont_draw_triangle_front],gl_draw_triangle_line	217	mov dword[edx+offs_cont_draw_triangle_front],gl_draw_triangle_line
204	jmp .end_if_1	218	jmp .end_if_1
205	@@: ;default:	219	@@: ;default:
206	mov dword[edx+offs_cont_draw_triangle_front],gl_draw_triangle_fill	220	mov dword[edx+offs_cont_draw_triangle_front],gl_draw_triangle_fill
207	.end_if_1:	221	.end_if_1:
208		222
209	cmp dword[edx+offs_cont_polygon_mode_back],GL_POINT	223	cmp dword[edx+offs_cont_polygon_mode_back],GL_POINT
210	jne @f	224	jne @f
211	mov dword[edx+offs_cont_draw_triangle_back],gl_draw_triangle_point	225	mov dword[edx+offs_cont_draw_triangle_back],gl_draw_triangle_point
212	jmp .end_if_2	226	jmp .end_if_2
213	@@:	227	@@:
214	cmp dword[edx+offs_cont_polygon_mode_back],GL_LINE	228	cmp dword[edx+offs_cont_polygon_mode_back],GL_LINE
215	jne @f	229	jne @f
216	mov dword[edx+offs_cont_draw_triangle_back],gl_draw_triangle_line	230	mov dword[edx+offs_cont_draw_triangle_back],gl_draw_triangle_line
217	jmp .end_if_2	231	jmp .end_if_2
218	@@: ;default:	232	@@: ;default:
219	mov dword[edx+offs_cont_draw_triangle_back],gl_draw_triangle_fill	233	mov dword[edx+offs_cont_draw_triangle_back],gl_draw_triangle_fill
220	.end_if_2:	234	.end_if_2:
221	ret	235	ret
222	endp	236	endp
223		237
224	; coords, tranformation , clip code and projection	238	; coords, tranformation , clip code and projection
225	; TODO : handle all cases	239	; TODO : handle all cases
226	align 4	240	align 4
227	proc gl_vertex_transform, context:dword, v:dword	241	proc gl_vertex_transform, context:dword, v:dword
228	pushad	242	pushad
229	mov eax,[context]	243	mov eax,[context]
230	mov edx,[v]	244	mov edx,[v]
231	cmp dword[eax+offs_cont_lighting_enabled],0 ;if (context.lighting_enabled)	245	cmp dword[eax+offs_cont_lighting_enabled],0 ;if (context.lighting_enabled)
232	je .els_0	246	je .els_0
233	; eye coordinates needed for lighting	247	; eye coordinates needed for lighting
234	mov ebx,dword[eax+offs_cont_matrix_stack_ptr]	248	mov ebx,dword[eax+offs_cont_matrix_stack_ptr]
235	finit	249	finit
236	fld dword[edx+offs_vert_coord+offs_X]	250	fld dword[edx+offs_vert_coord+offs_X]
237	fld dword[edx+offs_vert_coord+offs_Y]	251	fld dword[edx+offs_vert_coord+offs_Y]
238	fld dword[edx+offs_vert_coord+offs_Z]	252	fld dword[edx+offs_vert_coord+offs_Z]
239		253
240	mov ecx,4	254	mov ecx,4
241	.cycle_0:	255	.cycle_0:
242	fld dword[ebx] ;st0 = m[0]	256	fld dword[ebx] ;st0 = m[0]
243	fmul st0,st3 ;st0 *= v.coord.X	257	fmul st0,st3 ;st0 *= v.coord.X
244	fld dword[ebx+4] ;st0 = m[1]	258	fld dword[ebx+4] ;st0 = m[1]
245	fmul st0,st3 ;st0 *= v.coord.Y	259	fmul st0,st3 ;st0 *= v.coord.Y
246	fld dword[ebx+8] ;st0 = m[2]	260	fld dword[ebx+8] ;st0 = m[2]
247	fmul st0,st3 ;st0 *= v.coord.Z	261	fmul st0,st3 ;st0 *= v.coord.Z
248	fadd dword[ebx+12] ;st0 += m[3]	262	fadd dword[ebx+12] ;st0 += m[3]
249	faddp ;st0 += v.coord.Z * m[2]	263	faddp ;st0 += v.coord.Z * m[2]
250	faddp ;st0 += v.coord.Y * m[1]	264	faddp ;st0 += v.coord.Y * m[1]
251	fstp dword[edx+offs_vert_ec] ;v.ec.X = v.coord.X * m[0] + v.coord.Y * m[1] + v.coord.Z * m[2] + m[3]	265	fstp dword[edx+offs_vert_ec] ;v.ec.X = v.coord.X * m[0] + v.coord.Y * m[1] + v.coord.Z * m[2] + m[3]
252	add ebx,16 ;следущая строка матрицы	266	add ebx,16 ;следущая строка матрицы
253	add edx,4 ;следущая координата вектора	267	add edx,4 ;следущая координата вектора
254	loop .cycle_0	268	loop .cycle_0
255	ffree st0	269	ffree st0
256	fincstp	270	fincstp
257	ffree st0	271	ffree st0
258	fincstp	272	fincstp
259	ffree st0	273	ffree st0
260	fincstp	274	fincstp
261		275
262	; projection coordinates	276	; projection coordinates
263	mov ebx,dword[eax+offs_cont_matrix_stack_ptr+4]	277	mov ebx,dword[eax+offs_cont_matrix_stack_ptr+4]
264	mov edx,[v]	278	mov edx,[v]
265		279
266	fld dword[edx+offs_vert_ec+offs_X]	280	fld dword[edx+offs_vert_ec+offs_X]
267	fld dword[edx+offs_vert_ec+offs_Y]	281	fld dword[edx+offs_vert_ec+offs_Y]
268	fld dword[edx+offs_vert_ec+offs_Z]	282	fld dword[edx+offs_vert_ec+offs_Z]
269		283
270	mov ecx,4	284	mov ecx,4
271	.cycle_1:	285	.cycle_1:
272	fld dword[ebx] ;st0 = m[0]	286	fld dword[ebx] ;st0 = m[0]
273	fmul st0,st3 ;st0 *= v.ec.X	287	fmul st0,st3 ;st0 *= v.ec.X
274	fld dword[ebx+4] ;st0 = m[1]	288	fld dword[ebx+4] ;st0 = m[1]
275	fmul st0,st3 ;st0 *= v.ec.Y	289	fmul st0,st3 ;st0 *= v.ec.Y
276	fld dword[ebx+8] ;st0 = m[2]	290	fld dword[ebx+8] ;st0 = m[2]
277	fmul st0,st3 ;st0 *= v.ec.Z	291	fmul st0,st3 ;st0 *= v.ec.Z
278	fadd dword[ebx+12] ;st0 += m[3]	292	fadd dword[ebx+12] ;st0 += m[3]
279	faddp ;st0 += v.ec.Z * m[2]	293	faddp ;st0 += v.ec.Z * m[2]
280	faddp ;st0 += v.ec.Y * m[1]	294	faddp ;st0 += v.ec.Y * m[1]
281	fstp dword[edx+offs_vert_pc] ;v.pc.X = v.ec.X * m[0] + v.ec.Y * m[1] + v.ec.Z * m[2] + m[3]	295	fstp dword[edx+offs_vert_pc] ;v.pc.X = v.ec.X * m[0] + v.ec.Y * m[1] + v.ec.Z * m[2] + m[3]
282	add ebx,16 ;следущая строка матрицы	296	add ebx,16 ;следущая строка матрицы
283	add edx,4 ;следущая координата вектора	297	add edx,4 ;следущая координата вектора
284	loop .cycle_1	298	loop .cycle_1
285	ffree st0	299	ffree st0
286	fincstp	300	fincstp
287	ffree st0	301	ffree st0
288	fincstp	302	fincstp
289	ffree st0	303	ffree st0
290	fincstp	304	fincstp
291		305
292	mov ebx,eax	306	mov ebx,eax
293	add ebx,offs_cont_matrix_model_view_inv	307	add ebx,offs_cont_matrix_model_view_inv
294	mov edi,eax	308	mov edi,eax
295	add edi,offs_cont_current_normal	309	add edi,offs_cont_current_normal
296	mov edx,[v]	310	mov edx,[v]
297		311
298	fld dword[edi+offs_X]	312	fld dword[edi] ;edi = &n
299	fld dword[edi+offs_Y]	313	fld dword[edi+offs_Y]
300	fld dword[edi+offs_Z]	314	fld dword[edi+offs_Z]
301		315
302	mov ecx,3	316	mov ecx,3
303	.cycle_2:	317	.cycle_2:
304	fld dword[ebx] ;st0 = m[0]	318	fld dword[ebx] ;st0 = m[0]
305	fmul st0,st3 ;st0 *= n.X	319	fmul st0,st3 ;st0 *= n.X
306	fld dword[ebx+4] ;st0 = m[1]	320	fld dword[ebx+4] ;st0 = m[1]
307	fmul st0,st3 ;st0 *= n.Y	321	fmul st0,st3 ;st0 *= n.Y
308	fld dword[ebx+8] ;st0 = m[2]	322	fld dword[ebx+8] ;st0 = m[2]
309	fmul st0,st3 ;st0 *= n.Z	323	fmul st0,st3 ;st0 *= n.Z
310	faddp ;st0 += n.Z * m[2]	324	faddp ;st0 += n.Z * m[2]
311	faddp ;st0 += n.Y * m[1]	325	faddp ;st0 += n.Y * m[1]
312	fstp dword[edx+offs_vert_normal] ;v.normal.X = n.X * m[0] + n.Y * m[1] + n.Z * m[2]	326	fstp dword[edx+offs_vert_normal] ;v.normal.X = n.X * m[0] + n.Y * m[1] + n.Z * m[2]
313	add ebx,16 ;следущая строка матрицы	327	add ebx,16 ;следущая строка матрицы
314	add edx,4 ;следущая координата вектора	328	add edx,4 ;следущая координата вектора
315	loop .cycle_2	329	loop .cycle_2
316		330
317	cmp dword[eax+offs_cont_normalize_enabled],0	331	cmp dword[eax+offs_cont_normalize_enabled],0
318	je .end_els	332	je .end_els
319	mov edx,[v]	333	mov edx,[v]
320	add edx,offs_vert_normal	334	add edx,offs_vert_normal
321	stdcall gl_V3_Norm,edx	335	stdcall gl_V3_Norm,edx
322	jmp .end_els	336	jmp .end_els
323	.els_0:	337	.els_0:
324	; no eye coordinates needed, no normal	338	; no eye coordinates needed, no normal
325	; NOTE: W = 1 is assumed	339	; NOTE: W = 1 is assumed
326	mov ebx,eax	340	mov ebx,eax
327	add ebx,offs_cont_matrix_model_projection	341	add ebx,offs_cont_matrix_model_projection
328		342
329	finit	343	finit
330	fld dword[edx+offs_vert_coord+offs_X]	344	fld dword[edx+offs_vert_coord+offs_X]
331	fld dword[edx+offs_vert_coord+offs_Y]	345	fld dword[edx+offs_vert_coord+offs_Y]
332	fld dword[edx+offs_vert_coord+offs_Z]	346	fld dword[edx+offs_vert_coord+offs_Z]
333		347
334	mov esi,edx	348	mov esi,edx
335	add esi,offs_vert_pc	349	add esi,offs_vert_pc
336		350
337	fld dword[ebx] ;st0 = m[0]	351	fld dword[ebx] ;st0 = m[0]
338	fmul st0,st3 ;st0 *= v.coord.X	352	fmul st0,st3 ;st0 *= v.coord.X
339	fld dword[ebx+4] ;st0 = m[1]	353	fld dword[ebx+4] ;st0 = m[1]
340	fmul st0,st3 ;st0 *= v.coord.Y	354	fmul st0,st3 ;st0 *= v.coord.Y
341	fld dword[ebx+8] ;st0 = m[2]	355	fld dword[ebx+8] ;st0 = m[2]
342	fmul st0,st3 ;st0 *= v.coord.Z	356	fmul st0,st3 ;st0 *= v.coord.Z
343	fadd dword[ebx+12] ;st0 += m[3]	357	fadd dword[ebx+12] ;st0 += m[3]
344	faddp ;st0 += v.coord.Z * m[2]	358	faddp ;st0 += v.coord.Z * m[2]
345	faddp ;st0 += v.coord.Y * m[1]	359	faddp ;st0 += v.coord.Y * m[1]
346	fstp dword[esi] ;v.pc.X = v.coord.X * m[0] + v.coord.Y * m[1] + v.coord.Z * m[2] + m[3]	360	fstp dword[esi] ;v.pc.X = v.coord.X * m[0] + v.coord.Y * m[1] + v.coord.Z * m[2] + m[3]
347		361
348	fld dword[ebx+16] ;st0 = m[4]	362	fld dword[ebx+16] ;st0 = m[4]
349	fmul st0,st3 ;st0 *= v.coord.X	363	fmul st0,st3 ;st0 *= v.coord.X
350	fld dword[ebx+20] ;st0 = m[5]	364	fld dword[ebx+20] ;st0 = m[5]
351	fmul st0,st3 ;st0 *= v.coord.Y	365	fmul st0,st3 ;st0 *= v.coord.Y
352	fld dword[ebx+24] ;st0 = m[6]	366	fld dword[ebx+24] ;st0 = m[6]
353	fmul st0,st3 ;st0 *= v.coord.Z	367	fmul st0,st3 ;st0 *= v.coord.Z
354	fadd dword[ebx+28] ;st0 += m[7]	368	fadd dword[ebx+28] ;st0 += m[7]
355	faddp ;st0 += v.coord.Z * m[6]	369	faddp ;st0 += v.coord.Z * m[6]
356	faddp ;st0 += v.coord.Y * m[5]	370	faddp ;st0 += v.coord.Y * m[5]
357	fstp dword[esi+4] ;v.pc.X = v.coord.X * m[4] + v.coord.Y * m[5] + v.coord.Z * m[6] + m[7]	371	fstp dword[esi+4] ;v.pc.X = v.coord.X * m[4] + v.coord.Y * m[5] + v.coord.Z * m[6] + m[7]
358		372
359	fld dword[ebx+32] ;st0 = m[8]	373	fld dword[ebx+32] ;st0 = m[8]
360	fmul st0,st3 ;st0 *= v.coord.X	374	fmul st0,st3 ;st0 *= v.coord.X
361	fld dword[ebx+36] ;st0 = m[9]	375	fld dword[ebx+36] ;st0 = m[9]
362	fmul st0,st3 ;st0 *= v.coord.Y	376	fmul st0,st3 ;st0 *= v.coord.Y
363	fld dword[ebx+40] ;st0 = m[10]	377	fld dword[ebx+40] ;st0 = m[10]
364	fmul st0,st3 ;st0 *= v.coord.Z	378	fmul st0,st3 ;st0 *= v.coord.Z
365	fadd dword[ebx+44] ;st0 += m[11]	379	fadd dword[ebx+44] ;st0 += m[11]
366	faddp ;st0 += v.coord.Z * m[10]	380	faddp ;st0 += v.coord.Z * m[10]
367	faddp ;st0 += v.coord.Y * m[9]	381	faddp ;st0 += v.coord.Y * m[9]
368	fstp dword[esi+8] ;v.pc.X = v.coord.X * m[8] + v.coord.Y * m[9] + v.coord.Z * m[10] + m[11]	382	fstp dword[esi+8] ;v.pc.X = v.coord.X * m[8] + v.coord.Y * m[9] + v.coord.Z * m[10] + m[11]
369		383
370	cmp dword[eax+offs_cont_matrix_model_projection_no_w_transform],0	384	cmp dword[eax+offs_cont_matrix_model_projection_no_w_transform],0
371	je .els_1	385	je .els_1
372	;if (context.matrix_model_projection_no_w_transform)	386	;if (context.matrix_model_projection_no_w_transform)
373	mov ebx,dword[ebx+60] ;ebx = m[15]	387	mov ebx,dword[ebx+60] ;ebx = m[15]
374	mov dword[esi+12],ebx ;v.pc.W = m[15]	388	mov dword[esi+12],ebx ;v.pc.W = m[15]
375	jmp .end_els	389	jmp .end_els
376	.els_1:	390	.els_1:
377	fld dword[ebx+48] ;st0 = m[12]	391	fld dword[ebx+48] ;st0 = m[12]
378	fmul st0,st3 ;st0 *= v.coord.X	392	fmul st0,st3 ;st0 *= v.coord.X
379	fld dword[ebx+52] ;st0 = m[13]	393	fld dword[ebx+52] ;st0 = m[13]
380	fmul st0,st3 ;st0 *= v.coord.Y	394	fmul st0,st3 ;st0 *= v.coord.Y
381	fld dword[ebx+56] ;st0 = m[14]	395	fld dword[ebx+56] ;st0 = m[14]
382	fmul st0,st3 ;st0 *= v.coord.Z	396	fmul st0,st3 ;st0 *= v.coord.Z
383	fadd dword[ebx+60] ;st0 += m[15]	397	fadd dword[ebx+60] ;st0 += m[15]
384	faddp ;st0 += v.coord.Z * m[14]	398	faddp ;st0 += v.coord.Z * m[14]
385	faddp ;st0 += v.coord.Y * m[13]	399	faddp ;st0 += v.coord.Y * m[13]
386	fstp dword[esi+12] ;v.pc.W = v.coord.X * m[12] + v.coord.Y * m[13] + v.coord.Z * m[14] + m[15]	400	fstp dword[esi+12] ;v.pc.W = v.coord.X * m[12] + v.coord.Y * m[13] + v.coord.Z * m[14] + m[15]
387	.end_els:	401	.end_els:
388	ffree st0	402	ffree st0
389	fincstp	403	fincstp
390	ffree st0	404	ffree st0
391	fincstp	405	fincstp
392	ffree st0	406	ffree st0
393	fincstp	407	fincstp
394		408
395	if DEBUG ;gl_vertex_transform	409	if DEBUG ;gl_vertex_transform
396	stdcall dbg_print,f_vt,txt_nl	410	stdcall dbg_print,f_vt,txt_nl
397	mov edx,[v]	411	mov edx,[v]
398	add edx,offs_vert_pc	412	add edx,offs_vert_pc
399	stdcall gl_print_matrix,edx,1	413	stdcall gl_print_matrix,edx,1
400	end if	414	end if
401	mov edx,[v]	415	mov edx,[v]
402	stdcall gl_clipcode, dword[edx+offs_vert_pc+offs_X], dword[edx+offs_vert_pc+offs_Y],\	416	stdcall gl_clipcode, dword[edx+offs_vert_pc+offs_X], dword[edx+offs_vert_pc+offs_Y],\
403	dword[edx+offs_vert_pc+offs_Z], dword[edx+offs_vert_pc+offs_W]	417	dword[edx+offs_vert_pc+offs_Z], dword[edx+offs_vert_pc+offs_W]
404	mov dword[edx+offs_vert_clip_code],eax	418	mov dword[edx+offs_vert_clip_code],eax
405	popad	419	popad
406	ret	420	ret
407	endp	421	endp
408		422
409	align 4	423	align 4
410	proc glopVertex, context:dword, p:dword	424	proc glopVertex, context:dword, p:dword
411	locals	425	locals
412	;ebx = GLVertex * v	426	;ebx = GLVertex * v
413	n dd ? ;ebp-4	427	n dd ? ;ebp-4
414	endl	428	endl
415	pushad	429	pushad
416	mov edx,[context]	430	mov edx,[context]
417		431
418	; assert(c->in_begin != 0);	432	; assert(c->in_begin != 0);
419		433
420	mov ecx,[edx+offs_cont_vertex_n]	434	mov ecx,[edx+offs_cont_vertex_n]
421	mov [n],ecx	435	mov [n],ecx
422	inc dword[edx+offs_cont_vertex_cnt]	436	inc dword[edx+offs_cont_vertex_cnt]
423		437
424	; quick fix to avoid crashes on large polygons	438	; quick fix to avoid crashes on large polygons
425	mov ecx,[edx+offs_cont_vertex_max]	439	mov ecx,[edx+offs_cont_vertex_max]
426	cmp dword[n],ecx	440	cmp dword[n],ecx
427	jl @f	441	jl @f
428	shl dword[edx+offs_cont_vertex_max],1 ; just double size	442	shl dword[edx+offs_cont_vertex_max],1 ; just double size
429	imul ecx,2*sizeof.GLVertex	443	imul ecx,2*sizeof.GLVertex
430	stdcall gl_malloc,ecx	444	stdcall gl_malloc,ecx
431	cmp eax,0	445	cmp eax,0
432	jne .no_err	446	jne .no_err
433	;gl_fatal_error("unable to allocate GLVertex array.\n");	447	;gl_fatal_error("unable to allocate GLVertex array.\n");
434	.no_err:	448	.no_err:
435	mov edi,eax	449	mov edi,eax
436	mov ebx,eax	450	mov ebx,eax
437	mov esi,[edx+offs_cont_vertex]	451	mov esi,[edx+offs_cont_vertex]
438	mov ecx,[n]	452	mov ecx,[n]
439	imul ecx,(sizeof.GLVertex)/4 ;((...)/4) что-бы использовать movsd вместо movsb	453	imul ecx,(sizeof.GLVertex)/4 ;((...)/4) что-бы использовать movsd вместо movsb
440	rep movsd	454	rep movsd
441	stdcall gl_free,dword[edx+offs_cont_vertex]	455	stdcall gl_free,dword[edx+offs_cont_vertex]
442	mov dword[edx+offs_cont_vertex],ebx	456	mov dword[edx+offs_cont_vertex],ebx
443	@@:	457	@@:
444	; new vertex entry	458	; new vertex entry
445	mov ebx,[n]	459	mov ebx,[n]
446	imul ebx,sizeof.GLVertex	460	imul ebx,sizeof.GLVertex
447	add ebx,[edx+offs_cont_vertex]	461	add ebx,[edx+offs_cont_vertex]
448	inc dword[n]	462	inc dword[n]
449		463
450	mov esi,[p]	464	mov esi,[p]
451	add esi,4	465	add esi,4
452	mov edi,ebx	466	mov edi,ebx
453	add edi,offs_vert_coord ;edi = &v.coord	467	add edi,offs_vert_coord ;edi = &v.coord
454	mov ecx,4	468	mov ecx,4
455	rep movsd	469	rep movsd
456		470
457	stdcall gl_vertex_transform, edx, ebx	471	stdcall gl_vertex_transform, edx, ebx
458		472
459	; color	473	; color
460		474	cmp dword[edx+offs_cont_lighting_enabled],0
461	cmp dword[edx+offs_cont_lighting_enabled],0	-
462	je .els_0	475	je .els_0
463	stdcall gl_shade_vertex, edx,ebx	476	stdcall gl_shade_vertex, edx,ebx
464	jmp @f	477	jmp @f
465	.els_0:	478	.els_0:
466	mov eax,[edx+offs_cont_current_color]	479	mov eax,[edx+offs_cont_current_color]
467	mov [ebx+offs_vert_color],eax	480	mov [ebx+offs_vert_color],eax
468	mov eax,[edx+offs_cont_current_color+4]	481	mov eax,[edx+offs_cont_current_color+4]
469	mov [ebx+offs_vert_color+4],eax	482	mov [ebx+offs_vert_color+4],eax
470	mov eax,[edx+offs_cont_current_color+8]	483	mov eax,[edx+offs_cont_current_color+8]
471	mov [ebx+offs_vert_color+8],eax	484	mov [ebx+offs_vert_color+8],eax
472	@@:	485	@@:
473		486
474	; tex coords	487	; tex coords
475	cmp dword[edx+offs_cont_texture_2d_enabled],0	488	cmp dword[edx+offs_cont_texture_2d_enabled],0
476	je @f	489	je @f
477	cmp dword[edx+offs_cont_apply_texture_matrix],0	490	cmp dword[edx+offs_cont_apply_texture_matrix],0
478	je .els_1	491	je .els_1
479	; gl_M4_MulV4(&v->tex_coord, c->matrix_stack_ptr[2], &c->current_tex_coord);	492	; gl_M4_MulV4(&v->tex_coord, c->matrix_stack_ptr[2], &c->current_tex_coord);
480	jmp @f	493	jmp @f
481	.els_1:	494	.els_1:
482	mov eax,[edx+offs_cont_current_tex_coord]	495	mov eax,[edx+offs_cont_current_tex_coord]
483	mov [ebx+offs_vert_tex_coord],eax	496	mov [ebx+offs_vert_tex_coord],eax
484	@@:	497	@@:
485		498
486	; precompute the mapping to the viewport	499	; precompute the mapping to the viewport

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/TinyGL/asm_fork/vertex.asm – Rev 5218 → 5256