Subversion Repositories Kolibri OS

Rev

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