Subversion Repositories Kolibri OS

Rev

Rev 5387 | Rev 8059 | 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:dword,right:dword,bottom:dword,top:dword,\
  542.         near:dword,farv:dword
  543. locals
  544.         p rd 7
  545. endl
  546.         mov dword[p],OP_Frustum
  547.         mov eax,[left]
  548.         fld qword[eax]
  549.         fstp dword[p+4]
  550.         mov eax,[right]
  551.         fld qword[eax]
  552.         fstp dword[p+8]
  553.         mov eax,[bottom]
  554.         fld qword[eax]
  555.         fstp dword[p+12]
  556.         mov eax,[top]
  557.         fld qword[eax]
  558.         fstp dword[p+16]
  559.         mov eax,[near]
  560.         fld qword[eax]
  561.         fstp dword[p+20]
  562.         mov eax,[farv]
  563.         fld qword[eax]
  564.         fstp dword[p+24]
  565.  
  566.         mov eax,ebp
  567.         sub eax,28 ;=sizeof(dd)*7
  568.         stdcall gl_add_op,eax
  569.         ret
  570. endp
  571.  
  572. ; lightening
  573.  
  574. align 4
  575. proc glMaterialfv uses eax ecx, mode:dword, type:dword, v:dword
  576. locals
  577.         p rd 7
  578. endl
  579.  
  580. ;  assert(mode == GL_FRONT  || mode == GL_BACK || mode==GL_FRONT_AND_BACK);
  581.  
  582.         mov dword[p],OP_Material
  583.         mov eax,[mode]
  584.         mov dword[p+4],eax
  585.         mov eax,[type]
  586.         mov dword[p+8],eax
  587.  
  588.         mov eax,[v]
  589.         mov ecx,[eax+8]
  590.         mov dword[p+12],ecx
  591.         mov ecx,[eax+4]
  592.         mov dword[p+16],ecx
  593.         mov ecx,[eax]
  594.         mov dword[p+20],ecx
  595.         mov ecx,[eax+12]
  596.         mov dword[p+24],ecx
  597.  
  598.         cmp dword[type],GL_SHININESS
  599.         jne @f
  600.                 mov dword[p+16],0.0
  601.                 mov dword[p+20],0.0
  602.                 mov dword[p+24],0.0
  603.         @@:
  604.  
  605.         mov eax,ebp
  606.         sub eax,28 ;=sizeof(dd)*7
  607.         stdcall gl_add_op,eax
  608.         ret
  609. endp
  610.  
  611. align 4
  612. proc glMaterialf uses eax, mode:dword, type:dword, v:dword
  613. locals
  614.         p rd 7
  615. endl
  616.         mov dword[p],OP_Material
  617.         mov eax,[mode]
  618.         mov dword[p+4],eax
  619.         mov eax,[type]
  620.         mov dword[p+8],eax
  621.         mov eax,[v]
  622.         mov dword[p+12],eax
  623.         mov dword[p+16],0.0
  624.         mov dword[p+20],0.0
  625.         mov dword[p+24],0.0
  626.  
  627.         mov eax,ebp
  628.         sub eax,28 ;=sizeof(dd)*7
  629.         stdcall gl_add_op,eax
  630.         ret
  631. endp
  632.  
  633. align 4
  634. proc glColorMaterial uses eax, mode:dword, type:dword
  635. locals
  636.         p rd 3
  637. endl
  638.         mov dword[p],OP_ColorMaterial
  639.         mov eax,[mode]
  640.         mov dword[p+4],eax
  641.         mov eax,[type]
  642.         mov dword[p+8],eax
  643.  
  644.         mov eax,ebp
  645.         sub eax,12 ;=sizeof(dd)*3
  646.         stdcall gl_add_op,eax
  647.         ret
  648. endp
  649.  
  650. align 4
  651. proc glLightfv uses eax ecx, light:dword, type:dword, v:dword
  652. locals
  653.         p rd 7
  654. endl
  655.         mov dword[p],OP_Light
  656.         mov eax,[light]
  657.         mov dword[p+4],eax
  658.         mov eax,[type]
  659.         mov dword[p+8],eax
  660.  
  661.         ;TODO: 3 composants ?
  662.         mov eax,[v]
  663.         mov ecx,[eax]
  664.         mov dword[p+12],ecx
  665.         mov ecx,[eax+4]
  666.         mov dword[p+16],ecx
  667.         mov ecx,[eax+8]
  668.         mov dword[p+20],ecx
  669.         mov ecx,[eax+12]
  670.         mov dword[p+24],ecx
  671.  
  672.         mov eax,ebp
  673.         sub eax,28 ;=sizeof(dd)*7
  674.         stdcall gl_add_op,eax
  675.         ret
  676. endp
  677.  
  678. align 4
  679. proc glLightf uses eax, light:dword, type:dword, v:dword
  680. locals
  681.         p rd 7
  682. endl
  683.         mov dword[p],OP_Light
  684.         mov eax,[light]
  685.         mov dword[p+4],eax
  686.         mov eax,[type]
  687.         mov dword[p+8],eax
  688.         mov eax,[v]
  689.         mov dword[p+12],eax
  690.         mov dword[p+16],0.0
  691.         mov dword[p+20],0.0
  692.         mov dword[p+24],0.0
  693.  
  694.         mov eax,ebp
  695.         sub eax,28 ;=sizeof(dd)*7
  696.         stdcall gl_add_op,eax
  697.         ret
  698. endp
  699.  
  700. align 4
  701. proc glLightModeli uses eax, pname:dword, param:dword
  702. locals
  703.         p rd 6
  704. endl
  705.         mov dword[p],OP_LightModel
  706.         mov eax,[pname]
  707.         mov dword[p+4],eax
  708.         fild dword[param]
  709.         fstp dword[p+8] ;преобразовали int во float
  710.  
  711.         mov dword[p+12],0.0
  712.         mov dword[p+16],0.0
  713.         mov dword[p+20],0.0
  714.  
  715.         mov eax,ebp
  716.         sub eax,24 ;=sizeof(dd)*6
  717.         stdcall gl_add_op,eax
  718.         ret
  719. endp
  720.  
  721. align 4
  722. proc glLightModelfv uses eax ecx, pname:dword, param:dword
  723. locals
  724.         p rd 6
  725. endl
  726.         mov dword[p],OP_LightModel
  727.         mov eax,[pname]
  728.         mov dword[p+4],eax
  729.         mov eax,[param]
  730.         mov ecx,[eax]
  731.         mov dword[p+8],ecx
  732.         mov ecx,[eax+4]
  733.         mov dword[p+12],ecx
  734.         mov ecx,[eax+8]
  735.         mov dword[p+16],ecx
  736.         mov ecx,[eax+12]
  737.         mov dword[p+20],ecx
  738.  
  739.         mov eax,ebp
  740.         sub eax,24 ;=sizeof(dd)*6
  741.         stdcall gl_add_op,eax
  742.         ret
  743. endp
  744.  
  745. ; clear
  746.  
  747. align 4
  748. proc glClear uses eax, mask:dword
  749. locals
  750.         p rd 2
  751. endl
  752.         mov dword[p],OP_Clear
  753.         mov eax,[mask]
  754.         mov dword[p+4],eax
  755.  
  756.         mov eax,ebp
  757.         sub eax,8 ;=sizeof(dd)*2
  758.         stdcall gl_add_op,eax
  759.         ret
  760. endp
  761.  
  762. align 4
  763. proc glClearColor uses eax, r:dword, g:dword, b:dword, a:dword
  764. locals
  765.         p rd 5
  766. endl
  767.         mov dword[p],OP_ClearColor
  768.         mov eax,[b]
  769.         mov dword[p+4],eax
  770.         mov eax,[g]
  771.         mov dword[p+8],eax
  772.         mov eax,[r]
  773.         mov dword[p+12],eax
  774.         mov eax,[a]
  775.         mov dword[p+16],eax
  776.  
  777.         mov eax,ebp
  778.         sub eax,20 ;=sizeof(dd)*5
  779.         stdcall gl_add_op,eax
  780.         ret
  781. endp
  782.  
  783. align 4
  784. proc glClearDepth uses eax, depth:dword
  785. locals
  786.         p rd 2
  787. endl
  788.         mov dword[p],OP_ClearDepth
  789.         mov eax,[depth]
  790.         fld qword[eax]
  791.         fstp dword[p+4]
  792.  
  793.         mov eax,ebp
  794.         sub eax,8 ;=sizeof(dd)*2
  795.         stdcall gl_add_op,eax
  796.         ret
  797. endp
  798.  
  799. ; textures
  800.  
  801. align 4
  802. proc glTexImage2D uses ecx edi esi,\
  803.         target:dword, level:dword, components:dword,\
  804.         width:dword, height:dword, border:dword,\
  805.         format:dword, type:dword, pixels:dword
  806. locals
  807.         p rd 10
  808. endl
  809.         mov dword[p],OP_TexImage2D
  810.         mov ecx,9
  811.         mov esi,ebp
  812.         add esi,8 ;указатель на стек с входными параметрами
  813.         mov edi,ebp
  814.         sub edi,36 ;указатель на стек с локальным массивом
  815.         rep movsd ;копирование в цикле 9-ти входных параметров
  816.  
  817.         mov ecx,ebp
  818.         sub ecx,40 ;=sizeof(dd)*10
  819.         stdcall gl_add_op,ecx
  820.         ret
  821. endp
  822.  
  823. align 4
  824. proc glBindTexture uses eax, target:dword, texture:dword
  825. locals
  826.         p rd 3
  827. endl
  828.         mov dword[p],OP_BindTexture
  829.         mov eax,[target]
  830.         mov dword[p+4],eax
  831.         mov eax,[texture]
  832.         mov dword[p+8],eax
  833.  
  834.         mov eax,ebp
  835.         sub eax,12 ;=sizeof(dd)*3
  836.         stdcall gl_add_op,eax
  837.         ret
  838. endp
  839.  
  840. align 4
  841. proc glTexEnvi uses eax, target:dword, pname:dword, param:dword
  842. locals
  843.         p rd 8
  844. endl
  845.         mov dword[p],OP_TexEnv
  846.         mov eax,[target]
  847.         mov dword[p+4],eax
  848.         mov eax,[pname]
  849.         mov dword[p+8],eax
  850.         mov eax,[param]
  851.         mov dword[p+12],eax
  852.         mov dword[p+16],0.0
  853.         mov dword[p+20],0.0
  854.         mov dword[p+24],0.0
  855.         mov dword[p+28],0.0
  856.  
  857.         mov eax,ebp
  858.         sub eax,32 ;=sizeof(dd)*8
  859.         stdcall gl_add_op,eax
  860.         ret
  861. endp
  862.  
  863. align 4
  864. proc glTexParameteri uses eax, target:dword, pname:dword, param:dword
  865. locals
  866.         p rd 8
  867. endl
  868.         mov dword[p],OP_TexParameter
  869.         mov eax,[target]
  870.         mov dword[p+4],eax
  871.         mov eax,[pname]
  872.         mov dword[p+8],eax
  873.         mov eax,[param]
  874.         mov dword[p+12],eax
  875.         mov dword[p+16],0.0
  876.         mov dword[p+20],0.0
  877.         mov dword[p+24],0.0
  878.         mov dword[p+28],0.0
  879.  
  880.         mov eax,ebp
  881.         sub eax,32 ;=sizeof(dd)*8
  882.         stdcall gl_add_op,eax
  883.         ret
  884. endp
  885.  
  886. align 4
  887. proc glPixelStorei uses eax, pname:dword, param:dword
  888. locals
  889.         p rd 3
  890. endl
  891.         mov dword[p],OP_PixelStore
  892.         mov eax,[pname]
  893.         mov dword[p+4],eax
  894.         mov eax,[param]
  895.         mov dword[p+8],eax
  896.  
  897.         mov eax,ebp
  898.         sub eax,12 ;=sizeof(dd)*3
  899.         stdcall gl_add_op,eax
  900.         ret
  901. endp
  902.  
  903. ; selection
  904.  
  905. align 4
  906. proc glInitNames uses eax
  907. locals
  908.         p dd ?
  909. endl
  910.         mov dword[p],OP_InitNames
  911.  
  912.         mov eax,ebp
  913.         sub eax,4 ;=sizeof(dd)*1
  914.         stdcall gl_add_op,eax
  915.         ret
  916. endp
  917.  
  918. align 4
  919. proc glPushName uses eax, name:dword
  920. locals
  921.         p rd 2
  922. endl
  923.         mov dword[p],OP_PushName
  924.         mov eax,[name]
  925.         mov dword[p+4],eax
  926.  
  927.         mov eax,ebp
  928.         sub eax,8 ;=sizeof(dd)*2
  929.         stdcall gl_add_op,eax
  930.         ret
  931. endp
  932.  
  933. align 4
  934. proc glPopName uses eax
  935. locals
  936.         p dd ?
  937. endl
  938.         mov dword[p],OP_PopName
  939.  
  940.         mov eax,ebp
  941.         sub eax,4 ;=sizeof(dd)*1
  942.         stdcall gl_add_op,eax
  943.         ret
  944. endp
  945.  
  946. align 4
  947. proc glLoadName uses eax, name:dword
  948. locals
  949.         p rd 2
  950. endl
  951.         mov dword[p],OP_LoadName
  952.         mov eax,[name]
  953.         mov dword[p+4],eax
  954.  
  955.         mov eax,ebp
  956.         sub eax,8 ;=sizeof(dd)*2
  957.         stdcall gl_add_op,eax
  958.         ret
  959. endp
  960.  
  961. align 4
  962. proc glPolygonOffset uses eax, factor:dword, units:dword
  963. locals
  964.         p rd 3
  965. endl
  966.         mov dword[p],OP_PolygonOffset
  967.         mov eax,[factor]
  968.         mov dword[p+4],eax
  969.         mov eax,[units]
  970.         mov dword[p+8],eax
  971.  
  972.         mov eax,ebp
  973.         sub eax,12 ;=sizeof(dd)*3
  974.         stdcall gl_add_op,eax
  975.         ret
  976. endp
  977.  
  978. ; Special Functions
  979.  
  980. align 4
  981. proc glCallList uses eax, list:dword
  982. locals
  983.         p rd 2
  984. endl
  985.         mov dword[p],OP_CallList
  986.         mov eax,[list]
  987.         mov dword[p+4],eax
  988.  
  989.         mov eax,ebp
  990.         sub eax,8 ;=sizeof(dd)*2
  991.         stdcall gl_add_op,eax
  992.         ret
  993. endp
  994.  
  995. align 4
  996. proc glFlush ;(void)
  997.         ;nothing to do
  998.         ret
  999. endp
  1000.  
  1001. align 4
  1002. proc glHint uses eax, target:dword, mode:dword
  1003. locals
  1004.         p rd 3
  1005. endl
  1006.         mov dword[p],OP_Hint
  1007.         mov eax,[target]
  1008.         mov dword[p+4],eax
  1009.         mov eax,[mode]
  1010.         mov dword[p+8],eax
  1011.  
  1012.         mov eax,ebp
  1013.         sub eax,12 ;=sizeof(dd)*3
  1014.         stdcall gl_add_op,eax
  1015.         ret
  1016. endp
  1017.  
  1018. ; Non standard functions
  1019.  
  1020. align 4
  1021. proc glDebug uses eax, mode:dword
  1022.         stdcall gl_get_context ;после вызова функции в eax указатель на GLContext
  1023.         push dword[mode]
  1024.         pop dword[eax+offs_cont_print_flag]
  1025.         ret
  1026. endp
  1027.