Subversion Repositories Kolibri OS

Rev

Rev 8062 | Rev 8408 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 8062 Rev 8063
Line 1... Line 1...
1 
; glVertex
1 
; glVertex
Line 2... Line 2...
2 
 
 2 
 
3 
align 4
 3 
align 4
4 
proc glVertex4f uses eax, x:dword, y:dword, z:dword, w:dword
 - 
 
5 
locals
 - 
 
6 
	p rd 5
 - 
 
7 
endl
 4 
glVertex4f: ;x, y, z, w
8 
	mov dword[p],OP_Vertex
 5 
	push dword[esp] ;копируем адрес возврата
9 
	mov eax,[x]
 - 
 
10 
	mov dword[p+4],eax
 6 
	push eax
11 
	mov eax,[y]
 7 
	lea eax,[esp+8]
12 
	mov dword[p+8],eax
 - 
 
13 
	mov eax,[z]
 - 
 
14 
	mov dword[p+12],eax
 - 
 
15 
	mov eax,[w]
 - 
 
16 
	mov dword[p+16],eax
 - 
 
17 
 
 - 
 
18 
	mov eax,ebp
 - 
 
19 
	sub eax,20 ;=sizeof(dd)*5
 8 
	mov dword[eax],OP_Vertex
20 
	stdcall gl_add_op,eax
 9 
	stdcall gl_add_op,eax
21 
	ret
 10 
	pop eax
Line 22... Line 11...
22 
endp
 11 
	ret 20 ;=sizeof(dd)*5
23 
 
 12 
 
24 
align 4
 13 
align 4
25 
proc glVertex2f, x:dword, y:dword
 14 
proc glVertex2f, x:dword, y:dword
Line 55... Line 44...
55 
endp
 44 
endp
Line 56... Line 45...
56 
 
 45 
 
Line 57... Line 46...
57 
; glNormal
 46 
; glNormal
58 
 
 47 
 
59 
align 4
 - 
 
60 
proc glNormal3f uses eax, x:dword, y:dword, z:dword
 - 
 
61 
locals
 - 
 
62 
	p rd 4
 48 
align 4
63 
endl
 49 
glNormal3f: ;x, y, z
64 
	mov dword[p],OP_Normal
 - 
 
65 
	mov eax,[x]
 50 
	push dword[esp] ;копируем адрес возврата
66 
	mov dword[p+4],eax
 51 
	push eax
67 
	mov eax,[y]
 - 
 
68 
	mov dword[p+8],eax
 - 
 
69 
	mov eax,[z]
 - 
 
70 
	mov dword[p+12],eax
 - 
 
71 
 
 - 
 
72 
	mov eax,ebp
 52 
	lea eax,[esp+8]
73 
	sub eax,16 ;=sizeof(dd)*4
 53 
	mov dword[eax],OP_Normal
74 
	stdcall gl_add_op,eax
 54 
	stdcall gl_add_op,eax
Line 75... Line 55...
75 
	ret
 55 
	pop eax
76 
endp
 56 
	ret 16 ;=sizeof(dd)*4
77 
 
 57 
 
78 
align 4
 58 
align 4
Line 97... Line 77...
97 
	mov eax,[r]
 77 
	mov eax,[r]
98 
	mov dword[p+12],eax
 78 
	mov dword[p+12],eax
99 
	mov eax,[a]
 79 
	mov eax,[a]
100 
	mov dword[p+16],eax
 80 
	mov dword[p+16],eax
101 
	; direct convertion to integer to go faster if no shading
 81 
	; direct convertion to integer to go faster if no shading
102 
	mov eax,ebp
 - 
 
103 
	sub eax,12 ;ebp-12 = &p[5]
 82 
	lea eax,[ebp-12] ;ebp-12 = &p[5]
104 
	push eax
 83 
	push eax
105 
	add eax,4 ;ebp-8 = &p[6]
 84 
	add eax,4 ;ebp-8 = &p[6]
106 
	push eax
 85 
	push eax
107 
	add eax,4 ;ebp-4 = &p[7]
 86 
	add eax,4 ;ebp-4 = &p[7]
108 
	push eax
 87 
	push eax
109 
	stdcall RGBFtoRGBI,[r],[g],[b] ;call: r,g,b,&p[7],&p[6],&p[5]
 88 
	stdcall RGBFtoRGBI,[r],[g],[b] ;call: r,g,b,&p[7],&p[6],&p[5]
Line 110... Line -...
110 
 
 - 
 
111 
	mov eax,ebp
 89 
 
112 
	sub eax,32 ;=sizeof(dd)*8
 90 
	lea eax,[ebp-32] ;=sizeof(dd)*8
113 
	stdcall gl_add_op,eax
 91 
	stdcall gl_add_op,eax
114 
	ret
 92 
	ret
Line 115... Line 93...
115 
endp
 93 
endp
Line 166... Line 144...
166 
endp
 144 
endp
Line 167... Line 145...
167 
 
 145 
 
Line 168... Line 146...
168 
; TexCoord
 146 
; TexCoord
169 
 
 147 
 
170 
align 4
 - 
 
171 
proc glTexCoord4f uses eax, s:dword, t:dword, r:dword, q:dword
 - 
 
172 
locals
 - 
 
173 
	p rd 5
 148 
align 4
174 
endl
 149 
glTexCoord4f: ;s, t, r, q
175 
	mov dword[p],OP_TexCoord
 - 
 
176 
	mov eax,[s]
 150 
	push dword[esp] ;копируем адрес возврата
177 
	mov dword[p+4],eax
 151 
	push eax
178 
	mov eax,[t]
 - 
 
179 
	mov dword[p+8],eax
 - 
 
180 
	mov eax,[r]
 - 
 
181 
	mov dword[p+12],eax
 - 
 
182 
	mov eax,[q]
 - 
 
183 
	mov dword[p+16],eax
 - 
 
184 
 
 - 
 
185 
	mov eax,ebp
 152 
	lea eax,[esp+8]
186 
	sub eax,20 ;=sizeof(dd)*5
 153 
	mov dword[eax],OP_TexCoord
187 
	stdcall gl_add_op,eax
 154 
	stdcall gl_add_op,eax
Line 188... Line 155...
188 
	ret
 155 
	pop eax
189 
endp
 156 
	ret 20 ;=sizeof(dd)*5
190 
 
 157 
 
191 
align 4
 158 
align 4
Line 200... Line 167...
200 
	stdcall glTexCoord4f,[eax],[eax+4],0.0,1.0
 167 
	stdcall glTexCoord4f,[eax],[eax+4],0.0,1.0
201 
	ret
 168 
	ret
202 
endp
 169 
endp
Line 203... Line 170...
203 
 
 170 
 
204 
align 4
 171 
align 4
205 
proc glEdgeFlag uses eax, flag:dword
 - 
 
- 
 
 172 
glEdgeFlag: ;flag
206 
locals
 173 
	push dword[esp] ;копируем адрес возврата
207 
	p rd 2
 - 
 
208 
endl
 - 
 
209 
	mov dword[p],OP_EdgeFlag
 174 
	push eax
210 
	mov eax,[flag]
 175 
	lea eax,[esp+8]
211 
	mov dword[p+4],eax
 - 
 
212 
 
 - 
 
213 
	mov eax,ebp
 - 
 
214 
	sub eax,8 ;=sizeof(dd)*2
 176 
	mov dword[eax],OP_EdgeFlag
215 
	stdcall gl_add_op,eax
 177 
	stdcall gl_add_op,eax
216 
	ret
 178 
	pop eax
Line 217... Line 179...
217 
endp
 179 
	ret 8 ;=sizeof(dd)*2
Line 218... Line 180...
218 
 
 180 
 
219 
; misc
 181 
; misc
220 
 
 - 
 
221 
align 4
 - 
 
222 
proc glShadeModel uses eax, mode:dword
 - 
 
223 
locals
 - 
 
224 
	p rd 2
 182 
 
225 
endl
 - 
 
226 
 
 183 
align 4
227 
;  assert(mode == GL_FLAT || mode == GL_SMOOTH);
 184 
glShadeModel: ;mode
228 
 
 - 
 
229 
	mov dword[p],OP_ShadeModel
 - 
 
230 
	mov eax,[mode]
 185 
;  assert(mode == GL_FLAT || mode == GL_SMOOTH);
231 
	mov dword[p+4],eax
 186 
	push dword[esp] ;копируем адрес возврата
232 
 
 187 
	push eax
233 
	mov eax,ebp
 188 
	lea eax,[esp+8]
234 
	sub eax,8 ;=sizeof(dd)*2
 189 
	mov dword[eax],OP_ShadeModel
Line 235... Line 190...
235 
	stdcall gl_add_op,eax
 190 
	stdcall gl_add_op,eax
236 
	ret
 191 
	pop eax
237 
endp
 - 
 
238 
 
 - 
 
239 
align 4
 - 
 
240 
proc glCullFace uses eax, mode:dword
 - 
 
241 
locals
 192 
	ret 8 ;=sizeof(dd)*2
242 
	p rd 2
 193 
 
243 
endl
 194 
align 4
244 
 
 - 
 
245 
;  assert(mode == GL_BACK ||
195 
glCullFace: ;mode
246 
;         mode == GL_FRONT ||
196 
;  assert(mode == GL_BACK ||
247 
;         mode == GL_FRONT_AND_BACK);
 - 
 
248 
 
 - 
 
249 
	mov dword[p],OP_CullFace
 197 
;         mode == GL_FRONT ||
250 
	mov eax,[mode]
 198 
;         mode == GL_FRONT_AND_BACK);
251 
	mov dword[p+4],eax
 199 
	push dword[esp] ;копируем адрес возврата
252 
 
 200 
	push eax
253 
	mov eax,ebp
 201 
	lea eax,[esp+8]
Line 254... Line 202...
254 
	sub eax,8 ;=sizeof(dd)*2
 202 
	mov dword[eax],OP_CullFace
255 
	stdcall gl_add_op,eax
 203 
	stdcall gl_add_op,eax
256 
	ret
 204 
	pop eax
257 
endp
 205 
	ret 8 ;=sizeof(dd)*2
Line 270... Line 218...
270 
	je @f
 218 
	je @f
271 
		inc eax
 219 
		inc eax
272 
	@@:
 220 
	@@:
273 
	mov dword[p+4],eax
 221 
	mov dword[p+4],eax
Line 274... Line -...
274 
 
 - 
 
275 
	mov eax,ebp
 222 
 
276 
	sub eax,8 ;=sizeof(dd)*2
 223 
	lea eax,[ebp-8] ;=sizeof(dd)*2
277 
	stdcall gl_add_op,eax
 224 
	stdcall gl_add_op,eax
278 
	ret
 225 
	ret
Line 279... Line 226...
279 
endp
 226 
endp
280 
 
 227 
 
281 
align 4
 - 
 
282 
proc glPolygonMode uses eax, face:dword, mode:dword
 - 
 
283 
locals
 - 
 
284 
	p rd 3
 - 
 
285 
endl
 228 
align 4
286 
 
 229 
glPolygonMode: ;face, mode
287 
;  assert(face == GL_BACK ||
230 
;  assert(face == GL_BACK ||
288 
;         face == GL_FRONT ||
231 
;         face == GL_FRONT ||
289 
;         face == GL_FRONT_AND_BACK);
 - 
 
290 
;  assert(mode == GL_POINT || mode == GL_LINE || mode==GL_FILL);
 232 
;         face == GL_FRONT_AND_BACK);
291 
 
 233 
;  assert(mode == GL_POINT || mode == GL_LINE || mode==GL_FILL);
292 
	mov dword[p],OP_PolygonMode
 - 
 
293 
	mov eax,[face]
 234 
	push dword[esp] ;копируем адрес возврата
294 
	mov dword[p+4],eax
 235 
	push eax
295 
	mov eax,[mode]
 - 
 
296 
	mov dword[p+8],eax
 - 
 
297 
 
 - 
 
298 
	mov eax,ebp
 236 
	lea eax,[esp+8]
299 
	sub eax,12 ;=sizeof(dd)*3
 237 
	mov dword[eax],OP_PolygonMode
300 
	stdcall gl_add_op,eax
 238 
	stdcall gl_add_op,eax
Line 301... Line 239...
301 
	ret
 239 
	pop eax
Line 302... Line 240...
302 
endp
 240 
	ret 12 ;=sizeof(dd)*3
303 
 
 241 
 
Line 311... Line 249...
311 
	mov dword[p],OP_EnableDisable
 249 
	mov dword[p],OP_EnableDisable
312 
	mov eax,[cap]
 250 
	mov eax,[cap]
313 
	mov dword[p+4],eax
 251 
	mov dword[p+4],eax
314 
	mov dword[p+8],1
 252 
	mov dword[p+8],1
Line 315... Line -...
315 
 
 - 
 
316 
	mov eax,ebp
 253 
 
317 
	sub eax,12 ;=sizeof(dd)*3
 254 
	lea eax,[ebp-12] ;=sizeof(dd)*3
318 
	stdcall gl_add_op,eax
 255 
	stdcall gl_add_op,eax
319 
	ret
 256 
	ret
Line 320... Line 257...
320 
endp
 257 
endp
Line 327... Line 264...
327 
	mov dword[p],OP_EnableDisable
 264 
	mov dword[p],OP_EnableDisable
328 
	mov eax,[cap]
 265 
	mov eax,[cap]
329 
	mov dword[p+4],eax
 266 
	mov dword[p+4],eax
330 
	mov dword[p+8],0
 267 
	mov dword[p+8],0
Line 331... Line -...
331 
 
 - 
 
332 
	mov eax,ebp
 268 
 
333 
	sub eax,12 ;=sizeof(dd)*3
 269 
	lea eax,[ebp-12] ;=sizeof(dd)*3
334 
	stdcall gl_add_op,eax
 270 
	stdcall gl_add_op,eax
335 
	ret
 271 
	ret
Line 336... Line 272...
336 
endp
 272 
endp
Line 337... Line 273...
337 
 
 273 
 
338 
; glBegin / glEnd
 274 
; glBegin / glEnd
339 
 
 - 
 
- 
 
 275 
 
340 
align 4
 276 
align 4
341 
proc glBegin uses eax, mode:dword
 - 
 
342 
locals
 - 
 
343 
	p rd 2
 277 
glBegin: ;mode
344 
endl
 278 
	push dword[esp] ;копируем адрес возврата
345 
	mov dword[p],OP_Begin
 - 
 
346 
	mov eax,[mode]
 - 
 
347 
	mov dword[p+4],eax
 - 
 
348 
 
 279 
	push eax
349 
	mov eax,ebp
 280 
	lea eax,[esp+8]
350 
	sub eax,8 ;=sizeof(dd)*2
 281 
	mov dword[eax],OP_Begin
Line 351... Line 282...
351 
	stdcall gl_add_op,eax
 282 
	stdcall gl_add_op,eax
352 
	ret
 - 
 
353 
endp
 - 
 
354 
 
 - 
 
355 
align 4
 283 
	pop eax
356 
proc glEnd uses eax
 - 
 
357 
locals
 - 
 
358 
	p dd ?
 - 
 
359 
endl
 - 
 
360 
	mov dword[p],OP_End
 284 
	ret 8 ;=sizeof(dd)*2
361 
 
 285 
 
362 
	mov eax,ebp
 - 
 
Line 363... Line 286...
363 
	sub eax,4 ;=sizeof(dd)*1
 286 
align 4
Line 364... Line 287...
364 
	stdcall gl_add_op,eax
 287 
glEnd:
365 
	ret
 288 
	stdcall gl_add_op,op_End
366 
endp
 - 
 
- 
 
 289 
	ret
367 
 
 290 
 
368 
; matrix
 - 
 
369 
 
 - 
 
370 
align 4
 291 
; matrix
371 
proc glMatrixMode uses eax, mode:dword
 292 
 
372 
locals
 - 
 
373 
	p rd 2
 - 
 
374 
endl
 - 
 
375 
	mov dword[p],OP_MatrixMode
 293 
align 4
376 
	mov eax,[mode]
 294 
glMatrixMode: ;mode
377 
	mov dword[p+4],eax
 295 
	push dword[esp] ;копируем адрес возврата
Line 378... Line 296...
378 
 
 296 
	push eax
379 
	mov eax,ebp
 297 
	lea eax,[esp+8]
380 
	sub eax,8 ;=sizeof(dd)*2
 298 
	mov dword[eax],OP_MatrixMode
381 
	stdcall gl_add_op,eax
 299 
	stdcall gl_add_op,eax
Line 392... Line 310...
392 
	mov esi,[m]
 310 
	mov esi,[m]
393 
	mov edi,ebp
 311 
	mov edi,ebp
394 
	sub edi,64 ;=sizeof(M4)
 312 
	sub edi,64 ;=sizeof(M4)
395 
	rep movsd
 313 
	rep movsd
Line 396... Line -...
396 
 
 - 
 
397 
	mov ecx,ebp
 314 
 
398 
	sub ecx,68 ;=sizeof(dd)*17
 315 
	lea ecx,[ebp-68] ;=sizeof(dd)*17
399 
	stdcall gl_add_op,ecx
 316 
	stdcall gl_add_op,ecx
400 
	ret
 317 
	ret
Line 401... Line 318...
401 
endp
 318 
endp
402 
 
 319 
 
403 
align 4
 - 
 
404 
proc glLoadIdentity uses eax
 - 
 
405 
locals
 - 
 
406 
	p dd ?
 - 
 
407 
endl
 - 
 
408 
	mov dword[p],OP_LoadIdentity
 - 
 
409 
 
 - 
 
410 
	mov eax,ebp
 320 
align 4
411 
	sub eax,4 ;=sizeof(dd)*1
 321 
glLoadIdentity:
412 
	stdcall gl_add_op,eax
 - 
 
Line 413... Line 322...
413 
	ret
 322 
	stdcall gl_add_op,op_LoadIdentity
414 
endp
 323 
	ret
415 
 
 324 
 
416 
align 4
 325 
align 4
Line 423... Line 332...
423 
	mov esi,[m]
 332 
	mov esi,[m]
424 
	mov edi,ebp
 333 
	mov edi,ebp
425 
	sub edi,64 ;=sizeof(M4)
 334 
	sub edi,64 ;=sizeof(M4)
426 
	rep movsd
 335 
	rep movsd
Line 427... Line -...
427 
 
 - 
 
428 
	mov ecx,ebp
 336 
 
429 
	sub ecx,68 ;=sizeof(dd)*17
 337 
	lea ecx,[ebp-68] ;=sizeof(dd)*17
430 
	stdcall gl_add_op,ecx
 338 
	stdcall gl_add_op,ecx
431 
	ret
 339 
	ret
Line 432... Line 340...
432 
endp
 340 
endp
433 
 
 341 
 
434 
align 4
 - 
 
435 
proc glPushMatrix uses eax
 - 
 
436 
locals
 - 
 
437 
	p dd ?
 - 
 
438 
endl
 - 
 
439 
	mov dword[p],OP_PushMatrix
 - 
 
440 
 
 - 
 
441 
	mov eax,ebp
 342 
align 4
442 
	sub eax,4 ;=sizeof(dd)*1
 343 
glPushMatrix:
443 
	stdcall gl_add_op,eax
 - 
 
Line 444... Line 344...
444 
	ret
 344 
	stdcall gl_add_op,op_PushMatrix
445 
endp
 345 
	ret
446 
 
 - 
 
447 
align 4
 - 
 
448 
proc glPopMatrix uses eax
 - 
 
449 
locals
 - 
 
450 
	p dd ?
 - 
 
451 
endl
 - 
 
452 
	mov dword[p],OP_PopMatrix
 - 
 
453 
 
 346 
 
454 
	mov eax,ebp
 347 
align 4
455 
	sub eax,4 ;=sizeof(dd)*1
 - 
 
Line 456... Line 348...
456 
	stdcall gl_add_op,eax
 348 
glPopMatrix:
457 
	ret
 349 
	stdcall gl_add_op,op_PopMatrix
458 
endp
 - 
 
459 
 
 - 
 
460 
align 4
 - 
 
461 
proc glRotatef uses eax, angle:dword, x:dword, y:dword, z:dword
 350 
	ret
462 
locals
 - 
 
463 
	p rd 5
 - 
 
464 
endl
 - 
 
465 
	mov dword[p],OP_Rotate
 - 
 
466 
	mov eax,[angle]
 351 
 
467 
	mov dword[p+4],eax
 - 
 
468 
	mov eax,[x]
 352 
align 4
469 
	mov dword[p+8],eax
 353 
glRotatef: ;angle, x, y, z
470 
	mov eax,[y]
 - 
 
471 
	mov dword[p+12],eax
 - 
 
472 
	mov eax,[z]
 - 
 
473 
	mov dword[p+16],eax
 354 
	push dword[esp] ;копируем адрес возврата
474 
 
 355 
	push eax
475 
	mov eax,ebp
 356 
	lea eax,[esp+8]
Line 476... Line 357...
476 
	sub eax,20 ;=sizeof(dd)*5
 357 
	mov dword[eax],OP_Rotate
477 
	stdcall gl_add_op,eax
 358 
	stdcall gl_add_op,eax
478 
	ret
 - 
 
479 
endp
 - 
 
480 
 
 - 
 
481 
align 4
 359 
	pop eax
482 
proc glTranslatef uses eax, x:dword, y:dword, z:dword
 360 
	ret 20 ;=sizeof(dd)*5
483 
locals
 - 
 
484 
	p rd 4
 361 
 
485 
endl
 362 
align 4
486 
	mov dword[p],OP_Translate
 - 
 
487 
	mov eax,[x]
 - 
 
488 
	mov dword[p+4],eax
 - 
 
489 
	mov eax,[y]
 - 
 
490 
	mov dword[p+8],eax
 - 
 
491 
	mov eax,[z]
 363 
glTranslatef: ;x, y, z
492 
	mov dword[p+12],eax
 364 
	push dword[esp] ;копируем адрес возврата
493 
 
 365 
	push eax
Line 494... Line 366...
494 
	mov eax,ebp
 366 
	lea eax,[esp+8]
495 
	sub eax,16 ;=sizeof(dd)*4
 367 
	mov dword[eax],OP_Translate
496 
	stdcall gl_add_op,eax
 - 
 
497 
	ret
 - 
 
498 
endp
 - 
 
499 
 
 368 
	stdcall gl_add_op,eax
500 
align 4
 369 
	pop eax
501 
proc glScalef uses eax, x:dword, y:dword, z:dword
 - 
 
502 
locals
 370 
	ret 16 ;=sizeof(dd)*4
503 
	p rd 4
 371 
 
504 
endl
 - 
 
505 
	mov dword[p],OP_Scale
 - 
 
506 
	mov eax,[x]
 - 
 
507 
	mov dword[p+4],eax
 - 
 
508 
	mov eax,[y]
 - 
 
509 
	mov dword[p+8],eax
 372 
align 4
510 
	mov eax,[z]
 373 
glScalef: ;x, y, z
511 
	mov dword[p+12],eax
 374 
	push dword[esp] ;копируем адрес возврата
Line 512... Line 375...
512 
 
 375 
	push eax
513 
	mov eax,ebp
 376 
	lea eax,[esp+8]
514 
	sub eax,16 ;=sizeof(dd)*4
 - 
 
515 
	stdcall gl_add_op,eax
 - 
 
516 
	ret
 - 
 
517 
endp
 377 
	mov dword[eax],OP_Scale
518 
 
 - 
 
519 
align 4
 - 
 
520 
proc glViewport uses eax, x:dword, y:dword, width:dword, heigh:dword
 378 
	stdcall gl_add_op,eax
521 
locals
 - 
 
522 
	p rd 5
 - 
 
523 
endl
 - 
 
524 
	mov dword[p],OP_Viewport
 379 
	pop eax
525 
	mov eax,[x]
 380 
	ret 16 ;=sizeof(dd)*4
526 
	mov dword[p+4],eax
 - 
 
527 
	mov eax,[y]
 - 
 
528 
	mov dword[p+8],eax
 - 
 
529 
	mov eax,[width]
 381 
 
530 
	mov dword[p+12],eax
 382 
align 4
531 
	mov eax,[heigh]
 383 
glViewport: ;x, y, width, heigh
Line 532... Line 384...
532 
	mov dword[p+16],eax
 384 
	push dword[esp] ;копируем адрес возврата
533 
 
 385 
	push eax
534 
	mov eax,ebp
 386 
	lea eax,[esp+8]
535 
	sub eax,20 ;=sizeof(dd)*5
 387 
	mov dword[eax],OP_Viewport
Line 555... Line 407...
555 
	fld qword[near]
 407 
	fld qword[near]
556 
	fstp dword[p+20]
 408 
	fstp dword[p+20]
557 
	fld qword[farv]
 409 
	fld qword[farv]
558 
	fstp dword[p+24]
 410 
	fstp dword[p+24]
Line 559... Line -...
559 
 
 - 
 
560 
	mov eax,ebp
 411 
 
561 
	sub eax,28 ;=sizeof(dd)*7
 412 
	lea eax,[ebp-28] ;=sizeof(dd)*7
562 
	stdcall gl_add_op,eax
 413 
	stdcall gl_add_op,eax
563 
	ret
 414 
	ret
Line 564... Line 415...
564 
endp
 415 
endp
Line 619... Line 470...
619 
		mov dword[p+16],0.0
 470 
		mov dword[p+16],0.0
620 
		mov dword[p+20],0.0
 471 
		mov dword[p+20],0.0
621 
		mov dword[p+24],0.0
 472 
		mov dword[p+24],0.0
622 
	@@:
 473 
	@@:
Line 623... Line -...
623 
 
 - 
 
624 
	mov eax,ebp
 474 
 
625 
	sub eax,28 ;=sizeof(dd)*7
 475 
	lea eax,[ebp-28] ;=sizeof(dd)*7
626 
	stdcall gl_add_op,eax
 476 
	stdcall gl_add_op,eax
627 
	ret
 477 
	ret
Line 628... Line 478...
628 
endp
 478 
endp
Line 641... Line 491...
641 
	mov dword[p+12],eax
 491 
	mov dword[p+12],eax
642 
	mov dword[p+16],0.0
 492 
	mov dword[p+16],0.0
643 
	mov dword[p+20],0.0
 493 
	mov dword[p+20],0.0
644 
	mov dword[p+24],0.0
 494 
	mov dword[p+24],0.0
Line 645... Line -...
645 
 
 - 
 
646 
	mov eax,ebp
 495 
 
647 
	sub eax,28 ;=sizeof(dd)*7
 496 
	lea eax,[ebp-28] ;=sizeof(dd)*7
648 
	stdcall gl_add_op,eax
 497 
	stdcall gl_add_op,eax
649 
	ret
 498 
	ret
Line 650... Line 499...
650 
endp
 499 
endp
651 
 
 500 
 
652 
align 4
 - 
 
653 
proc glColorMaterial uses eax, mode:dword, type:dword
 - 
 
654 
locals
 - 
 
655 
	p rd 3
 501 
align 4
656 
endl
 502 
glColorMaterial: ;mode, type
657 
	mov dword[p],OP_ColorMaterial
 - 
 
658 
	mov eax,[mode]
 503 
	push dword[esp] ;копируем адрес возврата
659 
	mov dword[p+4],eax
 504 
	push eax
660 
	mov eax,[type]
 - 
 
661 
	mov dword[p+8],eax
 - 
 
662 
 
 - 
 
663 
	mov eax,ebp
 505 
	lea eax,[esp+8]
664 
	sub eax,12 ;=sizeof(dd)*3
 506 
	mov dword[eax],OP_ColorMaterial
665 
	stdcall gl_add_op,eax
 507 
	stdcall gl_add_op,eax
Line 666... Line 508...
666 
	ret
 508 
	pop eax
667 
endp
 509 
	ret 12 ;=sizeof(dd)*3
668 
 
 510 
 
669 
align 4
 511 
align 4
Line 686... Line 528...
686 
	mov ecx,[eax+8]
 528 
	mov ecx,[eax+8]
687 
	mov dword[p+20],ecx
 529 
	mov dword[p+20],ecx
688 
	mov ecx,[eax+12]
 530 
	mov ecx,[eax+12]
689 
	mov dword[p+24],ecx
 531 
	mov dword[p+24],ecx
Line 690... Line -...
690 
 
 - 
 
691 
	mov eax,ebp
 532 
 
692 
	sub eax,28 ;=sizeof(dd)*7
 533 
	lea eax,[ebp-28] ;=sizeof(dd)*7
693 
	stdcall gl_add_op,eax
 534 
	stdcall gl_add_op,eax
694 
	ret
 535 
	ret
Line 695... Line 536...
695 
endp
 536 
endp
Line 708... Line 549...
708 
	mov dword[p+12],eax
 549 
	mov dword[p+12],eax
709 
	mov dword[p+16],0.0
 550 
	mov dword[p+16],0.0
710 
	mov dword[p+20],0.0
 551 
	mov dword[p+20],0.0
711 
	mov dword[p+24],0.0
 552 
	mov dword[p+24],0.0
Line 712... Line -...
712 
 
 - 
 
713 
	mov eax,ebp
 553 
 
714 
	sub eax,28 ;=sizeof(dd)*7
 554 
	lea eax,[ebp-28] ;=sizeof(dd)*7
715 
	stdcall gl_add_op,eax
 555 
	stdcall gl_add_op,eax
716 
	ret
 556 
	ret
Line 717... Line 557...
717 
endp
 557 
endp
Line 729... Line 569...
729 
 
 569 
 
730 
	mov dword[p+12],0.0
 570 
	mov dword[p+12],0.0
731 
	mov dword[p+16],0.0
 571 
	mov dword[p+16],0.0
Line 732... Line -...
732 
	mov dword[p+20],0.0
 - 
 
733 
 
 572 
	mov dword[p+20],0.0
734 
	mov eax,ebp
 573 
 
735 
	sub eax,24 ;=sizeof(dd)*6
 574 
	lea eax,[ebp-24] ;=sizeof(dd)*6
736 
	stdcall gl_add_op,eax
 575 
	stdcall gl_add_op,eax
Line 737... Line 576...
737 
	ret
 576 
	ret
Line 753... Line 592...
753 
	mov ecx,[eax+8]
 592 
	mov ecx,[eax+8]
754 
	mov dword[p+16],ecx
 593 
	mov dword[p+16],ecx
755 
	mov ecx,[eax+12]
 594 
	mov ecx,[eax+12]
756 
	mov dword[p+20],ecx
 595 
	mov dword[p+20],ecx
Line 757... Line -...
757 
 
 - 
 
758 
	mov eax,ebp
 596 
 
759 
	sub eax,24 ;=sizeof(dd)*6
 597 
	lea eax,[ebp-24] ;=sizeof(dd)*6
760 
	stdcall gl_add_op,eax
 598 
	stdcall gl_add_op,eax
761 
	ret
 599 
	ret
Line 762... Line 600...
762 
endp
 600 
endp
Line 763... Line 601...
763 
 
 601 
 
764 
; clear
 602 
; clear
765 
 
 - 
 
- 
 
 603 
 
766 
align 4
 604 
align 4
767 
proc glClear uses eax, mask:dword
 - 
 
768 
locals
 - 
 
769 
	p rd 2
 605 
glClear: ;mask
770 
endl
 606 
	push dword[esp] ;копируем адрес возврата
771 
	mov dword[p],OP_Clear
 - 
 
772 
	mov eax,[mask]
 - 
 
773 
	mov dword[p+4],eax
 - 
 
774 
 
 607 
	push eax
775 
	mov eax,ebp
 608 
	lea eax,[esp+8]
776 
	sub eax,8 ;=sizeof(dd)*2
 609 
	mov dword[eax],OP_Clear
Line 777... Line 610...
777 
	stdcall gl_add_op,eax
 610 
	stdcall gl_add_op,eax
778 
	ret
 611 
	pop eax
779 
endp
 612 
	ret 8 ;=sizeof(dd)*2
780 
 
 613 
 
Line 791... Line 624...
791 
	mov eax,[r]
 624 
	mov eax,[r]
792 
	mov dword[p+12],eax
 625 
	mov dword[p+12],eax
793 
	mov eax,[a]
 626 
	mov eax,[a]
794 
	mov dword[p+16],eax
 627 
	mov dword[p+16],eax
Line 795... Line -...
795 
 
 - 
 
796 
	mov eax,ebp
 628 
 
797 
	sub eax,20 ;=sizeof(dd)*5
 629 
	lea eax,[ebp-20] ;=sizeof(dd)*5
798 
	stdcall gl_add_op,eax
 630 
	stdcall gl_add_op,eax
799 
	ret
 631 
	ret
Line 800... Line 632...
800 
endp
 632 
endp
Line 807... Line 639...
807 
	mov dword[p],OP_ClearDepth
 639 
	mov dword[p],OP_ClearDepth
808 
	mov eax,[depth]
 640 
	mov eax,[depth]
809 
	fld qword[eax]
 641 
	fld qword[eax]
810 
	fstp dword[p+4]
 642 
	fstp dword[p+4]
Line 811... Line -...
811 
 
 - 
 
812 
	mov eax,ebp
 643 
 
813 
	sub eax,8 ;=sizeof(dd)*2
 644 
	lea eax,[ebp-8] ;=sizeof(dd)*2
814 
	stdcall gl_add_op,eax
 645 
	stdcall gl_add_op,eax
815 
	ret
 646 
	ret
Line 816... Line 647...
816 
endp
 647 
endp
Line 817... Line 648...
817 
 
 648 
 
818 
; textures
 - 
 
819 
 
 649 
; textures
820 
align 4
 650 
 
821 
proc glTexImage2D uses ecx edi esi,\
 - 
 
822 
	target:dword, level:dword, components:dword,\
 - 
 
823 
	width:dword, height:dword, border:dword,\
 651 
align 4
824 
	format:dword, type:dword, pixels:dword
 652 
glTexImage2D: ;target, level, components, width, height, border, format, type, pixels
825 
locals
 653 
	push dword[esp] ;копируем адрес возврата
826 
	p rd 10
 - 
 
827 
endl
 - 
 
828 
	mov dword[p],OP_TexImage2D
 - 
 
829 
	mov ecx,9
 654 
	push eax
830 
	mov esi,ebp
 - 
 
831 
	add esi,8 ;указатель на стек с входными параметрами
 - 
 
832 
	mov edi,ebp
 - 
 
833 
	sub edi,36 ;указатель на стек с локальным массивом
 655 
	lea eax,[esp+8]
834 
	rep movsd ;копирование в цикле 9-ти входных параметров
 656 
	mov dword[eax],OP_TexImage2D
835 
 
 - 
 
836 
	mov ecx,ebp
 - 
 
837 
	sub ecx,40 ;=sizeof(dd)*10
 - 
 
Line 838... Line 657...
838 
	stdcall gl_add_op,ecx
 657 
	stdcall gl_add_op,eax
839 
	ret
 658 
	pop eax
840 
endp
 - 
 
841 
 
 - 
 
842 
align 4
 - 
 
843 
proc glBindTexture uses eax, target:dword, texture:dword
 659 
	ret 40 ;=sizeof(dd)*10
844 
locals
 660 
 
845 
	p rd 3
 - 
 
846 
endl
 661 
align 4
847 
	mov dword[p],OP_BindTexture
 662 
glBindTexture: ;target, texture
848 
	mov eax,[target]
 - 
 
849 
	mov dword[p+4],eax
 - 
 
850 
	mov eax,[texture]
 - 
 
851 
	mov dword[p+8],eax
 663 
	push dword[esp] ;копируем адрес возврата
852 
 
 664 
	push eax
853 
	mov eax,ebp
 665 
	lea eax,[esp+8]
Line 854... Line 666...
854 
	sub eax,12 ;=sizeof(dd)*3
 666 
	mov dword[eax],OP_BindTexture
855 
	stdcall gl_add_op,eax
 667 
	stdcall gl_add_op,eax
856 
	ret
 668 
	pop eax
857 
endp
 669 
	ret 12 ;=sizeof(dd)*3
Line 871... Line 683...
871 
	mov dword[p+16],0.0
 683 
	mov dword[p+16],0.0
872 
	mov dword[p+20],0.0
 684 
	mov dword[p+20],0.0
873 
	mov dword[p+24],0.0
 685 
	mov dword[p+24],0.0
874 
	mov dword[p+28],0.0
 686 
	mov dword[p+28],0.0
Line 875... Line -...
875 
 
 - 
 
876 
	mov eax,ebp
 687 
 
877 
	sub eax,32 ;=sizeof(dd)*8
 688 
	lea eax,[ebp-32] ;=sizeof(dd)*8
878 
	stdcall gl_add_op,eax
 689 
	stdcall gl_add_op,eax
879 
	ret
 690 
	ret
Line 880... Line 691...
880 
endp
 691 
endp
Line 894... Line 705...
894 
	mov dword[p+16],0.0
 705 
	mov dword[p+16],0.0
895 
	mov dword[p+20],0.0
 706 
	mov dword[p+20],0.0
896 
	mov dword[p+24],0.0
 707 
	mov dword[p+24],0.0
897 
	mov dword[p+28],0.0
 708 
	mov dword[p+28],0.0
Line 898... Line -...
898 
 
 - 
 
899 
	mov eax,ebp
 709 
 
900 
	sub eax,32 ;=sizeof(dd)*8
 710 
	lea eax,[ebp-32] ;=sizeof(dd)*8
901 
	stdcall gl_add_op,eax
 711 
	stdcall gl_add_op,eax
902 
	ret
 712 
	ret
Line 903... Line 713...
903 
endp
 713 
endp
904 
 
 714 
 
905 
align 4
 - 
 
906 
proc glPixelStorei uses eax, pname:dword, param:dword
 - 
 
907 
locals
 - 
 
908 
	p rd 3
 715 
align 4
909 
endl
 716 
glPixelStorei: ;pname, param
910 
	mov dword[p],OP_PixelStore
 - 
 
911 
	mov eax,[pname]
 717 
	push dword[esp] ;копируем адрес возврата
912 
	mov dword[p+4],eax
 718 
	push eax
913 
	mov eax,[param]
 - 
 
914 
	mov dword[p+8],eax
 - 
 
915 
 
 - 
 
916 
	mov eax,ebp
 719 
	lea eax,[esp+8]
917 
	sub eax,12 ;=sizeof(dd)*3
 720 
	mov dword[eax],OP_PixelStore
918 
	stdcall gl_add_op,eax
 721 
	stdcall gl_add_op,eax
Line 919... Line 722...
919 
	ret
 722 
	pop eax
Line 920... Line 723...
920 
endp
 723 
	ret 12 ;=sizeof(dd)*3
921 
 
 724 
 
922 
; selection
 - 
 
923 
 
 - 
 
924 
align 4
 - 
 
925 
proc glInitNames uses eax
 - 
 
926 
locals
 - 
 
927 
	p dd ?
 - 
 
928 
endl
 - 
 
929 
	mov dword[p],OP_InitNames
 725 
; selection
930 
 
 726 
 
931 
	mov eax,ebp
 - 
 
Line 932... Line 727...
932 
	sub eax,4 ;=sizeof(dd)*1
 727 
align 4
933 
	stdcall gl_add_op,eax
 728 
glInitNames:
934 
	ret
 - 
 
- 
 
 729 
	stdcall gl_add_op,op_InitNames
935 
endp
 730 
	ret
936 
 
 - 
 
937 
align 4
 - 
 
938 
proc glPushName uses eax, name:dword
 731 
 
939 
locals
 732 
align 4
940 
	p rd 2
 - 
 
941 
endl
 - 
 
942 
	mov dword[p],OP_PushName
 - 
 
943 
	mov eax,[name]
 733 
glPushName: ;name
944 
	mov dword[p+4],eax
 734 
	push dword[esp] ;копируем адрес возврата
945 
 
 735 
	push eax
Line 946... Line 736...
946 
	mov eax,ebp
 736 
	lea eax,[esp+8]
947 
	sub eax,8 ;=sizeof(dd)*2
 - 
 
948 
	stdcall gl_add_op,eax
 737 
	mov dword[eax],OP_PushName
949 
	ret
 - 
 
950 
endp
 - 
 
951 
 
 - 
 
952 
align 4
 - 
 
953 
proc glPopName uses eax
 - 
 
954 
locals
 - 
 
955 
	p dd ?
 738 
	stdcall gl_add_op,eax
956 
endl
 739 
	pop eax
957 
	mov dword[p],OP_PopName
 - 
 
Line 958... Line 740...
958 
 
 740 
	ret 8 ;=sizeof(dd)*2
959 
	mov eax,ebp
 741 
 
960 
	sub eax,4 ;=sizeof(dd)*1
 - 
 
- 
 
 742 
align 4
961 
	stdcall gl_add_op,eax
 743 
glPopName:
962 
	ret
 - 
 
963 
endp
 - 
 
964 
 
 744 
	stdcall gl_add_op,op_PopName
965 
align 4
 745 
	ret
966 
proc glLoadName uses eax, name:dword
 - 
 
967 
locals
 - 
 
968 
	p rd 2
 - 
 
969 
endl
 746 
 
970 
	mov dword[p],OP_LoadName
 747 
align 4
971 
	mov eax,[name]
 748 
glLoadName: ;name
Line 972... Line 749...
972 
	mov dword[p+4],eax
 749 
	push dword[esp] ;копируем адрес возврата
973 
 
 750 
	push eax
974 
	mov eax,ebp
 - 
 
975 
	sub eax,8 ;=sizeof(dd)*2
 - 
 
976 
	stdcall gl_add_op,eax
 - 
 
977 
	ret
 751 
	lea eax,[esp+8]
978 
endp
 752 
	mov dword[eax],OP_LoadName
979 
 
 - 
 
980 
align 4
 753 
	stdcall gl_add_op,eax
981 
proc glPolygonOffset uses eax, factor:dword, units:dword
 754 
	pop eax
982 
locals
 - 
 
983 
	p rd 3
 - 
 
984 
endl
 - 
 
985 
	mov dword[p],OP_PolygonOffset
 755 
	ret 8 ;=sizeof(dd)*2
986 
	mov eax,[factor]
 756 
 
987 
	mov dword[p+4],eax
 757 
align 4
Line 988... Line 758...
988 
	mov eax,[units]
 758 
glPolygonOffset: ;factor, units
Line 989... Line 759...
989 
	mov dword[p+8],eax
 759 
	push dword[esp] ;копируем адрес возврата
990 
 
 760 
	push eax
991 
	mov eax,ebp
 - 
 
- 
 
 761 
	lea eax,[esp+8]
992 
	sub eax,12 ;=sizeof(dd)*3
 762 
	mov dword[eax],OP_PolygonOffset
993 
	stdcall gl_add_op,eax
 - 
 
994 
	ret
 - 
 
995 
endp
 763 
	stdcall gl_add_op,eax
996 
 
 764 
	pop eax
997 
; Special Functions
 - 
 
998 
 
 - 
 
999 
align 4
 - 
 
1000 
proc glCallList uses eax, list:dword
 765 
	ret 12 ;=sizeof(dd)*3
1001 
locals
 766 
 
1002 
	p rd 2
 767 
; Special Functions
Line 1003... Line 768...
1003 
endl
 768 
 
1004 
	mov dword[p],OP_CallList
 769 
align 4
1005 
	mov eax,[list]
 770 
glCallList: ;list
1006 
	mov dword[p+4],eax
 771 
	push dword[esp] ;копируем адрес возврата
1007 
 
 772 
	push eax
Line 1008... Line 773...
1008 
	mov eax,ebp
 773 
	lea eax,[esp+8]
1009 
	sub eax,8 ;=sizeof(dd)*2
 774 
	mov dword[eax],OP_CallList
1010 
	stdcall gl_add_op,eax
 - 
 
1011 
	ret
 - 
 
1012 
endp
 - 
 
1013 
 
 775 
	stdcall gl_add_op,eax
1014 
align 4
 776 
	pop eax
1015 
proc glFlush ;(void)
 - 
 
1016 
	;nothing to do
 777 
	ret 8 ;=sizeof(dd)*2
1017 
	ret
 778 
 
1018 
endp
 - 
 
1019 
 
 - 
 
1020 
align 4
 - 
 
1021 
proc glHint uses eax, target:dword, mode:dword
 779 
align 4
1022 
locals
 780 
proc glFlush ;(void)
1023 
	p rd 3
 781 
	;nothing to do
Line 1024... Line 782...
1024 
endl
 782 
	ret
Line 1025... Line 783...
1025 
	mov dword[p],OP_Hint
 783 
endp
1026 
	mov eax,[target]
 784