Subversion Repositories Kolibri OS

Rev

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