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

;include 'msghandling.inc'

align 4
proc glopMaterial, context:dword, p:dword
;  int mode=p[1].i;
;  int type=p[2].i;
;  float *v=&p[3].f;
;  int i;
;  GLMaterial *m;

;  if (mode == GL_FRONT_AND_BACK) {
;    p[1].i=GL_FRONT;
;    glopMaterial(c,p);
;    mode=GL_BACK;
;  }
;  if (mode == GL_FRONT) m=&c->materials[0];
;  else m=&c->materials[1];

;  switch(type) {
;  case GL_EMISSION:
;    for(i=0;i<4;i++)
;      m->emission.v[i]=v[i];
;    break;
;  case GL_AMBIENT:
;    for(i=0;i<4;i++)
;      m->ambient.v[i]=v[i];
;    break;
;  case GL_DIFFUSE:
;    for(i=0;i<4;i++)
;      m->diffuse.v[i]=v[i];
;    break;
;  case GL_SPECULAR:
;    for(i=0;i<4;i++)
;      m->specular.v[i]=v[i];
;    break;
;  case GL_SHININESS:
;    m->shininess=v[0];
;    m->shininess_i = (v[0]/128.0f)*SPECULAR_BUFFER_RESOLUTION;
;    break;
;  case GL_AMBIENT_AND_DIFFUSE:
;    for(i=0;i<4;i++)
;      m->diffuse.v[i]=v[i];
;    for(i=0;i<4;i++)
;      m->ambient.v[i]=v[i];
;    break;
;  default:
;    assert(0);
;  }
	ret
endp

align 4
proc glopColorMaterial 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_current_color_material_mode],ecx
	mov ecx,[ebx+8] ;ecx = p[2]
	mov dword[eax+offs_cont_current_color_material_type],ecx
	ret
endp

;void glopLight(GLContext *c,GLParam *p)
;{
;  int light=p[1].i;
;  int type=p[2].i;
;  V4 v;
;  GLLight *l;
;  int i;
;  
;  assert(light >= GL_LIGHT0 && light < GL_LIGHT0+MAX_LIGHTS );
;
;  l=&c->lights[light-GL_LIGHT0];
;
;  for(i=0;i<4;i++) v.v[i]=p[3+i].f;
;
;  switch(type) {
;  case GL_AMBIENT:
;    l->ambient=v;
;    break;
;  case GL_DIFFUSE:
;    l->diffuse=v;
;    break;
;  case GL_SPECULAR:
;    l->specular=v;
;    break;
;  case GL_POSITION:
;    {
;      V4 pos;
;      gl_M4_MulV4(&pos,c->matrix_stack_ptr[0],&v);
;
;      l->position=pos;
;
;      if (l->position.v[3] == 0) {
;        l->norm_position.X=pos.X;
;        l->norm_position.Y=pos.Y;
;        l->norm_position.Z=pos.Z;
;        
;        gl_V3_Norm(&l->norm_position);
;      }
;    }
;    break;
;  case GL_SPOT_DIRECTION:
;    for(i=0;i<3;i++) {
;      l->spot_direction.v[i]=v.v[i];
;      l->norm_spot_direction.v[i]=v.v[i];
;    }
;    gl_V3_Norm(&l->norm_spot_direction);
;    break;
;  case GL_SPOT_EXPONENT:
;    l->spot_exponent=v.v[0];
;    break;
;  case GL_SPOT_CUTOFF:
;    {
;      float a=v.v[0];
;      assert(a == 180 || (a>=0 && a<=90));
;      l->spot_cutoff=a;
;      if (a != 180) l->cos_spot_cutoff=cos(a * M_PI / 180.0);
;    }
;    break;
;  case GL_CONSTANT_ATTENUATION:
;    l->attenuation[0]=v.v[0];
;    break;
;  case GL_LINEAR_ATTENUATION:
;    l->attenuation[1]=v.v[0];
;    break;
;  case GL_QUADRATIC_ATTENUATION:
;    l->attenuation[2]=v.v[0];
;    break;
;  default:
;    assert(0);
;  }
;}
  
align 4
proc glopLightModel uses ebx ecx esi edi, context:dword, p:dword
	mov edi,[context]
	mov ebx,[p]
	mov esi,[ebx+8]

	cmp dword[ebx+4],GL_LIGHT_MODEL_AMBIENT
	jne @f
		mov ecx,4
		mov edi,dword[edi+offs_cont_ambient_light_model]
		rep movsd ;for(i=0;i<4;i++) context.ambient_light_model.v[i]=v[i]
		jmp .end_f
	@@:
	cmp dword[ebx+4],GL_LIGHT_MODEL_LOCAL_VIEWER
	jne @f
		fld dword[esi] ;st0 = p[2].v[0]
		fistp dword[edi+offs_cont_local_light_model]
		jmp .end_f
	@@:
	cmp dword[ebx+4],GL_LIGHT_MODEL_TWO_SIDE
	jne @f
		fld dword[esi] ;st0 = p[2].v[0]
		fistp dword[edi+offs_cont_light_model_two_side]
		jmp .end_f
	@@: ;default:
;    tgl_warning("glopLightModel: illegal pname: 0x%x\n", dword[ebx+4]);
;    //assert(0);
	.end_f:
	ret
endp

;static inline float clampf(float a,float min,float max)
;{
;  if (a<min) return min;
;  else if (a>max) return max;
;  else return a;
;}

align 4
proc gl_enable_disable_light uses eax ebx ecx, context:dword, light:dword, v:dword
	mov eax,[context]
	mov ebx,[light]
	imul ebx,sizeof.GLLight
	add ebx,[eax+offs_cont_lights]

	xor ecx,ecx
	cmp dword[ebx+offs_ligh_enabled],0
	jne @f
		not ecx
	@@:
	and ecx,[v]
	cmp ecx,0
	je @f
		;if (v && !l.enabled)
		mov dword[ebx+offs_ligh_enabled],1
		mov ecx,[eax+offs_cont_first_light]
		mov [ebx+offs_ligh_next],ecx
		mov [eax+offs_cont_first_light],ebx ;context.first_light = l
		mov dword[ebx+offs_ligh_prev],0 ;l.prev = NULL
		jmp .end_f
	@@:
	xor ecx,ecx
	cmp dword[v],0
	jne @f
		not ecx
	@@:
	and ecx,[ebx+offs_ligh_enabled]
	cmp ecx,0
	je .end_f
		;else if (!v && l.enabled)
		mov dword[ebx+offs_ligh_enabled],0 ;l.enabled = 0
		mov ecx,[ebx+offs_ligh_next]
		cmp dword[ebx+offs_ligh_prev],0 ;if (l.prev == NULL)
		jne .els_0
			mov [eax+offs_cont_first_light],ecx	;context.first_light = l.next
			jmp @f
		.els_0:
			mov eax,[ebx+offs_ligh_prev]
			mov [eax+offs_ligh_next],ecx ;l.prev.next = l.next
		@@:
		cmp dword[ebx+offs_ligh_next],0
		je .end_f
			mov ecx,[ebx+offs_ligh_prev]
			mov eax,[ebx+offs_ligh_next]
			mov [eax+offs_ligh_prev],ecx ;l.next.prev = l.prev
	.end_f:
	ret
endp

; non optimized lightening model
align 4
proc gl_shade_vertex, context:dword, v:dword

;  float R,G,B,A;
;  GLMaterial *m;
;  GLLight *l;
;  V3 n,s,d;
;  float dist,tmp,att,dot,dot_spot,dot_spec;
;  int twoside = c->light_model_two_side;

;  m=&c->materials[0];

;  n.X=v->normal.X;
;  n.Y=v->normal.Y;
;  n.Z=v->normal.Z;

;  R=m->emission.v[0]+m->ambient.v[0]*c->ambient_light_model.v[0];
;  G=m->emission.v[1]+m->ambient.v[1]*c->ambient_light_model.v[1];
;  B=m->emission.v[2]+m->ambient.v[2]*c->ambient_light_model.v[2];
;  A=clampf(m->diffuse.v[3],0,1);

;  for(l=c->first_light;l!=NULL;l=l->next) {
;    float lR,lB,lG;

;    /* ambient */
;    lR=l->ambient.v[0] * m->ambient.v[0];
;    lG=l->ambient.v[1] * m->ambient.v[1];
;    lB=l->ambient.v[2] * m->ambient.v[2];

;    if (l->position.v[3] == 0) {
;      /* light at infinity */
;      d.X=l->position.v[0];
;      d.Y=l->position.v[1];
;      d.Z=l->position.v[2];
;      att=1;
;    } else {
;      /* distance attenuation */
;      d.X=l->position.v[0]-v->ec.v[0];
;      d.Y=l->position.v[1]-v->ec.v[1];
;      d.Z=l->position.v[2]-v->ec.v[2];
;      dist=sqrt(d.X*d.X+d.Y*d.Y+d.Z*d.Z);
;      if (dist>1E-3) {
;        tmp=1/dist;
;        d.X*=tmp;
;        d.Y*=tmp;
;        d.Z*=tmp;
;      }
;      att=1.0f/(l->attenuation[0]+dist*(l->attenuation[1]+
;                                    dist*l->attenuation[2]));
;    }
;    dot=d.X*n.X+d.Y*n.Y+d.Z*n.Z;
;    if (twoside && dot < 0) dot = -dot;
;    if (dot>0) {
;      /* diffuse light */
;      lR+=dot * l->diffuse.v[0] * m->diffuse.v[0];
;      lG+=dot * l->diffuse.v[1] * m->diffuse.v[1];
;      lB+=dot * l->diffuse.v[2] * m->diffuse.v[2];
;
;      /* spot light */
;      if (l->spot_cutoff != 180) {
;        dot_spot=-(d.X*l->norm_spot_direction.v[0]+
;                   d.Y*l->norm_spot_direction.v[1]+
;                   d.Z*l->norm_spot_direction.v[2]);
;        if (twoside && dot_spot < 0) dot_spot = -dot_spot;
;        if (dot_spot < l->cos_spot_cutoff) {
;          /* no contribution */
;          continue;
;        } else {
;          /* TODO: optimize */
;          if (l->spot_exponent > 0) {
;            att=att*pow(dot_spot,l->spot_exponent);
;          }
;        }
;      }

;      /* specular light */

;      if (c->local_light_model) {
;        V3 vcoord;
;        vcoord.X=v->ec.X;
;        vcoord.Y=v->ec.Y;
;        vcoord.Z=v->ec.Z;
;        gl_V3_Norm(&vcoord);
;        s.X=d.X-vcoord.X;
;        s.Y=d.Y-vcoord.X;
;        s.Z=d.Z-vcoord.X;
;      } else {
;        s.X=d.X;
;        s.Y=d.Y;
;        s.Z=d.Z+1.0;
;      }
;      dot_spec=n.X*s.X+n.Y*s.Y+n.Z*s.Z;
;      if (twoside && dot_spec < 0) dot_spec = -dot_spec;
;      if (dot_spec>0) {
;        GLSpecBuf *specbuf;
;        int idx;
;        tmp=sqrt(s.X*s.X+s.Y*s.Y+s.Z*s.Z);
;        if (tmp > 1E-3) {
;          dot_spec=dot_spec / tmp;
;        }

;        /* TODO: optimize */
;        /* testing specular buffer code */
;        /* dot_spec= pow(dot_spec,m->shininess);*/
;        specbuf = specbuf_get_buffer(c, m->shininess_i, m->shininess);
;        idx = (int)(dot_spec*SPECULAR_BUFFER_SIZE);
;        if (idx > SPECULAR_BUFFER_SIZE) idx = SPECULAR_BUFFER_SIZE;
;        dot_spec = specbuf->buf[idx];
;        lR+=dot_spec * l->specular.v[0] * m->specular.v[0];
;        lG+=dot_spec * l->specular.v[1] * m->specular.v[1];
;        lB+=dot_spec * l->specular.v[2] * m->specular.v[2];
;      }
;    }

;    R+=att * lR;
;    G+=att * lG;
;    B+=att * lB;
;  }

;  v->color.v[0]=clampf(R,0,1);
;  v->color.v[1]=clampf(G,0,1);
;  v->color.v[2]=clampf(B,0,1);
;  v->color.v[3]=A;
	ret
endp