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


; fill triangle profile
; #define PROFILE
 
CLIP_XMIN equ (1<<0)
CLIP_XMAX equ (1<<1)
CLIP_YMIN equ (1<<2)
CLIP_YMAX equ (1<<3)
CLIP_ZMIN equ (1<<4)
CLIP_ZMAX equ (1<<5)
 
align 16
proc gl_transform_to_viewport uses eax ebx ecx, context:dword,v:dword
locals
	point dd ?
endl
	mov eax,[context]
	mov ebx,[v]
 
	; coordinates
	fld1
	fdiv dword[ebx+offs_vert_pc+offs_W] ;st0 = 1/v.pc.W
 
	fld dword[ebx+offs_vert_pc+offs_X] ;st0 = v.pc.X
	fmul st0,st1
	fmul dword[eax+offs_cont_viewport+offs_vpor_scale+offs_X]
	fadd dword[eax+offs_cont_viewport+offs_vpor_trans+offs_X]
	fistp dword[ebx+offs_vert_zp] ;v.zp.x = st0, st0 = st1
 
	fld dword[ebx+offs_vert_pc+offs_Y] ;st0 = v.pc.Y
	fmul st0,st1
	fmul dword[eax+offs_cont_viewport+offs_vpor_scale+offs_Y]
	fadd dword[eax+offs_cont_viewport+offs_vpor_trans+offs_Y]
	fistp dword[ebx+offs_vert_zp+offs_zbup_y] ;v.zp.y = st0, st0 = st1
 
	fld dword[ebx+offs_vert_pc+offs_Z] ;st0 = v.pc.Z
	fmulp
	fmul dword[eax+offs_cont_viewport+offs_vpor_scale+offs_Z]
	fadd dword[eax+offs_cont_viewport+offs_vpor_trans+offs_Z]
	fistp dword[ebx+offs_vert_zp+offs_zbup_z] ;v.zp.z = st0, st0 = st1
 
	; color
	cmp dword[eax+offs_cont_lighting_enabled],0 ;if (context.lighting_enabled)
	je @f
		mov ecx,ebx
		add ecx,offs_vert_zp+offs_zbup_b
		push ecx
		add ecx,offs_zbup_g-offs_zbup_b
		push ecx
		add ecx,offs_zbup_r-offs_zbup_g
		push ecx
		stdcall RGBFtoRGBI, dword[ebx+offs_vert_color],dword[ebx+offs_vert_color+4],dword[ebx+offs_vert_color+8]
		jmp .end_if
align 4
	@@:
		; no need to convert to integer if no lighting : take current color
		mov ecx,[eax+offs_cont_longcurrent_color]
		mov dword[ebx+offs_vert_zp+offs_zbup_r],ecx
		mov ecx,[eax+offs_cont_longcurrent_color+4]
		mov dword[ebx+offs_vert_zp+offs_zbup_g],ecx
		mov ecx,[eax+offs_cont_longcurrent_color+8]
		mov dword[ebx+offs_vert_zp+offs_zbup_b],ecx
	.end_if:
  
	; texture
	cmp dword[eax+offs_cont_texture_2d_enabled],0
	je @f
		mov dword[point],dword(ZB_POINT_S_MAX - ZB_POINT_S_MIN)
		fild dword[point]
		fmul dword[ebx+offs_vert_tex_coord] ;st0 *= v.tex_coord.X
		fistp dword[ebx+offs_vert_zp+offs_zbup_s]
		add dword[ebx+offs_vert_zp+offs_zbup_s],ZB_POINT_S_MIN
 
		mov dword[point],dword(ZB_POINT_T_MAX - ZB_POINT_T_MIN)
		fild dword[point]
		fmul dword[ebx+offs_vert_tex_coord+offs_Y] ;st0 *= v.tex_coord.Y
		fistp dword[ebx+offs_vert_zp+offs_zbup_t]
		add dword[ebx+offs_vert_zp+offs_zbup_t],ZB_POINT_T_MIN
	@@:
	ret
endp
 
align 16
proc gl_add_select1 uses eax ebx ecx, context:dword, z1:dword,z2:dword,z3:dword
	mov eax,[z1]
	mov ebx,eax
	cmp [z2],eax
	jge @f
		mov eax,[z2]
	@@:
	cmp [z3],eax
	jge @f
		mov eax,[z3]
	@@:
	cmp [z2],ebx
	jle @f
		mov ebx,[z2]
	@@:
	cmp [z3],ebx
	jle @f
		mov ebx,[z3]
	@@:
	mov ecx,0xffffffff
	sub ecx,ebx
	push ecx
	mov ecx,0xffffffff
	sub ecx,eax
	push ecx
	stdcall gl_add_select, [context] ;,0xffffffff-eax,0xffffffff-ebx
	ret
endp
 
; point
 
align 16
proc gl_draw_point uses eax ebx, context:dword, p0:dword
	mov ebx,[p0]
	cmp dword[ebx+offs_vert_clip_code],0 ;if (p0.clip_code == 0)
	jne @f
	mov eax,[context]
	cmp dword[eax+offs_cont_render_mode],GL_SELECT
	jne .els
		stdcall gl_add_select, eax,dword[ebx+offs_vert_zp+offs_zbup_z],dword[ebx+offs_vert_zp+offs_zbup_z] ;p0.zp.z,p0.zp.z
		jmp @f
align 4
	.els:
		add ebx,offs_vert_zp
		stdcall ZB_plot, dword[eax+offs_cont_zb],ebx
	@@:
	ret
endp
 
; line
 
;input:
;q - регистр с адресом вершины для интерполяции
;p0 - регистр с адресом 1-й вершины
;p1 - регистр с адресом 2-й вершины
;t - float
macro interpolate q, p0, p1, t
{
	fld dword[t]
 
	; интерполяция по координатам
	fld dword[p1+offs_vert_pc]
	fsub dword[p0+offs_vert_pc]
	fmul st0,st1
	fadd dword[p0+offs_vert_pc]
	fstp dword[q+offs_vert_pc] ;q.pc.X = p0.pc.X + (p1.pc.X - p0.pc.X) * t
 
	fld dword[p1+offs_vert_pc+offs_Y]
	fsub dword[p0+offs_vert_pc+offs_Y]
	fmul st0,st1
	fadd dword[p0+offs_vert_pc+offs_Y]
	fstp dword[q+offs_vert_pc+offs_Y]
 
	fld dword[p1+offs_vert_pc+offs_Z]
	fsub dword[p0+offs_vert_pc+offs_Z]
	fmul st0,st1
	fadd dword[p0+offs_vert_pc+offs_Z]
	fstp dword[q+offs_vert_pc+offs_Z]
 
	fld dword[p1+offs_vert_pc+offs_W]
	fsub dword[p0+offs_vert_pc+offs_W]
	fmul st0,st1
	fadd dword[p0+offs_vert_pc+offs_W]
	fstp dword[q+offs_vert_pc+offs_W]
 
	; интерполяция по цвету
	fld dword[p1+offs_vert_color]
	fsub dword[p0+offs_vert_color]
	fmul st0,st1
	fadd dword[p0+offs_vert_color]
	fstp dword[q+offs_vert_color]
 
	fld dword[p1+offs_vert_color+4]
	fsub dword[p0+offs_vert_color+4]
	fmul st0,st1
	fadd dword[p0+offs_vert_color+4]
	fstp dword[q+offs_vert_color+4]
 
 
	fld dword[p1+offs_vert_color+8]
	fsub dword[p0+offs_vert_color+8]
	fmulp
	fadd dword[p0+offs_vert_color+8]
	fstp dword[q+offs_vert_color+8]
}
 
;
; Line Clipping 
;
 
; Line Clipping algorithm from 'Computer Graphics', Principles and
; Practice
; tmin,tmax -> &float
align 16
proc ClipLine1 uses ebx, denom:dword,num:dword,tmin:dword,tmax:dword
	fld dword[denom]
	ftst
	fstsw ax
	sahf
	jbe .els_0 ;if (denom>0)
		fld dword[num]
		fxch st1
		fdivp ;t=num/denom
		mov ebx,[tmax]
		fcom dword[ebx]
		fstsw ax
		sahf
		ja .r0_f1 ;if (t>*tmax) return 0
		mov ebx,[tmin]
		fcom dword[ebx]
		fstsw ax
		sahf
		jbe .r1_f1 ;if (t>*tmin) *tmin=t
			fstp dword[ebx] 
		jmp .r1
align 4
	.els_0: ;else if (denom<0)
		jae .els_1
		fld dword[num]
		fxch st1
		fdivp ;t=num/denom
		mov ebx,[tmin]
		fcom dword[ebx]
		fstsw ax
		sahf
		jb .r0_f1 ;if (t<*tmin) return 0
		mov ebx,[tmax]
		fcom dword[ebx]
		fstsw ax
		sahf
		jae .r1_f1
			fstp dword[ebx] ;if (t<*tmin) *tmax=t
		jmp .r1
align 4
	.els_1: ;else if (num>0)
		ffree st0 ;denom
		fincstp
		fld dword[num]
		ftst
		fstsw ax
		sahf
		ja .r0_f1 ;if (num>0) return 0
		jmp .r1_f1
align 4
	.r0_f1: ;return 0 & free st0
		ffree st0
		fincstp
	.r0: ;return 0
		xor eax,eax
		jmp .end_f
align 4
	.r1_f1: ;return 1 & free st0
		ffree st0
		fincstp
	.r1: ;return 1
		xor eax,eax
		inc eax
	.end_f:
	ret
endp
 
align 16
proc gl_draw_line, context:dword, p1:dword, p2:dword
locals
	d_x dd ?
	d_y dd ?
	d_z dd ?
	d_w dd ?
	x1 dd ?
	y1 dd ?
	z1 dd ?
	w1 dd ?
	q1 GLVertex ?
	q2 GLVertex ?
	tmin dd ? ;ebp-8
	tmax dd ? ;ebp-4
endl
pushad
	mov edx,[context]
	mov edi,[p1]
	mov esi,[p2]
 
	cmp dword[edi+offs_vert_clip_code],0
	jne .els_i
	cmp dword[esi+offs_vert_clip_code],0
	jne .els_i
		;if ( (p1.clip_code | p2.clip_code) == 0)
		cmp dword[edx+offs_cont_render_mode],GL_SELECT ;if (context.render_mode == GL_SELECT)
		jne .els_1
			stdcall gl_add_select1, edx,dword[edi+offs_vert_zp+offs_zbup_z],\
				dword[esi+offs_vert_zp+offs_zbup_z],dword[esi+offs_vert_zp+offs_zbup_z]
			jmp .end_f
align 4
		.els_1:
			add edi,offs_vert_zp
			add esi,offs_vert_zp
			push esi
			push edi
			push dword[edx+offs_cont_zb]
			cmp dword[edx+offs_cont_depth_test],0
			je .els_2
				;if (context.depth_test)
				call ZB_line_z ;, dword[edx+offs_cont_zb],edi,esi
				jmp .end_f
align 4
			.els_2:
				call ZB_line ;, dword[edx+offs_cont_zb],edi,esi
				jmp .end_f
align 4
	.els_i:
		;else if ( (p1.clip_code & p2.clip_code) != 0 )
		mov eax,[edi+offs_vert_clip_code]
		and eax,[esi+offs_vert_clip_code]
		or eax,eax
		jnz .end_f
	.els_0:
 
	fld dword[esi+offs_vert_pc+offs_X]
	fsub dword[edi+offs_vert_pc+offs_X]
	fstp dword[d_x] ;d_x = p2.pc.X - p1.pc.X
	fld dword[esi+offs_vert_pc+offs_Y]
	fsub dword[edi+offs_vert_pc+offs_Y]
	fstp dword[d_y] ;d_y = p2.pc.Y - p1.pc.Y
	fld dword[esi+offs_vert_pc+offs_Z]
	fsub dword[edi+offs_vert_pc+offs_Z]
	fstp dword[d_z] ;d_z = p2.pc.Z - p1.pc.Z
	fld dword[esi+offs_vert_pc+offs_W]
	fsub dword[edi+offs_vert_pc+offs_W]
	fstp dword[d_w] ;d_w = p2.pc.W - p1.pc.W
 
	mov eax,[edi+offs_vert_pc+offs_X]
	mov [x1],eax ;x1 = p1.pc.X
	mov eax,[edi+offs_vert_pc+offs_Y]
	mov [y1],eax ;y1 = p1.pc.Y
	mov eax,[edi+offs_vert_pc+offs_Z]
	mov [z1],eax ;z1 = p1.pc.Z
	mov eax,[edi+offs_vert_pc+offs_W]
	mov [w1],eax ;w1 = p1.pc.W
 
	mov dword[tmin],0.0
	mov dword[tmax],1.0
 
	mov eax,ebp
	sub eax,4
	push eax ;толкаем в стек адрес &tmax
	sub eax,4
	push eax ;толкаем в стек адрес &tmin
	fld dword[x1]
	fadd dword[w1]
	fchs
	fstp dword[esp-4]
	fld dword[d_x]
	fadd dword[d_w]
	fstp dword[esp-8]
	sub esp,8
	call ClipLine1 ;d_x+d_w,-x1-w1,&tmin,&tmax
	bt eax,0
	jnc .end_f
 
	sub esp,8 ;толкаем в стек адреса переменных &tmin и &tmax
	fld dword[x1]
	fsub dword[w1]
	fstp dword[esp-4]
	fld dword[d_w]
	fsub dword[d_x]
	fstp dword[esp-8]
	sub esp,8
	call ClipLine1 ;-d_x+d_w,x1-w1,&tmin,&tmax
	bt eax,0
	jnc .end_f
 
	sub esp,8 ;толкаем в стек адреса переменных &tmin и &tmax
	fld dword[y1]
	fadd dword[w1]
	fchs
	fstp dword[esp-4]
	fld dword[d_y]
	fadd dword[d_w]
	fstp dword[esp-8]
	sub esp,8
	call ClipLine1 ;d_y+d_w,-y1-w1,&tmin,&tmax
	bt eax,0
	jnc .end_f
 
	sub esp,8 ;толкаем в стек адреса переменных &tmin и &tmax
	fld dword[y1]
	fsub dword[w1]
	fstp dword[esp-4]
	fld dword[d_w]
	fsub dword[d_y]
	fstp dword[esp-8]
	sub esp,8
	call ClipLine1 ;-d_y+d_w,y1-w1,&tmin,&tmax
	bt eax,0
	jnc .end_f
 
	sub esp,8 ;толкаем в стек адреса переменных &tmin и &tmax
	fld dword[z1]
	fadd dword[w1]
	fchs
	fstp dword[esp-4]
	fld dword[d_z]
	fadd dword[d_w]
	fstp dword[esp-8]
	sub esp,8
	call ClipLine1 ;d_z+d_w,-z1-w1,&tmin,&tmax
	bt eax,0
	jnc .end_f
 
	sub esp,8 ;толкаем в стек адреса переменных &tmin и &tmax
	fld dword[z1]
	fsub dword[w1]
	fstp dword[esp-4]
	fld dword[d_w]
	fsub dword[d_z]
	fstp dword[esp-8]
	sub esp,8
	call ClipLine1 ;-d_z+d_w,z1-w1,&tmin,&tmax
	bt eax,0
	jnc .end_f
 
	mov eax,ebp
	sub eax,8+2*sizeof.GLVertex ;eax = &q1
	interpolate eax,edi,esi,tmin
	stdcall gl_transform_to_viewport, edx,eax
	add eax,sizeof.GLVertex ;eax = &q2
	interpolate eax,edi,esi,tmax
	stdcall gl_transform_to_viewport, edx,eax
 
	sub eax,sizeof.GLVertex ;eax = &q1
	mov ebx,eax
	add ebx,offs_vert_zp+offs_zbup_b
	push ebx
	add ebx,offs_zbup_g-offs_zbup_b
	push ebx
	add ebx,offs_zbup_r-offs_zbup_g
	push ebx
	stdcall RGBFtoRGBI, dword[eax+offs_vert_color],dword[eax+offs_vert_color+4],dword[eax+offs_vert_color+8]
 
	add eax,sizeof.GLVertex ;eax = &q2
	mov ebx,eax
	add ebx,offs_vert_zp+offs_zbup_b
	push ebx
	add ebx,offs_zbup_g-offs_zbup_b
	push ebx
	add ebx,offs_zbup_r-offs_zbup_g
	push ebx
	stdcall RGBFtoRGBI, dword[eax+offs_vert_color],dword[eax+offs_vert_color+4],dword[eax+offs_vert_color+8]
 
	add eax,offs_vert_zp ;eax = &q2.zp
	push eax
	sub eax,sizeof.GLVertex ;eax = &q1.zp
	push eax
	push dword[edx+offs_cont_zb]
	cmp dword[edx+offs_cont_depth_test],0
	je .els_3
		call ZB_line_z ;(context.zb,&q1.zp,&q2.zp)
		jmp .end_f
align 4
	.els_3:
		call ZB_line ;(context.zb,&q1.zp,&q2.zp)
	.end_f:
popad
	ret
endp
 
; triangle
 
;
; Clipping
;
 
; We clip the segment [a,b] against the 6 planes of the normal volume.
; We compute the point 'c' of intersection and the value of the parameter 't'
; of the intersection if x=a+t(b-a). 
;
; sign: 0 -> '-', 1 -> '+'
macro clip_func sign,dir,dir1,dir2
{
locals
	t dd ?
	d_X dd ?
	d_Y dd ?
	d_Z dd ?
	d_W dd ?
endl
	mov edx,[a]
	mov ebx,[b]
	mov ecx,[c]
	fld dword[ebx+offs_X]
	fsub dword[edx+offs_X]
	fstp dword[d_X] ;d_X = (b.X - a.X)
	fld dword[ebx+offs_Y]
	fsub dword[edx+offs_Y]
	fstp dword[d_Y] ;d_Y = (b.Y - a.Y)
	fld dword[ebx+offs_Z]
	fsub dword[edx+offs_Z]
	fstp dword[d_Z] ;d_Z = (b.Z - a.Z)
	fld dword[ebx+offs_W]
	fsub dword[edx+offs_W]
	fst dword[d_W] ;d_W = (b.W - a.W)
if sign eq 0
	fadd dword[d#dir]
else
	fsub dword[d#dir]
end if
 
	ftst
	fstsw ax
	sahf
	jne @f
		fldz
		fst dword[t] ;t=0
		jmp .e_zero
align 4
	@@: ;else
		fld dword[edx+offs#dir]
if sign eq 0		
		fchs
end if
		fsub dword[edx+offs_W]
		fdiv st0,st1
		fst dword[t] ;t = ( sign a.dir - a.W) / den
	.e_zero:
 
	fmul dword[d#dir1] ;st0 = t * d.dir1
	fadd dword[edx+offs#dir1]
	fstp dword[ecx+offs#dir1] ;c.dir1 = a.dir1 + t * d.dir1
 
	ffree st0
	fincstp
 
	fld dword[t]
	fmul dword[d#dir2] ;st0 = t * d.dir2
	fadd dword[edx+offs#dir2]
	fstp dword[ecx+offs#dir2] ;c.dir2 = a.dir2 + t * d.dir2
 
	fld dword[t]
	fmul dword[d_W]
	fadd dword[edx+offs_W]
	fst dword[ecx+offs_W] ;c.W = a.W + t * d_W
 
if sign eq 0		
		fchs
end if
	fstp dword[ecx+offs#dir] ;c.dir = sign c.W
	mov eax,[t]
}
 
align 16
proc clip_xmin uses ebx ecx edx, c:dword, a:dword, b:dword
	clip_func 0,_X,_Y,_Z
	ret
endp
 
align 16
proc clip_xmax uses ebx ecx edx, c:dword, a:dword, b:dword
	clip_func 1,_X,_Y,_Z
	ret
endp
 
align 16
proc clip_ymin uses ebx ecx edx, c:dword, a:dword, b:dword
	clip_func 0,_Y,_X,_Z
	ret
endp
 
align 16
proc clip_ymax uses ebx ecx edx, c:dword, a:dword, b:dword
	clip_func 1,_Y,_X,_Z
	ret
endp
 
align 16
proc clip_zmin uses ebx ecx edx, c:dword, a:dword, b:dword
	clip_func 0,_Z,_X,_Y
	ret
endp
 
align 16
proc clip_zmax uses ebx ecx edx, c:dword, a:dword, b:dword
	clip_func 1,_Z,_X,_Y
	ret
endp
 
align 4
clip_proc dd clip_xmin,clip_xmax, clip_ymin,clip_ymax, clip_zmin,clip_zmax
 
;input:
;edi - q
align 16
 
proc updateTmp uses eax ecx edx, context:dword, p0:dword, p1:dword, t:dword
	mov edx,[context]
	mov eax,[p0]
	cmp dword[edx+offs_cont_current_shade_model],GL_SMOOTH ;if (context.current_shade_model == GL_SMOOTH)
	jne .els_0
		mov ecx,[p1]
		fld dword[ecx+offs_vert_color]
		fsub dword[eax+offs_vert_color]
		fmul dword[t]
		fadd dword[eax+offs_vert_color]
		fstp dword[edi+offs_vert_color] ;q.color.v[0]=p0.color.v[0] + (p1.color.v[0]-p0.color.v[0])*t
		fld dword[ecx+offs_vert_color+4]
		fsub dword[eax+offs_vert_color+4]
		fmul dword[t]
		fadd dword[eax+offs_vert_color+4]
		fstp dword[edi+offs_vert_color+4] ;q.color.v[1]=p0.color.v[1] + (p1.color.v[1]-p0.color.v[1])*t
		fld dword[ecx+offs_vert_color+8]
		fsub dword[eax+offs_vert_color+8]
		fmul dword[t]
		fadd dword[eax+offs_vert_color+8]
		fstp dword[edi+offs_vert_color+8] ;q.color.v[2]=p0.color.v[2] + (p1.color.v[2]-p0.color.v[2])*t
		jmp @f
align 4
	.els_0:
		mov ecx,[eax+offs_vert_color]
		mov [edi+offs_vert_color],ecx ;q.color.v[0]=p0.color.v[0]
		mov ecx,[eax+offs_vert_color+4]
		mov [edi+offs_vert_color+4],ecx ;q.color.v[1]=p0.color.v[1]
		mov ecx,[eax+offs_vert_color+8]
		mov [edi+offs_vert_color+8],ecx ;q.color.v[2]=p0.color.v[2]
	@@:
 
	cmp dword[edx+offs_cont_texture_2d_enabled],0 ;if (context.texture_2d_enabled)
	je @f
		mov ecx,[p1]
		fld dword[ecx+offs_vert_tex_coord+offs_X]
		fsub dword[eax+offs_vert_tex_coord+offs_X]
		fmul dword[t]
		fadd dword[eax+offs_vert_tex_coord+offs_X]
		fstp dword[edi+offs_vert_tex_coord+offs_X] ;q.tex_coord.X=p0.tex_coord.X + (p1.tex_coord.X-p0.tex_coord.X)*t
		fld dword[ecx+offs_vert_tex_coord+offs_Y]
		fsub dword[eax+offs_vert_tex_coord+offs_Y]
		fmul dword[t]
		fadd dword[eax+offs_vert_tex_coord+offs_Y]
		fstp dword[edi+offs_vert_tex_coord+offs_Y] ;q.tex_coord.Y=p0.tex_coord.Y + (p1.tex_coord.Y-p0.tex_coord.Y)*t
	@@:
 
	stdcall gl_clipcode, [edi+offs_vert_pc+offs_X],[edi+offs_vert_pc+offs_Y],\
		[edi+offs_vert_pc+offs_Z],[edi+offs_vert_pc+offs_W]
	mov dword[edi+offs_vert_clip_code],eax
	or eax,eax ;if (q.clip_code==0)
	jnz @f
		stdcall gl_transform_to_viewport,[context],edi
		mov eax,edi
		add eax,offs_vert_zp+offs_zbup_b
		push eax
		add eax,offs_zbup_g-offs_zbup_b
		push eax
		add eax,offs_zbup_r-offs_zbup_g
		push eax
		stdcall RGBFtoRGBI, dword[edi+offs_vert_color],dword[edi+offs_vert_color+4],dword[edi+offs_vert_color+8]
	@@:
	ret
endp
 
align 16
proc gl_draw_triangle, context:dword, p0:dword, p1:dword, p2:dword
locals
	cc rd 3
	front dd ?
	norm dd ? ;float
endl
pushad
	mov ebx,[p0]
	mov ecx,[p1]
	mov edx,[p2]
	mov edi,[ebx+offs_vert_clip_code]
	mov dword[cc],edi
	mov eax,[ecx+offs_vert_clip_code]
	mov dword[cc+4],eax
	or edi,eax
	mov eax,[edx+offs_vert_clip_code]
	mov dword[cc+8],eax
	or edi,eax ;co = cc[0] | cc[1] | cc[2]
 
	; we handle the non clipped case here to go faster
	;or edi,___ - было выше
	jnz .els_0
		;if (co==0)
		mov edi,dword[edx+offs_vert_zp+offs_zbup_x]
		sub edi,dword[ebx+offs_vert_zp+offs_zbup_x]
		mov dword[norm],edi ;p2.x-p0.x
		fild dword[norm]
		mov edi,dword[ecx+offs_vert_zp+offs_zbup_y]
		sub edi,dword[ebx+offs_vert_zp+offs_zbup_y]
		mov dword[norm],edi ;p1.y-p0.y
		fimul dword[norm]
		fchs
		mov edi,dword[ecx+offs_vert_zp+offs_zbup_x]
		sub edi,dword[ebx+offs_vert_zp+offs_zbup_x]
		mov dword[norm],edi ;p1.x-p0.x
		fild dword[norm]
		mov edi,dword[edx+offs_vert_zp+offs_zbup_y]
		sub edi,dword[ebx+offs_vert_zp+offs_zbup_y]
		mov dword[norm],edi ;p2.y-p0.y
		fimul dword[norm]
		faddp
		;st0 = (p1.zp.x-p0.zp.x)*(p2.zp.y-p0.zp.y) - (p2.zp.x-p0.zp.x)*(p1.zp.y-p0.zp.y)
 
		mov dword[front],0
		ftst
		fstsw ax
		ffree st0
		fincstp
		sahf
		je .end_f
		jae @f
			inc dword[front] ;front = norm < 0.0
		@@:
		mov edi,[context]
		mov eax,dword[edi+offs_cont_current_front_face]
		xor dword[front],eax ;front ^= context.current_front_face
 
		; back face culling
		cmp dword[edi+offs_cont_cull_face_enabled],0
		je .els_1
			; most used case first
			cmp dword[edi+offs_cont_current_cull_face],GL_BACK
			jne @f
				cmp dword[front],0
				je .end_f
					stdcall dword[edi+offs_cont_draw_triangle_front], edi,ebx,ecx,edx
				jmp .end_f
align 4
			@@:
			cmp dword[edi+offs_cont_current_cull_face],GL_FRONT
			jne .end_f
				cmp dword[front],0
				jne .end_f
					stdcall dword[edi+offs_cont_draw_triangle_back], edi,ebx,ecx,edx
			jmp .end_f
align 4
		.els_1:
			; no culling
			cmp dword[front],0
			je @f
				stdcall dword[edi+offs_cont_draw_triangle_front], edi,ebx,ecx,edx
				jmp .end_f
align 4
			@@:
				stdcall dword[edi+offs_cont_draw_triangle_back], edi,ebx,ecx,edx
		jmp .end_f
align 4
	.els_0:
		;eax = cc[2]
		and eax,[cc]
		and eax,[cc+4] ;eax = c_and = cc[0] & cc[1] & cc[2]
		or eax,eax ;if (c_and==0)
		jnz .end_f
			stdcall gl_draw_triangle_clip, [context],ebx,ecx,edx,0
	.end_f:
popad
	ret
endp
 
align 16
proc gl_draw_triangle_clip, context:dword, p0:dword, p1:dword, p2:dword, clip_bit:dword
locals
	co dd ?
	cc rd 3
	edge_flag_tmp dd ?
	clip_mask dd ?
	q rd 3 ;GLVertex*
	tmp1 GLVertex ?
	tmp2 GLVertex ?
endl
pushad
	mov ebx,[p0]
	mov ecx,[p1]
	mov edx,[p2]
 
	mov edi,[ebx+offs_vert_clip_code]
	mov [cc],edi
	mov eax,[ecx+offs_vert_clip_code]
	mov [cc+4],eax
	or edi,eax
	mov eax,[edx+offs_vert_clip_code]
	mov [cc+8],eax
	or edi,eax
	mov [co],edi ;co = cc[0] | cc[1] | cc[2]
 
	or edi,edi ;if (co == 0)
	jnz .els_0
		stdcall gl_draw_triangle, [context],ebx,ecx,edx
		jmp .end_f
align 4
	.els_0:
		;eax = cc[2]
		and eax,[cc]
		and eax,[cc+4] ;c_and = cc[0] & cc[1] & cc[2]
 
		; the triangle is completely outside
		or eax,eax ;if (c_and!=0) return
		jnz .end_f
 
		; find the next direction to clip
		.cycle_0: ;while (clip_bit < 6 && (co & (1 << clip_bit)) == 0)
		cmp dword[clip_bit],6
		jge .cycle_0_end
		xor eax,eax
		inc eax
		mov ecx,[clip_bit]
		shl eax,cl
		and eax,[co]
		or eax,eax
		jnz .cycle_0_end
			inc dword[clip_bit]
			jmp .cycle_0
align 4
		.cycle_0_end:
 
	; this test can be true only in case of rounding errors
	cmp dword[clip_bit],6
if 0
	jne @f
;      printf("Error:\n");
;      printf("%f %f %f %f\n",p0->pc.X,p0->pc.Y,p0->pc.Z,p0->pc.W);
;      printf("%f %f %f %f\n",p1->pc.X,p1->pc.Y,p1->pc.Z,p1->pc.W);
;      printf("%f %f %f %f\n",p2->pc.X,p2->pc.Y,p2->pc.Z,p2->pc.W);
		jmp .end_f
	@@:
end if
if 1
	je .end_f
end if
 
	xor eax,eax
	inc eax
	mov ecx,[clip_bit]
	shl eax,cl
	mov [clip_mask],eax ;1 << clip_bit
	mov edi,[cc]
	xor edi,[cc+4]
	xor edi,[cc+8]
	and eax,edi ;eax = co1 = (cc[0] ^ cc[1] ^ cc[2]) & clip_mask
 
	mov ecx,[p1] ;востанавливаем после shl ___,cl
 
	or eax,eax ;if (co1)
	jz .els_1
		; one point outside
		mov eax,[cc]
		and eax,[clip_mask]
		or eax,eax ;if (cc[0] & clip_mask)
		jz .els_2
			;q[0]=p0 q[1]=p1 q[2]=p2
			mov [q],ebx
			mov [q+4],ecx
			mov [q+8],edx
			jmp .els_2_end
align 4
		.els_2:
		mov eax,[cc+4]
		and eax,[clip_mask]
		or eax,eax ;else if (cc[1] & clip_mask)
		jz .els_3
			;q[0]=p1 q[1]=p2 q[2]=p0
			mov [q],ecx
			mov [q+4],edx
			mov [q+8],ebx
			jmp .els_2_end
align 4
		.els_3:
			;q[0]=p2 q[1]=p0 q[2]=p1
			mov [q],edx
			mov [q+4],ebx
			mov [q+8],ecx
		.els_2_end:
 
		mov ebx,[q]
		add ebx,offs_vert_pc
		mov ecx,[q+4]
		add ecx,offs_vert_pc
		mov edx,[q+8]
		add edx,offs_vert_pc
 
		lea eax,[clip_proc]
		mov edi,[clip_bit]
		shl edi,2
		add eax,edi
		mov edi,ebp
		sub edi,(2*sizeof.GLVertex)-offs_vert_pc
		stdcall dword[eax],edi,ebx,ecx ;clip_proc[clip_bit](&tmp1.pc,&q[0].pc,&q[1].pc)
		sub edi,offs_vert_pc
 
		sub ebx,offs_vert_pc
		sub ecx,offs_vert_pc
		stdcall updateTmp,[context],ebx,ecx,eax ;(c,&tmp1,q[0],q[1],tt)
		add ebx,offs_vert_pc
 
		lea eax,[clip_proc]
		mov edi,[clip_bit]
		shl edi,2
		add eax,edi
		mov edi,ebp
		sub edi,sizeof.GLVertex-offs_vert_pc
		stdcall dword[eax],edi,ebx,edx ;clip_proc[clip_bit](&tmp2.pc,&q[0].pc,&q[2].pc)
		sub edi,offs_vert_pc
		sub ebx,offs_vert_pc
		sub edx,offs_vert_pc
		stdcall updateTmp,[context],ebx,edx,eax ;(c,&tmp2,q[0],q[2],tt)
 
		mov eax,[ebx+offs_vert_edge_flag]
		mov [tmp1.edge_flag],eax ;q[0].edge_flag
		mov eax,[edx+offs_vert_edge_flag]
		mov [edge_flag_tmp],eax	;q[2].edge_flag
		mov dword[edx+offs_vert_edge_flag],0 ;q[2].edge_flag=0
		mov eax,[clip_bit]
		inc eax
		push eax ;для вызова нижней функции
		mov edi,ebp
		sub edi,2*sizeof.GLVertex
		stdcall gl_draw_triangle_clip,[context],edi,ecx,edx,eax ;gl_draw_triangle_clip(c,&tmp1,q[1],q[2],clip_bit+1)
 
		mov dword[tmp2.edge_flag],0
		mov dword[tmp1.edge_flag],0
		mov eax,[edge_flag_tmp]
		mov [edx+offs_vert_edge_flag],eax ;q[2].edge_flag=edge_flag_tmp
		push edx
		push edi
		add edi,sizeof.GLVertex ;edi = &tmp2
		stdcall gl_draw_triangle_clip,[context],edi ;gl_draw_triangle_clip(c,&tmp2,&tmp1,q[2],clip_bit+1)
		jmp .end_f
align 4
	.els_1:
		; two points outside
		mov eax,[cc]
		and eax,[clip_mask]
		cmp eax,0 ;if (cc[0] & clip_mask)==0
		jne .els_4
			;q[0]=p0 q[1]=p1 q[2]=p2
			mov [q],ebx
			mov [q+4],ecx
			mov [q+8],edx
			jmp .els_4_end
align 4
		.els_4:
		mov eax,[cc+4]
		and eax,[clip_mask]
		cmp eax,0 ;else if (cc[1] & clip_mask)==0
		jne .els_5
			;q[0]=p1 q[1]=p2 q[2]=p0
			mov [q],ecx
			mov [q+4],edx
			mov [q+8],ebx
			jmp .els_4_end
align 4
		.els_5:
			;q[0]=p2 q[1]=p0 q[2]=p1
			mov [q],edx
			mov [q+4],ebx
			mov [q+8],ecx
		.els_4_end:
 
		mov ebx,[q]
		add ebx,offs_vert_pc
		mov ecx,[q+4]
		add ecx,offs_vert_pc
		mov edx,[q+8]
		add edx,offs_vert_pc
 
		lea eax,[clip_proc]
		mov edi,[clip_bit]
		shl edi,2
		add eax,edi
		mov edi,ebp
		sub edi,(2*sizeof.GLVertex)-offs_vert_pc
		stdcall dword[eax],edi,ebx,ecx ;clip_proc[clip_bit](&tmp1.pc,&q[0].pc,&q[1].pc)
		sub edi,offs_vert_pc
		stdcall updateTmp,[context],[q],[q+4],eax
 
		lea eax,[clip_proc]
		mov edi,[clip_bit]
		shl edi,2
		add eax,edi
		mov edi,ebp
		sub edi,sizeof.GLVertex-offs_vert_pc
		stdcall dword[eax],edi,ebx,edx ;clip_proc[clip_bit](&tmp2.pc,&q[0].pc,&q[2].pc)
		sub edi,offs_vert_pc
		stdcall updateTmp,[context],[q],[q+8],eax
 
		mov dword[tmp1.edge_flag],1
		mov eax,[edx+offs_vert_edge_flag-offs_vert_pc]
		mov dword[tmp2.edge_flag],eax ;tmp2.edge_flag = q[2].edge_flag
		mov eax,[clip_bit]
		inc eax
		push eax
		push edi
		sub edi,sizeof.GLVertex
		stdcall gl_draw_triangle_clip,[context],[q],edi ;gl_draw_triangle_clip(c,q[0],&tmp1,&tmp2,clip_bit+1)
	.end_f:
popad
	ret
endp
 
align 16
proc gl_draw_triangle_select uses eax, context:dword, p0:dword,p1:dword,p2:dword
	mov eax,[p2]
	push dword[eax+offs_vert_zp+offs_Z]
	mov eax,[p1]
	push dword[eax+offs_vert_zp+offs_Z]
	mov eax,[p0]
	push dword[eax+offs_vert_zp+offs_Z]
	stdcall gl_add_select1, [context] ;,p0.zp.z, p1.zp.z, p2.zp.z
	ret
endp
 
if PROFILE eq 1
	count_triangles dd ?
	count_triangles_textured dd ?
	count_pixels dd ?
end if
 
align 16
proc gl_draw_triangle_fill, context:dword, p0:dword,p1:dword,p2:dword
pushad
if PROFILE eq 1
;    int norm;
;    assert(p0->zp.x >= 0 && p0->zp.x < c->zb->xsize);
;    assert(p0->zp.y >= 0 && p0->zp.y < c->zb->ysize);
;    assert(p1->zp.x >= 0 && p1->zp.x < c->zb->xsize);
;    assert(p1->zp.y >= 0 && p1->zp.y < c->zb->ysize);
;    assert(p2->zp.x >= 0 && p2->zp.x < c->zb->xsize);
;    assert(p2->zp.y >= 0 && p2->zp.y < c->zb->ysize);
    
;    norm=(p1->zp.x-p0->zp.x)*(p2->zp.y-p0->zp.y)-
;      (p2->zp.x-p0->zp.x)*(p1->zp.y-p0->zp.y);
;    count_pixels+=abs(norm)/2;
	inc dword[count_triangles]
end if
 
	mov ebx,[p1]
	add ebx,offs_vert_zp
	mov ecx,[p2]
	add ecx,offs_vert_zp
	mov edx,[context]
	cmp dword[edx+offs_cont_texture_2d_enabled],0
	je .els_i
		;if (context.texture_2d_enabled)
if PROFILE eq 1
	inc dword[count_triangles_textured]
end if
		mov eax,dword[edx+offs_cont_current_texture]
		mov eax,[eax] ;переход по указателю
		;так как offs_text_images+offs_imag_pixmap = 0 то context.current_texture.images[0].pixmap = [eax]
		stdcall ZB_setTexture, dword[edx+offs_cont_zb],dword[eax]
		mov eax,[p0]
		add eax,offs_vert_zp
		push ecx
		push ebx
		push eax
		push dword[edx+offs_cont_zb]
		cmp dword[edx+offs_cont_matrix_model_projection_no_w_transform],0
		je @f
			call ZB_fillTriangleMappingPerspective
			jmp .end_f
align 4
		@@:
			call ZB_fillTriangleMapping
		jmp .end_f
align 4
	.els_i:
		mov eax,[p0]
		add eax,offs_vert_zp
		cmp dword[edx+offs_cont_current_shade_model],GL_SMOOTH
		jne .els
			;else if (context.current_shade_model == GL_SMOOTH)
			stdcall ZB_fillTriangleSmooth, dword[edx+offs_cont_zb],eax,ebx,ecx
			jmp .end_f
align 4
		.els:
			stdcall ZB_fillTriangleFlat, dword[edx+offs_cont_zb],eax,ebx,ecx
	.end_f:
popad
	ret
endp
 
; Render a clipped triangle in line mode
 
align 16
proc gl_draw_triangle_line uses eax ebx ecx edx, context:dword, p0:dword,p1:dword,p2:dword
	mov edx,[context]
	cmp dword[edx+offs_cont_depth_test],0
	je .els
		lea ecx,[ZB_line_z]
		jmp @f
align 4
	.els:
		lea ecx,[ZB_line]
	@@:
 
	;if (p0.edge_flag) ZB_line_z(context.zb,&p0.zp,&p1.zp)
	mov eax,[p0]
	cmp dword[eax+offs_vert_edge_flag],0
	je @f
		mov ebx,eax
		add ebx,offs_vert_zp
		mov eax,[p1]
		add eax,offs_vert_zp
		stdcall ecx,dword[edx+offs_cont_zb],ebx,eax
	@@:
	;if (p1.edge_flag) ZB_line_z(context.zb,&p1.zp,&p2.zp)
	mov eax,[p1]
	cmp dword[eax+offs_vert_edge_flag],0
	je @f
		mov ebx,eax
		add ebx,offs_vert_zp
		mov eax,[p2]
		add eax,offs_vert_zp
		stdcall ecx,dword[edx+offs_cont_zb],ebx,eax
	@@:
	;if (p2.edge_flag) ZB_line_z(context.zb,&p2.zp,&p0.zp);
	mov eax,[p2]
	cmp dword[eax+offs_vert_edge_flag],0
	je @f
		mov ebx,eax
		add ebx,offs_vert_zp
		mov eax,[p0]
		add eax,offs_vert_zp
		stdcall ecx,dword[edx+offs_cont_zb],ebx,eax
	@@:
 
	ret
endp
 
; Render a clipped triangle in point mode
align 16
proc gl_draw_triangle_point uses eax ebx edx, context:dword, p0:dword,p1:dword,p2:dword
	mov edx,[context]
	mov eax,[p0]
	cmp dword[eax+offs_vert_edge_flag],0
	je @f
		mov ebx,eax
		add ebx,offs_vert_zp
		stdcall ZB_plot,dword[edx+offs_cont_zb],ebx
	@@:
	mov eax,[p1]
	cmp dword[eax+offs_vert_edge_flag],0
	je @f
		mov ebx,eax
		add ebx,offs_vert_zp
		stdcall ZB_plot,dword[edx+offs_cont_zb],ebx
	@@:
	mov eax,[p2]
	cmp dword[eax+offs_vert_edge_flag],0
	je @f
		mov ebx,eax
		add ebx,offs_vert_zp
		stdcall ZB_plot,dword[edx+offs_cont_zb],ebx
	@@:
	ret
endp
>
 
align>
 
align>
CLIP_ZMAX>
CLIP_ZMAX>
CLIP_ZMIN>
CLIP_ZMIN>
CLIP_YMAX>
CLIP_YMAX>
CLIP_YMIN>
CLIP_YMIN>
CLIP_XMAX>
CLIP_XMAX>

Rev 6145	Rev 6172
1	; fill triangle profile	1	; fill triangle profile
2	; #define PROFILE	2	; #define PROFILE
3		3
4	CLIP_XMIN equ (1<<0)	4	CLIP_XMIN equ (1<<0)
5	CLIP_XMAX equ (1<<1)	5	CLIP_XMAX equ (1<<1)
6	CLIP_YMIN equ (1<<2)	6	CLIP_YMIN equ (1<<2)
7	CLIP_YMAX equ (1<<3)	7	CLIP_YMAX equ (1<<3)
8	CLIP_ZMIN equ (1<<4)	8	CLIP_ZMIN equ (1<<4)
9	CLIP_ZMAX equ (1<<5)	9	CLIP_ZMAX equ (1<<5)
10		10
11	align 16	11	align 16
12	proc gl_transform_to_viewport uses eax ebx ecx, context:dword,v:dword	12	proc gl_transform_to_viewport uses eax ebx ecx, context:dword,v:dword
13	locals	13	locals
14	point dd ?	14	point dd ?
15	endl	15	endl
16	mov eax,[context]	16	mov eax,[context]
17	mov ebx,[v]	17	mov ebx,[v]
18		18
19	; coordinates	19	; coordinates
20	fld1	20	fld1
21	fdiv dword[ebx+offs_vert_pc+offs_W] ;st0 = 1/v.pc.W	21	fdiv dword[ebx+offs_vert_pc+offs_W] ;st0 = 1/v.pc.W
22		22
23	fld dword[ebx+offs_vert_pc+offs_X] ;st0 = v.pc.X	23	fld dword[ebx+offs_vert_pc+offs_X] ;st0 = v.pc.X
24	fmul st0,st1	24	fmul st0,st1
25	fmul dword[eax+offs_cont_viewport+offs_vpor_scale+offs_X]	25	fmul dword[eax+offs_cont_viewport+offs_vpor_scale+offs_X]
26	fadd dword[eax+offs_cont_viewport+offs_vpor_trans+offs_X]	26	fadd dword[eax+offs_cont_viewport+offs_vpor_trans+offs_X]
27	fistp dword[ebx+offs_vert_zp] ;v.zp.x = st0, st0 = st1	27	fistp dword[ebx+offs_vert_zp] ;v.zp.x = st0, st0 = st1
28		28
29	fld dword[ebx+offs_vert_pc+offs_Y] ;st0 = v.pc.Y	29	fld dword[ebx+offs_vert_pc+offs_Y] ;st0 = v.pc.Y
30	fmul st0,st1	30	fmul st0,st1
31	fmul dword[eax+offs_cont_viewport+offs_vpor_scale+offs_Y]	31	fmul dword[eax+offs_cont_viewport+offs_vpor_scale+offs_Y]
32	fadd dword[eax+offs_cont_viewport+offs_vpor_trans+offs_Y]	32	fadd dword[eax+offs_cont_viewport+offs_vpor_trans+offs_Y]
33	fistp dword[ebx+offs_vert_zp+offs_zbup_y] ;v.zp.y = st0, st0 = st1	33	fistp dword[ebx+offs_vert_zp+offs_zbup_y] ;v.zp.y = st0, st0 = st1
34		34
35	fld dword[ebx+offs_vert_pc+offs_Z] ;st0 = v.pc.Z	35	fld dword[ebx+offs_vert_pc+offs_Z] ;st0 = v.pc.Z
36	fmulp	36	fmulp
37	fmul dword[eax+offs_cont_viewport+offs_vpor_scale+offs_Z]	37	fmul dword[eax+offs_cont_viewport+offs_vpor_scale+offs_Z]
38	fadd dword[eax+offs_cont_viewport+offs_vpor_trans+offs_Z]	38	fadd dword[eax+offs_cont_viewport+offs_vpor_trans+offs_Z]
39	fistp dword[ebx+offs_vert_zp+offs_zbup_z] ;v.zp.z = st0, st0 = st1	39	fistp dword[ebx+offs_vert_zp+offs_zbup_z] ;v.zp.z = st0, st0 = st1
40		40
41	; color	41	; color
42	cmp dword[eax+offs_cont_lighting_enabled],0 ;if (context.lighting_enabled)	42	cmp dword[eax+offs_cont_lighting_enabled],0 ;if (context.lighting_enabled)
43	je @f	43	je @f
44	mov ecx,ebx	44	mov ecx,ebx
45	add ecx,offs_vert_zp+offs_zbup_b	45	add ecx,offs_vert_zp+offs_zbup_b
46	push ecx	46	push ecx
47	add ecx,offs_zbup_g-offs_zbup_b	47	add ecx,offs_zbup_g-offs_zbup_b
48	push ecx	48	push ecx
49	add ecx,offs_zbup_r-offs_zbup_g	49	add ecx,offs_zbup_r-offs_zbup_g
50	push ecx	50	push ecx
51	stdcall RGBFtoRGBI, dword[ebx+offs_vert_color],dword[ebx+offs_vert_color+4],dword[ebx+offs_vert_color+8]	51	stdcall RGBFtoRGBI, dword[ebx+offs_vert_color],dword[ebx+offs_vert_color+4],dword[ebx+offs_vert_color+8]
52	jmp .end_if	52	jmp .end_if
53	align 4	53	align 4
54	@@:	54	@@:
55	; no need to convert to integer if no lighting : take current color	55	; no need to convert to integer if no lighting : take current color
56	mov ecx,[eax+offs_cont_longcurrent_color]	56	mov ecx,[eax+offs_cont_longcurrent_color]
57	mov dword[ebx+offs_vert_zp+offs_zbup_r],ecx	57	mov dword[ebx+offs_vert_zp+offs_zbup_r],ecx
58	mov ecx,[eax+offs_cont_longcurrent_color+4]	58	mov ecx,[eax+offs_cont_longcurrent_color+4]
59	mov dword[ebx+offs_vert_zp+offs_zbup_g],ecx	59	mov dword[ebx+offs_vert_zp+offs_zbup_g],ecx
60	mov ecx,[eax+offs_cont_longcurrent_color+8]	60	mov ecx,[eax+offs_cont_longcurrent_color+8]
61	mov dword[ebx+offs_vert_zp+offs_zbup_b],ecx	61	mov dword[ebx+offs_vert_zp+offs_zbup_b],ecx
62	.end_if:	62	.end_if:
63		63
64	; texture	64	; texture
65	cmp dword[eax+offs_cont_texture_2d_enabled],0	65	cmp dword[eax+offs_cont_texture_2d_enabled],0
66	je @f	66	je @f
67	mov dword[point],dword(ZB_POINT_S_MAX - ZB_POINT_S_MIN)	67	mov dword[point],dword(ZB_POINT_S_MAX - ZB_POINT_S_MIN)
68	fild dword[point]	68	fild dword[point]
69	fmul dword[ebx+offs_vert_tex_coord] ;st0 *= v.tex_coord.X	69	fmul dword[ebx+offs_vert_tex_coord] ;st0 *= v.tex_coord.X
70	fistp dword[ebx+offs_vert_zp+offs_zbup_s]	70	fistp dword[ebx+offs_vert_zp+offs_zbup_s]
71	add dword[ebx+offs_vert_zp+offs_zbup_s],ZB_POINT_S_MIN	71	add dword[ebx+offs_vert_zp+offs_zbup_s],ZB_POINT_S_MIN
72		72
73	mov dword[point],dword(ZB_POINT_T_MAX - ZB_POINT_T_MIN)	73	mov dword[point],dword(ZB_POINT_T_MAX - ZB_POINT_T_MIN)
74	fild dword[point]	74	fild dword[point]
75	fmul dword[ebx+offs_vert_tex_coord+offs_Y] ;st0 *= v.tex_coord.Y	75	fmul dword[ebx+offs_vert_tex_coord+offs_Y] ;st0 *= v.tex_coord.Y
76	fistp dword[ebx+offs_vert_zp+offs_zbup_t]	76	fistp dword[ebx+offs_vert_zp+offs_zbup_t]
77	add dword[ebx+offs_vert_zp+offs_zbup_t],ZB_POINT_T_MIN	77	add dword[ebx+offs_vert_zp+offs_zbup_t],ZB_POINT_T_MIN
78	@@:	78	@@:
79	ret	79	ret
80	endp	80	endp
81		81
82	align 16	82	align 16
83	proc gl_add_select1 uses eax ebx ecx, context:dword, z1:dword,z2:dword,z3:dword	83	proc gl_add_select1 uses eax ebx ecx, context:dword, z1:dword,z2:dword,z3:dword
84	mov eax,[z1]	84	mov eax,[z1]
85	mov ebx,eax	85	mov ebx,eax
86	cmp [z2],eax	86	cmp [z2],eax
87	jge @f	87	jge @f
88	mov eax,[z2]	88	mov eax,[z2]
89	@@:	89	@@:
90	cmp [z3],eax	90	cmp [z3],eax
91	jge @f	91	jge @f
92	mov eax,[z3]	92	mov eax,[z3]
93	@@:	93	@@:
94	cmp [z2],ebx	94	cmp [z2],ebx
95	jle @f	95	jle @f
96	mov ebx,[z2]	96	mov ebx,[z2]
97	@@:	97	@@:
98	cmp [z3],ebx	98	cmp [z3],ebx
99	jle @f	99	jle @f
100	mov ebx,[z3]	100	mov ebx,[z3]
101	@@:	101	@@:
102	mov ecx,0xffffffff	102	mov ecx,0xffffffff
103	sub ecx,ebx	103	sub ecx,ebx
104	push ecx	104	push ecx
105	mov ecx,0xffffffff	105	mov ecx,0xffffffff
106	sub ecx,eax	106	sub ecx,eax
107	push ecx	107	push ecx
108	stdcall gl_add_select, [context] ;,0xffffffff-eax,0xffffffff-ebx	108	stdcall gl_add_select, [context] ;,0xffffffff-eax,0xffffffff-ebx
109	ret	109	ret
110	endp	110	endp
111		111
112	; point	112	; point
113		113
114	align 16	114	align 16
115	proc gl_draw_point uses eax ebx, context:dword, p0:dword	115	proc gl_draw_point uses eax ebx, context:dword, p0:dword
116	mov ebx,[p0]	116	mov ebx,[p0]
117	cmp dword[ebx+offs_vert_clip_code],0 ;if (p0.clip_code == 0)	117	cmp dword[ebx+offs_vert_clip_code],0 ;if (p0.clip_code == 0)
118	jne @f	118	jne @f
119	mov eax,[context]	119	mov eax,[context]
120	cmp dword[eax+offs_cont_render_mode],GL_SELECT	120	cmp dword[eax+offs_cont_render_mode],GL_SELECT
121	jne .els	121	jne .els
122	stdcall gl_add_select, eax,dword[ebx+offs_vert_zp+offs_zbup_z],dword[ebx+offs_vert_zp+offs_zbup_z] ;p0.zp.z,p0.zp.z	122	stdcall gl_add_select, eax,dword[ebx+offs_vert_zp+offs_zbup_z],dword[ebx+offs_vert_zp+offs_zbup_z] ;p0.zp.z,p0.zp.z
123	jmp @f	123	jmp @f
124	align 4	124	align 4
125	.els:	125	.els:
126	add ebx,offs_vert_zp	126	add ebx,offs_vert_zp
127	stdcall ZB_plot, dword[eax+offs_cont_zb],ebx	127	stdcall ZB_plot, dword[eax+offs_cont_zb],ebx
128	@@:	128	@@:
129	ret	129	ret
130	endp	130	endp
131		131
132	; line	132	; line
133		133
-		134	;input:
-		135	;q - регистр с адресом вершины для интерполяции
134	align 16	136	;p0 - регистр с адресом 1-й вершины
135	proc interpolate uses eax ebx ecx, q:dword,p0:dword,p1:dword,t:dword	137	;p1 - регистр с адресом 2-й вершины
136	mov eax,[q]	138	;t - float
137	mov ebx,[p0]	139	macro interpolate q, p0, p1, t
138	mov ecx,[p1]	140	{
139	fld dword[t]	141	fld dword[t]
140		142
141	; интерполяция по координатам	143	; интерполяция по координатам
142	fld dword[ecx+offs_vert_pc]	144	fld dword[p1+offs_vert_pc]
143	fsub dword[ebx+offs_vert_pc]	145	fsub dword[p0+offs_vert_pc]
144	fmul st0,st1	146	fmul st0,st1
145	fadd dword[ebx+offs_vert_pc]	147	fadd dword[p0+offs_vert_pc]
146	fstp dword[eax+offs_vert_pc] ;q.pc.X = p0.pc.X + (p1.pc.X - p0.pc.X) * t	148	fstp dword[q+offs_vert_pc] ;q.pc.X = p0.pc.X + (p1.pc.X - p0.pc.X) * t
147		149
148	fld dword[ecx+offs_vert_pc+offs_Y]	150	fld dword[p1+offs_vert_pc+offs_Y]
149	fsub dword[ebx+offs_vert_pc+offs_Y]	151	fsub dword[p0+offs_vert_pc+offs_Y]
150	fmul st0,st1	152	fmul st0,st1
151	fadd dword[ebx+offs_vert_pc+offs_Y]	153	fadd dword[p0+offs_vert_pc+offs_Y]
152	fstp dword[eax+offs_vert_pc+offs_Y]	154	fstp dword[q+offs_vert_pc+offs_Y]
153		155
154	fld dword[ecx+offs_vert_pc+offs_Z]	156	fld dword[p1+offs_vert_pc+offs_Z]
155	fsub dword[ebx+offs_vert_pc+offs_Z]	157	fsub dword[p0+offs_vert_pc+offs_Z]
156	fmul st0,st1	158	fmul st0,st1
157	fadd dword[ebx+offs_vert_pc+offs_Z]	159	fadd dword[p0+offs_vert_pc+offs_Z]
158	fstp dword[eax+offs_vert_pc+offs_Z]	160	fstp dword[q+offs_vert_pc+offs_Z]
159		161
160	fld dword[ecx+offs_vert_pc+offs_W]	162	fld dword[p1+offs_vert_pc+offs_W]
161	fsub dword[ebx+offs_vert_pc+offs_W]	163	fsub dword[p0+offs_vert_pc+offs_W]
162	fmul st0,st1	164	fmul st0,st1
163	fadd dword[ebx+offs_vert_pc+offs_W]	165	fadd dword[p0+offs_vert_pc+offs_W]
164	fstp dword[eax+offs_vert_pc+offs_W]	166	fstp dword[q+offs_vert_pc+offs_W]
165		167
166	; интерполяция по цвету	168	; интерполяция по цвету
167	fld dword[ecx+offs_vert_color]	169	fld dword[p1+offs_vert_color]
168	fsub dword[ebx+offs_vert_color]	170	fsub dword[p0+offs_vert_color]
169	fmul st0,st1	171	fmul st0,st1
170	fadd dword[ebx+offs_vert_color]	172	fadd dword[p0+offs_vert_color]
171	fstp dword[eax+offs_vert_color]	173	fstp dword[q+offs_vert_color]
172		174
173	fld dword[ecx+offs_vert_color+4]	175	fld dword[p1+offs_vert_color+4]
174	fsub dword[ebx+offs_vert_color+4]	176	fsub dword[p0+offs_vert_color+4]
175	fmul st0,st1	177	fmul st0,st1
176	fadd dword[ebx+offs_vert_color+4]	178	fadd dword[p0+offs_vert_color+4]
177	fstp dword[eax+offs_vert_color+4]	179	fstp dword[q+offs_vert_color+4]
178		180
179	fld dword[ecx+offs_vert_color+8]	-
180	fsub dword[ebx+offs_vert_color+8]	181	fld dword[p1+offs_vert_color+8]
181	fmulp	182	fsub dword[p0+offs_vert_color+8]
182	fadd dword[ebx+offs_vert_color+8]	183	fmulp
183	fstp dword[eax+offs_vert_color+8]	184	fadd dword[p0+offs_vert_color+8]
184	ret	185	fstp dword[q+offs_vert_color+8]
185	endp	186	}
186		187
187	;	188	;
188	; Line Clipping	189	; Line Clipping
189	;	190	;
190		191
191	; Line Clipping algorithm from 'Computer Graphics', Principles and	192	; Line Clipping algorithm from 'Computer Graphics', Principles and
192	; Practice	193	; Practice
193	; tmin,tmax -> &float	194	; tmin,tmax -> &float
194	align 16	195	align 16
195	proc ClipLine1 uses ebx, denom:dword,num:dword,tmin:dword,tmax:dword	196	proc ClipLine1 uses ebx, denom:dword,num:dword,tmin:dword,tmax:dword
196	fld dword[denom]	197	fld dword[denom]
197	ftst	198	ftst
198	fstsw ax	199	fstsw ax
199	sahf	200	sahf
200	jbe .els_0 ;if (denom>0)	201	jbe .els_0 ;if (denom>0)
201	fld dword[num]	202	fld dword[num]
202	fxch st1	203	fxch st1
203	fdivp ;t=num/denom	204	fdivp ;t=num/denom
204	mov ebx,[tmax]	205	mov ebx,[tmax]
205	fcom dword[ebx]	206	fcom dword[ebx]
206	fstsw ax	207	fstsw ax
207	sahf	208	sahf
208	ja .r0_f1 ;if (t>*tmax) return 0	209	ja .r0_f1 ;if (t>*tmax) return 0
209	mov ebx,[tmin]	210	mov ebx,[tmin]
210	fcom dword[ebx]	211	fcom dword[ebx]
211	fstsw ax	212	fstsw ax
212	sahf	213	sahf
213	jbe .r1_f1 ;if (t>tmin) tmin=t	214	jbe .r1_f1 ;if (t>tmin) tmin=t
214	fstp dword[ebx]	215	fstp dword[ebx]
215	jmp .r1	216	jmp .r1
216	align 4	217	align 4
217	.els_0: ;else if (denom<0)	218	.els_0: ;else if (denom<0)
218	jae .els_1	219	jae .els_1
219	fld dword[num]	220	fld dword[num]
220	fxch st1	221	fxch st1
221	fdivp ;t=num/denom	222	fdivp ;t=num/denom
222	mov ebx,[tmin]	223	mov ebx,[tmin]
223	fcom dword[ebx]	224	fcom dword[ebx]
224	fstsw ax	225	fstsw ax
225	sahf	226	sahf
226	jb .r0_f1 ;if (t<*tmin) return 0	227	jb .r0_f1 ;if (t<*tmin) return 0
227	mov ebx,[tmax]	228	mov ebx,[tmax]
228	fcom dword[ebx]	229	fcom dword[ebx]
229	fstsw ax	230	fstsw ax
230	sahf	231	sahf
231	jae .r1_f1	232	jae .r1_f1
232	fstp dword[ebx] ;if (t<tmin) tmax=t	233	fstp dword[ebx] ;if (t<tmin) tmax=t
233	jmp .r1	234	jmp .r1
234	align 4	235	align 4
235	.els_1: ;else if (num>0)	236	.els_1: ;else if (num>0)
236	ffree st0 ;denom	237	ffree st0 ;denom
237	fincstp	238	fincstp
238	fld dword[num]	239	fld dword[num]
239	ftst	240	ftst
240	fstsw ax	241	fstsw ax
241	sahf	242	sahf
242	ja .r0_f1 ;if (num>0) return 0	243	ja .r0_f1 ;if (num>0) return 0
243	jmp .r1_f1	244	jmp .r1_f1
244	align 4	245	align 4
245	.r0_f1: ;return 0 & free st0	246	.r0_f1: ;return 0 & free st0
246	ffree st0	247	ffree st0
247	fincstp	248	fincstp
248	.r0: ;return 0	249	.r0: ;return 0
249	xor eax,eax	250	xor eax,eax
250	jmp .end_f	251	jmp .end_f
251	align 4	252	align 4
252	.r1_f1: ;return 1 & free st0	253	.r1_f1: ;return 1 & free st0
253	ffree st0	254	ffree st0
254	fincstp	255	fincstp
255	.r1: ;return 1	256	.r1: ;return 1
256	xor eax,eax	257	xor eax,eax
257	inc eax	258	inc eax
258	.end_f:	259	.end_f:
259	ret	260	ret
260	endp	261	endp
261		262
262	align 16	263	align 16
263	proc gl_draw_line, context:dword, p1:dword, p2:dword	264	proc gl_draw_line, context:dword, p1:dword, p2:dword
264	locals	265	locals
265	d_x dd ?	266	d_x dd ?
266	d_y dd ?	267	d_y dd ?
267	d_z dd ?	268	d_z dd ?
268	d_w dd ?	269	d_w dd ?
269	x1 dd ?	270	x1 dd ?
270	y1 dd ?	271	y1 dd ?
271	z1 dd ?	272	z1 dd ?
272	w1 dd ?	273	w1 dd ?
273	q1 GLVertex ?	274	q1 GLVertex ?
274	q2 GLVertex ?	275	q2 GLVertex ?
275	tmin dd ? ;ebp-8	276	tmin dd ? ;ebp-8
276	tmax dd ? ;ebp-4	277	tmax dd ? ;ebp-4
277	endl	278	endl
278	pushad	279	pushad
279	mov edx,[context]	280	mov edx,[context]
280	mov edi,[p1]	281	mov edi,[p1]
281	mov esi,[p2]	282	mov esi,[p2]
282		283
283	cmp dword[edi+offs_vert_clip_code],0	284	cmp dword[edi+offs_vert_clip_code],0
284	jne .els_i	285	jne .els_i
285	cmp dword[esi+offs_vert_clip_code],0	286	cmp dword[esi+offs_vert_clip_code],0
286	jne .els_i	287	jne .els_i
287	;if ( (p1.clip_code \| p2.clip_code) == 0)	288	;if ( (p1.clip_code \| p2.clip_code) == 0)
288	cmp dword[edx+offs_cont_render_mode],GL_SELECT ;if (context.render_mode == GL_SELECT)	289	cmp dword[edx+offs_cont_render_mode],GL_SELECT ;if (context.render_mode == GL_SELECT)
289	jne .els_1	290	jne .els_1
290	stdcall gl_add_select1, edx,dword[edi+offs_vert_zp+offs_zbup_z],\	291	stdcall gl_add_select1, edx,dword[edi+offs_vert_zp+offs_zbup_z],\
291	dword[esi+offs_vert_zp+offs_zbup_z],dword[esi+offs_vert_zp+offs_zbup_z]	292	dword[esi+offs_vert_zp+offs_zbup_z],dword[esi+offs_vert_zp+offs_zbup_z]
292	jmp .end_f	293	jmp .end_f
293	align 4	294	align 4
294	.els_1:	295	.els_1:
295	add edi,offs_vert_zp	296	add edi,offs_vert_zp
296	add esi,offs_vert_zp	297	add esi,offs_vert_zp
297	push esi	298	push esi
298	push edi	299	push edi
299	push dword[edx+offs_cont_zb]	300	push dword[edx+offs_cont_zb]
300	cmp dword[edx+offs_cont_depth_test],0	301	cmp dword[edx+offs_cont_depth_test],0
301	je .els_2	302	je .els_2
302	;if (context.depth_test)	303	;if (context.depth_test)
303	call ZB_line_z ;, dword[edx+offs_cont_zb],edi,esi	304	call ZB_line_z ;, dword[edx+offs_cont_zb],edi,esi
304	jmp .end_f	305	jmp .end_f
305	align 4	306	align 4
306	.els_2:	307	.els_2:
307	call ZB_line ;, dword[edx+offs_cont_zb],edi,esi	308	call ZB_line ;, dword[edx+offs_cont_zb],edi,esi
308	jmp .end_f	309	jmp .end_f
309	align 4	310	align 4
310	.els_i:	311	.els_i:
311	;else if ( (p1.clip_code & p2.clip_code) != 0 )	312	;else if ( (p1.clip_code & p2.clip_code) != 0 )
312	mov eax,[edi+offs_vert_clip_code]	313	mov eax,[edi+offs_vert_clip_code]
313	and eax,[esi+offs_vert_clip_code]	314	and eax,[esi+offs_vert_clip_code]
314	or eax,eax	315	or eax,eax
315	jnz .end_f	316	jnz .end_f
316	.els_0:	317	.els_0:
317		318
318	fld dword[esi+offs_vert_pc+offs_X]	319	fld dword[esi+offs_vert_pc+offs_X]
319	fsub dword[edi+offs_vert_pc+offs_X]	320	fsub dword[edi+offs_vert_pc+offs_X]
320	fstp dword[d_x] ;d_x = p2.pc.X - p1.pc.X	321	fstp dword[d_x] ;d_x = p2.pc.X - p1.pc.X
321	fld dword[esi+offs_vert_pc+offs_Y]	322	fld dword[esi+offs_vert_pc+offs_Y]
322	fsub dword[edi+offs_vert_pc+offs_Y]	323	fsub dword[edi+offs_vert_pc+offs_Y]
323	fstp dword[d_y] ;d_y = p2.pc.Y - p1.pc.Y	324	fstp dword[d_y] ;d_y = p2.pc.Y - p1.pc.Y
324	fld dword[esi+offs_vert_pc+offs_Z]	325	fld dword[esi+offs_vert_pc+offs_Z]
325	fsub dword[edi+offs_vert_pc+offs_Z]	326	fsub dword[edi+offs_vert_pc+offs_Z]
326	fstp dword[d_z] ;d_z = p2.pc.Z - p1.pc.Z	327	fstp dword[d_z] ;d_z = p2.pc.Z - p1.pc.Z
327	fld dword[esi+offs_vert_pc+offs_W]	328	fld dword[esi+offs_vert_pc+offs_W]
328	fsub dword[edi+offs_vert_pc+offs_W]	329	fsub dword[edi+offs_vert_pc+offs_W]
329	fstp dword[d_w] ;d_w = p2.pc.W - p1.pc.W	330	fstp dword[d_w] ;d_w = p2.pc.W - p1.pc.W
330		331
331	mov eax,[edi+offs_vert_pc+offs_X]	332	mov eax,[edi+offs_vert_pc+offs_X]
332	mov [x1],eax ;x1 = p1.pc.X	333	mov [x1],eax ;x1 = p1.pc.X
333	mov eax,[edi+offs_vert_pc+offs_Y]	334	mov eax,[edi+offs_vert_pc+offs_Y]
334	mov [y1],eax ;y1 = p1.pc.Y	335	mov [y1],eax ;y1 = p1.pc.Y
335	mov eax,[edi+offs_vert_pc+offs_Z]	336	mov eax,[edi+offs_vert_pc+offs_Z]
336	mov [z1],eax ;z1 = p1.pc.Z	337	mov [z1],eax ;z1 = p1.pc.Z
337	mov eax,[edi+offs_vert_pc+offs_W]	338	mov eax,[edi+offs_vert_pc+offs_W]
338	mov [w1],eax ;w1 = p1.pc.W	339	mov [w1],eax ;w1 = p1.pc.W
339		340
340	mov dword[tmin],0.0	341	mov dword[tmin],0.0
341	mov dword[tmax],1.0	342	mov dword[tmax],1.0
342		343
343	mov eax,ebp	344	mov eax,ebp
344	sub eax,4	345	sub eax,4
345	push eax ;толкаем в стек адрес &tmax	346	push eax ;толкаем в стек адрес &tmax
346	sub eax,4	347	sub eax,4
347	push eax ;толкаем в стек адрес &tmin	348	push eax ;толкаем в стек адрес &tmin
348	fld dword[x1]	349	fld dword[x1]
349	fadd dword[w1]	350	fadd dword[w1]
350	fchs	351	fchs
351	fstp dword[esp-4]	352	fstp dword[esp-4]
352	fld dword[d_x]	353	fld dword[d_x]
353	fadd dword[d_w]	354	fadd dword[d_w]
354	fstp dword[esp-8]	355	fstp dword[esp-8]
355	sub esp,8	356	sub esp,8
356	call ClipLine1 ;d_x+d_w,-x1-w1,&tmin,&tmax	357	call ClipLine1 ;d_x+d_w,-x1-w1,&tmin,&tmax
357	bt eax,0	358	bt eax,0
358	jnc .end_f	359	jnc .end_f
359		360
360	sub esp,8 ;толкаем в стек адреса переменных &tmin и &tmax	361	sub esp,8 ;толкаем в стек адреса переменных &tmin и &tmax
361	fld dword[x1]	362	fld dword[x1]
362	fsub dword[w1]	363	fsub dword[w1]
363	fstp dword[esp-4]	364	fstp dword[esp-4]
364	fld dword[d_w]	365	fld dword[d_w]
365	fsub dword[d_x]	366	fsub dword[d_x]
366	fstp dword[esp-8]	367	fstp dword[esp-8]
367	sub esp,8	368	sub esp,8
368	call ClipLine1 ;-d_x+d_w,x1-w1,&tmin,&tmax	369	call ClipLine1 ;-d_x+d_w,x1-w1,&tmin,&tmax
369	bt eax,0	370	bt eax,0
370	jnc .end_f	371	jnc .end_f
371		372
372	sub esp,8 ;толкаем в стек адреса переменных &tmin и &tmax	373	sub esp,8 ;толкаем в стек адреса переменных &tmin и &tmax
373	fld dword[y1]	374	fld dword[y1]
374	fadd dword[w1]	375	fadd dword[w1]
375	fchs	376	fchs
376	fstp dword[esp-4]	377	fstp dword[esp-4]
377	fld dword[d_y]	378	fld dword[d_y]
378	fadd dword[d_w]	379	fadd dword[d_w]
379	fstp dword[esp-8]	380	fstp dword[esp-8]
380	sub esp,8	381	sub esp,8
381	call ClipLine1 ;d_y+d_w,-y1-w1,&tmin,&tmax	382	call ClipLine1 ;d_y+d_w,-y1-w1,&tmin,&tmax
382	bt eax,0	383	bt eax,0
383	jnc .end_f	384	jnc .end_f
384		385
385	sub esp,8 ;толкаем в стек адреса переменных &tmin и &tmax	386	sub esp,8 ;толкаем в стек адреса переменных &tmin и &tmax
386	fld dword[y1]	387	fld dword[y1]
387	fsub dword[w1]	388	fsub dword[w1]
388	fstp dword[esp-4]	389	fstp dword[esp-4]
389	fld dword[d_w]	390	fld dword[d_w]
390	fsub dword[d_y]	391	fsub dword[d_y]
391	fstp dword[esp-8]	392	fstp dword[esp-8]
392	sub esp,8	393	sub esp,8
393	call ClipLine1 ;-d_y+d_w,y1-w1,&tmin,&tmax	394	call ClipLine1 ;-d_y+d_w,y1-w1,&tmin,&tmax
394	bt eax,0	395	bt eax,0
395	jnc .end_f	396	jnc .end_f
396		397
397	sub esp,8 ;толкаем в стек адреса переменных &tmin и &tmax	398	sub esp,8 ;толкаем в стек адреса переменных &tmin и &tmax
398	fld dword[z1]	399	fld dword[z1]
399	fadd dword[w1]	400	fadd dword[w1]
400	fchs	401	fchs
401	fstp dword[esp-4]	402	fstp dword[esp-4]
402	fld dword[d_z]	403	fld dword[d_z]
403	fadd dword[d_w]	404	fadd dword[d_w]
404	fstp dword[esp-8]	405	fstp dword[esp-8]
405	sub esp,8	406	sub esp,8
406	call ClipLine1 ;d_z+d_w,-z1-w1,&tmin,&tmax	407	call ClipLine1 ;d_z+d_w,-z1-w1,&tmin,&tmax
407	bt eax,0	408	bt eax,0
408	jnc .end_f	409	jnc .end_f
409		410
410	sub esp,8 ;толкаем в стек адреса переменных &tmin и &tmax	411	sub esp,8 ;толкаем в стек адреса переменных &tmin и &tmax
411	fld dword[z1]	412	fld dword[z1]
412	fsub dword[w1]	413	fsub dword[w1]
413	fstp dword[esp-4]	414	fstp dword[esp-4]
414	fld dword[d_w]	415	fld dword[d_w]
415	fsub dword[d_z]	416	fsub dword[d_z]
416	fstp dword[esp-8]	417	fstp dword[esp-8]
417	sub esp,8	418	sub esp,8
418	call ClipLine1 ;-d_z+d_w,z1-w1,&tmin,&tmax	419	call ClipLine1 ;-d_z+d_w,z1-w1,&tmin,&tmax
419	bt eax,0	420	bt eax,0
420	jnc .end_f	421	jnc .end_f
421		422
422	mov eax,ebp	423	mov eax,ebp
423	sub eax,8+2*sizeof.GLVertex ;eax = &q1	424	sub eax,8+2*sizeof.GLVertex ;eax = &q1
424	stdcall interpolate, eax,edi,esi,[tmin]	425	interpolate eax,edi,esi,tmin
425	stdcall gl_transform_to_viewport, edx,eax	426	stdcall gl_transform_to_viewport, edx,eax
426	add eax,sizeof.GLVertex ;eax = &q2	427	add eax,sizeof.GLVertex ;eax = &q2
427	stdcall interpolate, eax,edi,esi,[tmax]	428	interpolate eax,edi,esi,tmax
428	stdcall gl_transform_to_viewport, edx,eax	429	stdcall gl_transform_to_viewport, edx,eax
429		430
430	sub eax,sizeof.GLVertex ;eax = &q1	431	sub eax,sizeof.GLVertex ;eax = &q1
431	mov ebx,eax	432	mov ebx,eax
432	add ebx,offs_vert_zp+offs_zbup_b	433	add ebx,offs_vert_zp+offs_zbup_b
433	push ebx	434	push ebx
434	add ebx,offs_zbup_g-offs_zbup_b	435	add ebx,offs_zbup_g-offs_zbup_b
435	push ebx	436	push ebx
436	add ebx,offs_zbup_r-offs_zbup_g	437	add ebx,offs_zbup_r-offs_zbup_g
437	push ebx	438	push ebx
438	stdcall RGBFtoRGBI, dword[eax+offs_vert_color],dword[eax+offs_vert_color+4],dword[eax+offs_vert_color+8]	439	stdcall RGBFtoRGBI, dword[eax+offs_vert_color],dword[eax+offs_vert_color+4],dword[eax+offs_vert_color+8]
439		440
440	add eax,sizeof.GLVertex ;eax = &q2	441	add eax,sizeof.GLVertex ;eax = &q2
441	mov ebx,eax	442	mov ebx,eax
442	add ebx,offs_vert_zp+offs_zbup_b	443	add ebx,offs_vert_zp+offs_zbup_b
443	push ebx	444	push ebx
444	add ebx,offs_zbup_g-offs_zbup_b	445	add ebx,offs_zbup_g-offs_zbup_b
445	push ebx	446	push ebx
446	add ebx,offs_zbup_r-offs_zbup_g	447	add ebx,offs_zbup_r-offs_zbup_g
447	push ebx	448	push ebx
448	stdcall RGBFtoRGBI, dword[eax+offs_vert_color],dword[eax+offs_vert_color+4],dword[eax+offs_vert_color+8]	449	stdcall RGBFtoRGBI, dword[eax+offs_vert_color],dword[eax+offs_vert_color+4],dword[eax+offs_vert_color+8]
449		450
450	add eax,offs_vert_zp ;eax = &q2.zp	451	add eax,offs_vert_zp ;eax = &q2.zp
451	push eax	452	push eax
452	sub eax,sizeof.GLVertex ;eax = &q1.zp	453	sub eax,sizeof.GLVertex ;eax = &q1.zp
453	push eax	454	push eax
454	push dword[edx+offs_cont_zb]	455	push dword[edx+offs_cont_zb]
455	cmp dword[edx+offs_cont_depth_test],0	456	cmp dword[edx+offs_cont_depth_test],0
456	je .els_3	457	je .els_3
457	call ZB_line_z ;(context.zb,&q1.zp,&q2.zp)	458	call ZB_line_z ;(context.zb,&q1.zp,&q2.zp)
458	jmp .end_f	459	jmp .end_f
459	align 4	460	align 4
460	.els_3:	461	.els_3:
461	call ZB_line ;(context.zb,&q1.zp,&q2.zp)	462	call ZB_line ;(context.zb,&q1.zp,&q2.zp)
462	.end_f:	463	.end_f:
463	popad	464	popad
464	ret	465	ret
465	endp	466	endp
466		467
467	; triangle	468	; triangle
468		469
469	;	470	;
470	; Clipping	471	; Clipping
471	;	472	;
472		473
473	; We clip the segment [a,b] against the 6 planes of the normal volume.	474	; We clip the segment [a,b] against the 6 planes of the normal volume.
474	; We compute the point 'c' of intersection and the value of the parameter 't'	475	; We compute the point 'c' of intersection and the value of the parameter 't'
475	; of the intersection if x=a+t(b-a).	476	; of the intersection if x=a+t(b-a).
476	;	477	;
477	; sign: 0 -> '-', 1 -> '+'	478	; sign: 0 -> '-', 1 -> '+'
478	macro clip_func sign,dir,dir1,dir2	479	macro clip_func sign,dir,dir1,dir2
479	{	480	{
480	locals	481	locals
481	t dd ?	482	t dd ?
482	d_X dd ?	483	d_X dd ?
483	d_Y dd ?	484	d_Y dd ?
484	d_Z dd ?	485	d_Z dd ?
485	d_W dd ?	486	d_W dd ?
486	endl	487	endl
487	mov edx,[a]	488	mov edx,[a]
488	mov ebx,[b]	489	mov ebx,[b]
489	mov ecx,[c]	490	mov ecx,[c]
490	fld dword[ebx+offs_X]	491	fld dword[ebx+offs_X]
491	fsub dword[edx+offs_X]	492	fsub dword[edx+offs_X]
492	fstp dword[d_X] ;d_X = (b.X - a.X)	493	fstp dword[d_X] ;d_X = (b.X - a.X)
493	fld dword[ebx+offs_Y]	494	fld dword[ebx+offs_Y]
494	fsub dword[edx+offs_Y]	495	fsub dword[edx+offs_Y]
495	fstp dword[d_Y] ;d_Y = (b.Y - a.Y)	496	fstp dword[d_Y] ;d_Y = (b.Y - a.Y)
496	fld dword[ebx+offs_Z]	497	fld dword[ebx+offs_Z]
497	fsub dword[edx+offs_Z]	498	fsub dword[edx+offs_Z]
498	fstp dword[d_Z] ;d_Z = (b.Z - a.Z)	499	fstp dword[d_Z] ;d_Z = (b.Z - a.Z)

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/TinyGL/asm_fork/clip.asm – Rev 6145 → 6172