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


; glVertex 
 
align 4
proc glVertex4f uses eax, x:dword, y:dword, z:dword, w:dword
locals
	p rd 5
endl
	mov dword[p],OP_Vertex
	mov eax,[x]
	mov dword[p+4],eax
	mov eax,[y]
	mov dword[p+8],eax
	mov eax,[z]
	mov dword[p+12],eax
	mov eax,[w]
	mov dword[p+16],eax
 
	mov eax,ebp
	sub eax,20 ;=sizeof(dd)*5
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glVertex2f, x:dword, y:dword
	stdcall glVertex4f,[x],[y],0.0,1.0
	ret
endp
 
align 4
proc glVertex2fv uses eax, v:dword
	mov eax,[v]
	stdcall glVertex4f,[eax],[eax+4],0.0,1.0
	ret
endp
 
align 4
proc glVertex3f, x:dword, y:dword, z:dword
	stdcall glVertex4f,[x],[y],[z],1.0
	ret
endp
 
align 4
proc glVertex3fv uses eax, v:dword
	mov eax,[v]
	stdcall glVertex4f,[eax],[eax+4],[eax+8],1.0
	ret
endp
 
align 4
proc glVertex4fv uses eax, v:dword
	mov eax,[v]
	stdcall glVertex4f,[eax],[eax+4],[eax+8],[eax+12]
	ret
endp
 
; glNormal
 
align 4
proc glNormal3f uses eax, x:dword, y:dword, z:dword
locals
	p rd 4
endl
	mov dword[p],OP_Normal
	mov eax,[x]
	mov dword[p+4],eax
	mov eax,[y]
	mov dword[p+8],eax
	mov eax,[z]
	mov dword[p+12],eax
 
	mov eax,ebp
	sub eax,16 ;=sizeof(dd)*4
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glNormal3fv uses eax, v:dword
	mov eax,[v]
	stdcall glNormal3f,[eax],[eax+4],[eax+8]
	ret
endp
 
; glColor
 
align 4
proc glColor4f uses eax, r:dword, g:dword, b:dword, a:dword
locals
	p rd 8
endl
	mov dword[p],OP_Color
	mov eax,[b]
	mov dword[p+4],eax
	mov eax,[g]
	mov dword[p+8],eax
	mov eax,[r]
	mov dword[p+12],eax
	mov eax,[a]
	mov dword[p+16],eax
	; direct convertion to integer to go faster if no shading
	mov eax,ebp
	sub eax,12 ;ebp-12 = &p[5]
	push eax
	add eax,4 ;ebp-8 = &p[6]
	push eax
	add eax,4 ;ebp-4 = &p[7]
	push eax
	stdcall RGBFtoRGBI,[r],[g],[b] ;call: r,g,b,&p[7],&p[6],&p[5]
 
	mov eax,ebp
	sub eax,32 ;=sizeof(dd)*8
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glColor4fv uses eax ebx, v:dword
locals
	p rd 8
endl
	mov dword[p],OP_Color
	mov eax,[v]
	mov ebx,[eax+8]
	mov dword[p+4],ebx
	mov ebx,[eax+4]
	mov dword[p+8],ebx
	mov ebx,[eax]
	mov dword[p+12],ebx
	mov ebx,[eax+12]
	mov dword[p+16],ebx
	; direct convertion to integer to go faster if no shading
	mov eax,ebp
	sub eax,4
	push eax ;&p[7]
	sub eax,4
	push eax ;&p[6]
	sub eax,4
	push eax ;&p[5]
	stdcall RGBFtoRGBI,[eax+8],[eax+4],[eax] ;call: v[2],v[1],v[0],p[5],p[6],p[7]
 
	mov eax,ebp
	sub eax,32 ;=sizeof(dd)*8
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glColor3f, r:dword, g:dword, b:dword
	stdcall glColor4f,[r],[g],[b],1.0
	ret
endp
 
align 4
proc glColor3fv uses eax, v:dword
	mov eax,[v]
	stdcall glColor4f,[eax],[eax+4],[eax+8],1.0
	ret
endp
 
align 4
fl_255 dd 255.0
 
align 4
proc glColor3ub uses eax, r:dword, g:dword, b:dword
	push dword 1.0
	fld dword[fl_255]
 
	movzx eax,byte[b]
	mov dword[esp-4],eax
	fild dword[esp-4]
	fdiv st0,st1
	fstp dword[esp-4] ;преобразовали int во float
	movzx eax,byte[g]
	mov dword[esp-8],eax
	fild dword[esp-8]
	fdiv st0,st1
	fstp dword[esp-8]
	movzx eax,byte[r]
	mov dword[esp-12],eax
	fild dword[esp-12]
	fdiv st0,st1
	fstp dword[esp-12]
 
	ffree st0
	fincstp
	sub esp,12
	call glColor4f
	ret
endp
 
; TexCoord
 
align 4
proc glTexCoord4f uses eax, s:dword, t:dword, r:dword, q:dword
locals
	p rd 5
endl
	mov dword[p],OP_TexCoord
	mov eax,[s]
	mov dword[p+4],eax
	mov eax,[t]
	mov dword[p+8],eax
	mov eax,[r]
	mov dword[p+12],eax
	mov eax,[q]
	mov dword[p+16],eax
 
	mov eax,ebp
	sub eax,20 ;=sizeof(dd)*5
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glTexCoord2f, s:dword, t:dword
	stdcall glTexCoord4f,[s],[t],0.0,1.0
	ret
endp
 
align 4
proc glTexCoord2fv uses eax, v:dword
	mov eax,[v]
	stdcall glTexCoord4f,[eax],[eax+4],0.0,1.0
	ret
endp
 
align 4
proc glEdgeFlag uses eax, flag:dword
locals
	p rd 2
endl
	mov dword[p],OP_EdgeFlag
	mov eax,[flag]
	mov dword[p+4],eax
 
	mov eax,ebp
	sub eax,8 ;=sizeof(dd)*2
	stdcall gl_add_op,eax
	ret
endp
 
; misc
 
align 4
proc glShadeModel uses eax, mode:dword
locals
	p rd 2
endl
 
;  assert(mode == GL_FLAT || mode == GL_SMOOTH);
 
	mov dword[p],OP_ShadeModel
	mov eax,[mode]
	mov dword[p+4],eax
 
	mov eax,ebp
	sub eax,8 ;=sizeof(dd)*2
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glCullFace uses eax, mode:dword
locals
	p rd 2
endl
 
;  assert(mode == GL_BACK || 
;         mode == GL_FRONT || 
;         mode == GL_FRONT_AND_BACK);
 
	mov dword[p],OP_CullFace
	mov eax,[mode]
	mov dword[p+4],eax
 
	mov eax,ebp
	sub eax,8 ;=sizeof(dd)*2
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glFrontFace uses eax, mode:dword
locals
	p rd 2
endl
 
;  assert(mode == GL_CCW || mode == GL_CW);
 
	mov dword[p],OP_FrontFace
	xor eax,eax
	cmp dword[mode],GL_CCW
	je @f
		inc eax
	@@:
	mov dword[p+4],eax
 
	mov eax,ebp
	sub eax,8 ;=sizeof(dd)*2
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glPolygonMode uses eax, face:dword, mode:dword
locals
	p rd 3
endl
 
;  assert(face == GL_BACK || 
;         face == GL_FRONT || 
;         face == GL_FRONT_AND_BACK);
;  assert(mode == GL_POINT || mode == GL_LINE || mode==GL_FILL);
 
	mov dword[p],OP_PolygonMode
	mov eax,[face]
	mov dword[p+4],eax
	mov eax,[mode]
	mov dword[p+8],eax
 
	mov eax,ebp
	sub eax,12 ;=sizeof(dd)*3
	stdcall gl_add_op,eax
	ret
endp
 
; glEnable / glDisable
 
align 4
proc glEnable uses eax, cap:dword
locals
	p rd 3
endl
	mov dword[p],OP_EnableDisable
	mov eax,[cap]
	mov dword[p+4],eax
	mov dword[p+8],1
 
	mov eax,ebp
	sub eax,12 ;=sizeof(dd)*3
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glDisable uses eax, cap:dword
locals
	p rd 3
endl
	mov dword[p],OP_EnableDisable
	mov eax,[cap]
	mov dword[p+4],eax
	mov dword[p+8],0
 
	mov eax,ebp
	sub eax,12 ;=sizeof(dd)*3
	stdcall gl_add_op,eax
	ret
endp
 
; glBegin / glEnd
 
align 4
proc glBegin uses eax, mode:dword
locals
	p rd 2
endl
	mov dword[p],OP_Begin
	mov eax,[mode]
	mov dword[p+4],eax
 
	mov eax,ebp
	sub eax,8 ;=sizeof(dd)*2
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glEnd uses eax
locals
	p dd ?
endl
	mov dword[p],OP_End
 
	mov eax,ebp
	sub eax,4 ;=sizeof(dd)*1
	stdcall gl_add_op,eax
	ret
endp
 
; matrix
 
align 4
proc glMatrixMode uses eax, mode:dword
locals
	p rd 2
endl
	mov dword[p],OP_MatrixMode
	mov eax,[mode]
	mov dword[p+4],eax
 
	mov eax,ebp
	sub eax,8 ;=sizeof(dd)*2
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glLoadMatrixf uses ecx edi esi, m:dword
locals
	p rd 17
endl
	mov dword[p],OP_LoadMatrix
	mov ecx,16
	mov esi,[m]
	mov edi,ebp
	sub edi,64 ;=sizeof(M4)
	rep movsd
 
	mov ecx,ebp
	sub ecx,68 ;=sizeof(dd)*17
	stdcall gl_add_op,ecx
	ret
endp
 
align 4
proc glLoadIdentity uses eax
locals
	p dd ?
endl
	mov dword[p],OP_LoadIdentity
 
	mov eax,ebp
	sub eax,4 ;=sizeof(dd)*1
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glMultMatrixf uses ecx edi esi, m:dword
locals
	p rd 17
endl
	mov dword[p],OP_MultMatrix
	mov ecx,16
	mov esi,[m]
	mov edi,ebp
	sub edi,64 ;=sizeof(M4)
	rep movsd
 
	mov ecx,ebp
	sub ecx,68 ;=sizeof(dd)*17
	stdcall gl_add_op,ecx
	ret
endp
 
align 4
proc glPushMatrix uses eax
locals
	p dd ?
endl
	mov dword[p],OP_PushMatrix
 
	mov eax,ebp
	sub eax,4 ;=sizeof(dd)*1
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glPopMatrix uses eax
locals
	p dd ?
endl
	mov dword[p],OP_PopMatrix
 
	mov eax,ebp
	sub eax,4 ;=sizeof(dd)*1
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glRotatef uses eax, angle:dword, x:dword, y:dword, z:dword
locals
	p rd 5
endl
	mov dword[p],OP_Rotate
	mov eax,[angle]
	mov dword[p+4],eax
	mov eax,[x]
	mov dword[p+8],eax
	mov eax,[y]
	mov dword[p+12],eax
	mov eax,[z]
	mov dword[p+16],eax
 
	mov eax,ebp
	sub eax,20 ;=sizeof(dd)*5
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glTranslatef uses eax, x:dword, y:dword, z:dword
locals
	p rd 4
endl
	mov dword[p],OP_Translate
	mov eax,[x]
	mov dword[p+4],eax
	mov eax,[y]
	mov dword[p+8],eax
	mov eax,[z]
	mov dword[p+12],eax
 
	mov eax,ebp
	sub eax,16 ;=sizeof(dd)*4
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glScalef uses eax, x:dword, y:dword, z:dword
locals
	p rd 4
endl
	mov dword[p],OP_Scale
	mov eax,[x]
	mov dword[p+4],eax
	mov eax,[y]
	mov dword[p+8],eax
	mov eax,[z]
	mov dword[p+12],eax
 
	mov eax,ebp
	sub eax,16 ;=sizeof(dd)*4
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glViewport uses eax, x:dword, y:dword, width:dword, heigh:dword
locals
	p rd 5
endl
	mov dword[p],OP_Viewport
	mov eax,[x]
	mov dword[p+4],eax
	mov eax,[y]
	mov dword[p+8],eax
	mov eax,[width]
	mov dword[p+12],eax
	mov eax,[heigh]
	mov dword[p+16],eax
 
	mov eax,ebp
	sub eax,20 ;=sizeof(dd)*5
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glFrustum uses eax, left:dword,right:dword,bottom:dword,top:dword,\
	near:dword,farv:dword
locals
	p rd 7
endl
	mov dword[p],OP_Frustum
	mov eax,[left]
	fld qword[eax]
	fstp dword[p+4]
	mov eax,[right]
	fld qword[eax]
	fstp dword[p+8]
	mov eax,[bottom]
	fld qword[eax]
	fstp dword[p+12]
	mov eax,[top]
	fld qword[eax]
	fstp dword[p+16]
	mov eax,[near]
	fld qword[eax]
	fstp dword[p+20]
	mov eax,[farv]
	fld qword[eax]
	fstp dword[p+24]
 
	mov eax,ebp
	sub eax,28 ;=sizeof(dd)*7
	stdcall gl_add_op,eax
	ret
endp
 
; lightening
 
align 4
proc glMaterialfv uses eax ecx, mode:dword, type:dword, v:dword
locals
	p rd 7
endl
 
;  assert(mode == GL_FRONT  || mode == GL_BACK || mode==GL_FRONT_AND_BACK);
 
	mov dword[p],OP_Material
	mov eax,[mode]
	mov dword[p+4],eax
	mov eax,[type]
	mov dword[p+8],eax
 
	mov eax,[v]
	mov ecx,[eax+8]
	mov dword[p+12],ecx
	mov ecx,[eax+4]
	mov dword[p+16],ecx
	mov ecx,[eax]
	mov dword[p+20],ecx
	mov ecx,[eax+12]
	mov dword[p+24],ecx
 
	cmp dword[type],GL_SHININESS
	jne @f
		mov dword[p+16],0.0
		mov dword[p+20],0.0
		mov dword[p+24],0.0
	@@:
 
	mov eax,ebp
	sub eax,28 ;=sizeof(dd)*7
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glMaterialf uses eax, mode:dword, type:dword, v:dword
locals
	p rd 7
endl
	mov dword[p],OP_Material
	mov eax,[mode]
	mov dword[p+4],eax
	mov eax,[type]
	mov dword[p+8],eax
	mov eax,[v]
	mov dword[p+12],eax
	mov dword[p+16],0.0
	mov dword[p+20],0.0
	mov dword[p+24],0.0
 
	mov eax,ebp
	sub eax,28 ;=sizeof(dd)*7
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glColorMaterial uses eax, mode:dword, type:dword
locals
	p rd 3
endl
	mov dword[p],OP_ColorMaterial
	mov eax,[mode]
	mov dword[p+4],eax
	mov eax,[type]
	mov dword[p+8],eax
 
	mov eax,ebp
	sub eax,12 ;=sizeof(dd)*3
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glLightfv uses eax ecx, light:dword, type:dword, v:dword
locals
	p rd 7
endl
	mov dword[p],OP_Light
	mov eax,[light]
	mov dword[p+4],eax
	mov eax,[type]
	mov dword[p+8],eax
 
	;TODO: 3 composants ?
	mov eax,[v]
	mov ecx,[eax]
	mov dword[p+12],ecx
	mov ecx,[eax+4]
	mov dword[p+16],ecx
	mov ecx,[eax+8]
	mov dword[p+20],ecx
	mov ecx,[eax+12]
	mov dword[p+24],ecx
 
	mov eax,ebp
	sub eax,28 ;=sizeof(dd)*7
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glLightf uses eax, light:dword, type:dword, v:dword
locals
	p rd 7
endl
	mov dword[p],OP_Light
	mov eax,[light]
	mov dword[p+4],eax
	mov eax,[type]
	mov dword[p+8],eax
	mov eax,[v]
	mov dword[p+12],eax
	mov dword[p+16],0.0
	mov dword[p+20],0.0
	mov dword[p+24],0.0
 
	mov eax,ebp
	sub eax,28 ;=sizeof(dd)*7
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glLightModeli uses eax, pname:dword, param:dword
locals
	p rd 6
endl
	mov dword[p],OP_LightModel
	mov eax,[pname]
	mov dword[p+4],eax
	fild dword[param]
	fstp dword[p+8] ;преобразовали int во float
 
	mov dword[p+12],0.0
	mov dword[p+16],0.0
	mov dword[p+20],0.0
 
	mov eax,ebp
	sub eax,24 ;=sizeof(dd)*6
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glLightModelfv uses eax ecx, pname:dword, param:dword
locals
	p rd 6
endl
	mov dword[p],OP_LightModel
	mov eax,[pname]
	mov dword[p+4],eax
	mov eax,[param]
	mov ecx,[eax]
	mov dword[p+8],ecx
	mov ecx,[eax+4]
	mov dword[p+12],ecx
	mov ecx,[eax+8]
	mov dword[p+16],ecx
	mov ecx,[eax+12]
	mov dword[p+20],ecx
 
	mov eax,ebp
	sub eax,24 ;=sizeof(dd)*6
	stdcall gl_add_op,eax
	ret
endp
 
; clear
 
align 4
proc glClear uses eax, mask:dword
locals
	p rd 2
endl
	mov dword[p],OP_Clear
	mov eax,[mask]
	mov dword[p+4],eax
 
	mov eax,ebp
	sub eax,8 ;=sizeof(dd)*2
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glClearColor uses eax, r:dword, g:dword, b:dword, a:dword
locals
	p rd 5
endl
	mov dword[p],OP_ClearColor
	mov eax,[b]
	mov dword[p+4],eax
	mov eax,[g]
	mov dword[p+8],eax
	mov eax,[r]
	mov dword[p+12],eax
	mov eax,[a]
	mov dword[p+16],eax
 
	mov eax,ebp
	sub eax,20 ;=sizeof(dd)*5
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glClearDepth uses eax, depth:dword
locals
	p rd 2
endl
	mov dword[p],OP_ClearDepth
	mov eax,[depth]
	fld qword[eax]
	fstp dword[p+4]
 
	mov eax,ebp
	sub eax,8 ;=sizeof(dd)*2
	stdcall gl_add_op,eax
	ret
endp
 
; textures
 
align 4
proc glTexImage2D uses ecx edi esi,\
	target:dword, level:dword, components:dword,\
	width:dword, height:dword, border:dword,\
	format:dword, type:dword, pixels:dword
locals
	p rd 10
endl
	mov dword[p],OP_TexImage2D
	mov ecx,9
	mov esi,ebp
	add esi,8 ;указатель на стек с входными параметрами
	mov edi,ebp
	sub edi,36 ;указатель на стек с локальным массивом
	rep movsd ;копирование в цикле 9-ти входных параметров
 
	mov ecx,ebp
	sub ecx,40 ;=sizeof(dd)*10
	stdcall gl_add_op,ecx
	ret
endp
 
align 4
proc glBindTexture uses eax, target:dword, texture:dword
locals
	p rd 3
endl
	mov dword[p],OP_BindTexture
	mov eax,[target]
	mov dword[p+4],eax
	mov eax,[texture]
	mov dword[p+8],eax
 
	mov eax,ebp
	sub eax,12 ;=sizeof(dd)*3
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glTexEnvi uses eax, target:dword, pname:dword, param:dword
locals
	p rd 8
endl
	mov dword[p],OP_TexEnv
	mov eax,[target]
	mov dword[p+4],eax
	mov eax,[pname]
	mov dword[p+8],eax
	mov eax,[param]
	mov dword[p+12],eax
	mov dword[p+16],0.0
	mov dword[p+20],0.0
	mov dword[p+24],0.0
	mov dword[p+28],0.0
 
	mov eax,ebp
	sub eax,32 ;=sizeof(dd)*8
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glTexParameteri uses eax, target:dword, pname:dword, param:dword
locals
	p rd 8
endl
	mov dword[p],OP_TexParameter
	mov eax,[target]
	mov dword[p+4],eax
	mov eax,[pname]
	mov dword[p+8],eax
	mov eax,[param]
	mov dword[p+12],eax
	mov dword[p+16],0.0
	mov dword[p+20],0.0
	mov dword[p+24],0.0
	mov dword[p+28],0.0
 
	mov eax,ebp
	sub eax,32 ;=sizeof(dd)*8
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glPixelStorei uses eax, pname:dword, param:dword
locals
	p rd 3
endl
	mov dword[p],OP_PixelStore
	mov eax,[pname]
	mov dword[p+4],eax
	mov eax,[param]
	mov dword[p+8],eax
 
	mov eax,ebp
	sub eax,12 ;=sizeof(dd)*3
	stdcall gl_add_op,eax
	ret
endp
 
; selection
 
align 4
proc glInitNames uses eax
locals
	p dd ?
endl
	mov dword[p],OP_InitNames
 
	mov eax,ebp
	sub eax,4 ;=sizeof(dd)*1
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glPushName uses eax, name:dword
locals
	p rd 2
endl
	mov dword[p],OP_PushName
	mov eax,[name]
	mov dword[p+4],eax
 
	mov eax,ebp
	sub eax,8 ;=sizeof(dd)*2
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glPopName uses eax
locals
	p dd ?
endl
	mov dword[p],OP_PopName
 
	mov eax,ebp
	sub eax,4 ;=sizeof(dd)*1
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glLoadName uses eax, name:dword
locals
	p rd 2
endl
	mov dword[p],OP_LoadName
	mov eax,[name]
	mov dword[p+4],eax
 
	mov eax,ebp
	sub eax,8 ;=sizeof(dd)*2
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glPolygonOffset uses eax, factor:dword, units:dword
locals
	p rd 3
endl
	mov dword[p],OP_PolygonOffset
	mov eax,[factor]
	mov dword[p+4],eax
	mov eax,[units]
	mov dword[p+8],eax
 
	mov eax,ebp
	sub eax,12 ;=sizeof(dd)*3
	stdcall gl_add_op,eax
	ret
endp
 
; Special Functions
 
align 4
proc glCallList uses eax, list:dword
locals
	p rd 2
endl
	mov dword[p],OP_CallList
	mov eax,[list]
	mov dword[p+4],eax
 
	mov eax,ebp
	sub eax,8 ;=sizeof(dd)*2
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glFlush ;(void)
	;nothing to do
	ret
endp
 
align 4
proc glHint uses eax, target:dword, mode:dword
locals
	p rd 3
endl
	mov dword[p],OP_Hint
	mov eax,[target]
	mov dword[p+4],eax
	mov eax,[mode]
	mov dword[p+8],eax
 
	mov eax,ebp
	sub eax,12 ;=sizeof(dd)*3
	stdcall gl_add_op,eax
	ret
endp
 
; Non standard functions
 
align 4
proc glDebug uses eax, mode:dword
	stdcall gl_get_context ;после вызова функции в eax указатель на GLContext
	push dword[mode]
	pop dword[eax+offs_cont_print_flag]
	ret
endp

Rev 5353	Rev 5387
1	; glVertex	1	; glVertex
2		2
3	align 4	3	align 4
4	proc glVertex4f uses eax, x:dword, y:dword, z:dword, w:dword	4	proc glVertex4f uses eax, x:dword, y:dword, z:dword, w:dword
5	locals	5	locals
6	p rd 5	6	p rd 5
7	endl	7	endl
8	mov dword[p],OP_Vertex	8	mov dword[p],OP_Vertex
9	mov eax,[x]	9	mov eax,[x]
10	mov dword[p+4],eax	10	mov dword[p+4],eax
11	mov eax,[y]	11	mov eax,[y]
12	mov dword[p+8],eax	12	mov dword[p+8],eax
13	mov eax,[z]	13	mov eax,[z]
14	mov dword[p+12],eax	14	mov dword[p+12],eax
15	mov eax,[w]	15	mov eax,[w]
16	mov dword[p+16],eax	16	mov dword[p+16],eax
17		17
18	mov eax,ebp	18	mov eax,ebp
19	sub eax,20 ;=sizeof(dd)*5	19	sub eax,20 ;=sizeof(dd)*5
20	stdcall gl_add_op,eax	20	stdcall gl_add_op,eax
21	ret	21	ret
22	endp	22	endp
23		23
24	align 4	24	align 4
25	proc glVertex2f, x:dword, y:dword	25	proc glVertex2f, x:dword, y:dword
26	stdcall glVertex4f,[x],[y],0.0,1.0	26	stdcall glVertex4f,[x],[y],0.0,1.0
27	ret	27	ret
28	endp	28	endp
29		29
30	align 4	30	align 4
31	proc glVertex2fv uses eax, v:dword	31	proc glVertex2fv uses eax, v:dword
32	mov eax,[v]	32	mov eax,[v]
33	stdcall glVertex4f,[eax],[eax+4],0.0,1.0	33	stdcall glVertex4f,[eax],[eax+4],0.0,1.0
34	ret	34	ret
35	endp	35	endp
36		36
37	align 4	37	align 4
38	proc glVertex3f, x:dword, y:dword, z:dword	38	proc glVertex3f, x:dword, y:dword, z:dword
39	stdcall glVertex4f,[x],[y],[z],1.0	39	stdcall glVertex4f,[x],[y],[z],1.0
40	ret	40	ret
41	endp	41	endp
42		42
43	align 4	43	align 4
44	proc glVertex3fv uses eax, v:dword	44	proc glVertex3fv uses eax, v:dword
45	mov eax,[v]	45	mov eax,[v]
46	stdcall glVertex4f,[eax],[eax+4],[eax+8],1.0	46	stdcall glVertex4f,[eax],[eax+4],[eax+8],1.0
47	ret	47	ret
48	endp	48	endp
49		49
50	align 4	50	align 4
51	proc glVertex4fv uses eax, v:dword	51	proc glVertex4fv uses eax, v:dword
52	mov eax,[v]	52	mov eax,[v]
53	stdcall glVertex4f,[eax],[eax+4],[eax+8],[eax+12]	53	stdcall glVertex4f,[eax],[eax+4],[eax+8],[eax+12]
54	ret	54	ret
55	endp	55	endp
56		56
57	; glNormal	57	; glNormal
58		58
59	align 4	59	align 4
60	proc glNormal3f uses eax, x:dword, y:dword, z:dword	60	proc glNormal3f uses eax, x:dword, y:dword, z:dword
61	locals	61	locals
62	p rd 4	62	p rd 4
63	endl	63	endl
64	mov dword[p],OP_Normal	64	mov dword[p],OP_Normal
65	mov eax,[x]	65	mov eax,[x]
66	mov dword[p+4],eax	66	mov dword[p+4],eax
67	mov eax,[y]	67	mov eax,[y]
68	mov dword[p+8],eax	68	mov dword[p+8],eax
69	mov eax,[z]	69	mov eax,[z]
70	mov dword[p+12],eax	70	mov dword[p+12],eax
71		71
72	mov eax,ebp	72	mov eax,ebp
73	sub eax,16 ;=sizeof(dd)*4	73	sub eax,16 ;=sizeof(dd)*4
74	stdcall gl_add_op,eax	74	stdcall gl_add_op,eax
75	ret	75	ret
76	endp	76	endp
77		77
78	align 4	78	align 4
79	proc glNormal3fv uses eax, v:dword	79	proc glNormal3fv uses eax, v:dword
80	mov eax,[v]	80	mov eax,[v]
81	stdcall glNormal3f,[eax],[eax+4],[eax+8]	81	stdcall glNormal3f,[eax],[eax+4],[eax+8]
82	ret	82	ret
83	endp	83	endp
84		84
85	; glColor	85	; glColor
86		86
87	align 4	87	align 4
88	proc glColor4f uses eax, r:dword, g:dword, b:dword, a:dword	88	proc glColor4f uses eax, r:dword, g:dword, b:dword, a:dword
89	locals	89	locals
90	p rd 8	90	p rd 8
91	endl	91	endl
92	mov dword[p],OP_Color	92	mov dword[p],OP_Color
93	mov eax,[b]	93	mov eax,[b]
94	mov dword[p+4],eax	94	mov dword[p+4],eax
95	mov eax,[g]	95	mov eax,[g]
96	mov dword[p+8],eax	96	mov dword[p+8],eax
97	mov eax,[r]	97	mov eax,[r]
98	mov dword[p+12],eax	98	mov dword[p+12],eax
99	mov eax,[a]	99	mov eax,[a]
100	mov dword[p+16],eax	100	mov dword[p+16],eax
101	; direct convertion to integer to go faster if no shading	101	; direct convertion to integer to go faster if no shading
102	mov eax,ebp	102	mov eax,ebp
103	sub eax,12 ;ebp-12 = &p[5]	103	sub eax,12 ;ebp-12 = &p[5]
104	push eax	104	push eax
105	add eax,4 ;ebp-8 = &p[6]	105	add eax,4 ;ebp-8 = &p[6]
106	push eax	106	push eax
107	add eax,4 ;ebp-4 = &p[7]	107	add eax,4 ;ebp-4 = &p[7]
108	push eax	108	push eax
109	stdcall RGBFtoRGBI,[r],[g],[b] ;call: r,g,b,&p[7],&p[6],&p[5]	109	stdcall RGBFtoRGBI,[r],[g],[b] ;call: r,g,b,&p[7],&p[6],&p[5]
110		110
111	mov eax,ebp	111	mov eax,ebp
112	sub eax,32 ;=sizeof(dd)*8	112	sub eax,32 ;=sizeof(dd)*8
113	stdcall gl_add_op,eax	113	stdcall gl_add_op,eax
114	ret	114	ret
115	endp	115	endp
116		116
117	align 4	117	align 4
118	proc glColor4fv uses eax ebx, v:dword	118	proc glColor4fv uses eax ebx, v:dword
119	locals	119	locals
120	p rd 8	120	p rd 8
121	endl	121	endl
122	mov dword[p],OP_Color	122	mov dword[p],OP_Color
123	mov eax,[v]	123	mov eax,[v]
124	mov ebx,[eax+8]	124	mov ebx,[eax+8]
125	mov dword[p+4],ebx	125	mov dword[p+4],ebx
126	mov ebx,[eax+4]	126	mov ebx,[eax+4]
127	mov dword[p+8],ebx	127	mov dword[p+8],ebx
128	mov ebx,[eax]	128	mov ebx,[eax]
129	mov dword[p+12],ebx	129	mov dword[p+12],ebx
130	mov ebx,[eax+12]	130	mov ebx,[eax+12]
131	mov dword[p+16],ebx	131	mov dword[p+16],ebx
132	; direct convertion to integer to go faster if no shading	132	; direct convertion to integer to go faster if no shading
133	mov eax,ebp	133	mov eax,ebp
134	sub eax,4	134	sub eax,4
135	push eax ;&p[7]	135	push eax ;&p[7]
136	sub eax,4	136	sub eax,4
137	push eax ;&p[6]	137	push eax ;&p[6]
138	sub eax,4	138	sub eax,4
139	push eax ;&p[5]	139	push eax ;&p[5]
140	stdcall RGBFtoRGBI,[eax+8],[eax+4],[eax] ;call: v[2],v[1],v[0],p[5],p[6],p[7]	140	stdcall RGBFtoRGBI,[eax+8],[eax+4],[eax] ;call: v[2],v[1],v[0],p[5],p[6],p[7]
141		141
142	mov eax,ebp	142	mov eax,ebp
143	sub eax,32 ;=sizeof(dd)*8	143	sub eax,32 ;=sizeof(dd)*8
144	stdcall gl_add_op,eax	144	stdcall gl_add_op,eax
145	ret	145	ret
146	endp	146	endp
147		147
148	align 4	148	align 4
149	proc glColor3f, r:dword, g:dword, b:dword	149	proc glColor3f, r:dword, g:dword, b:dword
150	stdcall glColor4f,[r],[g],[b],1.0	150	stdcall glColor4f,[r],[g],[b],1.0
151	ret	151	ret
152	endp	152	endp
153		153
154	align 4	154	align 4
155	proc glColor3fv uses eax, v:dword	155	proc glColor3fv uses eax, v:dword
156	mov eax,[v]	156	mov eax,[v]
157	stdcall glColor4f,[eax],[eax+4],[eax+8],1.0	157	stdcall glColor4f,[eax],[eax+4],[eax+8],1.0
158	ret	158	ret
159	endp	159	endp
-		160
-		161	align 4
-		162	fl_255 dd 255.0
-		163
-		164	align 4
-		165	proc glColor3ub uses eax, r:dword, g:dword, b:dword
-		166	push dword 1.0
-		167	fld dword[fl_255]
-		168
-		169	movzx eax,byte[b]
-		170	mov dword[esp-4],eax
-		171	fild dword[esp-4]
-		172	fdiv st0,st1
-		173	fstp dword[esp-4] ;преобразовали int во float
-		174	movzx eax,byte[g]
-		175	mov dword[esp-8],eax
-		176	fild dword[esp-8]
-		177	fdiv st0,st1
-		178	fstp dword[esp-8]
-		179	movzx eax,byte[r]
-		180	mov dword[esp-12],eax
-		181	fild dword[esp-12]
-		182	fdiv st0,st1
-		183	fstp dword[esp-12]
-		184
-		185	ffree st0
-		186	fincstp
-		187	sub esp,12
-		188	call glColor4f
-		189	ret
-		190	endp
160		191
161	; TexCoord	192	; TexCoord
162		193
163	align 4	194	align 4
164	proc glTexCoord4f uses eax, s:dword, t:dword, r:dword, q:dword	195	proc glTexCoord4f uses eax, s:dword, t:dword, r:dword, q:dword
165	locals	196	locals
166	p rd 5	197	p rd 5
167	endl	198	endl
168	mov dword[p],OP_TexCoord	199	mov dword[p],OP_TexCoord
169	mov eax,[s]	200	mov eax,[s]
170	mov dword[p+4],eax	201	mov dword[p+4],eax
171	mov eax,[t]	202	mov eax,[t]
172	mov dword[p+8],eax	203	mov dword[p+8],eax
173	mov eax,[r]	204	mov eax,[r]
174	mov dword[p+12],eax	205	mov dword[p+12],eax
175	mov eax,[q]	206	mov eax,[q]
176	mov dword[p+16],eax	207	mov dword[p+16],eax
177		208
178	mov eax,ebp	209	mov eax,ebp
179	sub eax,20 ;=sizeof(dd)*5	210	sub eax,20 ;=sizeof(dd)*5
180	stdcall gl_add_op,eax	211	stdcall gl_add_op,eax
181	ret	212	ret
182	endp	213	endp
183		214
184	align 4	215	align 4
185	proc glTexCoord2f, s:dword, t:dword	216	proc glTexCoord2f, s:dword, t:dword
186	stdcall glTexCoord4f,[s],[t],0.0,1.0	217	stdcall glTexCoord4f,[s],[t],0.0,1.0
187	ret	218	ret
188	endp	219	endp
189		220
190	align 4	221	align 4
191	proc glTexCoord2fv uses eax, v:dword	222	proc glTexCoord2fv uses eax, v:dword
192	mov eax,[v]	223	mov eax,[v]
193	stdcall glTexCoord4f,[eax],[eax+4],0.0,1.0	224	stdcall glTexCoord4f,[eax],[eax+4],0.0,1.0
194	ret	225	ret
195	endp	226	endp
196		227
197	align 4	228	align 4
198	proc glEdgeFlag uses eax, flag:dword	229	proc glEdgeFlag uses eax, flag:dword
199	locals	230	locals
200	p rd 2	231	p rd 2
201	endl	232	endl
202	mov dword[p],OP_EdgeFlag	233	mov dword[p],OP_EdgeFlag
203	mov eax,[flag]	234	mov eax,[flag]
204	mov dword[p+4],eax	235	mov dword[p+4],eax
205		236
206	mov eax,ebp	237	mov eax,ebp
207	sub eax,8 ;=sizeof(dd)*2	238	sub eax,8 ;=sizeof(dd)*2
208	stdcall gl_add_op,eax	239	stdcall gl_add_op,eax
209	ret	240	ret
210	endp	241	endp
211		242
212	; misc	243	; misc
213		244
214	align 4	245	align 4
215	proc glShadeModel uses eax, mode:dword	246	proc glShadeModel uses eax, mode:dword
216	locals	247	locals
217	p rd 2	248	p rd 2
218	endl	249	endl
219		250
220	; assert(mode == GL_FLAT \|\| mode == GL_SMOOTH);	251	; assert(mode == GL_FLAT \|\| mode == GL_SMOOTH);
221		252
222	mov dword[p],OP_ShadeModel	253	mov dword[p],OP_ShadeModel
223	mov eax,[mode]	254	mov eax,[mode]
224	mov dword[p+4],eax	255	mov dword[p+4],eax
225		256
226	mov eax,ebp	257	mov eax,ebp
227	sub eax,8 ;=sizeof(dd)*2	258	sub eax,8 ;=sizeof(dd)*2
228	stdcall gl_add_op,eax	259	stdcall gl_add_op,eax
229	ret	260	ret
230	endp	261	endp
231		262
232	align 4	263	align 4
233	proc glCullFace uses eax, mode:dword	264	proc glCullFace uses eax, mode:dword
234	locals	265	locals
235	p rd 2	266	p rd 2
236	endl	267	endl
237		268
238	; assert(mode == GL_BACK \|\|	269	; assert(mode == GL_BACK \|\|
239	; mode == GL_FRONT \|\|	270	; mode == GL_FRONT \|\|
240	; mode == GL_FRONT_AND_BACK);	271	; mode == GL_FRONT_AND_BACK);
241		272
242	mov dword[p],OP_CullFace	273	mov dword[p],OP_CullFace
243	mov eax,[mode]	274	mov eax,[mode]
244	mov dword[p+4],eax	275	mov dword[p+4],eax
245		276
246	mov eax,ebp	277	mov eax,ebp
247	sub eax,8 ;=sizeof(dd)*2	278	sub eax,8 ;=sizeof(dd)*2
248	stdcall gl_add_op,eax	279	stdcall gl_add_op,eax
249	ret	280	ret
250	endp	281	endp
251		282
252	align 4	283	align 4
253	proc glFrontFace uses eax, mode:dword	284	proc glFrontFace uses eax, mode:dword
254	locals	285	locals
255	p rd 2	286	p rd 2
256	endl	287	endl
257		288
258	; assert(mode == GL_CCW \|\| mode == GL_CW);	289	; assert(mode == GL_CCW \|\| mode == GL_CW);
259		290
260	mov dword[p],OP_FrontFace	291	mov dword[p],OP_FrontFace
261	xor eax,eax	292	xor eax,eax
262	cmp dword[mode],GL_CCW	293	cmp dword[mode],GL_CCW
263	je @f	294	je @f
264	inc eax	295	inc eax
265	@@:	296	@@:
266	mov dword[p+4],eax	297	mov dword[p+4],eax
267		298
268	mov eax,ebp	299	mov eax,ebp
269	sub eax,8 ;=sizeof(dd)*2	300	sub eax,8 ;=sizeof(dd)*2
270	stdcall gl_add_op,eax	301	stdcall gl_add_op,eax
271	ret	302	ret
272	endp	303	endp
273		304
274	align 4	305	align 4
275	proc glPolygonMode uses eax, face:dword, mode:dword	306	proc glPolygonMode uses eax, face:dword, mode:dword
276	locals	307	locals
277	p rd 3	308	p rd 3
278	endl	309	endl
279		310
280	; assert(face == GL_BACK \|\|	311	; assert(face == GL_BACK \|\|
281	; face == GL_FRONT \|\|	312	; face == GL_FRONT \|\|
282	; face == GL_FRONT_AND_BACK);	313	; face == GL_FRONT_AND_BACK);
283	; assert(mode == GL_POINT \|\| mode == GL_LINE \|\| mode==GL_FILL);	314	; assert(mode == GL_POINT \|\| mode == GL_LINE \|\| mode==GL_FILL);
284		315
285	mov dword[p],OP_PolygonMode	316	mov dword[p],OP_PolygonMode
286	mov eax,[face]	317	mov eax,[face]
287	mov dword[p+4],eax	318	mov dword[p+4],eax
288	mov eax,[mode]	319	mov eax,[mode]
289	mov dword[p+8],eax	320	mov dword[p+8],eax
290		321
291	mov eax,ebp	322	mov eax,ebp
292	sub eax,12 ;=sizeof(dd)*3	323	sub eax,12 ;=sizeof(dd)*3
293	stdcall gl_add_op,eax	324	stdcall gl_add_op,eax
294	ret	325	ret
295	endp	326	endp
296		327
297	; glEnable / glDisable	328	; glEnable / glDisable
298		329
299	align 4	330	align 4
300	proc glEnable uses eax, cap:dword	331	proc glEnable uses eax, cap:dword
301	locals	332	locals
302	p rd 3	333	p rd 3
303	endl	334	endl
304	mov dword[p],OP_EnableDisable	335	mov dword[p],OP_EnableDisable
305	mov eax,[cap]	336	mov eax,[cap]
306	mov dword[p+4],eax	337	mov dword[p+4],eax
307	mov dword[p+8],1	338	mov dword[p+8],1
308		339
309	mov eax,ebp	340	mov eax,ebp
310	sub eax,12 ;=sizeof(dd)*3	341	sub eax,12 ;=sizeof(dd)*3
311	stdcall gl_add_op,eax	342	stdcall gl_add_op,eax
312	ret	343	ret
313	endp	344	endp
314		345
315	align 4	346	align 4
316	proc glDisable uses eax, cap:dword	347	proc glDisable uses eax, cap:dword
317	locals	348	locals
318	p rd 3	349	p rd 3
319	endl	350	endl
320	mov dword[p],OP_EnableDisable	351	mov dword[p],OP_EnableDisable
321	mov eax,[cap]	352	mov eax,[cap]
322	mov dword[p+4],eax	353	mov dword[p+4],eax
323	mov dword[p+8],0	354	mov dword[p+8],0
324		355
325	mov eax,ebp	356	mov eax,ebp
326	sub eax,12 ;=sizeof(dd)*3	357	sub eax,12 ;=sizeof(dd)*3
327	stdcall gl_add_op,eax	358	stdcall gl_add_op,eax
328	ret	359	ret
329	endp	360	endp
330		361
331	; glBegin / glEnd	362	; glBegin / glEnd
332		363
333	align 4	364	align 4
334	proc glBegin uses eax, mode:dword	365	proc glBegin uses eax, mode:dword
335	locals	366	locals
336	p rd 2	367	p rd 2
337	endl	368	endl
338	mov dword[p],OP_Begin	369	mov dword[p],OP_Begin
339	mov eax,[mode]	370	mov eax,[mode]
340	mov dword[p+4],eax	371	mov dword[p+4],eax
341		372
342	mov eax,ebp	373	mov eax,ebp
343	sub eax,8 ;=sizeof(dd)*2	374	sub eax,8 ;=sizeof(dd)*2
344	stdcall gl_add_op,eax	375	stdcall gl_add_op,eax
345	ret	376	ret
346	endp	377	endp
347		378
348	align 4	379	align 4
349	proc glEnd uses eax	380	proc glEnd uses eax
350	locals	381	locals
351	p dd ?	382	p dd ?
352	endl	383	endl
353	mov dword[p],OP_End	384	mov dword[p],OP_End
354		385
355	mov eax,ebp	386	mov eax,ebp
356	sub eax,4 ;=sizeof(dd)*1	387	sub eax,4 ;=sizeof(dd)*1
357	stdcall gl_add_op,eax	388	stdcall gl_add_op,eax
358	ret	389	ret
359	endp	390	endp
360		391
361	; matrix	392	; matrix
362		393
363	align 4	394	align 4
364	proc glMatrixMode uses eax, mode:dword	395	proc glMatrixMode uses eax, mode:dword
365	locals	396	locals
366	p rd 2	397	p rd 2
367	endl	398	endl
368	mov dword[p],OP_MatrixMode	399	mov dword[p],OP_MatrixMode
369	mov eax,[mode]	400	mov eax,[mode]
370	mov dword[p+4],eax	401	mov dword[p+4],eax
371		402
372	mov eax,ebp	403	mov eax,ebp
373	sub eax,8 ;=sizeof(dd)*2	404	sub eax,8 ;=sizeof(dd)*2
374	stdcall gl_add_op,eax	405	stdcall gl_add_op,eax
375	ret	406	ret
376	endp	407	endp
377		408
378	align 4	409	align 4
379	proc glLoadMatrixf uses ecx edi esi, m:dword	410	proc glLoadMatrixf uses ecx edi esi, m:dword
380	locals	411	locals
381	p rd 17	412	p rd 17
382	endl	413	endl
383	mov dword[p],OP_LoadMatrix	414	mov dword[p],OP_LoadMatrix
384	mov ecx,16	415	mov ecx,16
385	mov esi,[m]	416	mov esi,[m]
386	mov edi,ebp	417	mov edi,ebp
387	sub edi,64 ;=sizeof(M4)	418	sub edi,64 ;=sizeof(M4)
388	rep movsd	419	rep movsd
389		420
390	mov ecx,ebp	421	mov ecx,ebp
391	sub ecx,68 ;=sizeof(dd)*17	422	sub ecx,68 ;=sizeof(dd)*17
392	stdcall gl_add_op,ecx	423	stdcall gl_add_op,ecx
393	ret	424	ret
394	endp	425	endp
395		426
396	align 4	427	align 4
397	proc glLoadIdentity uses eax	428	proc glLoadIdentity uses eax
398	locals	429	locals
399	p dd ?	430	p dd ?
400	endl	431	endl
401	mov dword[p],OP_LoadIdentity	432	mov dword[p],OP_LoadIdentity
402		433
403	mov eax,ebp	434	mov eax,ebp
404	sub eax,4 ;=sizeof(dd)*1	435	sub eax,4 ;=sizeof(dd)*1
405	stdcall gl_add_op,eax	436	stdcall gl_add_op,eax
406	ret	437	ret
407	endp	438	endp
408		439
409	align 4	440	align 4
410	proc glMultMatrixf uses ecx edi esi, m:dword	441	proc glMultMatrixf uses ecx edi esi, m:dword
411	locals	442	locals
412	p rd 17	443	p rd 17
413	endl	444	endl
414	mov dword[p],OP_MultMatrix	445	mov dword[p],OP_MultMatrix
415	mov ecx,16	446	mov ecx,16
416	mov esi,[m]	447	mov esi,[m]
417	mov edi,ebp	448	mov edi,ebp
418	sub edi,64 ;=sizeof(M4)	449	sub edi,64 ;=sizeof(M4)
419	rep movsd	450	rep movsd
420		451
421	mov ecx,ebp	452	mov ecx,ebp
422	sub ecx,68 ;=sizeof(dd)*17	453	sub ecx,68 ;=sizeof(dd)*17
423	stdcall gl_add_op,ecx	454	stdcall gl_add_op,ecx
424	ret	455	ret
425	endp	456	endp
426		457
427	align 4	458	align 4
428	proc glPushMatrix uses eax	459	proc glPushMatrix uses eax
429	locals	460	locals
430	p dd ?	461	p dd ?
431	endl	462	endl
432	mov dword[p],OP_PushMatrix	463	mov dword[p],OP_PushMatrix
433		464
434	mov eax,ebp	465	mov eax,ebp
435	sub eax,4 ;=sizeof(dd)*1	466	sub eax,4 ;=sizeof(dd)*1
436	stdcall gl_add_op,eax	467	stdcall gl_add_op,eax
437	ret	468	ret
438	endp	469	endp
439		470
440	align 4	471	align 4
441	proc glPopMatrix uses eax	472	proc glPopMatrix uses eax
442	locals	473	locals
443	p dd ?	474	p dd ?
444	endl	475	endl
445	mov dword[p],OP_PopMatrix	476	mov dword[p],OP_PopMatrix
446		477
447	mov eax,ebp	478	mov eax,ebp
448	sub eax,4 ;=sizeof(dd)*1	479	sub eax,4 ;=sizeof(dd)*1
449	stdcall gl_add_op,eax	480	stdcall gl_add_op,eax
450	ret	481	ret
451	endp	482	endp
452		483
453	align 4	484	align 4
454	proc glRotatef uses eax, angle:dword, x:dword, y:dword, z:dword	485	proc glRotatef uses eax, angle:dword, x:dword, y:dword, z:dword
455	locals	486	locals
456	p rd 5	487	p rd 5
457	endl	488	endl
458	mov dword[p],OP_Rotate	489	mov dword[p],OP_Rotate
459	mov eax,[angle]	490	mov eax,[angle]
460	mov dword[p+4],eax	491	mov dword[p+4],eax
461	mov eax,[x]	492	mov eax,[x]
462	mov dword[p+8],eax	493	mov dword[p+8],eax
463	mov eax,[y]	494	mov eax,[y]
464	mov dword[p+12],eax	495	mov dword[p+12],eax
465	mov eax,[z]	496	mov eax,[z]
466	mov dword[p+16],eax	497	mov dword[p+16],eax
467		498
468	mov eax,ebp	499	mov eax,ebp
469	sub eax,20 ;=sizeof(dd)*5	500	sub eax,20 ;=sizeof(dd)*5

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/TinyGL/asm_fork/api.asm – Rev 5353 → 5387