| 0,0 → 1,521 |
|---|
| |
| if DEBUG |
| 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 |
| |
| fld dword[ebx] |
| fstp qword[Data_Double] |
| call DoubleFloat_to_String |
| stdcall str_cat, edi,Data_String |
| |
| stdcall str_n_cat,edi,txt_zp_sp,2 |
| stdcall str_len,edi |
| add edi,eax |
| |
| fld dword[ebx+4] |
| fstp qword[Data_Double] |
| call DoubleFloat_to_String |
| stdcall str_cat, edi,Data_String |
| |
| stdcall str_n_cat,edi,txt_zp_sp,2 |
| stdcall str_len,edi |
| add edi,eax |
| |
| fld dword[ebx+8] |
| fstp qword[Data_Double] |
| call DoubleFloat_to_String |
| stdcall str_cat, edi,Data_String |
| |
| stdcall str_n_cat,edi,txt_zp_sp,2 |
| stdcall str_len,edi |
| add edi,eax |
| |
| fld dword[ebx+12] |
| fstp qword[Data_Double] |
| call DoubleFloat_to_String |
| stdcall str_cat, edi,Data_String |
| |
| stdcall str_n_cat,edi,txt_nl,2 |
| stdcall dbg_print,txt_sp,buf_param |
| |
| add ebx,16 |
| dec ecx |
| cmp ecx,0 |
| jg @b |
| .end_f: |
| ret |
| endp |
| end if |
| |
| macro gl_matrix_update context, reg |
| { |
| 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 |
| } |
| |
| align 4 |
| proc glopMatrixMode uses eax ebx, context:dword, p:dword |
| mov eax,[context] |
| mov ebx,[p] |
| |
| cmp dword[ebx+4],GL_MODELVIEW ;cmp p[1],... |
| 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 |
| |
| align 4 |
| 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] |
| |
| mov esi,[p] |
| add esi,4 |
| stdcall gl_M4_Transpose,edi,esi ;транспонируем входную матрицу в матрицу context.matrix_stack_ptr[context.matrix_mode] |
| |
| gl_matrix_update eax,edi |
| ret |
| endp |
| |
| align 4 |
| 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 |
| |
| stdcall gl_M4_Id,[ebx+offs_cont_matrix_stack_ptr] |
| if DEBUG ;glopLoadIdentity |
| stdcall gl_print_matrix,[ebx+offs_cont_matrix_stack_ptr],4 |
| end if |
| gl_matrix_update eax,ebx |
| ret |
| endp |
| |
| align 4 |
| 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 eax,[context] |
| 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 |
| |
| gl_matrix_update eax,edi |
| ret |
| endp |
| |
| align 4 |
| proc glopPushMatrix uses eax ebx, context:dword, p:dword |
| mov eax,[context] |
| mov ebx,[eax+offs_cont_matrix_mode] |
| |
| ; assert( (c->matrix_stack_ptr[ebx] - c->matrix_stack[ebx] + 1 ) |
| ; < c->matrix_stack_depth_max[ebx] ); |
| |
| shl ebx,2 |
| 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] |
| |
| sub ebx,sizeof.M4 |
| push ebx |
| add ebx,sizeof.M4 |
| stdcall gl_M4_Move, ebx |
| |
| gl_matrix_update eax,ebx |
| ret |
| endp |
| |
| align 4 |
| proc glopPopMatrix uses eax ebx, context:dword, p:dword |
| mov eax,[context] |
| mov ebx,[eax+offs_cont_matrix_mode] |
| |
| ; assert( c->matrix_stack_ptr[n] > c->matrix_stack[n] ); |
| |
| shl ebx,2 |
| add ebx,eax |
| sub dword[ebx+offs_cont_matrix_stack_ptr],sizeof.M4 |
| |
| gl_matrix_update eax,ebx |
| ret |
| endp |
| |
| align 4 |
| 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 eax,[context] |
| 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 |
| |
| fldz |
| fild dword[ebx+8] |
| fstp dword[u0] |
| fild dword[ebx+12] |
| fstp dword[u1] |
| fild dword[ebx+16] |
| fst dword[u2] |
| |
| ; simple case detection |
| 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 |
| |
| ;ebx = ((u0 != 0)<<2) | ((u1 != 0)<<1) | (u2 != 0) |
| 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 |
| |
| ; normalize vector |
| 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 |
| |
| ; store cos and sin values |
| finit |
| fld dword[angle] |
| fcos |
| fst dword[cost] ;cost=cos(angle) |
| fld dword[angle] |
| fsin |
| fst dword[sint] ;sint=sin(angle) |
| |
| ; fill in the values |
| 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] |
| |
| ; do the math |
| ; 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 eax,[context] |
| 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 |
| |
| align 4 |
| proc glopScale uses eax ebx ecx, context:dword, p:dword |
| mov ecx,[p] |
| |
| mov eax,[context] |
| 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+ 4] ;x |
| 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 |
| |
| if DEBUG ;glopScale |
| 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 |
| |
| align 4 |
| proc glopTranslate uses eax ebx ecx, context:dword, p:dword |
| mov ecx,[p] |
| |
| mov eax,[context] |
| 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+ 4] ;x |
| 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 |
| fadd st0,st1 |
| fadd st0,st2 |
| fadd dword[ebx+12] ;m[3] |
| fstp dword[ebx+12] ;m[3] = m[0] * x + m[1] * y + m[2] * z + m[3] |
| ffree st0 |
| fincstp |
| ffree st0 |
| fincstp |
| add ebx,16 |
| loop @b |
| |
| if DEBUG ;glopTranslate |
| 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 |
| |
| align 4 |
| 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] |
| |
| fld dword[ebx+8] |
| 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) |
| |
| mov ecx,ebp |
| sub ecx,sizeof.M4 |
| |
| mov ebx,[x] |
| 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 |
| |
| 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 ;glopFrustum |
| 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 |
| |
| |