Subversion Repositories Kolibri OS

Rev

Rev 5153 | 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]
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
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
5153 IgorA 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
 
5337 IgorA 500
	mov dword[p],OP_VertexPointer
5153 IgorA 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