Subversion Repositories Kolibri OS

Rev

Rev 8059 | Rev 8063 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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