kolibrios/programs/develop/libraries/TinyGL/asm_fork/arrays.asm

VERTEX_ARRAY   equ 0x0001
COLOR_ARRAY    equ 0x0002
NORMAL_ARRAY   equ 0x0004
TEXCOORD_ARRAY equ 0x0008

;glArrayElement - использование (рисование) одного элемента из массива
;glDrawArrays - рисование всех элементов в массиве
;glDrawElements - рисование тех элементов в массиве, которые заданны в массиве индексов

align 4
proc glopArrayElement uses eax ebx ecx edx, context:dword, param:dword
locals
	p rd 5
endl
	mov eax,[context]
	mov ebx,[param]
	mov ebx,[ebx+4] ;ebx = p[1]
  
	bt dword[eax+offs_cont_client_states],1 ;2^1=COLOR_ARRAY
	jnc @f
		mov ecx,[eax+offs_cont_color_array_size]
		add ecx,[eax+offs_cont_color_array_stride]
		imul ecx,ebx
		shl ecx,2
		add ecx,[eax+offs_cont_color_array] ;ecx = &context.color_array[i]
		mov ebx,ebp
		sub ebx,20 ;=sizeof(dd)*5
		mov edx,[ecx]
		mov [ebx+4],edx
		mov edx,[ecx+4]
		mov [ebx+8],edx
		mov edx,[ecx+8]
		mov [ebx+12],edx
		cmp dword[eax+offs_cont_color_array_size],3
		jg .l0
			mov edx,1.0
			jmp .l1
		.l0:
			mov edx,[ecx+12]
		.l1:
		mov [ebx+16],edx
		stdcall glopColor, eax,ebx
	@@:
	bt dword[eax+offs_cont_client_states],2 ;2^2=NORMAL_ARRAY
	jnc @f
		mov esi,dword[eax+offs_cont_normal_array_stride]
		add esi,3
		imul esi,ebx
		shl esi,2
		add esi,[eax+offs_cont_normal_array] ;esi = &normal_array[ebx * (3 + c->normal_array_stride)]
		mov edi,eax
		add edi,offs_cont_current_normal
		mov ecx,3
		rep movsd
		mov dword[edi],0.0
	@@:
	bt dword[eax+offs_cont_client_states],3 ;2^3=TEXCOORD_ARRAY
	jnc @f
		mov ecx,[eax+offs_cont_texcoord_array_size]
		add ecx,[eax+offs_cont_texcoord_array_stride]
		imul ecx,ebx
		shl ecx,2
		add ecx,[eax+offs_cont_texcoord_array] ;ecx = &context.texcoord_array[i]
		mov edx,[ecx]
		mov [eax+offs_cont_current_tex_coord],edx
		mov edx,[ecx+4]
		mov [eax+offs_cont_current_tex_coord+4],edx

		cmp dword[eax+offs_cont_texcoord_array_size],2
		jg .l2
			mov edx,0.0
			jmp .l3
		.l2:
			mov edx,[ecx+8]
		.l3:
		mov [eax+offs_cont_current_tex_coord+8],edx

		cmp dword[eax+offs_cont_texcoord_array_size],3
		jg .l4
			mov edx,1.0
			jmp .l5
		.l4:
			mov edx,[ecx+12]
		.l5:

		mov [eax+offs_cont_current_tex_coord+12],edx
	@@:
	bt dword[eax+offs_cont_client_states],0 ;2^0=VERTEX_ARRAY
	jnc @f
		mov ecx,[eax+offs_cont_vertex_array_size]
		add ecx,[eax+offs_cont_vertex_array_stride]
		imul ecx,ebx
		shl ecx,2
		add ecx,[eax+offs_cont_vertex_array] ;ecx = &context.vertex_array[i]
		mov ebx,ebp
		sub ebx,20 ;=sizeof(dd)*5
		mov edx,[ecx]
		mov [ebx+4],edx
		mov edx,[ecx+4]
		mov [ebx+8],edx

		cmp dword[eax+offs_cont_vertex_array_size],2
		jg .l6
			mov edx,0.0
			jmp .l7
		.l6:
			mov edx,[ecx+8]
		.l7:
		mov [ebx+12],edx
		cmp dword[eax+offs_cont_vertex_array_size],3
		jg .l8
			mov edx,1.0
			jmp .l9
		.l8:
			mov edx,[ecx+12]
		.l9:

		mov [ebx+16],edx
		stdcall glopVertex, eax,ebx
	@@:
	ret
endp

align 4
proc glArrayElement uses eax, i:dword
locals
	p rd 2
endl
	mov dword[p],OP_ArrayElement
	mov eax,[i]
	mov dword[p+4],eax

	mov eax,ebp
	sub eax,8 ;=sizeof(dd)*2
	stdcall gl_add_op,eax
	ret
endp

align 4
proc glopDrawArrays, context:dword, param:dword
locals
	vi dd ?
	idx dd ?
	states dd ?
	size dd ?
	p rd 8 ;функция glopColor требует 8 параметров, другие функции требуют меньше, берем по максимуму что-бы не портить стек
endl
pushad
	mov edx,[context]
	mov ebx,[param]
	mov ecx,[ebx+12] ;count = param[3].i
	mov eax,[edx+offs_cont_client_states]
	mov [states],eax
	mov eax,[ebx+8]
	mov [idx],eax ;param[2].i
	mov eax,[ebx+4]
	mov [p+4],eax ;p[1].i = param[1].i
	mov eax,ebp
	sub eax,32 ;=sizeof(dd)*8
	stdcall glopBegin, edx,eax

	mov dword[vi],0
align 4
	.cycle_0: ;for (int vi=0; vi<count; vi++)
	cmp dword[vi],ecx
	jge .cycle_0_end
		bt dword[states],1 ;2^1=COLOR_ARRAY
		jnc @f
			mov esi,[edx+offs_cont_color_array_size]
			mov [size],esi
			add esi,[edx+offs_cont_color_array_stride]
			imul esi,[idx] ;esi = i
			shl esi,2
			add esi,[edx+offs_cont_color_array] ;esi = &context.color_array[i]
			mov edi,ebp
			sub edi,28 ;edi = &p[1]
			mov ebx,[esi+8]
			mov [edi],ebx   ;p[1].f = context.color_array[i+2]
			mov ebx,[esi+4]
			mov [edi+4],ebx ;p[2].f = context.color_array[i+1]
			mov ebx,[esi]
			mov [edi+8],ebx ;p[3].f = context.color_array[i]
			add edi,12
			cmp dword[size],3
			jle .e1
				add esi,12
				movsd
				jmp .e2
			.e1:
				mov dword[edi],1.0 ;если задано 3 параметра, то 4-й ставим по умолчанию 1.0
			.e2:
			mov edi,ebp
			sub edi,32 ;edi = &p[0]
			mov ebx,ebp
			sub ebx,12 ;ebp-12 = &p[5]
			push ebx
			add ebx,4 ;ebp-8 = &p[6]
			push ebx
			add ebx,4 ;ebp-4 = &p[7]
			push ebx
			stdcall RGBFtoRGBI,[edi+12],[edi+8],[edi+4] ;call: r,g,b,&p[7],&p[6],&p[5]
			stdcall glopColor, edx,edi ;(context, p(op,rf,gf,bf,af,ri,gi,bi))
		@@:
		bt dword[states],2 ;2^2=NORMAL_ARRAY
		jnc @f
			mov esi,[edx+offs_cont_normal_array_stride]
			add esi,3
			imul esi,[idx]
			shl esi,2
			add esi,[edx+offs_cont_normal_array] ;esi = &context.normal_array[ idx * (3 + context.normal_array_stride) ]
			mov edi,edx
			add edi,offs_cont_current_normal
			movsd ;context.current_normal.X = context.normal_array[i]
			movsd
			movsd
			mov dword[edi],0.0 ;context.current_normal.W = 0.0f
		@@:
		bt dword[states],3 ;2^3=TEXCOORD_ARRAY
		jnc @f
			mov esi,[edx+offs_cont_texcoord_array_size]
			mov [size],esi
			add esi,[edx+offs_cont_texcoord_array_stride]
			imul esi,[idx] ;esi = i
			shl esi,2
			add esi,[edx+offs_cont_texcoord_array] ;esi = &context.texcoord_array[i]
			mov edi,edx
			add edi,offs_cont_current_tex_coord
			movsd ;context.current_tex_coord.X = ccontext.texcoord_array[i]
			movsd
			cmp dword[size],2
			jle .e3
				movsd
				jmp .e4
			.e3:
				mov dword[edi],0.0 ;если задано 2 параметра, то 3-й ставим по умолчанию 0.0
				add edi,4
			.e4:
			cmp dword[size],3
			jle .e5
				movsd
				jmp @f
			.e5:
				mov dword[edi],1.0 ;если задано 3 параметра, то 4-й ставим по умолчанию 1.0
		@@:
		bt dword[states],0 ;2^0=VERTEX_ARRAY
		jnc @f
			mov esi,[edx+offs_cont_vertex_array_size]
			mov [size],esi
			add esi,[edx+offs_cont_vertex_array_stride]
			imul esi,[idx] ;esi = i
			shl esi,2
			add esi,[edx+offs_cont_vertex_array] ;esi = &context.vertex_array[i]
			mov edi,ebp
			sub edi,28 ;edi = &p[1]
			movsd ;p[1].f = context.vertex_array[i]
			movsd
			cmp dword[size],2
			jle .e6
				movsd
				jmp .e7
			.e6:
				mov dword[edi],0.0 ;если задано 2 параметра, то 3-й ставим по умолчанию 0.0
				add edi,4
				jmp .e8 ;и 4-й тоже ставим по умолчанию
			.e7:
			cmp dword[size],3
			jle .e8
				movsd
				sub edi,20 ;edi=&p[0]
				jmp .e9
			.e8:
				mov dword[edi],1.0 ;если задано 3 параметра, то 4-й ставим по умолчанию 1.0
				sub edi,16 ;edi=&p[0]
			.e9:
			stdcall glopVertex, edx,edi
		@@:
		inc dword[idx]
	inc dword[vi]
	jmp .cycle_0
	.cycle_0_end:

	;mov eax,ebp
	;sub eax,32 ;=sizeof(dd)*8
	stdcall glopEnd, edx,eax
popad
	ret
endp

align 4
proc glDrawArrays uses eax, mode:dword, first:dword, count:dword
locals
	p rd 4
endl
	mov dword[p],OP_DrawArrays
	mov eax,[mode]
	mov dword[p+4],eax
	mov eax,[first]
	mov dword[p+8],eax
	mov eax,[count]
	mov dword[p+12],eax

	mov eax,ebp
	sub eax,16 ;=sizeof(dd)*4
	stdcall gl_add_op,eax
	ret
endp

align 4
proc glopDrawElements uses eax ebx edx, context:dword, param:dword
locals
	p rd 8
endl

	mov edx,[context]
	mov ebx,[param]
  ;int i;
  ;int idx;
  ;int states = c->client_states;
  ;int count = param[2].i;
  ;int type = param[3].i;
  ;unsigned int *indices_u32 = (unsigned int*)param[4].p;
  ;unsigned short *indices_u16 = (unsigned short*)indices_u32;

	mov eax,[ebx+4]
	mov [p+4],eax ;p[1].i = param[1].i
	mov eax,ebp
	sub eax,32 ;=sizeof(dd)*8
	stdcall glopBegin, edx,eax

;  for (int ii=0; ii<count; ii++) {
;    idx = (type == GL_UNSIGNED_INT) ? indices_u32[ii] : indices_u16[ii];
;    if (states & COLOR_ARRAY) {
;      GLParam p[5];
;      int size = c->color_array_size; 
;      i = idx * (size + c->color_array_stride);
;      p[1].f = c->color_array[i];
;      p[2].f = c->color_array[i+1];
;      p[3].f = c->color_array[i+2];
;      p[4].f = size > 3 ? c->color_array[i+3] : 1.0f;
;      glopColor(c, p);  
;    }
;    if (states & NORMAL_ARRAY) {
;      i = idx * (3 + c->normal_array_stride);
;      c->current_normal.X = c->normal_array[i];
;      c->current_normal.Y = c->normal_array[i+1];
;      c->current_normal.Z = c->normal_array[i+2];
;      c->current_normal.W = 0.0f;
;    }
;    if (states & TEXCOORD_ARRAY) {
;      int size = c->texcoord_array_size;
;      i = idx * (size + c->texcoord_array_stride);
;      c->current_tex_coord.X = c->texcoord_array[i];
;      c->current_tex_coord.Y = c->texcoord_array[i+1];
;      c->current_tex_coord.Z = size > 2 ? c->texcoord_array[i+2] : 0.0f;
;      c->current_tex_coord.W = size > 3 ? c->texcoord_array[i+3] : 1.0f;
;    }
;    if (states & VERTEX_ARRAY) {
;      GLParam p[5];
;      int size = c->vertex_array_size;
;      i = idx * (size + c->vertex_array_stride);
;      p[1].f = c->vertex_array[i];
;      p[2].f = c->vertex_array[i+1];
;      p[3].f = size > 2 ? c->vertex_array[i+2] : 0.0f;
;      p[4].f = size > 3 ? c->vertex_array[i+3] : 1.0f;
;      glopVertex(c, p);
;    }
;  }
	mov eax,ebp
	sub eax,32 ;=sizeof(dd)*8
	stdcall glopEnd, edx,eax
	ret
endp

align 4
proc glDrawElements uses eax, mode:dword, count:dword, type:dword, indices:dword
locals
	p rd 5
endl
;assert(type == GL_UNSIGNED_SHORT || type == GL_UNSIGNED_INT/* nonstandard */);
	mov dword[p],OP_DrawElements
	mov eax,[mode]
	mov dword[p+4],eax
	mov eax,[count]
	mov dword[p+8],eax
	mov eax,[type]
	mov dword[p+12],eax
	mov eax,[indices]
	mov dword[p+16],eax

	mov eax,ebp
	sub eax,20 ;=sizeof(dd)*5
	stdcall gl_add_op,eax
	ret
endp

align 4
proc glopEnableClientState uses eax ebx, context:dword, p:dword
	mov eax,[context]
	mov ebx,[p]
	mov ebx,[ebx+4] ;ebx = p[1]
	or dword[eax+offs_cont_client_states],ebx
	ret
endp

align 4
proc glEnableClientState uses eax, array:dword
locals
	p rd 2
endl
	mov dword[p],OP_EnableClientState

	cmp dword[array],GL_VERTEX_ARRAY
	jne @f
		mov dword[p+4],VERTEX_ARRAY
		jmp .end_f
	@@:
	cmp dword[array],GL_NORMAL_ARRAY
	jne @f
		mov dword[p+4],NORMAL_ARRAY
		jmp .end_f
	@@:
	cmp dword[array],GL_COLOR_ARRAY
	jne @f
		mov dword[p+4],COLOR_ARRAY
		jmp .end_f
	@@:
	cmp dword[array],GL_TEXTURE_COORD_ARRAY
	jne @f
		mov dword[p+4],TEXCOORD_ARRAY
		jmp .end_f
	@@:
		;assert(0);
	.end_f:

	mov eax,ebp
	sub eax,8 ;=sizeof(dd)*2
	stdcall gl_add_op,eax
	ret
endp

align 4
proc glopDisableClientState uses eax ebx, context:dword, p:dword
	mov eax,[context]
	mov ebx,[p]
	mov ebx,[ebx+4] ;ebx = p[1]
	and dword[eax+offs_cont_client_states],ebx
	ret
endp

align 4
proc glDisableClientState uses eax, array:dword
locals
	p rd 2
endl
	mov dword[p],OP_DisableClientState

	cmp dword[array],GL_VERTEX_ARRAY
	jne @f
		mov dword[p+4], not VERTEX_ARRAY
		jmp .end_f
	@@:
	cmp dword[array],GL_NORMAL_ARRAY
	jne @f
		mov dword[p+4], not NORMAL_ARRAY
		jmp .end_f
	@@:
	cmp dword[array],GL_COLOR_ARRAY
	jne @f
		mov dword[p+4], not COLOR_ARRAY
		jmp .end_f
	@@:
	cmp dword[array],GL_TEXTURE_COORD_ARRAY
	jne @f
		mov dword[p+4], not TEXCOORD_ARRAY
		jmp .end_f
	@@:
		;assert(0);
	.end_f:

	mov eax,ebp
	sub eax,8 ;=sizeof(dd)*2
	stdcall gl_add_op,eax
	ret
endp

align 4
proc glopVertexPointer uses eax ebx ecx, context:dword, p:dword
	mov eax,[context]
	mov ebx,[p]
	mov ecx,[ebx+4] ;ecx = p[1]
	mov dword[eax+offs_cont_vertex_array_size],ecx
	mov ecx,[ebx+8] ;ecx = p[2]
	mov dword[eax+offs_cont_vertex_array_stride],ecx
	mov ecx,[ebx+12] ;ecx = p[3]
	mov dword[eax+offs_cont_vertex_array],ecx
	ret
endp

align 4
proc glVertexPointer uses eax, size:dword, type:dword, stride:dword, pointer:dword
locals
	p rd 4
endl
;  assert(type == GL_FLOAT);

	mov dword[p],OP_VertexPointer
	mov eax,[size]
	mov dword[p+4],eax
	mov eax,[stride]
	mov dword[p+8],eax
	mov eax,[pointer]
	mov dword[p+12],eax

	mov eax,ebp
	sub eax,16 ;=sizeof(dd)*4
	stdcall gl_add_op,eax
	ret
endp

align 4
proc glopColorPointer uses eax ebx ecx, context:dword, p:dword
	mov eax,[context]
	mov ebx,[p]
	mov ecx,[ebx+4] ;ecx = p[1]
	mov dword[eax+offs_cont_color_array_size],ecx
	mov ecx,[ebx+8] ;ecx = p[2]
	mov dword[eax+offs_cont_color_array_stride],ecx
	mov ecx,[ebx+12] ;ecx = p[3]
	mov dword[eax+offs_cont_color_array],ecx
	ret
endp

align 4
proc glColorPointer uses eax, size:dword, type:dword, stride:dword, pointer:dword
locals
	p rd 4
endl
;  assert(type == GL_FLOAT);

	mov dword[p],OP_ColorPointer
	mov eax,[size]
	mov dword[p+4],eax
	mov eax,[stride]
	mov dword[p+8],eax
	mov eax,[pointer]
	mov dword[p+12],eax

	mov eax,ebp
	sub eax,16 ;=sizeof(dd)*4
	stdcall gl_add_op,eax
	ret
endp

align 4
proc glopNormalPointer uses eax ebx ecx, context:dword, p:dword
	mov eax,[context]
	mov ebx,[p]
	mov ecx,[ebx+4] ;ecx = p[1]
	mov dword[eax+offs_cont_normal_array_stride],ecx
	mov ecx,[ebx+8] ;ecx = p[2]
	mov dword[eax+offs_cont_normal_array],ecx
	ret
endp

align 4
proc glNormalPointer uses eax, type:dword, stride:dword, pointer:dword
locals
	p rd 3
endl
;  assert(type == GL_FLOAT);

	mov dword[p],OP_NormalPointer
	mov eax,[stride]
	mov dword[p+4],eax
	mov eax,[pointer]
	mov dword[p+8],eax

	mov eax,ebp
	sub eax,12 ;=sizeof(dd)*3
	stdcall gl_add_op,eax
	ret
endp

align 4
proc glopTexCoordPointer uses eax ebx ecx, context:dword, p:dword
	mov eax,[context]
	mov ebx,[p]
	mov ecx,[ebx+4] ;ecx = p[1]
	mov dword[eax+offs_cont_texcoord_array_size],ecx
	mov ecx,[ebx+8] ;ecx = p[2]
	mov dword[eax+offs_cont_texcoord_array_stride],ecx
	mov ecx,[ebx+12] ;ecx = p[3]
	mov dword[eax+offs_cont_texcoord_array],ecx
	ret
endp

align 4
proc glTexCoordPointer uses eax, size:dword, type:dword, stride:dword, pointer:dword
locals
	p rd 4
endl
;  assert(type == GL_FLOAT);

	mov dword[p],OP_TexCoordPointer
	mov eax,[size]
	mov dword[p+4],eax
	mov eax,[stride]
	mov dword[p+8],eax
	mov eax,[pointer]
	mov dword[p+12],eax

	mov eax,ebp
	sub eax,16 ;=sizeof(dd)*4
	stdcall gl_add_op,eax
	ret
endp