Subversion Repositories Kolibri OS

Rev

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