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

Subversion Repositories Kolibri OS

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