Subversion Repositories Kolibri OS

;строки с именами функций

op_table_str:

macro ADD_OP a,b,c

{

	db 'gl',`a,' ',c,0

}

include 'opinfo.inc'

;указатели на функции ;static void (*op_table_func[])(GLContext *,GLParam *)=

op_table_func:

macro ADD_OP a,b,c

{

	dd glop#a

}

include 'opinfo.inc'

;число параметров в функциях

op_table_size:

macro ADD_OP a,b,c

{

	dd b+1

}

include 'opinfo.inc'

;output:

; eax = context.shared_state.lists[list]

align 4

proc find_list uses ebx, context:dword, list:dword

	mov eax,[context]

	mov eax,[eax+offs_cont_shared_state]

	mov ebx,[list]

	shl ebx,2

	add eax,ebx

	mov eax,[eax]

	ret

endp

;static void delete_list(GLContext *c,int list)

;{

;  GLParamBuffer *pb,*pb1;

;  GLList *l;

;  l=find_list(c,list);

;  assert(l != NULL);

;  /* free param buffer */

;  pb=l->first_op_buffer;

;  while (pb!=NULL) {

;    pb1=pb->next;

;    gl_free(pb);

;    pb=pb1;

;  }

;  gl_free(l);

;  c->shared_state.lists[list]=NULL;

;}

;static GLList *alloc_list(GLContext *c,int list)

;{

;  GLList *l;

;  GLParamBuffer *ob;

;  l=gl_zalloc(sizeof(GLList));

;  ob=gl_zalloc(sizeof(GLParamBuffer));

;  ob->next=NULL;

;  l->first_op_buffer=ob;

;  ob->ops[0].op=OP_EndList;

;  c->shared_state.lists[list]=l;

;  return l;

;}

;void gl_print_op(FILE *f,GLParam *p)

;{

;  int op;

;  char *s;

;  op=p[0].op;

;  p++;

;  s=op_table_str[op];

;  while (*s != 0) {

;    if (*s == '%') {

;      s++;

;      switch (*s++) {

;      case 'f':

;       fprintf(f,"%g",p[0].f);

;       break;

;      default:

;       fprintf(f,"%d",p[0].i);

;       break;

;      }

;      p++;

;    } else {

;      fputc(*s,f);

;      s++;

;    }

;  }

;  fprintf(f,"\n");

;}

align 4

proc gl_compile_op uses eax ebx, context:dword, p:dword

	mov eax,[context]

;  int op,op_size;

;  GLParamBuffer *ob,*ob1;

;  int index,i;

;  op=p[0].op;

;  op_size=op_table_size[op];

;  index=c->current_op_buffer_index;

;  ob=c->current_op_buffer;

;  /* we should be able to add a NextBuffer opcode */

;  if ((index + op_size) > (OP_BUFFER_MAX_SIZE-2)) {

;    ob1=gl_zalloc(sizeof(GLParamBuffer));

;    ob1->next=NULL;

;    ob->next=ob1;

;    ob->ops[index].op=OP_NextBuffer;

;    ob->ops[index+1].p=(void *)ob1;

;    c->current_op_buffer=ob1;

;    ob=ob1;

;    index=0;

;  }

;  for(i=0;i

;    ob->ops[index]=p[i];

;    index++;

;  }

;  c->current_op_buffer_index=index;

	ret

endp

align 4

proc gl_add_op uses eax ebx ecx, p:dword ;GLParam*

if DEBUG

push edi esi

	mov ebx,[p]

	mov ebx,[ebx]

	lea eax,[op_table_str]

	@@:

		cmp ebx,0

		je @f

		cmp byte[eax],0

		jne .no_dec

			dec ebx

		.no_dec:

		inc eax

		jmp @b

	@@:

	stdcall dbg_print,eax,txt_nl

	mov esi,eax

	mov word[NumberSymbolsAD],3

	mov ebx,[p]

	lea edi,[buf_param]

	mov byte[edi],0

	mov ecx,80

	.cycle_0:

		cmp byte[esi],'%'

		jne .no_param

			cmp ebx,[p]

			je @f

				stdcall str_n_cat,edi,txt_zp_sp,2

				stdcall str_len,edi

				add edi,eax

			@@:

			add ebx,4

			inc esi

			cmp byte[esi],'f'

			jne @f

				fld dword[ebx]

				fstp qword[Data_Double]

				call DoubleFloat_to_String

				stdcall str_cat, edi,Data_String

			@@:

			cmp byte[esi],'d'

			jne @f

				stdcall str_len,edi

				add edi,eax

				sub ecx,eax

				mov eax,dword[ebx]

				stdcall convert_int_to_str,ecx

			@@:

		.no_param:

		inc esi

		cmp byte[esi],0

		jne .cycle_0

	stdcall str_cat, edi,txt_nl

	stdcall dbg_print,txt_sp,buf_param

pop esi edi

end if

	call gl_get_context

	mov ebx,[p]

	cmp dword[eax+offs_cont_exec_flag],0

	je @f

		push ebx

		push eax

		mov ecx,dword[ebx] ;ecx = OP_...

		shl ecx,2

		lea ebx,[op_table_func]

		add ecx,ebx

		call dword[ecx] ;op_table_func[op](c,p)

	@@:

	cmp dword[eax+offs_cont_compile_flag],0

	je @f

		stdcall gl_compile_op,eax,[p]

	@@:

	cmp dword[eax+offs_cont_print_flag],0

	je @f

		;gl_print_op(stderr,p);

	@@:

	ret

endp

; this opcode is never called directly

align 4

proc glopEndList, context:dword, p:dword

;  assert(0);

	ret

endp

; this opcode is never called directly

align 4

proc glopNextBuffer, context:dword, p:dword

;  assert(0);

	ret

endp

;void glopCallList(GLContext *c,GLParam *p)

;{

;  GLList *l;

;  int list,op;

;  list=p[1].ui;

;  l=find_list(c,list);

;  if (l == NULL) gl_fatal_error("list %d not defined",list);

;  p=l->first_op_buffer->ops;

;  while (1) {

;    op=p[0].op;

;    if (op == OP_EndList) break;

;    if (op == OP_NextBuffer) {

;      p=(GLParam *)p[1].p;

;    } else {

;      op_table_func[op](c,p);

;      p+=op_table_size[op];

;    }

;  }

;}

;void glNewList(unsigned int list,int mode)

;{

;  GLList *l;

;  GLContext *c=gl_get_context();

;

;  assert(mode == GL_COMPILE || mode == GL_COMPILE_AND_EXECUTE);

;  assert(c->compile_flag == 0);

;

;  l=find_list(c,list);

;  if (l!=NULL) delete_list(c,list);

;  l=alloc_list(c,list);

;

;  c->current_op_buffer=l->first_op_buffer;

;  c->current_op_buffer_index=0;

;

;  c->compile_flag=1;

;  c->exec_flag=(mode == GL_COMPILE_AND_EXECUTE);

;}

;void glEndList(void)

;{

;  GLContext *c=gl_get_context();

;  GLParam p[1];

;  assert(c->compile_flag == 1);

;  /* end of list */

;  p[0].op=OP_EndList;

;  gl_compile_op(c,p);

;  c->compile_flag=0;

;  c->exec_flag=1;

;}

;output:

; eax = (find_list(gl_get_context,list) != NULL)

align 4

proc glIsList, list:dword

	call gl_get_context

	stdcall find_list, eax,[list]

	cmp eax,0 ;NULL

	je @f

		mov eax,1

	@@:

	ret

endp

;unsigned int glGenLists(int range)

;{

;  GLContext *c=gl_get_context();

;  int count,i,list;

;  GLList **lists;

;  lists=c->shared_state.lists;

;  count=0;

;  for(i=0;i

;    if (lists[i]==NULL) {

;      count++;

;      if (count == range) {

;       list=i-range+1;

;       for(i=0;i

;         alloc_list(c,list+i);

;       }

;       return list;

;      }

;    } else {

;      count=0;

;    }

;  }

;  return 0;

;}