-/* $Id: t_vb_program.c,v 1.17 2003/01/14 04:55:47 brianp Exp $ */
-
/*
* Mesa 3-D graphics library
* Version: 5.1
*
- * Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2003 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
#include "light.h"
#include "macros.h"
#include "imports.h"
-#include "mmath.h"
#include "simple_list.h"
#include "mtypes.h"
#include "nvvertprog.h"
#include "t_context.h"
#include "t_pipeline.h"
-#include "t_imm_api.h"
-#include "t_imm_exec.h"
/**
/** The results of running the vertex program go into these arrays. */
GLvector4f attribs[15];
- /* These point to the attribs[VERT_RESULT_COL0, COL1, BFC0, BFC1] arrays */
- struct gl_client_array color0[2]; /**< diffuse front and back */
- struct gl_client_array color1[2]; /**< specular front and back */
-
GLvector4f ndcCoords; /**< normalized device coords */
GLubyte *clipmask; /**< clip flags */
GLubyte ormask, andmask; /**< for clipping */
/**
* This function executes vertex programs
*/
-static GLboolean run_vp( GLcontext *ctx, struct gl_pipeline_stage *stage )
+static GLboolean run_vp( GLcontext *ctx, struct tnl_pipeline_stage *stage )
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vp_stage_data *store = VP_STAGE_DATA(stage);
struct vertex_buffer *VB = &tnl->vb;
- struct vp_machine *machine = &(ctx->VertexProgram.Machine);
struct vertex_program *program = ctx->VertexProgram.Current;
GLuint i;
VB->AttribPtr[2]->data[i][3]);
#endif
- /* load the input attribute registers */
- if (VB->Flag) {
- /* the traditional glBegin/glVertex/glEnd case */
- for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
- if (attr == 0 || (VB->Flag[i] & (1 << attr))) {
- COPY_4V(machine->Registers[VP_INPUT_REG_START + attr],
- VB->AttribPtr[attr]->data[i]);
- }
- }
- }
- else {
- /* the vertex array case */
- for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
- if (program->InputsRead & (1 << attr)) {
- const GLubyte *ptr = (const GLubyte*) VB->AttribPtr[attr]->data;
- const GLuint stride = VB->AttribPtr[attr]->stride;
- const GLfloat *data = (GLfloat *) (ptr + stride * i);
- COPY_4V(machine->Registers[VP_INPUT_REG_START + attr], data);
- /*ASSERT(VB->AttribPtr[attr]->size == 4);*/
- ASSERT(stride == 4 * sizeof(GLfloat) || stride == 0);
- }
- }
+ /* the vertex array case */
+ for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
+ if (program->InputsRead & (1 << attr)) {
+ const GLubyte *ptr = (const GLubyte*) VB->AttribPtr[attr]->data;
+ const GLuint size = VB->AttribPtr[attr]->size;
+ const GLuint stride = VB->AttribPtr[attr]->stride;
+ const GLfloat *data = (GLfloat *) (ptr + stride * i);
+ ASSIGN_4V(ctx->VertexProgram.Inputs[attr], 0, 0, 0, 1);
+ COPY_SZ_4V(ctx->VertexProgram.Inputs[attr], size, data);
+ }
}
/* execute the program */
ASSERT(program);
_mesa_exec_vertex_program(ctx, program);
-#if 0
- printf("Output %d: %f, %f, %f, %f\n", i,
- machine->Registers[VP_OUTPUT_REG_START + 0][0],
- machine->Registers[VP_OUTPUT_REG_START + 0][1],
- machine->Registers[VP_OUTPUT_REG_START + 0][2],
- machine->Registers[VP_OUTPUT_REG_START + 0][3]);
- printf(" color: %f, %f, %f, %f\n",
- machine->Registers[VP_OUTPUT_REG_START +_1][0],
- machine->Registers[VP_OUTPUT_REG_START + 1][1],
- machine->Registers[VP_OUTPUT_REG_START + 1][2],
- machine->Registers[VP_OUTPUT_REG_START + 1][3]);
- printf("PointSize[%d]: %g\n", i,
- machine->Registers[VP_OUTPUT_REG_START + VERT_RESULT_PSIZ][0]);
-#endif
-
/* Fixup fog an point size results if needed */
if (ctx->Fog.Enabled &&
(program->OutputsWritten & (1 << VERT_RESULT_FOGC)) == 0) {
- machine->Registers[VP_OUTPUT_REG_START + VERT_RESULT_FOGC][0] = 1.0;
+ ctx->VertexProgram.Outputs[VERT_RESULT_FOGC][0] = 1.0;
}
if (ctx->VertexProgram.PointSizeEnabled &&
(program->OutputsWritten & (1 << VERT_RESULT_PSIZ)) == 0) {
- machine->Registers[VP_OUTPUT_REG_START + VERT_RESULT_PSIZ][0]
- = ctx->Point.Size;
+ ctx->VertexProgram.Outputs[VERT_RESULT_PSIZ][0] = ctx->Point.Size;
}
/* copy the output registers into the VB->attribs arrays */
/* XXX (optimize) could use a conditional and smaller loop limit here */
for (attr = 0; attr < 15; attr++) {
- COPY_4V( store->attribs[attr].data[i],
- machine->Registers[VP_OUTPUT_REG_START + attr] );
+ COPY_4V(store->attribs[attr].data[i],
+ ctx->VertexProgram.Outputs[attr]);
}
}
VB->ClipPtr = &store->attribs[VERT_RESULT_HPOS];
VB->ClipPtr->size = 4;
VB->ClipPtr->count = VB->Count;
- VB->ColorPtr[0] = &store->color0[0];
- VB->ColorPtr[1] = &store->color0[1];
- VB->SecondaryColorPtr[0] = &store->color1[0];
- VB->SecondaryColorPtr[1] = &store->color1[1];
+ VB->ColorPtr[0] = &store->attribs[VERT_RESULT_COL0];
+ VB->ColorPtr[1] = &store->attribs[VERT_RESULT_BFC0];
+ VB->SecondaryColorPtr[0] = &store->attribs[VERT_RESULT_COL1];
+ VB->SecondaryColorPtr[1] = &store->attribs[VERT_RESULT_BFC1];
VB->FogCoordPtr = &store->attribs[VERT_RESULT_FOGC];
VB->PointSizePtr = &store->attribs[VERT_RESULT_PSIZ];
- for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
- VB->TexCoordPtr[i] = &store->attribs[VERT_RESULT_TEX0 + i];
+
+ VB->AttribPtr[VERT_ATTRIB_COLOR0] = VB->ColorPtr[0];
+ VB->AttribPtr[VERT_ATTRIB_COLOR1] = VB->SecondaryColorPtr[0];
+ VB->AttribPtr[VERT_ATTRIB_FOG] = VB->FogCoordPtr;
+ VB->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->attribs[VERT_RESULT_PSIZ];
+
+ for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
+ VB->AttribPtr[VERT_ATTRIB_TEX0+i] = VB->TexCoordPtr[i] =
+ &store->attribs[VERT_RESULT_TEX0 + i];
+ }
+
+
/* Cliptest and perspective divide. Clip functions must clear
* the clipmask.
VB->ClipOrMask = store->ormask;
VB->ClipMask = store->clipmask;
- /* XXXX what's this?
- if (VB->ClipPtr == VB->ObjPtr && (VB->importable_data & VERT_BIT_POS))
- VB->importable_data |= VERT_BIT_CLIP;
- */
-
return GL_TRUE;
}
* This function validates stuff.
*/
static GLboolean run_validate_program( GLcontext *ctx,
- struct gl_pipeline_stage *stage )
+ struct tnl_pipeline_stage *stage )
{
#if 000
/* XXX do we need any validation for vertex programs? */
}
-/**
- * Initialize a gl_client_array to point into a GLvector4f color vector.
- */
-static void init_color_array( struct gl_client_array *a, GLvector4f *vec )
-{
- a->Ptr = vec->data;
- a->Size = 4;
- a->Type = GL_FLOAT;
- a->Stride = 0;
- a->StrideB = sizeof(GLfloat) * 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_vp( GLcontext *ctx,
- struct gl_pipeline_stage *stage )
+ struct tnl_pipeline_stage *stage )
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &(tnl->vb);
return GL_FALSE;
/* Allocate arrays of vertex output values */
- for (i = 0; i < 15; i++)
+ for (i = 0; i < 15; i++) {
_mesa_vector4f_alloc( &store->attribs[i], 0, size, 32 );
-
- /* Make the color0[] and color1[] arrays point into the attribs[] arrays */
- init_color_array( &store->color0[0], &store->attribs[VERT_RESULT_COL0] );
- init_color_array( &store->color0[1], &store->attribs[VERT_RESULT_COL1] );
- init_color_array( &store->color1[0], &store->attribs[VERT_RESULT_BFC0] );
- init_color_array( &store->color1[1], &store->attribs[VERT_RESULT_BFC1] );
+ store->attribs[i].size = 4;
+ }
/* a few other misc allocations */
_mesa_vector4f_alloc( &store->ndcCoords, 0, size, 32 );
* Check if vertex program mode is enabled.
* If so, configure the pipeline stage's type, inputs, and outputs.
*/
-static void check_vp( GLcontext *ctx, struct gl_pipeline_stage *stage )
+static void check_vp( GLcontext *ctx, struct tnl_pipeline_stage *stage )
{
stage->active = ctx->VertexProgram.Enabled;
if (stage->active) {
- /* I believe this is right - Keith?
- * Set stage->inputs equal to the bitmask of vertex attributes
+ /* Set stage->inputs equal to the bitmask of vertex attributes
* which the program needs for inputs.
*/
-
stage->inputs = ctx->VertexProgram.Current->InputsRead;
-
-#if 000
- if (stage->privatePtr)
- stage->run = run_validate_program;
- 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_BIT_COLOR0;
- if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
- stage->outputs |= VERT_BIT_COLOR1;
-#endif
}
}
/**
* Destructor for this pipeline stage.
*/
-static void dtr( struct gl_pipeline_stage *stage )
+static void dtr( struct tnl_pipeline_stage *stage )
{
struct vp_stage_data *store = VP_STAGE_DATA(stage);
/**
* Public description of this pipeline stage.
*/
-const struct gl_pipeline_stage _tnl_vertex_program_stage =
+const struct tnl_pipeline_stage _tnl_vertex_program_stage =
{
"vertex-program",
_NEW_ALL, /*XXX FIX */ /* recheck */
- _NEW_ALL, /*XXX FIX */ /* recalc -- modelview dependency
- * otherwise not captured by inputs
- * (which may be VERT_BIT_POS) */
+ _NEW_ALL, /*XXX FIX */ /* recalc */
GL_FALSE, /* active */
- /*0*/ VERT_BIT_POS, /* inputs XXX OK? */
- VERT_BIT_CLIP | VERT_BIT_COLOR0, /* outputs XXX OK? */
+ 0, /* inputs - calculated on the fly */
+ _TNL_BITS_PROG_ANY, /* outputs -- could calculate */
0, /* changed_inputs */
NULL, /* private_data */
dtr, /* destroy */