Subversion Repositories Kolibri OS

Rev

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.                         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, context:dword, param:dword
  310. locals
  311.         ii dd ?
  312.         idx dd ?
  313.         states dd ?
  314.         type dd ?
  315.         size dd ?
  316.         indices dd ? ;указатель на 16 или 32 битные индексы
  317.         p rd 8
  318. endl
  319. pushad
  320.         mov edx,[context]
  321.         mov ebx,[param]
  322.         mov eax,[edx+offs_cont_client_states]
  323.         mov [states],eax
  324.         mov eax,[ebx+4]
  325.         mov [p+4],eax ;p[1].i = param[1].i
  326.         mov ecx,[ebx+8] ;count = param[2].i
  327.         mov eax,[ebx+12]
  328.         mov [type],eax ;type = param[3].i
  329.         mov eax,[ebx+16]
  330.         mov [indices],eax ;*indices = param[4].p
  331.         mov eax,ebp
  332.         sub eax,32 ;=sizeof(dd)*8
  333.         stdcall glopBegin, edx,eax
  334.  
  335.         mov dword[ii],0
  336. align 4
  337.         .cycle_0: ;for (int ii=0; ii<count; ii++)
  338.         cmp dword[ii],ecx
  339.         jge .cycle_0_end
  340.                 mov esi,[ii]
  341.                 cmp dword[type],GL_UNSIGNED_INT
  342.                 jne @f
  343.                         shl esi,2
  344.                         add esi,[indices]
  345.                         mov esi,[esi]
  346.                         jmp .end_0
  347.                 @@:
  348.                         shl esi,1
  349.                         add esi,[indices]
  350.                         movzx esi,word[esi]
  351.                 .end_0:
  352.                 mov [idx],esi
  353.  
  354.                 bt dword[states],1 ;2^1=COLOR_ARRAY
  355.                 jnc @f
  356.                         mov esi,[edx+offs_cont_color_array_size]
  357.                         mov [size],esi
  358.                         add esi,[edx+offs_cont_color_array_stride]
  359.                         imul esi,[idx] ;esi = i
  360.                         shl esi,2
  361.                         add esi,[edx+offs_cont_color_array] ;esi = &context.color_array[i]
  362.                         mov edi,ebp
  363.                         sub edi,28 ;edi = &p[1]
  364.                         mov ebx,[esi+8]
  365.                         mov [edi],ebx   ;p[1].f = context.color_array[i+2]
  366.                         mov ebx,[esi+4]
  367.                         mov [edi+4],ebx ;p[2].f = context.color_array[i+1]
  368.                         mov ebx,[esi]
  369.                         mov [edi+8],ebx ;p[3].f = context.color_array[i]
  370.                         add edi,12
  371.                         cmp dword[size],3
  372.                         jle .e1
  373.                                 add esi,12
  374.                                 movsd
  375.                                 jmp .e2
  376.                         .e1:
  377.                                 mov dword[edi],1.0 ;если задано 3 параметра, то 4-й ставим по умолчанию 1.0
  378.                         .e2:
  379.                         mov edi,ebp
  380.                         sub edi,32 ;edi = &p[0]
  381.                         mov ebx,ebp
  382.                         sub ebx,12 ;ebp-12 = &p[5]
  383.                         push ebx
  384.                         add ebx,4 ;ebp-8 = &p[6]
  385.                         push ebx
  386.                         add ebx,4 ;ebp-4 = &p[7]
  387.                         push ebx
  388.                         stdcall RGBFtoRGBI,[edi+12],[edi+8],[edi+4] ;call: r,g,b,&p[7],&p[6],&p[5]
  389.                         stdcall glopColor, edx,edi ;(context, p(op,rf,gf,bf,af,ri,gi,bi))
  390.                 @@:
  391.                 bt dword[states],2 ;2^2=NORMAL_ARRAY
  392.                 jnc @f
  393.                         mov esi,[edx+offs_cont_normal_array_stride]
  394.                         add esi,3
  395.                         imul esi,[idx] ;esi = idx * (3 + context.normal_array_stride)
  396.                         shl esi,2
  397.                         add esi,[edx+offs_cont_normal_array]
  398.                         mov edi,edx
  399.                         add edi,offs_cont_current_normal
  400.                         movsd ;context.current_normal.X = context.normal_array[i]
  401.                         movsd
  402.                         movsd
  403.                         mov dword[edi],0.0 ;context.current_normal.W = 0.0f
  404.                 @@:
  405.                 bt dword[states],3 ;2^3=TEXCOORD_ARRAY
  406.                 jnc @f
  407.                         mov esi,[edx+offs_cont_texcoord_array_size]
  408.                         mov [size],esi
  409.                         add esi,[edx+offs_cont_texcoord_array_stride]
  410.                         imul esi,[idx] ;esi = i
  411.                         shl esi,2
  412.                         add esi,[edx+offs_cont_texcoord_array] ;esi = &context.texcoord_array[i]
  413.                         mov edi,edx
  414.                         add edi,offs_cont_current_tex_coord
  415.                         movsd ;context.current_tex_coord.X = ccontext.texcoord_array[i]
  416.                         movsd
  417.                         cmp dword[size],2
  418.                         jle .e3
  419.                                 movsd
  420.                                 jmp .e4
  421.                         .e3:
  422.                                 mov dword[edi],0.0 ;если задано 2 параметра, то 3-й ставим по умолчанию 0.0
  423.                                 add edi,4
  424.                         .e4:
  425.                         cmp dword[size],3
  426.                         jle .e5
  427.                                 movsd
  428.                                 jmp @f
  429.                         .e5:
  430.                                 mov dword[edi],1.0 ;если задано 3 параметра, то 4-й ставим по умолчанию 1.0
  431.                 @@:
  432.                 bt dword[states],0 ;2^0=VERTEX_ARRAY
  433.                 jnc @f
  434.                         mov esi,[edx+offs_cont_vertex_array_size]
  435.                         mov [size],esi
  436.                         add esi,[edx+offs_cont_vertex_array_stride]
  437.                         imul esi,[idx] ;esi = i
  438.                         shl esi,2
  439.                         add esi,[edx+offs_cont_vertex_array] ;esi = &context.vertex_array[i]
  440.                         mov edi,ebp
  441.                         sub edi,28 ;edi = &p[1]
  442.                         movsd ;p[1].f = context.vertex_array[i]
  443.                         movsd
  444.                         cmp dword[size],2
  445.                         jle .e6
  446.                                 movsd
  447.                                 jmp .e7
  448.                         .e6:
  449.                                 mov dword[edi],0.0 ;если задано 2 параметра, то 3-й ставим по умолчанию 0.0
  450.                                 add edi,4
  451.                                 jmp .e8 ;и 4-й тоже ставим по умолчанию
  452.                         .e7:
  453.                         cmp dword[size],3
  454.                         jle .e8
  455.                                 movsd
  456.                                 sub edi,20 ;edi=&p[0]
  457.                                 jmp .e9
  458.                         .e8:
  459.                                 mov dword[edi],1.0 ;если задано 3 параметра, то 4-й ставим по умолчанию 1.0
  460.                                 sub edi,16 ;edi=&p[0]
  461.                         .e9:
  462.                         stdcall glopVertex, edx,edi
  463.                 @@:
  464.         inc dword[ii]
  465.         jmp .cycle_0
  466.         .cycle_0_end:
  467.  
  468.         mov eax,ebp
  469.         sub eax,32 ;=sizeof(dd)*8
  470.         stdcall glopEnd, edx,eax
  471. popad
  472.         ret
  473. endp
  474.  
  475. align 4
  476. proc glDrawElements uses eax, mode:dword, count:dword, type:dword, indices:dword
  477. locals
  478.         p rd 5
  479. endl
  480. ;assert(type == GL_UNSIGNED_SHORT || type == GL_UNSIGNED_INT/* nonstandard */);
  481.         mov dword[p],OP_DrawElements
  482.         mov eax,[mode]
  483.         mov dword[p+4],eax
  484.         mov eax,[count]
  485.         mov dword[p+8],eax
  486.         mov eax,[type]
  487.         mov dword[p+12],eax
  488.         mov eax,[indices]
  489.         mov dword[p+16],eax
  490.  
  491.         mov eax,ebp
  492.         sub eax,20 ;=sizeof(dd)*5
  493.         stdcall gl_add_op,eax
  494.         ret
  495. endp
  496.  
  497. align 4
  498. proc glopEnableClientState uses eax ebx, context:dword, p:dword
  499.         mov eax,[context]
  500.         mov ebx,[p]
  501.         mov ebx,[ebx+4] ;ebx = p[1]
  502.         or dword[eax+offs_cont_client_states],ebx
  503.         ret
  504. endp
  505.  
  506. align 4
  507. proc glEnableClientState uses eax, array:dword
  508. locals
  509.         p rd 2
  510. endl
  511.         mov dword[p],OP_EnableClientState
  512.  
  513.         cmp dword[array],GL_VERTEX_ARRAY
  514.         jne @f
  515.                 mov dword[p+4],VERTEX_ARRAY
  516.                 jmp .end_f
  517.         @@:
  518.         cmp dword[array],GL_NORMAL_ARRAY
  519.         jne @f
  520.                 mov dword[p+4],NORMAL_ARRAY
  521.                 jmp .end_f
  522.         @@:
  523.         cmp dword[array],GL_COLOR_ARRAY
  524.         jne @f
  525.                 mov dword[p+4],COLOR_ARRAY
  526.                 jmp .end_f
  527.         @@:
  528.         cmp dword[array],GL_TEXTURE_COORD_ARRAY
  529.         jne @f
  530.                 mov dword[p+4],TEXCOORD_ARRAY
  531.                 jmp .end_f
  532.         @@:
  533.                 ;assert(0);
  534.         .end_f:
  535.  
  536.         mov eax,ebp
  537.         sub eax,8 ;=sizeof(dd)*2
  538.         stdcall gl_add_op,eax
  539.         ret
  540. endp
  541.  
  542. align 4
  543. proc glopDisableClientState uses eax ebx, context:dword, p:dword
  544.         mov eax,[context]
  545.         mov ebx,[p]
  546.         mov ebx,[ebx+4] ;ebx = p[1]
  547.         and dword[eax+offs_cont_client_states],ebx
  548.         ret
  549. endp
  550.  
  551. align 4
  552. proc glDisableClientState uses eax, array:dword
  553. locals
  554.         p rd 2
  555. endl
  556.         mov dword[p],OP_DisableClientState
  557.  
  558.         cmp dword[array],GL_VERTEX_ARRAY
  559.         jne @f
  560.                 mov dword[p+4], not VERTEX_ARRAY
  561.                 jmp .end_f
  562.         @@:
  563.         cmp dword[array],GL_NORMAL_ARRAY
  564.         jne @f
  565.                 mov dword[p+4], not NORMAL_ARRAY
  566.                 jmp .end_f
  567.         @@:
  568.         cmp dword[array],GL_COLOR_ARRAY
  569.         jne @f
  570.                 mov dword[p+4], not COLOR_ARRAY
  571.                 jmp .end_f
  572.         @@:
  573.         cmp dword[array],GL_TEXTURE_COORD_ARRAY
  574.         jne @f
  575.                 mov dword[p+4], not TEXCOORD_ARRAY
  576.                 jmp .end_f
  577.         @@:
  578.                 ;assert(0);
  579.         .end_f:
  580.  
  581.         mov eax,ebp
  582.         sub eax,8 ;=sizeof(dd)*2
  583.         stdcall gl_add_op,eax
  584.         ret
  585. endp
  586.  
  587. align 4
  588. proc glopVertexPointer uses eax ebx ecx, context:dword, p:dword
  589.         mov eax,[context]
  590.         mov ebx,[p]
  591.         mov ecx,[ebx+4] ;ecx = p[1]
  592.         mov dword[eax+offs_cont_vertex_array_size],ecx
  593.         mov ecx,[ebx+8] ;ecx = p[2]
  594.         mov dword[eax+offs_cont_vertex_array_stride],ecx
  595.         mov ecx,[ebx+12] ;ecx = p[3]
  596.         mov dword[eax+offs_cont_vertex_array],ecx
  597.         ret
  598. endp
  599.  
  600. align 4
  601. proc glVertexPointer uses eax, size:dword, type:dword, stride:dword, pointer:dword
  602. locals
  603.         p rd 4
  604. endl
  605. ;  assert(type == GL_FLOAT);
  606.  
  607.         mov dword[p],OP_VertexPointer
  608.         mov eax,[size]
  609.         mov dword[p+4],eax
  610.         mov eax,[stride]
  611.         mov dword[p+8],eax
  612.         mov eax,[pointer]
  613.         mov dword[p+12],eax
  614.  
  615.         mov eax,ebp
  616.         sub eax,16 ;=sizeof(dd)*4
  617.         stdcall gl_add_op,eax
  618.         ret
  619. endp
  620.  
  621. align 4
  622. proc glopColorPointer uses eax ebx ecx, context:dword, p:dword
  623.         mov eax,[context]
  624.         mov ebx,[p]
  625.         mov ecx,[ebx+4] ;ecx = p[1]
  626.         mov dword[eax+offs_cont_color_array_size],ecx
  627.         mov ecx,[ebx+8] ;ecx = p[2]
  628.         mov dword[eax+offs_cont_color_array_stride],ecx
  629.         mov ecx,[ebx+12] ;ecx = p[3]
  630.         mov dword[eax+offs_cont_color_array],ecx
  631.         ret
  632. endp
  633.  
  634. align 4
  635. proc glColorPointer uses eax, size:dword, type:dword, stride:dword, pointer:dword
  636. locals
  637.         p rd 4
  638. endl
  639. ;  assert(type == GL_FLOAT);
  640.  
  641.         mov dword[p],OP_ColorPointer
  642.         mov eax,[size]
  643.         mov dword[p+4],eax
  644.         mov eax,[stride]
  645.         mov dword[p+8],eax
  646.         mov eax,[pointer]
  647.         mov dword[p+12],eax
  648.  
  649.         mov eax,ebp
  650.         sub eax,16 ;=sizeof(dd)*4
  651.         stdcall gl_add_op,eax
  652.         ret
  653. endp
  654.  
  655. align 4
  656. proc glopNormalPointer uses eax ebx ecx, context:dword, p:dword
  657.         mov eax,[context]
  658.         mov ebx,[p]
  659.         mov ecx,[ebx+4] ;ecx = p[1]
  660.         mov dword[eax+offs_cont_normal_array_stride],ecx
  661.         mov ecx,[ebx+8] ;ecx = p[2]
  662.         mov dword[eax+offs_cont_normal_array],ecx
  663.         ret
  664. endp
  665.  
  666. align 4
  667. proc glNormalPointer uses eax, type:dword, stride:dword, pointer:dword
  668. locals
  669.         p rd 3
  670. endl
  671. ;  assert(type == GL_FLOAT);
  672.  
  673.         mov dword[p],OP_NormalPointer
  674.         mov eax,[stride]
  675.         mov dword[p+4],eax
  676.         mov eax,[pointer]
  677.         mov dword[p+8],eax
  678.  
  679.         mov eax,ebp
  680.         sub eax,12 ;=sizeof(dd)*3
  681.         stdcall gl_add_op,eax
  682.         ret
  683. endp
  684.  
  685. align 4
  686. proc glopTexCoordPointer uses eax ebx ecx, context:dword, p:dword
  687.         mov eax,[context]
  688.         mov ebx,[p]
  689.         mov ecx,[ebx+4] ;ecx = p[1]
  690.         mov dword[eax+offs_cont_texcoord_array_size],ecx
  691.         mov ecx,[ebx+8] ;ecx = p[2]
  692.         mov dword[eax+offs_cont_texcoord_array_stride],ecx
  693.         mov ecx,[ebx+12] ;ecx = p[3]
  694.         mov dword[eax+offs_cont_texcoord_array],ecx
  695.         ret
  696. endp
  697.  
  698. align 4
  699. proc glTexCoordPointer uses eax, size:dword, type:dword, stride:dword, pointer:dword
  700. locals
  701.         p rd 4
  702. endl
  703. ;  assert(type == GL_FLOAT);
  704.  
  705.         mov dword[p],OP_TexCoordPointer
  706.         mov eax,[size]
  707.         mov dword[p+4],eax
  708.         mov eax,[stride]
  709.         mov dword[p+8],eax
  710.         mov eax,[pointer]
  711.         mov dword[p+12],eax
  712.  
  713.         mov eax,ebp
  714.         sub eax,16 ;=sizeof(dd)*4
  715.         stdcall gl_add_op,eax
  716.         ret
  717. endp
  718.