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:qword, right:qword, bottom:qword, top:qword,\
	near:qword, farv:qword
locals
	p rd 7
endl
	mov dword[p],OP_Frustum
	fld qword[left]
	fstp dword[p+4]
	fld qword[right]
	fstp dword[p+8]
	fld qword[bottom]
	fstp dword[p+12]
	fld qword[top]
	fstp dword[p+16]
	fld qword[near]
	fstp dword[p+20]
	fld qword[farv]
	fstp dword[p+24]
 
	mov eax,ebp
	sub eax,28 ;=sizeof(dd)*7
	stdcall gl_add_op,eax
	ret
endp
 
align 4
proc glOrtho uses eax, left:qword, right:qword, bottom:qword, top:qword,\
	near:qword, farv:qword
locals
	p rd 7
endl
	mov dword[p],OP_Ortho
	fld qword[left]
	fstp dword[p+4]
	fld qword[right]
	fstp dword[p+8]
	fld qword[bottom]
	fstp dword[p+12]
	fld qword[top]
	fstp dword[p+16]
	fld qword[near]
	fstp dword[p+20]
	fld qword[farv]
	fstp dword[p+24]
 
	lea eax,[ebp-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+GLContext.print_flag]
	ret
endp

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

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/TinyGL/asm_fork/api.asm – Rev 8059 → 8062