Subversion Repositories Kolibri OS

Rev

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