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

Subversion Repositories Kolibri OS

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