Subversion Repositories Kolibri OS

Rev

Rev 5353 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5153 IgorA 1 
VERTEX_ARRAY   equ 0x0001
2 
COLOR_ARRAY    equ 0x0002
3 
NORMAL_ARRAY   equ 0x0004
4 
TEXCOORD_ARRAY equ 0x0008
5 
 
5337 IgorA 6 
;glArrayElement - использование (рисование) одного элемента из массива
7 
;glDrawArrays - рисование всех элементов в массиве
8 
;glDrawElements - рисование тех элементов в массиве, которые заданны в массиве индексов
9 
 
5153 IgorA 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
5337 IgorA 25 
		add ecx,[eax+offs_cont_color_array] ;ecx = &context.color_array[i]
5153 IgorA 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
5337 IgorA 42 
		stdcall glopColor, eax,ebx
5153 IgorA 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
5337 IgorA 50 
		add esi,[eax+offs_cont_normal_array] ;esi = &normal_array[ebx * (3 + c->normal_array_stride)]
5153 IgorA 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
5337 IgorA 63 
		add ecx,[eax+offs_cont_texcoord_array] ;ecx = &context.texcoord_array[i]
5153 IgorA 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
5337 IgorA 94 
		add ecx,[eax+offs_cont_vertex_array] ;ecx = &context.vertex_array[i]
5153 IgorA 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
5337 IgorA 119 
		stdcall glopVertex, eax,ebx
5153 IgorA 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
5337 IgorA 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
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]
5353 IgorA 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
5337 IgorA 184 
			cmp dword[size],3
185 
			jle .e1
5353 IgorA 186 
				add esi,12
5337 IgorA 187 
				movsd
188 
				jmp .e2
189 
			.e1:
190 
				mov dword[edi],1.0 ;если задано 3 параметра, то 4-й ставим по умолчанию 1.0
191 
			.e2:
5353 IgorA 192 
			mov edi,ebp
193 
			sub edi,32 ;edi = &p[0]
5337 IgorA 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
5353 IgorA 264 
				jmp .e8 ;и 4-й тоже ставим по умолчанию
5337 IgorA 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
5380 IgorA 309 
proc glopDrawElements, context:dword, param:dword
5337 IgorA 310 
locals
5380 IgorA 311 
	ii dd ?
312 
	idx dd ?
313 
	states dd ?
314 
	type dd ?
315 
	size dd ?
316 
	indices dd ? ;указатель на 16 или 32 битные индексы
5353 IgorA 317 
	p rd 8
5337 IgorA 318 
endl
5380 IgorA 319 
pushad
5337 IgorA 320 
	mov edx,[context]
321 
	mov ebx,[param]
5380 IgorA 322 
	mov eax,[edx+offs_cont_client_states]
323 
	mov [states],eax
5337 IgorA 324 
	mov eax,[ebx+4]
325 
	mov [p+4],eax ;p[1].i = param[1].i
5380 IgorA 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
5337 IgorA 331 
	mov eax,ebp
5353 IgorA 332 
	sub eax,32 ;=sizeof(dd)*8
5337 IgorA 333 
	stdcall glopBegin, edx,eax
334 
 
5380 IgorA 335 
	mov dword[ii],0
336 
align 4
337 
	.cycle_0: ;for (int ii=0; 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 
 
5337 IgorA 468 
	mov eax,ebp
5353 IgorA 469 
	sub eax,32 ;=sizeof(dd)*8
5337 IgorA 470 
	stdcall glopEnd, edx,eax
5380 IgorA 471 
popad
5337 IgorA 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
5153 IgorA 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 
 
5337 IgorA 607 
	mov dword[p],OP_VertexPointer
5153 IgorA 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