Subversion Repositories Kolibri OS

Rev

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