Subversion Repositories Kolibri OS

align 4

proc gl_print_matrix uses eax ebx ecx edi, m:dword, rows:dword

	mov ecx,[rows]

	cmp ecx,1

	jl .end_f

	mov ebx,[m]

	mov word[NumberSymbolsAD],3

	finit

	@@:

		lea edi,[buf_param]

		mov byte[edi],0

		fstp qword[Data_Double]

		call DoubleFloat_to_String

		stdcall str_cat, edi,Data_String

		stdcall str_len,edi

		add edi,eax

		fstp qword[Data_Double]

		call DoubleFloat_to_String

		stdcall str_cat, edi,Data_String

		stdcall str_len,edi

		add edi,eax

		fstp qword[Data_Double]

		call DoubleFloat_to_String

		stdcall str_cat, edi,Data_String

		stdcall str_len,edi

		add edi,eax

		fstp qword[Data_Double]

		call DoubleFloat_to_String

		stdcall str_cat, edi,Data_String

		stdcall dbg_print,txt_sp,buf_param

	dec ecx

	cmp ecx,0

	jg @b

	.end_f:

	ret

endp

end if

{

	local .end_0

	xor reg,reg

	cmp dword[context+offs_cont_matrix_mode],1

	jg .end_0

		inc reg

	.end_0:

	mov dword[context+offs_cont_matrix_model_projection_updated],reg

}

proc glopMatrixMode uses eax ebx, context:dword, p:dword

	mov eax,[context]

	mov ebx,[p]

	jne @f

		mov dword[eax+offs_cont_matrix_mode],0

		jmp .end_f

	@@:

	cmp dword[ebx+4],GL_PROJECTION

	jne @f

		mov dword[eax+offs_cont_matrix_mode],1

		jmp .end_f

	@@:

	cmp dword[ebx+4],GL_TEXTURE

	jne .def

		mov dword[eax+offs_cont_matrix_mode],2

		jmp .end_f

	.def:

;assert(0);

	.end_f:

	ret

endp

proc glopLoadMatrix uses eax edi esi, context:dword, p:dword

	mov eax,[context]

	mov edi,[eax+offs_cont_matrix_mode]

	shl edi,2

	add edi,eax

	mov edi,dword[edi+offs_cont_matrix_stack_ptr]

	add esi,4

	stdcall gl_M4_Transpose,edi,esi ;транспонируем входную матрицу в матрицу context.matrix_stack_ptr[context.matrix_mode]

	ret

endp

proc glopLoadIdentity uses eax ebx, context:dword, p:dword

	mov eax,[context]

	mov ebx,[eax+offs_cont_matrix_mode]

	shl ebx,2

	add ebx,eax

if DEBUG ;glopLoadIdentity

	stdcall gl_print_matrix,[ebx+offs_cont_matrix_stack_ptr],4

end if

	gl_matrix_update eax,ebx

	ret

endp

proc glopMultMatrix uses eax edi esi, context:dword, p:dword

locals

	m M4

endl

	mov esi,[p]

	add esi,4

	mov edi,ebp

	sub edi,sizeof.M4

	stdcall gl_M4_Transpose,edi,esi ;транспонируем входную матрицу в локальную матрицу m

	mov esi,[eax+offs_cont_matrix_mode]

	shl esi,2

	add esi,eax

	stdcall gl_M4_MulLeft,dword[esi+offs_cont_matrix_stack_ptr],edi

	ret

endp

proc glopPushMatrix uses eax ebx, context:dword, p:dword

	mov eax,[context]

	mov ebx,[eax+offs_cont_matrix_mode]

;	   < c->matrix_stack_depth_max[ebx] );

	add ebx,eax

	add ebx,offs_cont_matrix_stack_ptr

	add dword[ebx],sizeof.M4

	mov ebx,[ebx] ;ebx = ++context.matrix_stack_ptr[context.matrix_mode]

	push ebx

	add ebx,sizeof.M4

	stdcall gl_M4_Move, ebx

	ret

endp

proc glopPopMatrix uses eax ebx, context:dword, p:dword

	mov eax,[context]

	mov ebx,[eax+offs_cont_matrix_mode]

	add ebx,eax

	sub dword[ebx+offs_cont_matrix_stack_ptr],sizeof.M4

	ret

endp

proc glopRotate uses eax ebx ecx, context:dword, p:dword

locals

	u0 dd ?

	u1 dd ?

	u2 dd ?

	angle dd ?

	cost dd ?

	sint dd ?

	m M4

endl

	mov ebx,[p]

	mov ecx,ebp

	sub ecx,sizeof.M4 ;ecx=&m

	finit

	fldpi

	fmul dword[ebx+4]

	fdiv dword[an180f]

	fst dword[angle] ;angle = p[1].f * M_PI / 180.0

	;st0 = angle

	fild dword[ebx+8]

	fstp dword[u0]

	fild dword[ebx+12]

	fstp dword[u1]

	fild dword[ebx+16]

	fst dword[u2]

	xor ebx,ebx

	fcomp st1 ;u2 ... 0

	fstsw ax

	sahf

	je @f

		inc ebx

	@@:

	fcom dword[u1] ;0 ... u1

	fstsw ax

	sahf

	je @f

		or ebx,2

	@@:

	fcom dword[u0] ;0 ... u0

	fstsw ax

	sahf

	je @f

		or ebx,4

	@@:

	;st0 = 0, st1 = angle

	cmp ebx,0

	je .end_f ;если нет поворотов выход из функции

	cmp ebx,4

	jne @f

		fcomp dword[u0] ;0 ... u0

		fstsw ax

		sahf

		jae .u0ch

			fchs

			fstp dword[angle] ;if (u0 < 0) angle *= -1

		.u0ch:

		stdcall gl_M4_Rotate, ecx,[angle],0

		jmp .end_sw

	@@:

	cmp ebx,2

	jne @f

		fcomp dword[u1] ;0 ... u1

		fstsw ax

		sahf

		jae .u1ch

			fchs

			fstp dword[angle] ;if (u1 < 0) angle *= -1

		.u1ch:

		stdcall gl_M4_Rotate, ecx,[angle],1

		jmp .end_sw

	@@:

	cmp ebx,1

	jne @f

		fcomp dword[u2] ;0 ... u2

		fstsw ax

		sahf

		jae .u2ch

			fchs

			fstp dword[angle] ;if (u2 < 0) angle *= -1

		.u2ch:

		stdcall gl_M4_Rotate, ecx,[angle],2

		jmp .end_sw

	@@: ;default:

if DEBUG ;glopRotete

		stdcall dbg_print,txt_sp,m_1

end if

		fld dword[u0]

		fmul st0,st0

		fld dword[u1]

		fmul st0,st0

		fld dword[u2]

		fmul st0,st0

		fadd st0,st1

		fadd st0,st2

;		fst dword[len] ;len = u0*u0+u1*u1+u2*u2

		fcom st1

		fstsw ax

		sahf

		je .end_f ;if (len == 0.0f) return

		fsqrt

		fld1

		fdiv st0,st1

;		fst dword[len] ;len = 1.0f / sqrt(len)

		fld dword[u0]

		fmul st0,st1

		fstp dword[u0] ;u0 *= len

		fld dword[u1]

		fmul st0,st1

		fstp dword[u1] ;u1 *= len

		fld dword[u2]

		fmul st0,st1

		fstp dword[u2] ;u2 *= len

		;st0 = len, st1=..., st2=..., st3 = 0, st4 = angle

		finit

		fld dword[angle]

		fcos

		fst dword[cost] ;cost=cos(angle)

		fld dword[angle]

		fsin

		fst dword[sint] ;sint=sin(angle)

		mov ebx,0.0

		mov [ecx+3*16   ],ebx ;m[3][0]

		mov [ecx+3*16 +4],ebx ;m[3][1]

		mov [ecx+3*16 +8],ebx ;m[3][2]

		mov [ecx+     12],ebx ;m[0][3]

		mov [ecx+  16+12],ebx ;m[1][3]

		mov [ecx+2*16+12],ebx ;m[2][3]

		mov ebx,1.0

		mov [ecx+3*16+12],ebx ;m[3][3]

;      m.m[0][0]=u[0]*u[0]+cost*(1-u[0]*u[0]);

;      m.m[1][0]=u[0]*u[1]*(1-cost)-u[2]*sint;

;      m.m[2][0]=u[2]*u[0]*(1-cost)+u[1]*sint;

;      m.m[0][1]=u[0]*u[1]*(1-cost)+u[2]*sint;

;      m.m[1][1]=u[1]*u[1]+cost*(1-u[1]*u[1]);

;      m.m[2][1]=u[1]*u[2]*(1-cost)-u[0]*sint;

;      m.m[0][2]=u[2]*u[0]*(1-cost)-u[1]*sint;

;      m.m[1][2]=u[1]*u[2]*(1-cost)+u[0]*sint;

;      m.m[2][2]=u[2]*u[2]+cost*(1-u[2]*u[2]);

	.end_sw:

	mov ebx,[eax+offs_cont_matrix_mode]

	shl ebx,2

	add ebx,eax

	stdcall gl_M4_MulLeft,dword[ebx+offs_cont_matrix_stack_ptr],ecx

if DEBUG ;glopRotete

		stdcall gl_print_matrix,ecx,4

end if

	gl_matrix_update eax,ebx

	.end_f:

	ret

endp

proc glopScale uses eax ebx ecx, context:dword, p:dword

	mov ecx,[p]

	mov ebx,[eax+offs_cont_matrix_mode]

	shl ebx,2

	add ebx,eax

	mov ebx,[ebx+offs_cont_matrix_stack_ptr] ;ebx = &m[0]

	fld dword[ecx+ 8] ;y

	fld dword[ecx+12] ;z

	mov ecx,4

	@@:

	fld dword[ebx]   ;m[0]

	fmul st0,st3     ;m[0] * x

	fstp dword[ebx]  ;m[0] *= x

	fld dword[ebx+4] ;m[1]

	fmul st0,st2     ;m[1] * y

	fstp dword[ebx+4];m[1] *= y

	fld dword[ebx+8] ;m[2]

	fmul st0,st1     ;m[2] * z

	fstp dword[ebx+8];m[2] *= z

	add ebx,16

	loop @b

	mov ebx,[eax+offs_cont_matrix_mode]

	shl ebx,2

	add ebx,eax

	stdcall gl_print_matrix,[ebx+offs_cont_matrix_stack_ptr],4

end if

	gl_matrix_update eax,ebx

	ret

endp

proc glopTranslate uses eax ebx ecx, context:dword, p:dword

	mov ecx,[p]

	mov ebx,[eax+offs_cont_matrix_mode]

	shl ebx,2

	add ebx,eax

	mov ebx,[ebx+offs_cont_matrix_stack_ptr] ;ebx = &m[0]

	fld dword[ecx+ 8] ;y

	fld dword[ecx+12] ;z

	mov ecx,4

	@@:

		fld dword[ebx]   ;m[0]

		fmul st0,st3     ;m[0] * x

		fld dword[ebx+4] ;m[1]

		fmul st0,st3     ;m[1] * y

		fld dword[ebx+8] ;m[2]

		fmul st0,st3     ;m[2] * z

		faddp

		faddp

		fadd dword[ebx+12] ;m[3]

		fstp dword[ebx+12] ;m[3] = m[0] * x + m[1] * y + m[2] * z + m[3]

		add ebx,16

	loop @b

	ffree st0

	fincstp

	ffree st0

	fincstp

	ffree st0

	fincstp

	mov ebx,[eax+offs_cont_matrix_mode]

	shl ebx,2

	add ebx,eax

	stdcall gl_print_matrix,[ebx+offs_cont_matrix_stack_ptr],4

end if

	gl_matrix_update eax,ebx

	ret

endp

proc glopFrustum uses eax ebx ecx, context:dword, p:dword

locals

	x dd ?

	y dd ?

	A dd ?

	B dd ?

	C dd ?

	D dd ?

	m M4

endl

	mov eax,[context]

	mov ebx,[p]

	fsub dword[ebx+4]  ;st0 = (right-left)

	fld dword[ebx+20]  ;st0 = near

	fadd st0,st0

	fdiv st0,st1

	fstp dword[x]      ;x = (2.0*near) / (right-left)

	fld dword[ebx+16]

	fsub dword[ebx+12] ;st0 = (top-bottom)

	fld dword[ebx+20]  ;st0 = near

	fadd st0,st0

	fdiv st0,st1

	fstp dword[y]      ;y = (2.0*near) / (top-bottom)

	fld dword[ebx+8]

	fadd dword[ebx+4]  ;st0 = (right+left)

	fdiv st0,st2       ;st2 = (right-left)

	fstp dword[A]      ;A = (right+left) / (right-left)

	fld dword[ebx+16]

	fadd dword[ebx+12] ;st0 = (top+bottom)

	fdiv st0,st1       ;st1 = (top-bottom)

	fstp dword[B]      ;B = (top+bottom) / (top-bottom)

	fld dword[ebx+24]

	fsub dword[ebx+20] ;st0 = (farp-near)

	fldz

	fsub dword[ebx+24]

	fsub dword[ebx+20] ;st0 = -(farp+near)

	fdiv st0,st1

	fstp dword[C]      ;C = -(farp+near) / (farp-near)

	fld dword[ebx+24]

	fmul dword[ebx+20] ;st0 = farp*near

	fadd st0,st0

	fchs               ;st0 = -(2.0*farp*near)

	fdiv st0,st1

	fstp dword[D]      ;D = -(2.0*farp*near) / (farp-near)

	sub ecx,sizeof.M4

	mov dword[ecx],ebx

	mov dword[ecx+4],0.0

	mov ebx,[A]

	mov dword[ecx+8],ebx

	mov dword[ecx+12],0.0

	mov dword[ecx+16],0.0

	mov ebx,[y]

	mov dword[ecx+20],ebx

	mov ebx,[B]

	mov dword[ecx+24],ebx

	mov dword[ecx+28],0.0

	mov dword[ecx+32],0.0

	mov dword[ecx+36],0.0

	mov ebx,[C]

	mov dword[ecx+40],ebx

	mov ebx,[D]

	mov dword[ecx+44],ebx

	mov dword[ecx+48],0.0

	mov dword[ecx+52],0.0

	mov dword[ecx+56],-1.0

	mov dword[ecx+60],0.0

	shl ebx,2

	add ebx,eax

	stdcall gl_M4_MulLeft,dword[ebx+offs_cont_matrix_stack_ptr],ecx

	stdcall gl_print_matrix,ecx,4

	stdcall gl_print_matrix,dword[ebx+offs_cont_matrix_stack_ptr],4

end if

	gl_matrix_update eax,ebx

	ret

endp