Subversion Repositories Kolibri OS

Rev

Rev 8062 | Rev 8408 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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