X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Ftnl%2Ft_vb_program.c;h=62141ad12477ce28f6aa87026fdfd486ad8358d0;hb=30a8a0b8fa9e66efb97aef630765e4cdf6d9cb68;hp=2097ecc8cc4f77bea74923fd1a95db291aaa63ba;hpb=4c8fadc6d996c8c433826c4c763104b7d69cf7e5;p=mesa.git diff --git a/src/mesa/tnl/t_vb_program.c b/src/mesa/tnl/t_vb_program.c index 2097ecc8cc4..62141ad1247 100644 --- a/src/mesa/tnl/t_vb_program.c +++ b/src/mesa/tnl/t_vb_program.c @@ -1,10 +1,8 @@ -/* $Id: t_vb_program.c,v 1.10 2002/01/22 14:35:17 brianp Exp $ */ - /* * Mesa 3-D graphics library - * Version: 4.1 + * 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"), @@ -24,55 +22,10 @@ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/* - * -------- Regarding NV_vertex_program -------- - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * o Redistribution of the source code must contain a copyright notice - * and this list of conditions; - * - * o Redistribution in binary and source code form must contain the - * following Notice in the software and any documentation and/or other - * materials provided with the distribution; and - * - * o The name of Nvidia may not be used to promote or endorse software - * derived from the software. - * - * NOTICE: Nvidia hereby grants to each recipient a non-exclusive worldwide - * royalty free patent license under patent claims that are licensable by - * Nvidia and which are necessarily required and for which no commercially - * viable non infringing alternative exists to make, use, sell, offer to sell, - * import and otherwise transfer the vertex extension for the Mesa 3D Graphics - * Library as distributed in source code and object code form. No hardware or - * hardware implementation (including a semiconductor implementation and chips) - * are licensed hereunder. If a recipient makes a patent claim or institutes - * patent litigation against Nvidia or Nvidia's customers for use or sale of - * Nvidia products, then this license grant as to such recipient shall - * immediately terminate and recipient immediately agrees to cease use and - * distribution of the Mesa Program and derivatives thereof. - * - * THE MESA 3D GRAPHICS LIBRARY IS PROVIDED ON AN "AS IS BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, - * WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-NFRINGEMENT - * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. - * - * NVIDIA SHALL NOT HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION - * LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE MESA 3D GRAPHICS - * LIBRARY OR EVIDENCE OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDR, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - * If you do not comply with this agreement, then Nvidia may cancel the license - * and rights granted herein. - * --------------------------------------------- - */ /** * \file tnl/t_vb_program.c - * \brief Pipeline stage for executing vertex programs + * \brief Pipeline stage for executing NVIDIA vertex programs. * \author Brian Paul, Keith Whitwell */ @@ -85,18 +38,17 @@ #include "hash.h" #include "light.h" #include "macros.h" -#include "mem.h" -#include "mmath.h" +#include "imports.h" #include "simple_list.h" #include "mtypes.h" -#include "vpexec.h" +#include "nvvertprog.h" +#include "nvvertexec.h" +#include "nvprogram.h" #include "math/m_translate.h" #include "t_context.h" #include "t_pipeline.h" -#include "t_imm_api.h" -#include "t_imm_exec.h" /** @@ -127,10 +79,6 @@ struct vp_stage_data { /** 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 */ @@ -143,23 +91,16 @@ struct vp_stage_data { /** * 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 vp_program *program = ctx->VertexProgram.Current; - GLint i; - - _mesa_init_tracked_matrices(ctx); - _mesa_init_vp_registers(ctx); /* init temp and result regs */ - /* XXX if GL_FOG is enabled but the program doesn't write to the - * o[FOGC] register, set the fog result to 1.0 - */ - /* XXX if GL_VERTEX_PROGRAM_POINT_SIZE_NV is enabled but the program - * doesn't write the PSIZ variable then use ctx->Point.Size - */ + struct vertex_program *program = ctx->VertexProgram.Current; + GLuint i; + + _mesa_init_tracked_matrices(ctx); /* load registers with matrices */ + _mesa_init_vp_registers(ctx); /* init temp and result regs */ for (i = 0; i < VB->Count; i++) { GLuint attr; @@ -182,56 +123,38 @@ static GLboolean run_vp( GLcontext *ctx, struct gl_pipeline_stage *stage ) VB->AttribPtr[2]->data[i][3]); #endif - /* XXXX - * We have to deal with stride!=16 bytes, size!=4, etc in these loops!!! - */ - - /* load the input attribute registers */ - if (VB->Flag) { - /* the traditional glBegin/glVertex/glEnd case */ - for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) { - if (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++) { - const GLubyte *ptr = (const GLubyte *) VB->AttribPtr[attr]->data; - const GLint stride = VB->AttribPtr[attr]->stride; - const GLfloat *data = (GLfloat *) (ptr + stride * i); - const GLint size = VB->AttribPtr[attr]->size; - COPY_4V(machine->Registers[VP_INPUT_REG_START + attr], data); - if (size == 3) - machine->Registers[VP_INPUT_REG_START + attr][3] = 1.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_program(ctx, program); -#if 0 - printf("Output %d: %f, %f, %f, %f\n", i, - machine->Registers[VP_OUT_HPOS][0], - machine->Registers[VP_OUT_HPOS][1], - machine->Registers[VP_OUT_HPOS][2], - machine->Registers[VP_OUT_HPOS][3]); - printf(" color: %f, %f, %f, %f\n", - machine->Registers[VP_OUT_COL0][0], - machine->Registers[VP_OUT_COL0][1], - machine->Registers[VP_OUT_COL0][2], - machine->Registers[VP_OUT_COL0][3]); - printf("PointSize[%d]: %g\n", i, - machine->Registers[VP_OUTPUT_REG_START + VERT_RESULT_PSIZ][0]); -#endif + _mesa_exec_vertex_program(ctx, program); + + /* Fixup fog an point size results if needed */ + if (ctx->Fog.Enabled && + (program->OutputsWritten & (1 << VERT_RESULT_FOGC)) == 0) { + ctx->VertexProgram.Outputs[VERT_RESULT_FOGC][0] = 1.0; + } + + if (ctx->VertexProgram.PointSizeEnabled && + (program->OutputsWritten & (1 << VERT_RESULT_PSIZ)) == 0) { + 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]); } } @@ -241,14 +164,24 @@ static GLboolean run_vp( GLcontext *ctx, struct gl_pipeline_stage *stage ) 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. @@ -263,7 +196,6 @@ static GLboolean run_vp( GLcontext *ctx, struct gl_pipeline_stage *stage ) store->clipmask, &store->ormask, &store->andmask ); - } else { VB->NdcPtr = 0; @@ -285,11 +217,6 @@ static GLboolean run_vp( GLcontext *ctx, struct gl_pipeline_stage *stage ) 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; } @@ -298,7 +225,7 @@ static GLboolean run_vp( GLcontext *ctx, struct gl_pipeline_stage *stage ) * 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? */ @@ -342,27 +269,13 @@ static GLboolean run_validate_program( GLcontext *ctx, } -/** - * 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); @@ -376,14 +289,10 @@ static GLboolean run_init_vp( GLcontext *ctx, 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 ); @@ -401,29 +310,15 @@ static GLboolean run_init_vp( GLcontext *ctx, * 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) { - /* XXX what do we need here??? */ - /* - GLbitfield vpInput = 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 + /* Set stage->inputs equal to the bitmask of vertex attributes + * which the program needs for inputs. + */ + stage->inputs = ctx->VertexProgram.Current->InputsRead; } } @@ -431,7 +326,7 @@ static void check_vp( GLcontext *ctx, struct gl_pipeline_stage *stage ) /** * 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); @@ -454,16 +349,14 @@ static void dtr( struct gl_pipeline_stage *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 */