Subversion Repositories Kolibri OS

Rev

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

  1. VERTEX_ARRAY   equ 0x0001
  2. COLOR_ARRAY    equ 0x0002
  3. NORMAL_ARRAY   equ 0x0004
  4. TEXCOORD_ARRAY equ 0x0008
  5.  
  6. ;glArrayElement - использование (рисование) одного элемента из массива
  7. ;glDrawArrays - рисование всех элементов в массиве
  8. ;glDrawElements - рисование тех элементов в массиве, которые заданны в массиве индексов
  9.  
  10. align 4
  11. proc glopArrayElement uses eax ebx ecx edx, context:dword, param:dword
  12. locals
  13.         p rd 5
  14. endl
  15.         mov eax,[context]
  16.         mov ebx,[param]
  17.         mov ebx,[ebx+4] ;ebx = p[1]
  18.  
  19.         bt dword[eax+offs_cont_client_states],1 ;2^1=COLOR_ARRAY
  20.         jnc @f
  21.                 mov ecx,[eax+offs_cont_color_array_size]
  22.                 add ecx,[eax+offs_cont_color_array_stride]
  23.                 imul ecx,ebx
  24.                 shl ecx,2
  25.                 add ecx,[eax+offs_cont_color_array] ;ecx = &context.color_array[i]
  26.                 mov ebx,ebp
  27.                 sub ebx,20 ;=sizeof(dd)*5
  28.                 mov edx,[ecx]
  29.                 mov [ebx+4],edx
  30.                 mov edx,[ecx+4]
  31.                 mov [ebx+8],edx
  32.                 mov edx,[ecx+8]
  33.                 mov [ebx+12],edx
  34.                 cmp dword[eax+offs_cont_color_array_size],3
  35.                 jg .l0
  36.                         mov edx,1.0
  37.                         jmp .l1
  38.                 .l0:
  39.                         mov edx,[ecx+12]
  40.                 .l1:
  41.                 mov [ebx+16],edx
  42.                 stdcall glopColor, eax,ebx
  43.         @@:
  44.         bt dword[eax+offs_cont_client_states],2 ;2^2=NORMAL_ARRAY
  45.         jnc @f
  46.                 mov esi,dword[eax+offs_cont_normal_array_stride]
  47.                 add esi,3
  48.                 imul esi,ebx
  49.                 shl esi,2
  50.                 add esi,[eax+offs_cont_normal_array] ;esi = &normal_array[ebx * (3 + c->normal_array_stride)]
  51.                 mov edi,eax
  52.                 add edi,offs_cont_current_normal
  53.                 mov ecx,3
  54.                 rep movsd
  55.                 mov dword[edi],0.0
  56.         @@:
  57.         bt dword[eax+offs_cont_client_states],3 ;2^3=TEXCOORD_ARRAY
  58.         jnc @f
  59.                 mov ecx,[eax+offs_cont_texcoord_array_size]
  60.                 add ecx,[eax+offs_cont_texcoord_array_stride]
  61.                 imul ecx,ebx
  62.                 shl ecx,2
  63.                 add ecx,[eax+offs_cont_texcoord_array] ;ecx = &context.texcoord_array[i]
  64.                 mov edx,[ecx]
  65.                 mov [eax+offs_cont_current_tex_coord],edx
  66.                 mov edx,[ecx+4]
  67.                 mov [eax+offs_cont_current_tex_coord+4],edx
  68.  
  69.                 cmp dword[eax+offs_cont_texcoord_array_size],2
  70.                 jg .l2
  71.                         mov edx,0.0
  72.                         jmp .l3
  73.                 .l2:
  74.                         mov edx,[ecx+8]
  75.                 .l3:
  76.                 mov [eax+offs_cont_current_tex_coord+8],edx
  77.  
  78.                 cmp dword[eax+offs_cont_texcoord_array_size],3
  79.                 jg .l4
  80.                         mov edx,1.0
  81.                         jmp .l5
  82.                 .l4:
  83.                         mov edx,[ecx+12]
  84.                 .l5:
  85.  
  86.                 mov [eax+offs_cont_current_tex_coord+12],edx
  87.         @@:
  88.         bt dword[eax+offs_cont_client_states],0 ;2^0=VERTEX_ARRAY
  89.         jnc @f
  90.                 mov ecx,[eax+offs_cont_vertex_array_size]
  91.                 add ecx,[eax+offs_cont_vertex_array_stride]
  92.                 imul ecx,ebx
  93.                 shl ecx,2
  94.                 add ecx,[eax+offs_cont_vertex_array] ;ecx = &context.vertex_array[i]
  95.                 mov ebx,ebp
  96.                 sub ebx,20 ;=sizeof(dd)*5
  97.                 mov edx,[ecx]
  98.                 mov [ebx+4],edx
  99.                 mov edx,[ecx+4]
  100.                 mov [ebx+8],edx
  101.  
  102.                 cmp dword[eax+offs_cont_vertex_array_size],2
  103.                 jg .l6
  104.                         mov edx,0.0
  105.                         jmp .l7
  106.                 .l6:
  107.                         mov edx,[ecx+8]
  108.                 .l7:
  109.                 mov [ebx+12],edx
  110.                 cmp dword[eax+offs_cont_vertex_array_size],3
  111.                 jg .l8
  112.                         mov edx,1.0
  113.                         jmp .l9
  114.                 .l8:
  115.                         mov edx,[ecx+12]
  116.                 .l9:
  117.  
  118.                 mov [ebx+16],edx
  119.                 stdcall glopVertex, eax,ebx
  120.         @@:
  121.         ret
  122. endp
  123.  
  124. align 4
  125. proc glArrayElement uses eax, i:dword
  126. locals
  127.         p rd 2
  128. endl
  129.         mov dword[p],OP_ArrayElement
  130.         mov eax,[i]
  131.         mov dword[p+4],eax
  132.  
  133.         mov eax,ebp
  134.         sub eax,8 ;=sizeof(dd)*2
  135.         stdcall gl_add_op,eax
  136.         ret
  137. endp
  138.  
  139. align 4
  140. proc glopDrawArrays, context:dword, param:dword
  141. locals
  142.         vi dd ?
  143.         idx dd ?
  144.         states dd ?
  145.         size dd ?
  146.         p rd 8 ;функция glopColor требует 8 параметров, другие функции требуют меньше, берем по максимуму что-бы не портить стек
  147. endl
  148. pushad
  149.         mov edx,[context]
  150.         mov ebx,[param]
  151.         mov ecx,[ebx+12] ;count = param[3].i
  152.         mov eax,[edx+offs_cont_client_states]
  153.         mov [states],eax
  154.         mov eax,[ebx+8]
  155.         mov [idx],eax ;param[2].i
  156.         mov eax,[ebx+4]
  157.         mov [p+4],eax ;p[1].i = param[1].i
  158.         mov eax,ebp
  159.         sub eax,32 ;=sizeof(dd)*8
  160.         stdcall glopBegin, edx,eax
  161.  
  162.         mov dword[vi],0
  163. align 4
  164.         .cycle_0: ;for (int vi=0; vi<count; vi++)
  165.         cmp dword[vi],ecx
  166.         jge .cycle_0_end
  167.                 bt dword[states],1 ;2^1=COLOR_ARRAY
  168.                 jnc @f
  169.                         mov esi,[edx+offs_cont_color_array_size]
  170.                         mov [size],esi
  171.                         add esi,[edx+offs_cont_color_array_stride]
  172.                         imul esi,[idx] ;esi = i
  173.                         shl esi,2
  174.                         add esi,[edx+offs_cont_color_array] ;esi = &context.color_array[i]
  175.                         mov edi,ebp
  176.                         sub edi,28 ;edi = &p[1]
  177.                         mov ebx,[esi+8]
  178.                         mov [edi],ebx   ;p[1].f = context.color_array[i+2]
  179.                         mov ebx,[esi+4]
  180.                         mov [edi+4],ebx ;p[2].f = context.color_array[i+1]
  181.                         mov ebx,[esi]
  182.                         mov [edi+8],ebx ;p[3].f = context.color_array[i]
  183.                         add edi,12
  184.                         cmp dword[size],3
  185.                         jle .e1
  186.                                 add esi,12
  187.                                 movsd
  188.                                 jmp .e2
  189.                         .e1:
  190.                                 mov dword[edi],1.0 ;если задано 3 параметра, то 4-й ставим по умолчанию 1.0
  191.                         .e2:
  192.                         mov edi,ebp
  193.                         sub edi,32 ;edi = &p[0]
  194.                         mov ebx,ebp
  195.                         sub ebx,12 ;ebp-12 = &p[5]
  196.                         push ebx
  197.                         add ebx,4 ;ebp-8 = &p[6]
  198.                         push ebx
  199.                         add ebx,4 ;ebp-4 = &p[7]
  200.                         push ebx
  201.                         stdcall RGBFtoRGBI,[edi+12],[edi+8],[edi+4] ;call: r,g,b,&p[7],&p[6],&p[5]
  202.                         stdcall glopColor, edx,edi ;(context, p(op,rf,gf,bf,af,ri,gi,bi))
  203.                 @@:
  204.                 bt dword[states],2 ;2^2=NORMAL_ARRAY
  205.                 jnc @f
  206.                         mov esi,[edx+offs_cont_normal_array_stride]
  207.                         add esi,3
  208.                         imul esi,[idx]
  209.                         shl esi,2
  210.                         add esi,[edx+offs_cont_normal_array] ;esi = &context.normal_array[ idx * (3 + context.normal_array_stride) ]
  211.                         mov edi,edx
  212.                         add edi,offs_cont_current_normal
  213.                         movsd ;context.current_normal.X = context.normal_array[i]
  214.                         movsd
  215.                         movsd
  216.                         mov dword[edi],0.0 ;context.current_normal.W = 0.0f
  217.                 @@:
  218.                 bt dword[states],3 ;2^3=TEXCOORD_ARRAY
  219.                 jnc @f
  220.                         mov esi,[edx+offs_cont_texcoord_array_size]
  221.                         mov [size],esi
  222.                         add esi,[edx+offs_cont_texcoord_array_stride]
  223.                         imul esi,[idx] ;esi = i
  224.                         shl esi,2
  225.                         add esi,[edx+offs_cont_texcoord_array] ;esi = &context.texcoord_array[i]
  226.                         mov edi,edx
  227.                         add edi,offs_cont_current_tex_coord
  228.                         movsd ;context.current_tex_coord.X = ccontext.texcoord_array[i]
  229.                         movsd
  230.                         cmp dword[size],2
  231.                         jle .e3
  232.                                 movsd
  233.                                 jmp .e4
  234.                         .e3:
  235.                                 mov dword[edi],0.0 ;если задано 2 параметра, то 3-й ставим по умолчанию 0.0
  236.                                 add edi,4
  237.                         .e4:
  238.                         cmp dword[size],3
  239.                         jle .e5
  240.                                 movsd
  241.                                 jmp @f
  242.                         .e5:
  243.                                 mov dword[edi],1.0 ;если задано 3 параметра, то 4-й ставим по умолчанию 1.0
  244.                 @@:
  245.                 bt dword[states],0 ;2^0=VERTEX_ARRAY
  246.                 jnc @f
  247.                         mov esi,[edx+offs_cont_vertex_array_size]
  248.                         mov [size],esi
  249.                         add esi,[edx+offs_cont_vertex_array_stride]
  250.                         imul esi,[idx] ;esi = i
  251.                         shl esi,2
  252.                         add esi,[edx+offs_cont_vertex_array] ;esi = &context.vertex_array[i]
  253.                         mov edi,ebp
  254.                         sub edi,28 ;edi = &p[1]
  255.                         movsd ;p[1].f = context.vertex_array[i]
  256.                         movsd
  257.                         cmp dword[size],2
  258.                         jle .e6
  259.                                 movsd
  260.                                 jmp .e7
  261.                         .e6:
  262.                                 mov dword[edi],0.0 ;если задано 2 параметра, то 3-й ставим по умолчанию 0.0
  263.                                 add edi,4
  264.                                 jmp .e8 ;и 4-й тоже ставим по умолчанию
  265.                         .e7:
  266.                         cmp dword[size],3
  267.                         jle .e8
  268.                                 movsd
  269.                                 sub edi,20 ;edi=&p[0]
  270.                                 jmp .e9
  271.                         .e8:
  272.                                 mov dword[edi],1.0 ;если задано 3 параметра, то 4-й ставим по умолчанию 1.0
  273.                                 sub edi,16 ;edi=&p[0]
  274.                         .e9:
  275.                         stdcall glopVertex, edx,edi
  276.                 @@:
  277.                 inc dword[idx]
  278.         inc dword[vi]
  279.         jmp .cycle_0
  280.         .cycle_0_end:
  281.  
  282.         ;mov eax,ebp
  283.         ;sub eax,32 ;=sizeof(dd)*8
  284.         stdcall glopEnd, edx,eax
  285. popad
  286.         ret
  287. endp
  288.  
  289. align 4
  290. proc glDrawArrays uses eax, mode:dword, first:dword, count:dword
  291. locals
  292.         p rd 4
  293. endl
  294.         mov dword[p],OP_DrawArrays
  295.         mov eax,[mode]
  296.         mov dword[p+4],eax
  297.         mov eax,[first]
  298.         mov dword[p+8],eax
  299.         mov eax,[count]
  300.         mov dword[p+12],eax
  301.  
  302.         mov eax,ebp
  303.         sub eax,16 ;=sizeof(dd)*4
  304.         stdcall gl_add_op,eax
  305.         ret
  306. endp
  307.  
  308. align 4
  309. proc glopDrawElements uses eax ebx edx, context:dword, param:dword
  310. locals
  311.         p rd 8
  312. endl
  313.  
  314.         mov edx,[context]
  315.         mov ebx,[param]
  316.   ;int i;
  317.   ;int idx;
  318.   ;int states = c->client_states;
  319.   ;int count = param[2].i;
  320.   ;int type = param[3].i;
  321.   ;unsigned int *indices_u32 = (unsigned int*)param[4].p;
  322.   ;unsigned short *indices_u16 = (unsigned short*)indices_u32;
  323.  
  324.         mov eax,[ebx+4]
  325.         mov [p+4],eax ;p[1].i = param[1].i
  326.         mov eax,ebp
  327.         sub eax,32 ;=sizeof(dd)*8
  328.         stdcall glopBegin, edx,eax
  329.  
  330. ;  for (int ii=0; ii<count; ii++) {
  331. ;    idx = (type == GL_UNSIGNED_INT) ? indices_u32[ii] : indices_u16[ii];
  332. ;    if (states & COLOR_ARRAY) {
  333. ;      GLParam p[5];
  334. ;      int size = c->color_array_size;
  335. ;      i = idx * (size + c->color_array_stride);
  336. ;      p[1].f = c->color_array[i];
  337. ;      p[2].f = c->color_array[i+1];
  338. ;      p[3].f = c->color_array[i+2];
  339. ;      p[4].f = size > 3 ? c->color_array[i+3] : 1.0f;
  340. ;      glopColor(c, p);  
  341. ;    }
  342. ;    if (states & NORMAL_ARRAY) {
  343. ;      i = idx * (3 + c->normal_array_stride);
  344. ;      c->current_normal.X = c->normal_array[i];
  345. ;      c->current_normal.Y = c->normal_array[i+1];
  346. ;      c->current_normal.Z = c->normal_array[i+2];
  347. ;      c->current_normal.W = 0.0f;
  348. ;    }
  349. ;    if (states & TEXCOORD_ARRAY) {
  350. ;      int size = c->texcoord_array_size;
  351. ;      i = idx * (size + c->texcoord_array_stride);
  352. ;      c->current_tex_coord.X = c->texcoord_array[i];
  353. ;      c->current_tex_coord.Y = c->texcoord_array[i+1];
  354. ;      c->current_tex_coord.Z = size > 2 ? c->texcoord_array[i+2] : 0.0f;
  355. ;      c->current_tex_coord.W = size > 3 ? c->texcoord_array[i+3] : 1.0f;
  356. ;    }
  357. ;    if (states & VERTEX_ARRAY) {
  358. ;      GLParam p[5];
  359. ;      int size = c->vertex_array_size;
  360. ;      i = idx * (size + c->vertex_array_stride);
  361. ;      p[1].f = c->vertex_array[i];
  362. ;      p[2].f = c->vertex_array[i+1];
  363. ;      p[3].f = size > 2 ? c->vertex_array[i+2] : 0.0f;
  364. ;      p[4].f = size > 3 ? c->vertex_array[i+3] : 1.0f;
  365. ;      glopVertex(c, p);
  366. ;    }
  367. ;  }
  368.         mov eax,ebp
  369.         sub eax,32 ;=sizeof(dd)*8
  370.         stdcall glopEnd, edx,eax
  371.         ret
  372. endp
  373.  
  374. align 4
  375. proc glDrawElements uses eax, mode:dword, count:dword, type:dword, indices:dword
  376. locals
  377.         p rd 5
  378. endl
  379. ;assert(type == GL_UNSIGNED_SHORT || type == GL_UNSIGNED_INT/* nonstandard */);
  380.         mov dword[p],OP_DrawElements
  381.         mov eax,[mode]
  382.         mov dword[p+4],eax
  383.         mov eax,[count]
  384.         mov dword[p+8],eax
  385.         mov eax,[type]
  386.         mov dword[p+12],eax
  387.         mov eax,[indices]
  388.         mov dword[p+16],eax
  389.  
  390.         mov eax,ebp
  391.         sub eax,20 ;=sizeof(dd)*5
  392.         stdcall gl_add_op,eax
  393.         ret
  394. endp
  395.  
  396. align 4
  397. proc glopEnableClientState uses eax ebx, context:dword, p:dword
  398.         mov eax,[context]
  399.         mov ebx,[p]
  400.         mov ebx,[ebx+4] ;ebx = p[1]
  401.         or dword[eax+offs_cont_client_states],ebx
  402.         ret
  403. endp
  404.  
  405. align 4
  406. proc glEnableClientState uses eax, array:dword
  407. locals
  408.         p rd 2
  409. endl
  410.         mov dword[p],OP_EnableClientState
  411.  
  412.         cmp dword[array],GL_VERTEX_ARRAY
  413.         jne @f
  414.                 mov dword[p+4],VERTEX_ARRAY
  415.                 jmp .end_f
  416.         @@:
  417.         cmp dword[array],GL_NORMAL_ARRAY
  418.         jne @f
  419.                 mov dword[p+4],NORMAL_ARRAY
  420.                 jmp .end_f
  421.         @@:
  422.         cmp dword[array],GL_COLOR_ARRAY
  423.         jne @f
  424.                 mov dword[p+4],COLOR_ARRAY
  425.                 jmp .end_f
  426.         @@:
  427.         cmp dword[array],GL_TEXTURE_COORD_ARRAY
  428.         jne @f
  429.                 mov dword[p+4],TEXCOORD_ARRAY
  430.                 jmp .end_f
  431.         @@:
  432.                 ;assert(0);
  433.         .end_f:
  434.  
  435.         mov eax,ebp
  436.         sub eax,8 ;=sizeof(dd)*2
  437.         stdcall gl_add_op,eax
  438.         ret
  439. endp
  440.  
  441. align 4
  442. proc glopDisableClientState uses eax ebx, context:dword, p:dword
  443.         mov eax,[context]
  444.         mov ebx,[p]
  445.         mov ebx,[ebx+4] ;ebx = p[1]
  446.         and dword[eax+offs_cont_client_states],ebx
  447.         ret
  448. endp
  449.  
  450. align 4
  451. proc glDisableClientState uses eax, array:dword
  452. locals
  453.         p rd 2
  454. endl
  455.         mov dword[p],OP_DisableClientState
  456.  
  457.         cmp dword[array],GL_VERTEX_ARRAY
  458.         jne @f
  459.                 mov dword[p+4], not VERTEX_ARRAY
  460.                 jmp .end_f
  461.         @@:
  462.         cmp dword[array],GL_NORMAL_ARRAY
  463.         jne @f
  464.                 mov dword[p+4], not NORMAL_ARRAY
  465.                 jmp .end_f
  466.         @@:
  467.         cmp dword[array],GL_COLOR_ARRAY
  468.         jne @f
  469.                 mov dword[p+4], not COLOR_ARRAY
  470.                 jmp .end_f
  471.         @@:
  472.         cmp dword[array],GL_TEXTURE_COORD_ARRAY
  473.         jne @f
  474.                 mov dword[p+4], not TEXCOORD_ARRAY
  475.                 jmp .end_f
  476.         @@:
  477.                 ;assert(0);
  478.         .end_f:
  479.  
  480.         mov eax,ebp
  481.         sub eax,8 ;=sizeof(dd)*2
  482.         stdcall gl_add_op,eax
  483.         ret
  484. endp
  485.  
  486. align 4
  487. proc glopVertexPointer uses eax ebx ecx, context:dword, p:dword
  488.         mov eax,[context]
  489.         mov ebx,[p]
  490.         mov ecx,[ebx+4] ;ecx = p[1]
  491.         mov dword[eax+offs_cont_vertex_array_size],ecx
  492.         mov ecx,[ebx+8] ;ecx = p[2]
  493.         mov dword[eax+offs_cont_vertex_array_stride],ecx
  494.         mov ecx,[ebx+12] ;ecx = p[3]
  495.         mov dword[eax+offs_cont_vertex_array],ecx
  496.         ret
  497. endp
  498.  
  499. align 4
  500. proc glVertexPointer uses eax, size:dword, type:dword, stride:dword, pointer:dword
  501. locals
  502.         p rd 4
  503. endl
  504. ;  assert(type == GL_FLOAT);
  505.  
  506.         mov dword[p],OP_VertexPointer
  507.         mov eax,[size]
  508.         mov dword[p+4],eax
  509.         mov eax,[stride]
  510.         mov dword[p+8],eax
  511.         mov eax,[pointer]
  512.         mov dword[p+12],eax
  513.  
  514.         mov eax,ebp
  515.         sub eax,16 ;=sizeof(dd)*4
  516.         stdcall gl_add_op,eax
  517.         ret
  518. endp
  519.  
  520. align 4
  521. proc glopColorPointer uses eax ebx ecx, context:dword, p:dword
  522.         mov eax,[context]
  523.         mov ebx,[p]
  524.         mov ecx,[ebx+4] ;ecx = p[1]
  525.         mov dword[eax+offs_cont_color_array_size],ecx
  526.         mov ecx,[ebx+8] ;ecx = p[2]
  527.         mov dword[eax+offs_cont_color_array_stride],ecx
  528.         mov ecx,[ebx+12] ;ecx = p[3]
  529.         mov dword[eax+offs_cont_color_array],ecx
  530.         ret
  531. endp
  532.  
  533. align 4
  534. proc glColorPointer uses eax, size:dword, type:dword, stride:dword, pointer:dword
  535. locals
  536.         p rd 4
  537. endl
  538. ;  assert(type == GL_FLOAT);
  539.  
  540.         mov dword[p],OP_ColorPointer
  541.         mov eax,[size]
  542.         mov dword[p+4],eax
  543.         mov eax,[stride]
  544.         mov dword[p+8],eax
  545.         mov eax,[pointer]
  546.         mov dword[p+12],eax
  547.  
  548.         mov eax,ebp
  549.         sub eax,16 ;=sizeof(dd)*4
  550.         stdcall gl_add_op,eax
  551.         ret
  552. endp
  553.  
  554. align 4
  555. proc glopNormalPointer uses eax ebx ecx, context:dword, p:dword
  556.         mov eax,[context]
  557.         mov ebx,[p]
  558.         mov ecx,[ebx+4] ;ecx = p[1]
  559.         mov dword[eax+offs_cont_normal_array_stride],ecx
  560.         mov ecx,[ebx+8] ;ecx = p[2]
  561.         mov dword[eax+offs_cont_normal_array],ecx
  562.         ret
  563. endp
  564.  
  565. align 4
  566. proc glNormalPointer uses eax, type:dword, stride:dword, pointer:dword
  567. locals
  568.         p rd 3
  569. endl
  570. ;  assert(type == GL_FLOAT);
  571.  
  572.         mov dword[p],OP_NormalPointer
  573.         mov eax,[stride]
  574.         mov dword[p+4],eax
  575.         mov eax,[pointer]
  576.         mov dword[p+8],eax
  577.  
  578.         mov eax,ebp
  579.         sub eax,12 ;=sizeof(dd)*3
  580.         stdcall gl_add_op,eax
  581.         ret
  582. endp
  583.  
  584. align 4
  585. proc glopTexCoordPointer uses eax ebx ecx, context:dword, p:dword
  586.         mov eax,[context]
  587.         mov ebx,[p]
  588.         mov ecx,[ebx+4] ;ecx = p[1]
  589.         mov dword[eax+offs_cont_texcoord_array_size],ecx
  590.         mov ecx,[ebx+8] ;ecx = p[2]
  591.         mov dword[eax+offs_cont_texcoord_array_stride],ecx
  592.         mov ecx,[ebx+12] ;ecx = p[3]
  593.         mov dword[eax+offs_cont_texcoord_array],ecx
  594.         ret
  595. endp
  596.  
  597. align 4
  598. proc glTexCoordPointer uses eax, size:dword, type:dword, stride:dword, pointer:dword
  599. locals
  600.         p rd 4
  601. endl
  602. ;  assert(type == GL_FLOAT);
  603.  
  604.         mov dword[p],OP_TexCoordPointer
  605.         mov eax,[size]
  606.         mov dword[p+4],eax
  607.         mov eax,[stride]
  608.         mov dword[p+8],eax
  609.         mov eax,[pointer]
  610.         mov dword[p+12],eax
  611.  
  612.         mov eax,ebp
  613.         sub eax,16 ;=sizeof(dd)*4
  614.         stdcall gl_add_op,eax
  615.         ret
  616. endp
  617.