Subversion Repositories Kolibri OS

Rev

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