Subversion Repositories Kolibri OS

Rev

Rev 5153 | Rev 5387 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5153 IgorA 1
; glVertex
2
 
3
align 4
4
proc glVertex4f uses eax, x:dword, y:dword, z:dword, w:dword
5
locals
6
	p rd 5
7
endl
8
	mov dword[p],OP_Vertex
9
	mov eax,[x]
10
	mov dword[p+4],eax
11
	mov eax,[y]
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
20
	stdcall gl_add_op,eax
21
	ret
22
endp
23
 
24
align 4
25
proc glVertex2f, x:dword, y:dword
26
	stdcall glVertex4f,[x],[y],0.0,1.0
27
	ret
28
endp
29
 
30
align 4
5353 IgorA 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
5153 IgorA 38
proc glVertex3f, x:dword, y:dword, z:dword
39
	stdcall glVertex4f,[x],[y],[z],1.0
40
	ret
41
endp
42
 
43
align 4
44
proc glVertex3fv uses eax, v:dword
45
	mov eax,[v]
46
	stdcall glVertex4f,[eax],[eax+4],[eax+8],1.0
47
	ret
48
endp
49
 
5353 IgorA 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
56
 
5153 IgorA 57
; glNormal
58
 
59
align 4
60
proc glNormal3f uses eax, x:dword, y:dword, z:dword
61
locals
62
	p rd 4
63
endl
64
	mov dword[p],OP_Normal
65
	mov eax,[x]
66
	mov dword[p+4],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
73
	sub eax,16 ;=sizeof(dd)*4
74
	stdcall gl_add_op,eax
75
	ret
76
endp
77
 
78
align 4
79
proc glNormal3fv uses eax, v:dword
80
	mov eax,[v]
81
	stdcall glNormal3f,[eax],[eax+4],[eax+8]
82
	ret
83
endp
84
 
85
; glColor
86
 
87
align 4
88
proc glColor4f uses eax, r:dword, g:dword, b:dword, a:dword
89
locals
90
	p rd 8
91
endl
92
	mov dword[p],OP_Color
93
	mov eax,[b]
94
	mov dword[p+4],eax
95
	mov eax,[g]
96
	mov dword[p+8],eax
97
	mov eax,[r]
98
	mov dword[p+12],eax
99
	mov eax,[a]
100
	mov dword[p+16],eax
101
	; direct convertion to integer to go faster if no shading
102
	mov eax,ebp
103
	sub eax,12 ;ebp-12 = &p[5]
104
	push eax
105
	add eax,4 ;ebp-8 = &p[6]
106
	push eax
107
	add eax,4 ;ebp-4 = &p[7]
108
	push eax
109
	stdcall RGBFtoRGBI,[r],[g],[b] ;call: r,g,b,&p[7],&p[6],&p[5]
110
 
111
	mov eax,ebp
112
	sub eax,32 ;=sizeof(dd)*8
113
	stdcall gl_add_op,eax
114
	ret
115
endp
116
 
117
align 4
118
proc glColor4fv uses eax ebx, v:dword
119
locals
120
	p rd 8
121
endl
122
	mov dword[p],OP_Color
123
	mov eax,[v]
124
	mov ebx,[eax+8]
125
	mov dword[p+4],ebx
126
	mov ebx,[eax+4]
127
	mov dword[p+8],ebx
128
	mov ebx,[eax]
129
	mov dword[p+12],ebx
130
	mov ebx,[eax+12]
131
	mov dword[p+16],ebx
132
	; direct convertion to integer to go faster if no shading
133
	mov eax,ebp
134
	sub eax,4
135
	push eax ;&p[7]
136
	sub eax,4
137
	push eax ;&p[6]
138
	sub eax,4
139
	push eax ;&p[5]
140
	stdcall RGBFtoRGBI,[eax+8],[eax+4],[eax] ;call: v[2],v[1],v[0],p[5],p[6],p[7]
141
 
142
	mov eax,ebp
143
	sub eax,32 ;=sizeof(dd)*8
144
	stdcall gl_add_op,eax
145
	ret
146
endp
147
 
148
align 4
149
proc glColor3f, r:dword, g:dword, b:dword
150
	stdcall glColor4f,[r],[g],[b],1.0
151
	ret
152
endp
153
 
154
align 4
155
proc glColor3fv uses eax, v:dword
156
	mov eax,[v]
157
	stdcall glColor4f,[eax],[eax+4],[eax+8],1.0
158
	ret
159
endp
160
 
161
; TexCoord
162
 
163
align 4
164
proc glTexCoord4f uses eax, s:dword, t:dword, r:dword, q:dword
165
locals
166
	p rd 5
167
endl
168
	mov dword[p],OP_TexCoord
169
	mov eax,[s]
170
	mov dword[p+4],eax
171
	mov eax,[t]
172
	mov dword[p+8],eax
173
	mov eax,[r]
174
	mov dword[p+12],eax
175
	mov eax,[q]
176
	mov dword[p+16],eax
177
 
178
	mov eax,ebp
179
	sub eax,20 ;=sizeof(dd)*5
180
	stdcall gl_add_op,eax
181
	ret
182
endp
183
 
184
align 4
185
proc glTexCoord2f, s:dword, t:dword
186
	stdcall glTexCoord4f,[s],[t],0.0,1.0
187
	ret
188
endp
189
 
190
align 4
191
proc glTexCoord2fv uses eax, v:dword
192
	mov eax,[v]
193
	stdcall glTexCoord4f,[eax],[eax+4],0.0,1.0
194
	ret
195
endp
196
 
197
align 4
198
proc glEdgeFlag uses eax, flag:dword
199
locals
200
	p rd 2
201
endl
202
	mov dword[p],OP_EdgeFlag
203
	mov eax,[flag]
204
	mov dword[p+4],eax
205
 
206
	mov eax,ebp
207
	sub eax,8 ;=sizeof(dd)*2
208
	stdcall gl_add_op,eax
209
	ret
210
endp
211
 
212
; misc
213
 
214
align 4
215
proc glShadeModel uses eax, mode:dword
216
locals
217
	p rd 2
218
endl
219
 
220
;  assert(mode == GL_FLAT || mode == GL_SMOOTH);
221
 
222
	mov dword[p],OP_ShadeModel
223
	mov eax,[mode]
224
	mov dword[p+4],eax
225
 
226
	mov eax,ebp
227
	sub eax,8 ;=sizeof(dd)*2
228
	stdcall gl_add_op,eax
229
	ret
230
endp
231
 
232
align 4
233
proc glCullFace uses eax, mode:dword
234
locals
235
	p rd 2
236
endl
237
 
238
;  assert(mode == GL_BACK ||
239
;         mode == GL_FRONT ||
240
;         mode == GL_FRONT_AND_BACK);
241
 
242
	mov dword[p],OP_CullFace
243
	mov eax,[mode]
244
	mov dword[p+4],eax
245
 
246
	mov eax,ebp
247
	sub eax,8 ;=sizeof(dd)*2
248
	stdcall gl_add_op,eax
249
	ret
250
endp
251
 
252
align 4
253
proc glFrontFace uses eax, mode:dword
254
locals
255
	p rd 2
256
endl
257
 
258
;  assert(mode == GL_CCW || mode == GL_CW);
259
 
260
	mov dword[p],OP_FrontFace
261
	xor eax,eax
262
	cmp dword[mode],GL_CCW
263
	je @f
264
		inc eax
265
	@@:
266
	mov dword[p+4],eax
267
 
268
	mov eax,ebp
269
	sub eax,8 ;=sizeof(dd)*2
270
	stdcall gl_add_op,eax
271
	ret
272
endp
273
 
274
align 4
275
proc glPolygonMode uses eax, face:dword, mode:dword
276
locals
277
	p rd 3
278
endl
279
 
280
;  assert(face == GL_BACK ||
281
;         face == GL_FRONT ||
282
;         face == GL_FRONT_AND_BACK);
283
;  assert(mode == GL_POINT || mode == GL_LINE || mode==GL_FILL);
284
 
285
	mov dword[p],OP_PolygonMode
286
	mov eax,[face]
287
	mov dword[p+4],eax
288
	mov eax,[mode]
289
	mov dword[p+8],eax
290
 
291
	mov eax,ebp
292
	sub eax,12 ;=sizeof(dd)*3
293
	stdcall gl_add_op,eax
294
	ret
295
endp
296
 
297
; glEnable / glDisable
298
 
299
align 4
300
proc glEnable uses eax, cap:dword
301
locals
302
	p rd 3
303
endl
304
	mov dword[p],OP_EnableDisable
305
	mov eax,[cap]
306
	mov dword[p+4],eax
307
	mov dword[p+8],1
308
 
309
	mov eax,ebp
310
	sub eax,12 ;=sizeof(dd)*3
311
	stdcall gl_add_op,eax
312
	ret
313
endp
314
 
315
align 4
316
proc glDisable uses eax, cap:dword
317
locals
318
	p rd 3
319
endl
320
	mov dword[p],OP_EnableDisable
321
	mov eax,[cap]
322
	mov dword[p+4],eax
323
	mov dword[p+8],0
324
 
325
	mov eax,ebp
326
	sub eax,12 ;=sizeof(dd)*3
327
	stdcall gl_add_op,eax
328
	ret
329
endp
330
 
331
; glBegin / glEnd
332
 
333
align 4
334
proc glBegin uses eax, mode:dword
335
locals
336
	p rd 2
337
endl
338
	mov dword[p],OP_Begin
339
	mov eax,[mode]
340
	mov dword[p+4],eax
341
 
342
	mov eax,ebp
343
	sub eax,8 ;=sizeof(dd)*2
344
	stdcall gl_add_op,eax
345
	ret
346
endp
347
 
348
align 4
349
proc glEnd uses eax
350
locals
351
	p dd ?
352
endl
353
	mov dword[p],OP_End
354
 
355
	mov eax,ebp
356
	sub eax,4 ;=sizeof(dd)*1
357
	stdcall gl_add_op,eax
358
	ret
359
endp
360
 
361
; matrix
362
 
363
align 4
364
proc glMatrixMode uses eax, mode:dword
365
locals
366
	p rd 2
367
endl
368
	mov dword[p],OP_MatrixMode
369
	mov eax,[mode]
370
	mov dword[p+4],eax
371
 
372
	mov eax,ebp
373
	sub eax,8 ;=sizeof(dd)*2
374
	stdcall gl_add_op,eax
375
	ret
376
endp
377
 
378
align 4
379
proc glLoadMatrixf uses ecx edi esi, m:dword
380
locals
381
	p rd 17
382
endl
383
	mov dword[p],OP_LoadMatrix
384
	mov ecx,16
385
	mov esi,[m]
386
	mov edi,ebp
387
	sub edi,64 ;=sizeof(M4)
388
	rep movsd
389
 
390
	mov ecx,ebp
391
	sub ecx,68 ;=sizeof(dd)*17
392
	stdcall gl_add_op,ecx
393
	ret
394
endp
395
 
396
align 4
397
proc glLoadIdentity uses eax
398
locals
399
	p dd ?
400
endl
401
	mov dword[p],OP_LoadIdentity
402
 
403
	mov eax,ebp
404
	sub eax,4 ;=sizeof(dd)*1
405
	stdcall gl_add_op,eax
406
	ret
407
endp
408
 
409
align 4
410
proc glMultMatrixf uses ecx edi esi, m:dword
411
locals
412
	p rd 17
413
endl
414
	mov dword[p],OP_MultMatrix
415
	mov ecx,16
416
	mov esi,[m]
417
	mov edi,ebp
418
	sub edi,64 ;=sizeof(M4)
419
	rep movsd
420
 
421
	mov ecx,ebp
422
	sub ecx,68 ;=sizeof(dd)*17
423
	stdcall gl_add_op,ecx
424
	ret
425
endp
426
 
427
align 4
428
proc glPushMatrix uses eax
429
locals
430
	p dd ?
431
endl
432
	mov dword[p],OP_PushMatrix
433
 
434
	mov eax,ebp
435
	sub eax,4 ;=sizeof(dd)*1
436
	stdcall gl_add_op,eax
437
	ret
438
endp
439
 
440
align 4
441
proc glPopMatrix uses eax
442
locals
443
	p dd ?
444
endl
445
	mov dword[p],OP_PopMatrix
446
 
447
	mov eax,ebp
448
	sub eax,4 ;=sizeof(dd)*1
449
	stdcall gl_add_op,eax
450
	ret
451
endp
452
 
453
align 4
454
proc glRotatef uses eax, angle:dword, x:dword, y:dword, z:dword
455
locals
456
	p rd 5
457
endl
458
	mov dword[p],OP_Rotate
459
	mov eax,[angle]
460
	mov dword[p+4],eax
461
	mov eax,[x]
462
	mov dword[p+8],eax
463
	mov eax,[y]
464
	mov dword[p+12],eax
465
	mov eax,[z]
466
	mov dword[p+16],eax
467
 
468
	mov eax,ebp
469
	sub eax,20 ;=sizeof(dd)*5
470
	stdcall gl_add_op,eax
471
	ret
472
endp
473
 
474
align 4
475
proc glTranslatef uses eax, x:dword, y:dword, z:dword
476
locals
477
	p rd 4
478
endl
479
	mov dword[p],OP_Translate
480
	mov eax,[x]
481
	mov dword[p+4],eax
482
	mov eax,[y]
483
	mov dword[p+8],eax
484
	mov eax,[z]
485
	mov dword[p+12],eax
486
 
487
	mov eax,ebp
488
	sub eax,16 ;=sizeof(dd)*4
489
	stdcall gl_add_op,eax
490
	ret
491
endp
492
 
493
align 4
494
proc glScalef uses eax, x:dword, y:dword, z:dword
495
locals
496
	p rd 4
497
endl
498
	mov dword[p],OP_Scale
499
	mov eax,[x]
500
	mov dword[p+4],eax
501
	mov eax,[y]
502
	mov dword[p+8],eax
503
	mov eax,[z]
504
	mov dword[p+12],eax
505
 
506
	mov eax,ebp
507
	sub eax,16 ;=sizeof(dd)*4
508
	stdcall gl_add_op,eax
509
	ret
510
endp
511
 
512
align 4
513
proc glViewport uses eax, x:dword, y:dword, width:dword, heigh:dword
514
locals
515
	p rd 5
516
endl
517
	mov dword[p],OP_Viewport
518
	mov eax,[x]
519
	mov dword[p+4],eax
520
	mov eax,[y]
521
	mov dword[p+8],eax
522
	mov eax,[width]
523
	mov dword[p+12],eax
524
	mov eax,[heigh]
525
	mov dword[p+16],eax
526
 
527
	mov eax,ebp
528
	sub eax,20 ;=sizeof(dd)*5
529
	stdcall gl_add_op,eax
530
	ret
531
endp
532
 
533
align 4
534
proc glFrustum uses eax, left:dword,right:dword,bottom:dword,top:dword,\
535
	near:dword,farv:dword
536
locals
537
	p rd 7
538
endl
539
	mov dword[p],OP_Frustum
540
	mov eax,[left]
541
	fld qword[eax]
542
	fstp dword[p+4]
543
	mov eax,[right]
544
	fld qword[eax]
545
	fstp dword[p+8]
546
	mov eax,[bottom]
547
	fld qword[eax]
548
	fstp dword[p+12]
549
	mov eax,[top]
550
	fld qword[eax]
551
	fstp dword[p+16]
552
	mov eax,[near]
553
	fld qword[eax]
554
	fstp dword[p+20]
555
	mov eax,[farv]
556
	fld qword[eax]
557
	fstp dword[p+24]
558
 
559
	mov eax,ebp
560
	sub eax,28 ;=sizeof(dd)*7
561
	stdcall gl_add_op,eax
562
	ret
563
endp
564
 
5353 IgorA 565
; lightening
5153 IgorA 566
 
567
align 4
568
proc glMaterialfv uses eax ecx, mode:dword, type:dword, v:dword
569
locals
570
	p rd 7
571
endl
572
 
573
;  assert(mode == GL_FRONT  || mode == GL_BACK || mode==GL_FRONT_AND_BACK);
574
 
575
	mov dword[p],OP_Material
576
	mov eax,[mode]
577
	mov dword[p+4],eax
578
	mov eax,[type]
579
	mov dword[p+8],eax
580
 
581
	mov eax,[v]
582
	mov ecx,[eax+8]
583
	mov dword[p+12],ecx
584
	mov ecx,[eax+4]
585
	mov dword[p+16],ecx
586
	mov ecx,[eax]
587
	mov dword[p+20],ecx
588
	mov ecx,[eax+12]
589
	mov dword[p+24],ecx
590
 
591
	cmp dword[type],GL_SHININESS
592
	jne @f
593
		mov dword[p+16],0.0
594
		mov dword[p+20],0.0
595
		mov dword[p+24],0.0
596
	@@:
597
 
598
	mov eax,ebp
599
	sub eax,28 ;=sizeof(dd)*7
600
	stdcall gl_add_op,eax
601
	ret
602
endp
603
 
604
align 4
605
proc glMaterialf uses eax, mode:dword, type:dword, v:dword
606
locals
607
	p rd 7
608
endl
609
	mov dword[p],OP_Material
610
	mov eax,[mode]
611
	mov dword[p+4],eax
612
	mov eax,[type]
613
	mov dword[p+8],eax
614
	mov eax,[v]
615
	mov dword[p+12],eax
616
	mov dword[p+16],0.0
617
	mov dword[p+20],0.0
618
	mov dword[p+24],0.0
619
 
620
	mov eax,ebp
621
	sub eax,28 ;=sizeof(dd)*7
622
	stdcall gl_add_op,eax
623
	ret
624
endp
625
 
626
align 4
627
proc glColorMaterial uses eax, mode:dword, type:dword
628
locals
629
	p rd 3
630
endl
631
	mov dword[p],OP_ColorMaterial
632
	mov eax,[mode]
633
	mov dword[p+4],eax
634
	mov eax,[type]
635
	mov dword[p+8],eax
636
 
637
	mov eax,ebp
638
	sub eax,12 ;=sizeof(dd)*3
639
	stdcall gl_add_op,eax
640
	ret
641
endp
642
 
643
align 4
644
proc glLightfv uses eax ecx, light:dword, type:dword, v:dword
645
locals
646
	p rd 7
647
endl
648
	mov dword[p],OP_Light
649
	mov eax,[light]
650
	mov dword[p+4],eax
651
	mov eax,[type]
652
	mov dword[p+8],eax
653
 
654
	;TODO: 3 composants ?
655
	mov eax,[v]
656
	mov ecx,[eax]
657
	mov dword[p+12],ecx
658
	mov ecx,[eax+4]
659
	mov dword[p+16],ecx
660
	mov ecx,[eax+8]
661
	mov dword[p+20],ecx
662
	mov ecx,[eax+12]
663
	mov dword[p+24],ecx
664
 
665
	mov eax,ebp
666
	sub eax,28 ;=sizeof(dd)*7
667
	stdcall gl_add_op,eax
668
	ret
669
endp
670
 
671
align 4
672
proc glLightf uses eax, light:dword, type:dword, v:dword
673
locals
674
	p rd 7
675
endl
676
	mov dword[p],OP_Light
677
	mov eax,[light]
678
	mov dword[p+4],eax
679
	mov eax,[type]
680
	mov dword[p+8],eax
681
	mov eax,[v]
682
	mov dword[p+12],eax
683
	mov dword[p+16],0.0
684
	mov dword[p+20],0.0
685
	mov dword[p+24],0.0
686
 
687
	mov eax,ebp
688
	sub eax,28 ;=sizeof(dd)*7
689
	stdcall gl_add_op,eax
690
	ret
691
endp
692
 
693
align 4
694
proc glLightModeli uses eax, pname:dword, param:dword
695
locals
696
	p rd 6
697
endl
698
	mov dword[p],OP_LightModel
699
	mov eax,[pname]
700
	mov dword[p+4],eax
701
	fild dword[param]
702
	fstp dword[p+8] ;преобразовали int во float
703
 
704
	mov dword[p+12],0.0
705
	mov dword[p+16],0.0
706
	mov dword[p+20],0.0
707
 
708
	mov eax,ebp
709
	sub eax,24 ;=sizeof(dd)*6
710
	stdcall gl_add_op,eax
711
	ret
712
endp
713
 
714
align 4
715
proc glLightModelfv uses eax ecx, pname:dword, param:dword
716
locals
717
	p rd 6
718
endl
719
	mov dword[p],OP_LightModel
720
	mov eax,[pname]
721
	mov dword[p+4],eax
722
	mov eax,[param]
723
	mov ecx,[eax]
724
	mov dword[p+8],ecx
725
	mov ecx,[eax+4]
726
	mov dword[p+12],ecx
727
	mov ecx,[eax+8]
728
	mov dword[p+16],ecx
729
	mov ecx,[eax+12]
730
	mov dword[p+20],ecx
731
 
732
	mov eax,ebp
733
	sub eax,24 ;=sizeof(dd)*6
734
	stdcall gl_add_op,eax
735
	ret
736
endp
737
 
5353 IgorA 738
; clear
5153 IgorA 739
 
740
align 4
741
proc glClear uses eax, mask:dword
742
locals
743
	p rd 2
744
endl
745
	mov dword[p],OP_Clear
746
	mov eax,[mask]
747
	mov dword[p+4],eax
748
 
749
	mov eax,ebp
750
	sub eax,8 ;=sizeof(dd)*2
751
	stdcall gl_add_op,eax
752
	ret
753
endp
754
 
755
align 4
756
proc glClearColor uses eax, r:dword, g:dword, b:dword, a:dword
757
locals
758
	p rd 5
759
endl
760
	mov dword[p],OP_ClearColor
761
	mov eax,[b]
762
	mov dword[p+4],eax
763
	mov eax,[g]
764
	mov dword[p+8],eax
765
	mov eax,[r]
766
	mov dword[p+12],eax
767
	mov eax,[a]
768
	mov dword[p+16],eax
769
 
770
	mov eax,ebp
771
	sub eax,20 ;=sizeof(dd)*5
772
	stdcall gl_add_op,eax
773
	ret
774
endp
775
 
776
align 4
777
proc glClearDepth uses eax, depth:dword
778
locals
779
	p rd 2
780
endl
781
	mov dword[p],OP_ClearDepth
782
	mov eax,[depth]
783
	fld qword[eax]
784
	fstp dword[p+4]
785
 
786
	mov eax,ebp
787
	sub eax,8 ;=sizeof(dd)*2
788
	stdcall gl_add_op,eax
789
	ret
790
endp
791
 
5353 IgorA 792
; textures
5153 IgorA 793
 
794
align 4
795
proc glTexImage2D uses ecx edi esi,\
796
	target:dword, level:dword, components:dword,\
797
	width:dword, height:dword, border:dword,\
798
	format:dword, type:dword, pixels:dword
799
locals
800
	p rd 10
801
endl
802
	mov dword[p],OP_TexImage2D
803
	mov ecx,9
804
	mov esi,ebp
805
	add esi,8 ;указатель на стек с входными параметрами
806
	mov edi,ebp
807
	sub edi,36 ;указатель на стек с локальным массивом
808
	rep movsd ;копирование в цикле 9-ти входных параметров
809
 
810
	mov ecx,ebp
811
	sub ecx,40 ;=sizeof(dd)*10
812
	stdcall gl_add_op,ecx
813
	ret
814
endp
815
 
816
align 4
817
proc glBindTexture uses eax, target:dword, texture:dword
818
locals
819
	p rd 3
820
endl
821
	mov dword[p],OP_BindTexture
822
	mov eax,[target]
823
	mov dword[p+4],eax
824
	mov eax,[texture]
825
	mov dword[p+8],eax
826
 
827
	mov eax,ebp
828
	sub eax,12 ;=sizeof(dd)*3
829
	stdcall gl_add_op,eax
830
	ret
831
endp
832
 
833
align 4
834
proc glTexEnvi uses eax, target:dword, pname:dword, param:dword
835
locals
836
	p rd 8
837
endl
838
	mov dword[p],OP_TexEnv
839
	mov eax,[target]
840
	mov dword[p+4],eax
841
	mov eax,[pname]
842
	mov dword[p+8],eax
843
	mov eax,[param]
844
	mov dword[p+12],eax
845
	mov dword[p+16],0.0
846
	mov dword[p+20],0.0
847
	mov dword[p+24],0.0
848
	mov dword[p+28],0.0
849
 
850
	mov eax,ebp
851
	sub eax,32 ;=sizeof(dd)*8
852
	stdcall gl_add_op,eax
853
	ret
854
endp
855
 
856
align 4
857
proc glTexParameteri uses eax, target:dword, pname:dword, param:dword
858
locals
859
	p rd 8
860
endl
861
	mov dword[p],OP_TexParameter
862
	mov eax,[target]
863
	mov dword[p+4],eax
864
	mov eax,[pname]
865
	mov dword[p+8],eax
866
	mov eax,[param]
867
	mov dword[p+12],eax
868
	mov dword[p+16],0.0
869
	mov dword[p+20],0.0
870
	mov dword[p+24],0.0
871
	mov dword[p+28],0.0
872
 
873
	mov eax,ebp
874
	sub eax,32 ;=sizeof(dd)*8
875
	stdcall gl_add_op,eax
876
	ret
877
endp
878
 
879
align 4
880
proc glPixelStorei uses eax, pname:dword, param:dword
881
locals
882
	p rd 3
883
endl
884
	mov dword[p],OP_PixelStore
885
	mov eax,[pname]
886
	mov dword[p+4],eax
887
	mov eax,[param]
888
	mov dword[p+8],eax
889
 
890
	mov eax,ebp
891
	sub eax,12 ;=sizeof(dd)*3
892
	stdcall gl_add_op,eax
893
	ret
894
endp
895
 
5353 IgorA 896
; selection
5153 IgorA 897
 
898
align 4
899
proc glInitNames uses eax
900
locals
901
	p dd ?
902
endl
903
	mov dword[p],OP_InitNames
904
 
905
	mov eax,ebp
906
	sub eax,4 ;=sizeof(dd)*1
907
	stdcall gl_add_op,eax
908
	ret
909
endp
910
 
911
align 4
912
proc glPushName uses eax, name:dword
913
locals
914
	p rd 2
915
endl
916
	mov dword[p],OP_PushName
917
	mov eax,[name]
918
	mov dword[p+4],eax
919
 
920
	mov eax,ebp
921
	sub eax,8 ;=sizeof(dd)*2
922
	stdcall gl_add_op,eax
923
	ret
924
endp
925
 
926
align 4
927
proc glPopName uses eax
928
locals
929
	p dd ?
930
endl
931
	mov dword[p],OP_PopName
932
 
933
	mov eax,ebp
934
	sub eax,4 ;=sizeof(dd)*1
935
	stdcall gl_add_op,eax
936
	ret
937
endp
938
 
939
align 4
940
proc glLoadName uses eax, name:dword
941
locals
942
	p rd 2
943
endl
944
	mov dword[p],OP_LoadName
945
	mov eax,[name]
946
	mov dword[p+4],eax
947
 
948
	mov eax,ebp
949
	sub eax,8 ;=sizeof(dd)*2
950
	stdcall gl_add_op,eax
951
	ret
952
endp
953
 
954
align 4
955
proc glPolygonOffset uses eax, factor:dword, units:dword
956
locals
957
	p rd 3
958
endl
959
	mov dword[p],OP_PolygonOffset
960
	mov eax,[factor]
961
	mov dword[p+4],eax
962
	mov eax,[units]
963
	mov dword[p+8],eax
964
 
965
	mov eax,ebp
966
	sub eax,12 ;=sizeof(dd)*3
967
	stdcall gl_add_op,eax
968
	ret
969
endp
970
 
5353 IgorA 971
; Special Functions
5153 IgorA 972
 
973
align 4
974
proc glCallList uses eax, list:dword
975
locals
976
	p rd 2
977
endl
978
	mov dword[p],OP_CallList
979
	mov eax,[list]
980
	mov dword[p+4],eax
981
 
982
	mov eax,ebp
983
	sub eax,8 ;=sizeof(dd)*2
984
	stdcall gl_add_op,eax
985
	ret
986
endp
987
 
988
align 4
989
proc glFlush ;(void)
990
	;nothing to do
991
	ret
992
endp
993
 
994
align 4
995
proc glHint uses eax, target:dword, mode:dword
996
locals
997
	p rd 3
998
endl
999
	mov dword[p],OP_Hint
1000
	mov eax,[target]
1001
	mov dword[p+4],eax
1002
	mov eax,[mode]
1003
	mov dword[p+8],eax
1004
 
1005
	mov eax,ebp
1006
	sub eax,12 ;=sizeof(dd)*3
1007
	stdcall gl_add_op,eax
1008
	ret
1009
endp
1010
 
1011
; Non standard functions
1012
 
1013
align 4
1014
proc glDebug uses eax, mode:dword
1015
	stdcall gl_get_context ;после вызова функции в eax указатель на GLContext
1016
	push dword[mode]
1017
	pop dword[eax+offs_cont_print_flag]
1018
	ret
1019
endp