static void TAG() light_rgba	(	GLcontext *	ctx,
		struct vertex_buffer *	VB,
		struct tnl_pipeline_stage *	stage,
		GLvector4f *	input
	)		`[static]`
Definition at line 235 of file t_vb_lighttmp.h.
Referenced by init_light_tab().
{
   struct light_stage_data *store = LIGHT_STAGE_DATA(stage);
   GLuint j;

   GLfloat (*base)[3] = ctx->Light._BaseColor;
   GLfloat sumA[2];

   const GLuint vstride = input->stride;
   const GLfloat *vertex = (GLfloat *) input->data;
   const GLuint nstride = VB->AttribPtr[_TNL_ATTRIB_NORMAL]->stride;
   const GLfloat *normal = (GLfloat *)VB->AttribPtr[_TNL_ATTRIB_NORMAL]->data;

   GLfloat (*Fcolor)[4] = (GLfloat (*)[4]) store->LitColor[0].data;
#if IDX & LIGHT_TWOSIDE
   GLfloat (*Bcolor)[4] = (GLfloat (*)[4]) store->LitColor[1].data;
#endif

   const GLuint nr = VB->Count;

#ifdef TRACE
   fprintf(stderr, "%s\n", __FUNCTION__ );
#endif

   VB->ColorPtr[0] = &store->LitColor[0];
   sumA[0] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE][3];

#if IDX & LIGHT_TWOSIDE
   VB->ColorPtr[1] = &store->LitColor[1];
   sumA[1] = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_DIFFUSE][3];
#endif

   store->LitColor[0].stride = 16;
   store->LitColor[1].stride = 16;

   for (j = 0; j < nr; j++,STRIDE_F(vertex,vstride),STRIDE_F(normal,nstride)) {
      GLfloat sum[2][3];
      struct gl_light *light;

#if IDX & LIGHT_MATERIAL
      update_materials( ctx, store );
      sumA[0] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE][3];
#if IDX & LIGHT_TWOSIDE
      sumA[1] = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_DIFFUSE][3];
#endif
#endif

      COPY_3V(sum[0], base[0]);

#if IDX & LIGHT_TWOSIDE
      COPY_3V(sum[1], base[1]);
#endif

      /* Add contribution from each enabled light source */
      foreach (light, &ctx->Light.EnabledList) {

     GLfloat n_dot_h;
     GLfloat correction;
     GLint side;
     GLfloat contrib[3];
     GLfloat attenuation = 1.0;
     GLfloat VP[3];          /* unit vector from vertex to light */
     GLfloat n_dot_VP;       /* n dot VP */
     GLfloat *h;

     /* compute VP and attenuation */
     if (!(light->_Flags & LIGHT_POSITIONAL)) {
        /* directional light */
        COPY_3V(VP, light->_VP_inf_norm);
        attenuation = light->_VP_inf_spot_attenuation;
     }
     else {
        GLfloat d;     /* distance from vertex to light */


        SUB_3V(VP, light->_Position, vertex);

        d = (GLfloat) LEN_3FV( VP );

        if ( d > 1e-6) {
           GLfloat invd = 1.0F / d;
           SELF_SCALE_SCALAR_3V(VP, invd);
        }

            attenuation = 1.0F / (light->ConstantAttenuation + d *
                                  (light->LinearAttenuation + d *
                                   light->QuadraticAttenuation));

        /* spotlight attenuation */
        if (light->_Flags & LIGHT_SPOT) {
           GLfloat PV_dot_dir = - DOT3(VP, light->_NormDirection);

           if (PV_dot_dir<light->_CosCutoff) {
          continue; /* this light makes no contribution */
           }
           else {
          GLdouble x = PV_dot_dir * (EXP_TABLE_SIZE-1);
          GLint k = (GLint) x;
          GLfloat spot = (GLfloat) (light->_SpotExpTable[k][0]
                  + (x-k)*light->_SpotExpTable[k][1]);
          attenuation *= spot;
           }
        }
     }

     if (attenuation < 1e-3)
        continue;       /* this light makes no contribution */

     /* Compute dot product or normal and vector from V to light pos */
     n_dot_VP = DOT3( normal, VP );

     /* which side are we lighting? */
     if (n_dot_VP < 0.0F) {
        ACC_SCALE_SCALAR_3V(sum[0], attenuation, light->_MatAmbient[0]);
#if IDX & LIGHT_TWOSIDE
        side = 1;
        correction = -1;
        n_dot_VP = -n_dot_VP;
#else
            continue;
#endif
     }
         else {
#if IDX & LIGHT_TWOSIDE
            ACC_SCALE_SCALAR_3V( sum[1], attenuation, light->_MatAmbient[1]);
#endif
        side = 0;
        correction = 1;
     }

     COPY_3V(contrib, light->_MatAmbient[side]);

     /* diffuse term */
     ACC_SCALE_SCALAR_3V(contrib, n_dot_VP, light->_MatDiffuse[side]);

     /* specular term - cannibalize VP... */
     {
        if (ctx->Light.Model.LocalViewer) {
           GLfloat v[3];
           COPY_3V(v, vertex);
           NORMALIZE_3FV(v);
           SUB_3V(VP, VP, v);                /* h = VP + VPe */
           h = VP;
           NORMALIZE_3FV(h);
        }
        else if (light->_Flags & LIGHT_POSITIONAL) {
           h = VP;
           ACC_3V(h, ctx->_EyeZDir);
           NORMALIZE_3FV(h);
        }
            else {
           h = light->_h_inf_norm;
        }

        n_dot_h = correction * DOT3(normal, h);

        if (n_dot_h > 0.0F)
        {
           GLfloat spec_coef;
           struct gl_shine_tab *tab = ctx->_ShineTable[side];

           GET_SHINE_TAB_ENTRY( tab, n_dot_h, spec_coef );

           ACC_SCALE_SCALAR_3V( contrib, spec_coef,
                    light->_MatSpecular[side]);
        }
     }

     ACC_SCALE_SCALAR_3V( sum[side], attenuation, contrib );
      }

      COPY_3V( Fcolor[j], sum[0] );
      Fcolor[j][3] = sumA[0];

#if IDX & LIGHT_TWOSIDE
      COPY_3V( Bcolor[j], sum[1] );
      Bcolor[j][3] = sumA[1];
#endif
   }
}
ReactOS Development > Doxygen
