Subversion Repositories Kolibri OS

Rev

Rev 5153 | Rev 5353 | 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.                         movsd ;p[1].f = context.color_array[i]
  178.                         movsd
  179.                         movsd
  180.                         cmp dword[size],3
  181.                         jle .e1
  182.                                 movsd
  183.                                 sub edi,20 ;&p[0]
  184.                                 jmp .e2
  185.                         .e1:
  186.                                 mov dword[edi],1.0 ;если задано 3 параметра, то 4-й ставим по умолчанию 1.0
  187.                                 sub edi,16 ;&p[0]
  188.                         .e2:
  189.                         mov ebx,ebp
  190.                         sub ebx,12 ;ebp-12 = &p[5]
  191.                         push ebx
  192.                         add ebx,4 ;ebp-8 = &p[6]
  193.                         push ebx
  194.                         add ebx,4 ;ebp-4 = &p[7]
  195.                         push ebx
  196.                         stdcall RGBFtoRGBI,[edi+12],[edi+8],[edi+4] ;call: r,g,b,&p[7],&p[6],&p[5]
  197.                         stdcall glopColor, edx,edi ;(context, p(op,rf,gf,bf,af,ri,gi,bi))
  198.                 @@:
  199.                 bt dword[states],2 ;2^2=NORMAL_ARRAY
  200.                 jnc @f
  201.                         mov esi,[edx+offs_cont_normal_array_stride]
  202.                         add esi,3
  203.                         imul esi,[idx]
  204.                         shl esi,2
  205.                         add esi,[edx+offs_cont_normal_array] ;esi = &context.normal_array[ idx * (3 + context.normal_array_stride) ]
  206.                         mov edi,edx
  207.                         add edi,offs_cont_current_normal
  208.                         movsd ;context.current_normal.X = context.normal_array[i]
  209.                         movsd
  210.                         movsd
  211.                         mov dword[edi],0.0 ;context.current_normal.W = 0.0f
  212.                 @@:
  213.                 bt dword[states],3 ;2^3=TEXCOORD_ARRAY
  214.                 jnc @f
  215.                         mov esi,[edx+offs_cont_texcoord_array_size]
  216.                         mov [size],esi
  217.                         add esi,[edx+offs_cont_texcoord_array_stride]
  218.                         imul esi,[idx] ;esi = i
  219.                         shl esi,2
  220.                         add esi,[edx+offs_cont_texcoord_array] ;esi = &context.texcoord_array[i]
  221.                         mov edi,edx
  222.                         add edi,offs_cont_current_tex_coord
  223.                         movsd ;context.current_tex_coord.X = ccontext.texcoord_array[i]
  224.                         movsd
  225.                         cmp dword[size],2
  226.                         jle .e3
  227.                                 movsd
  228.                                 jmp .e4
  229.                         .e3:
  230.                                 mov dword[edi],0.0 ;если задано 2 параметра, то 3-й ставим по умолчанию 0.0
  231.                                 add edi,4
  232.                         .e4:
  233.                         cmp dword[size],3
  234.                         jle .e5
  235.                                 movsd
  236.                                 jmp @f
  237.                         .e5:
  238.                                 mov dword[edi],1.0 ;если задано 3 параметра, то 4-й ставим по умолчанию 1.0
  239.                 @@:
  240.                 bt dword[states],0 ;2^0=VERTEX_ARRAY
  241.                 jnc @f
  242.                         mov esi,[edx+offs_cont_vertex_array_size]
  243.                         mov [size],esi
  244.                         add esi,[edx+offs_cont_vertex_array_stride]
  245.                         imul esi,[idx] ;esi = i
  246.                         shl esi,2
  247.                         add esi,[edx+offs_cont_vertex_array] ;esi = &context.vertex_array[i]
  248.                         mov edi,ebp
  249.                         sub edi,28 ;edi = &p[1]
  250.                         movsd ;p[1].f = context.vertex_array[i]
  251.                         movsd
  252.                         cmp dword[size],2
  253.                         jle .e6
  254.                                 movsd
  255.                                 jmp .e7
  256.                         .e6:
  257.                                 mov dword[edi],0.0 ;если задано 2 параметра, то 3-й ставим по умолчанию 0.0
  258.                                 add edi,4
  259.                         .e7:
  260.                         cmp dword[size],3
  261.                         jle .e8
  262.                                 movsd
  263.                                 sub edi,20 ;edi=&p[0]
  264.                                 jmp .e9
  265.                         .e8:
  266.                                 mov dword[edi],1.0 ;если задано 3 параметра, то 4-й ставим по умолчанию 1.0
  267.                                 sub edi,16 ;edi=&p[0]
  268.                         .e9:
  269.                         stdcall glopVertex, edx,edi
  270.                 @@:
  271.                 inc dword[idx]
  272.         inc dword[vi]
  273.         jmp .cycle_0
  274.         .cycle_0_end:
  275.  
  276.         ;mov eax,ebp
  277.         ;sub eax,32 ;=sizeof(dd)*8
  278.         stdcall glopEnd, edx,eax
  279. popad
  280.         ret
  281. endp
  282.  
  283. align 4
  284. proc glDrawArrays uses eax, mode:dword, first:dword, count:dword
  285. locals
  286.         p rd 4
  287. endl
  288.         mov dword[p],OP_DrawArrays
  289.         mov eax,[mode]
  290.         mov dword[p+4],eax
  291.         mov eax,[first]
  292.         mov dword[p+8],eax
  293.         mov eax,[count]
  294.         mov dword[p+12],eax
  295.  
  296.         mov eax,ebp
  297.         sub eax,16 ;=sizeof(dd)*4
  298.         stdcall gl_add_op,eax
  299.         ret
  300. endp
  301.  
  302. align 4
  303. proc glopDrawElements uses eax ebx edx, context:dword, param:dword
  304. locals
  305.         p rd 5
  306. endl
  307.  
  308.         mov edx,[context]
  309.         mov ebx,[param]
  310.   ;int i;
  311.   ;int idx;
  312.   ;int states = c->client_states;
  313.   ;int count = param[2].i;
  314.   ;int type = param[3].i;
  315.   ;unsigned int *indices_u32 = (unsigned int*)param[4].p;
  316.   ;unsigned short *indices_u16 = (unsigned short*)indices_u32;
  317.  
  318.         mov eax,[ebx+4]
  319.         mov [p+4],eax ;p[1].i = param[1].i
  320.         mov eax,ebp
  321.         sub eax,20 ;=sizeof(dd)*5
  322.         stdcall glopBegin, edx,eax
  323.  
  324. ;  for (int ii=0; ii<count; ii++) {
  325. ;    idx = (type == GL_UNSIGNED_INT) ? indices_u32[ii] : indices_u16[ii];
  326. ;    if (states & COLOR_ARRAY) {
  327. ;      GLParam p[5];
  328. ;      int size = c->color_array_size;
  329. ;      i = idx * (size + c->color_array_stride);
  330. ;      p[1].f = c->color_array[i];
  331. ;      p[2].f = c->color_array[i+1];
  332. ;      p[3].f = c->color_array[i+2];
  333. ;      p[4].f = size > 3 ? c->color_array[i+3] : 1.0f;
  334. ;      glopColor(c, p);  
  335. ;    }
  336. ;    if (states & NORMAL_ARRAY) {
  337. ;      i = idx * (3 + c->normal_array_stride);
  338. ;      c->current_normal.X = c->normal_array[i];
  339. ;      c->current_normal.Y = c->normal_array[i+1];
  340. ;      c->current_normal.Z = c->normal_array[i+2];
  341. ;      c->current_normal.W = 0.0f;
  342. ;    }
  343. ;    if (states & TEXCOORD_ARRAY) {
  344. ;      int size = c->texcoord_array_size;
  345. ;      i = idx * (size + c->texcoord_array_stride);
  346. ;      c->current_tex_coord.X = c->texcoord_array[i];
  347. ;      c->current_tex_coord.Y = c->texcoord_array[i+1];
  348. ;      c->current_tex_coord.Z = size > 2 ? c->texcoord_array[i+2] : 0.0f;
  349. ;      c->current_tex_coord.W = size > 3 ? c->texcoord_array[i+3] : 1.0f;
  350. ;    }
  351. ;    if (states & VERTEX_ARRAY) {
  352. ;      GLParam p[5];
  353. ;      int size = c->vertex_array_size;
  354. ;      i = idx * (size + c->vertex_array_stride);
  355. ;      p[1].f = c->vertex_array[i];
  356. ;      p[2].f = c->vertex_array[i+1];
  357. ;      p[3].f = size > 2 ? c->vertex_array[i+2] : 0.0f;
  358. ;      p[4].f = size > 3 ? c->vertex_array[i+3] : 1.0f;
  359. ;      glopVertex(c, p);
  360. ;    }
  361. ;  }
  362.         mov eax,ebp
  363.         sub eax,20 ;=sizeof(dd)*5
  364.         stdcall glopEnd, edx,eax
  365.         ret
  366. endp
  367.  
  368. align 4
  369. proc glDrawElements uses eax, mode:dword, count:dword, type:dword, indices:dword
  370. locals
  371.         p rd 5
  372. endl
  373. ;assert(type == GL_UNSIGNED_SHORT || type == GL_UNSIGNED_INT/* nonstandard */);
  374.         mov dword[p],OP_DrawElements
  375.         mov eax,[mode]
  376.         mov dword[p+4],eax
  377.         mov eax,[count]
  378.         mov dword[p+8],eax
  379.         mov eax,[type]
  380.         mov dword[p+12],eax
  381.         mov eax,[indices]
  382.         mov dword[p+16],eax
  383.  
  384.         mov eax,ebp
  385.         sub eax,20 ;=sizeof(dd)*5
  386.         stdcall gl_add_op,eax
  387.         ret
  388. endp
  389.  
  390. align 4
  391. proc glopEnableClientState uses eax ebx, context:dword, p:dword
  392.         mov eax,[context]
  393.         mov ebx,[p]
  394.         mov ebx,[ebx+4] ;ebx = p[1]
  395.         or dword[eax+offs_cont_client_states],ebx
  396.         ret
  397. endp
  398.  
  399. align 4
  400. proc glEnableClientState uses eax, array:dword
  401. locals
  402.         p rd 2
  403. endl
  404.         mov dword[p],OP_EnableClientState
  405.  
  406.         cmp dword[array],GL_VERTEX_ARRAY
  407.         jne @f
  408.                 mov dword[p+4],VERTEX_ARRAY
  409.                 jmp .end_f
  410.         @@:
  411.         cmp dword[array],GL_NORMAL_ARRAY
  412.         jne @f
  413.                 mov dword[p+4],NORMAL_ARRAY
  414.                 jmp .end_f
  415.         @@:
  416.         cmp dword[array],GL_COLOR_ARRAY
  417.         jne @f
  418.                 mov dword[p+4],COLOR_ARRAY
  419.                 jmp .end_f
  420.         @@:
  421.         cmp dword[array],GL_TEXTURE_COORD_ARRAY
  422.         jne @f
  423.                 mov dword[p+4],TEXCOORD_ARRAY
  424.                 jmp .end_f
  425.         @@:
  426.                 ;assert(0);
  427.         .end_f:
  428.  
  429.         mov eax,ebp
  430.         sub eax,8 ;=sizeof(dd)*2
  431.         stdcall gl_add_op,eax
  432.         ret
  433. endp
  434.  
  435. align 4
  436. proc glopDisableClientState uses eax ebx, context:dword, p:dword
  437.         mov eax,[context]
  438.         mov ebx,[p]
  439.         mov ebx,[ebx+4] ;ebx = p[1]
  440.         and dword[eax+offs_cont_client_states],ebx
  441.         ret
  442. endp
  443.  
  444. align 4
  445. proc glDisableClientState uses eax, array:dword
  446. locals
  447.         p rd 2
  448. endl
  449.         mov dword[p],OP_DisableClientState
  450.  
  451.         cmp dword[array],GL_VERTEX_ARRAY
  452.         jne @f
  453.                 mov dword[p+4], not VERTEX_ARRAY
  454.                 jmp .end_f
  455.         @@:
  456.         cmp dword[array],GL_NORMAL_ARRAY
  457.         jne @f
  458.                 mov dword[p+4], not NORMAL_ARRAY
  459.                 jmp .end_f
  460.         @@:
  461.         cmp dword[array],GL_COLOR_ARRAY
  462.         jne @f
  463.                 mov dword[p+4], not COLOR_ARRAY
  464.                 jmp .end_f
  465.         @@:
  466.         cmp dword[array],GL_TEXTURE_COORD_ARRAY
  467.         jne @f
  468.                 mov dword[p+4], not TEXCOORD_ARRAY
  469.                 jmp .end_f
  470.         @@:
  471.                 ;assert(0);
  472.         .end_f:
  473.  
  474.         mov eax,ebp
  475.         sub eax,8 ;=sizeof(dd)*2
  476.         stdcall gl_add_op,eax
  477.         ret
  478. endp
  479.  
  480. align 4
  481. proc glopVertexPointer uses eax ebx ecx, context:dword, p:dword
  482.         mov eax,[context]
  483.         mov ebx,[p]
  484.         mov ecx,[ebx+4] ;ecx = p[1]
  485.         mov dword[eax+offs_cont_vertex_array_size],ecx
  486.         mov ecx,[ebx+8] ;ecx = p[2]
  487.         mov dword[eax+offs_cont_vertex_array_stride],ecx
  488.         mov ecx,[ebx+12] ;ecx = p[3]
  489.         mov dword[eax+offs_cont_vertex_array],ecx
  490.         ret
  491. endp
  492.  
  493. align 4
  494. proc glVertexPointer uses eax, size:dword, type:dword, stride:dword, pointer:dword
  495. locals
  496.         p rd 4
  497. endl
  498. ;  assert(type == GL_FLOAT);
  499.  
  500.         mov dword[p],OP_VertexPointer
  501.         mov eax,[size]
  502.         mov dword[p+4],eax
  503.         mov eax,[stride]
  504.         mov dword[p+8],eax
  505.         mov eax,[pointer]
  506.         mov dword[p+12],eax
  507.  
  508.         mov eax,ebp
  509.         sub eax,16 ;=sizeof(dd)*4
  510.         stdcall gl_add_op,eax
  511.         ret
  512. endp
  513.  
  514. align 4
  515. proc glopColorPointer uses eax ebx ecx, context:dword, p:dword
  516.         mov eax,[context]
  517.         mov ebx,[p]
  518.         mov ecx,[ebx+4] ;ecx = p[1]
  519.         mov dword[eax+offs_cont_color_array_size],ecx
  520.         mov ecx,[ebx+8] ;ecx = p[2]
  521.         mov dword[eax+offs_cont_color_array_stride],ecx
  522.         mov ecx,[ebx+12] ;ecx = p[3]
  523.         mov dword[eax+offs_cont_color_array],ecx
  524.         ret
  525. endp
  526.  
  527. align 4
  528. proc glColorPointer uses eax, size:dword, type:dword, stride:dword, pointer:dword
  529. locals
  530.         p rd 4
  531. endl
  532. ;  assert(type == GL_FLOAT);
  533.  
  534.         mov dword[p],OP_ColorPointer
  535.         mov eax,[size]
  536.         mov dword[p+4],eax
  537.         mov eax,[stride]
  538.         mov dword[p+8],eax
  539.         mov eax,[pointer]
  540.         mov dword[p+12],eax
  541.  
  542.         mov eax,ebp
  543.         sub eax,16 ;=sizeof(dd)*4
  544.         stdcall gl_add_op,eax
  545.         ret
  546. endp
  547.  
  548. align 4
  549. proc glopNormalPointer uses eax ebx ecx, context:dword, p:dword
  550.         mov eax,[context]
  551.         mov ebx,[p]
  552.         mov ecx,[ebx+4] ;ecx = p[1]
  553.         mov dword[eax+offs_cont_normal_array_stride],ecx
  554.         mov ecx,[ebx+8] ;ecx = p[2]
  555.         mov dword[eax+offs_cont_normal_array],ecx
  556.         ret
  557. endp
  558.  
  559. align 4
  560. proc glNormalPointer uses eax, type:dword, stride:dword, pointer:dword
  561. locals
  562.         p rd 3
  563. endl
  564. ;  assert(type == GL_FLOAT);
  565.  
  566.         mov dword[p],OP_NormalPointer
  567.         mov eax,[stride]
  568.         mov dword[p+4],eax
  569.         mov eax,[pointer]
  570.         mov dword[p+8],eax
  571.  
  572.         mov eax,ebp
  573.         sub eax,12 ;=sizeof(dd)*3
  574.         stdcall gl_add_op,eax
  575.         ret
  576. endp
  577.  
  578. align 4
  579. proc glopTexCoordPointer uses eax ebx ecx, context:dword, p:dword
  580.         mov eax,[context]
  581.         mov ebx,[p]
  582.         mov ecx,[ebx+4] ;ecx = p[1]
  583.         mov dword[eax+offs_cont_texcoord_array_size],ecx
  584.         mov ecx,[ebx+8] ;ecx = p[2]
  585.         mov dword[eax+offs_cont_texcoord_array_stride],ecx
  586.         mov ecx,[ebx+12] ;ecx = p[3]
  587.         mov dword[eax+offs_cont_texcoord_array],ecx
  588.         ret
  589. endp
  590.  
  591. align 4
  592. proc glTexCoordPointer uses eax, size:dword, type:dword, stride:dword, pointer:dword
  593. locals
  594.         p rd 4
  595. endl
  596. ;  assert(type == GL_FLOAT);
  597.  
  598.         mov dword[p],OP_TexCoordPointer
  599.         mov eax,[size]
  600.         mov dword[p+4],eax
  601.         mov eax,[stride]
  602.         mov dword[p+8],eax
  603.         mov eax,[pointer]
  604.         mov dword[p+12],eax
  605.  
  606.         mov eax,ebp
  607.         sub eax,16 ;=sizeof(dd)*4
  608.         stdcall gl_add_op,eax
  609.         ret
  610. endp
  611.