-/* $Id: t_vb_light.c,v 1.10 2001/03/03 20:33:31 brianp Exp $ */
+/* $Id: t_vb_light.c,v 1.19 2002/10/24 23:57:25 brianp Exp $ */
/*
* Mesa 3-D graphics library
#include "colormac.h"
#include "light.h"
#include "macros.h"
-#include "mem.h"
+#include "imports.h"
#include "mmath.h"
#include "simple_list.h"
#include "mtypes.h"
+#include "math/m_translate.h"
+
#include "t_context.h"
#include "t_pipeline.h"
GLvector4f *input );
struct light_stage_data {
- GLvector4chan LitColor[2];
- GLvector4chan LitSecondary[2];
+ struct gl_client_array FloatColor;
+ struct gl_client_array LitColor[2];
+ struct gl_client_array LitSecondary[2];
GLvector1ui LitIndex[2];
light_func *light_func_tab;
};
-#define LIGHT_STAGE_DATA(stage) ((struct light_stage_data *)(stage->private))
+
+#define LIGHT_STAGE_DATA(stage) ((struct light_stage_data *)(stage->privatePtr))
+
+
+static void import_color_material( GLcontext *ctx,
+ struct gl_pipeline_stage *stage )
+{
+ struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+ struct gl_client_array *to = &LIGHT_STAGE_DATA(stage)->FloatColor;
+ struct gl_client_array *from = VB->ColorPtr[0];
+ GLuint count = VB->Count;
+
+ if (!to->Ptr) {
+ to->Ptr = ALIGN_MALLOC( VB->Size * 4 * sizeof(GLfloat), 32 );
+ to->Type = GL_FLOAT;
+ }
+
+ /* No need to transform the same value 3000 times.
+ */
+ if (!from->StrideB) {
+ to->StrideB = 0;
+ count = 1;
+ }
+ else
+ to->StrideB = 4 * sizeof(GLfloat);
+
+ _math_trans_4f( (GLfloat (*)[4]) to->Ptr,
+ from->Ptr,
+ from->StrideB,
+ from->Type,
+ from->Size,
+ 0,
+ count);
+
+ VB->ColorPtr[0] = to;
+}
+
/* Tables for all the shading functions.
*/
GLvector4f *input = ctx->_NeedEyeCoords ? VB->EyePtr : VB->ObjPtr;
GLuint ind;
+/* _tnl_print_vert_flags( __FUNCTION__, stage->changed_inputs ); */
+
/* Make sure we can talk about elements 0..2 in the vector we are
* lighting.
*/
- if (stage->changed_inputs & (VERT_EYE|VERT_OBJ)) {
+ if (stage->changed_inputs & (VERT_BIT_EYE|VERT_BIT_POS)) {
if (input->size <= 2) {
if (input->flags & VEC_NOT_WRITEABLE) {
- ASSERT(VB->importable_data & VERT_OBJ);
+ ASSERT(VB->importable_data & VERT_BIT_POS);
- VB->import_data( ctx, VERT_OBJ, VEC_NOT_WRITEABLE );
+ VB->import_data( ctx, VERT_BIT_POS, VEC_NOT_WRITEABLE );
input = ctx->_NeedEyeCoords ? VB->EyePtr : VB->ObjPtr;
ASSERT((input->flags & VEC_NOT_WRITEABLE) == 0);
_mesa_vector4f_clean_elem(input, VB->Count, 2);
}
}
-
+
if (VB->Flag)
ind = LIGHT_FLAGS;
- else
+ else
ind = 0;
- /* The individual tabs know about replaying side-effects vs. full
- * re-execution.
+ /* The individual functions know about replaying side-effects
+ * vs. full re-execution.
*/
store->light_func_tab[ind]( ctx, VB, stage, input );
/* Called in place of do_lighting when the light table may have changed.
*/
-static GLboolean run_validate_lighting( GLcontext *ctx,
+static GLboolean run_validate_lighting( GLcontext *ctx,
struct gl_pipeline_stage *stage )
{
GLuint ind = 0;
- light_func *tab;
-
+ light_func *tab;
+
if (ctx->Visual.rgbMode) {
if (ctx->Light._NeedVertices) {
if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
tab = _tnl_light_spec_tab;
else
- tab = _tnl_light_tab;
- }
+ tab = _tnl_light_tab;
+ }
else {
if (ctx->Light.EnabledList.next == ctx->Light.EnabledList.prev)
tab = _tnl_light_fast_single_tab;
if (ctx->Light.ColorMaterialEnabled)
ind |= LIGHT_COLORMATERIAL;
-
+
if (ctx->Light.Model.TwoSide)
ind |= LIGHT_TWOSIDE;
/* This and the above should only be done on _NEW_LIGHT:
*/
- _mesa_validate_all_lighting_tables( ctx );
+ TNL_CONTEXT(ctx)->Driver.NotifyMaterialChange( ctx );
/* Now run the stage...
*/
return stage->run( ctx, stage );
}
+static void alloc_4chan( struct gl_client_array *a, GLuint sz )
+{
+ a->Ptr = ALIGN_MALLOC( sz * sizeof(GLchan) * 4, 32 );
+ a->Size = 4;
+ a->Type = CHAN_TYPE;
+ a->Stride = 0;
+ a->StrideB = sizeof(GLchan) * 4;
+ a->Enabled = 0;
+ a->Flags = 0;
+}
+
+
/* Called the first time stage->run is called. In effect, don't
* allocate data until the first time the stage is run.
*/
-static GLboolean run_init_lighting( GLcontext *ctx,
+static GLboolean run_init_lighting( GLcontext *ctx,
struct gl_pipeline_stage *stage )
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct light_stage_data *store;
GLuint size = tnl->vb.Size;
- stage->private = MALLOC(sizeof(*store));
+ stage->privatePtr = MALLOC(sizeof(*store));
store = LIGHT_STAGE_DATA(stage);
if (!store)
return GL_FALSE;
*/
init_lighting();
- _mesa_vector4chan_alloc( &store->LitColor[0], 0, size, 32 );
- _mesa_vector4chan_alloc( &store->LitColor[1], 0, size, 32 );
- _mesa_vector4chan_alloc( &store->LitSecondary[0], 0, size, 32 );
- _mesa_vector4chan_alloc( &store->LitSecondary[1], 0, size, 32 );
+ store->FloatColor.Ptr = 0;
+
+ alloc_4chan( &store->LitColor[0], size );
+ alloc_4chan( &store->LitColor[1], size );
+ alloc_4chan( &store->LitSecondary[0], size );
+ alloc_4chan( &store->LitSecondary[1], size );
+
_mesa_vector1ui_alloc( &store->LitIndex[0], 0, size, 32 );
_mesa_vector1ui_alloc( &store->LitIndex[1], 0, size, 32 );
*/
static void check_lighting( GLcontext *ctx, struct gl_pipeline_stage *stage )
{
- stage->active = ctx->Light.Enabled;
+ stage->active = ctx->Light.Enabled && !ctx->VertexProgram.Enabled;
if (stage->active) {
- if (stage->private)
+ if (stage->privatePtr)
stage->run = run_validate_lighting;
- stage->inputs = VERT_NORM|VERT_MATERIAL;
- if (ctx->Light._NeedVertices)
- stage->inputs |= VERT_EYE; /* effectively, even when lighting in obj */
- if (ctx->Light.ColorMaterialEnabled)
- stage->inputs |= VERT_RGBA;
+ stage->inputs = VERT_BIT_NORMAL|VERT_BIT_MATERIAL;
+ if (ctx->Light._NeedVertices)
+ stage->inputs |= VERT_BIT_EYE; /* effectively, even when lighting in obj */
+ if (ctx->Light.ColorMaterialEnabled)
+ stage->inputs |= VERT_BIT_COLOR0;
- stage->outputs = VERT_RGBA;
+ stage->outputs = VERT_BIT_COLOR0;
if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
- stage->outputs |= VERT_SPEC_RGB;
+ stage->outputs |= VERT_BIT_COLOR1;
}
}
struct light_stage_data *store = LIGHT_STAGE_DATA(stage);
if (store) {
- _mesa_vector4chan_free( &store->LitColor[0] );
- _mesa_vector4chan_free( &store->LitColor[1] );
- _mesa_vector4chan_free( &store->LitSecondary[0] );
- _mesa_vector4chan_free( &store->LitSecondary[1] );
- _mesa_vector1ui_free( &store->LitIndex[0] );
- _mesa_vector1ui_free( &store->LitIndex[1] );
+ ALIGN_FREE( store->LitColor[0].Ptr );
+ ALIGN_FREE( store->LitColor[1].Ptr );
+ ALIGN_FREE( store->LitSecondary[0].Ptr );
+ ALIGN_FREE( store->LitSecondary[1].Ptr );
+
+ if (store->FloatColor.Ptr)
+ ALIGN_FREE( store->FloatColor.Ptr );
+
+ _mesa_vector1ui_free( &store->LitIndex[0] );
+ _mesa_vector1ui_free( &store->LitIndex[1] );
FREE( store );
- stage->private = 0;
+ stage->privatePtr = 0;
}
}
-const struct gl_pipeline_stage _tnl_lighting_stage =
-{
- "lighting",
+const struct gl_pipeline_stage _tnl_lighting_stage =
+{
+ "lighting", /* name */
_NEW_LIGHT, /* recheck */
_NEW_LIGHT|_NEW_MODELVIEW, /* recalc -- modelview dependency
* otherwise not captured by inputs
- * (which may be VERT_OBJ) */
- 0,0,0, /* active, inputs, outputs */
- 0,0, /* changed_inputs, private_data */
+ * (which may be VERT_BIT_POS) */
+ GL_FALSE, /* active? */
+ 0, /* inputs */
+ 0, /* outputs */
+ 0, /* changed_inputs */
+ NULL, /* private_data */
dtr, /* destroy */
check_lighting, /* check */
run_init_lighting /* run -- initially set to ctr */
};
-
projects / mesa.git / blobdiff