diff options
Diffstat (limited to 'src/mesa/tnl')
39 files changed, 14629 insertions, 0 deletions
diff --git a/src/mesa/tnl/descrip.mms b/src/mesa/tnl/descrip.mms new file mode 100644 index 0000000..c2e3540 --- /dev/null +++ b/src/mesa/tnl/descrip.mms @@ -0,0 +1,69 @@ +# Makefile for core library for VMS +# contributed by Jouk Jansen joukj@hrem.stm.tudelft.nl +# Last revision : 18 August 2004 + +.first + define gl [---.include.gl] + define math [-.math] + define array_cache [-.array_cache] + +.include [---]mms-config. + +##### MACROS ##### + +VPATH = RCS + +INCDIR = [---.include],[-.main],[-.glapi],[-.shader] +LIBDIR = [---.lib] +CFLAGS = /include=($(INCDIR),[])/define=(PTHREADS=1)/name=(as_is,short) + +SOURCES = t_array_api.c t_array_import.c t_context.c \ + t_pipeline.c t_vb_fog.c t_save_api.c t_vtx_api.c \ + t_vb_light.c t_vb_normals.c t_vb_points.c t_vb_program.c \ + t_vb_render.c t_vb_texgen.c t_vb_texmat.c t_vb_vertex.c \ + t_vtx_eval.c t_vtx_exec.c t_save_playback.c t_save_loopback.c \ + t_vertex.c t_vtx_generic.c t_vtx_x86.c t_vertex_c.c; + +OBJECTS = t_array_api.obj,t_array_import.obj,t_context.obj,\ + t_pipeline.obj,t_vb_fog.obj,t_vb_light.obj,t_vb_normals.obj,\ + t_vb_points.obj,t_vb_program.obj,t_vb_render.obj,t_vb_texgen.obj,\ + t_vb_texmat.obj,t_vb_vertex.obj,t_save_api.obj,t_vtx_api.obj,\ + t_vtx_eval.obj,t_vtx_exec.obj,t_save_playback.obj,t_save_loopback.obj,\ + t_vertex.obj,t_vtx_generic.obj,t_vtx_x86.obj,t_vertex_c.obj + +##### RULES ##### + +VERSION=Mesa V3.4 + +##### TARGETS ##### +# Make the library +$(LIBDIR)$(GL_LIB) : $(OBJECTS) + @ library $(LIBDIR)$(GL_LIB) $(OBJECTS) + +clean : + purge + delete *.obj;* + +t_array_api.obj : t_array_api.c +t_array_import.obj : t_array_import.c +t_context.obj : t_context.c +t_pipeline.obj : t_pipeline.c +t_vb_fog.obj : t_vb_fog.c +t_vb_light.obj : t_vb_light.c +t_vb_normals.obj : t_vb_normals.c +t_vb_points.obj : t_vb_points.c +t_vb_program.obj : t_vb_program.c +t_vb_render.obj : t_vb_render.c +t_vb_texgen.obj : t_vb_texgen.c +t_vb_texmat.obj : t_vb_texmat.c +t_vb_vertex.obj : t_vb_vertex.c +t_save_api.obj : t_save_api.c +t_vtx_api.obj : t_vtx_api.c +t_vtx_eval.obj : t_vtx_eval.c +t_vtx_exec.obj : t_vtx_exec.c +t_save_playback.obj : t_save_playback.c +t_save_loopback.obj : t_save_loopback.c +t_vertex.obj : t_vertex.c +t_vtx_x86.obj : t_vtx_x86.c +t_vtx_generic.obj : t_vtx_generic.c +t_vertex_c.obj : t_vertex_c.c diff --git a/src/mesa/tnl/t_array_api.c b/src/mesa/tnl/t_array_api.c new file mode 100644 index 0000000..c3e6358 --- /dev/null +++ b/src/mesa/tnl/t_array_api.c @@ -0,0 +1,442 @@ +/* + * Mesa 3-D graphics library + * Version: 6.1 + * + * Copyright (C) 1999-2004 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/** + * \file t_array_api.c + * \brief Vertex array API functions (glDrawArrays, etc) + * \author Keith Whitwell + */ + +#include "glheader.h" +#include "api_validate.h" +#include "context.h" +#include "imports.h" +#include "macros.h" +#include "mtypes.h" +#include "state.h" + +#include "array_cache/acache.h" + +#include "t_array_api.h" +#include "t_array_import.h" +#include "t_save_api.h" +#include "t_context.h" +#include "t_pipeline.h" + +static void fallback_drawarrays( GLcontext *ctx, GLenum mode, GLint start, + GLsizei count ) +{ + GLint i; + + assert(!ctx->CompileFlag); + assert(ctx->Driver.CurrentExecPrimitive == GL_POLYGON+1); + + GL_CALL(Begin)(mode); + for (i = 0; i < count; i++) + GL_CALL(ArrayElement)( start + i ); + GL_CALL(End)(); +} + + +static void fallback_drawelements( GLcontext *ctx, GLenum mode, GLsizei count, + const GLuint *indices) +{ + GLint i; + + assert(!ctx->CompileFlag); + assert(ctx->Driver.CurrentExecPrimitive == GL_POLYGON+1); + + /* Here, indices will already reflect the buffer object if active */ + + GL_CALL(Begin)(mode); + for (i = 0 ; i < count ; i++) { + GL_CALL(ArrayElement)( indices[i] ); + } + GL_CALL(End)(); +} + + +/* Note this function no longer takes a 'start' value, the range is + * assumed to start at zero. The old trick of subtracting 'start' + * from each index won't work if the indices are not in writeable + * memory. + */ +static void _tnl_draw_range_elements( GLcontext *ctx, GLenum mode, + GLuint max_index, + GLsizei index_count, GLuint *indices ) + +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct tnl_prim prim; + FLUSH_CURRENT( ctx, 0 ); + + if (tnl->pipeline.build_state_changes) + _tnl_validate_pipeline( ctx ); + + _tnl_vb_bind_arrays( ctx, 0, max_index ); + + tnl->vb.Primitive = &prim; + tnl->vb.Primitive[0].mode = mode | PRIM_BEGIN | PRIM_END; + tnl->vb.Primitive[0].start = 0; + tnl->vb.Primitive[0].count = index_count; + tnl->vb.PrimitiveCount = 1; + + tnl->vb.Elts = (GLuint *)indices; + + if (ctx->Array.LockCount) + tnl->Driver.RunPipeline( ctx ); + else { + /* The lower 16 bits represent the conventional arrays while the + * upper 16 bits represent the generic arrays. OR those bits + * together to indicate which vertex attribs are in effect. + */ + GLuint enabledArrays = ctx->Array._Enabled | (ctx->Array._Enabled >> 16); + /* Note that arrays may have changed before/after execution. + */ + tnl->pipeline.run_input_changes |= enabledArrays & 0xffff; + tnl->Driver.RunPipeline( ctx ); + tnl->pipeline.run_input_changes |= enabledArrays & 0xffff; + } +} + + + +/** + * Called via the GL API dispatcher. + */ +void GLAPIENTRY +_tnl_DrawArrays(GLenum mode, GLint start, GLsizei count) +{ + GET_CURRENT_CONTEXT(ctx); + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint thresh = (ctx->Driver.NeedFlush & FLUSH_STORED_VERTICES) ? 30 : 10; + GLuint enabledArrays; + + if (MESA_VERBOSE & VERBOSE_API) + _mesa_debug(NULL, "_tnl_DrawArrays %d %d\n", start, count); + + /* Check arguments, etc. + */ + if (!_mesa_validate_DrawArrays( ctx, mode, start, count )) + return; + + if (tnl->pipeline.build_state_changes) + _tnl_validate_pipeline( ctx ); + + assert(!ctx->CompileFlag); + + if (!ctx->Array.LockCount && (GLuint) count < thresh) { + /* Small primitives: attempt to share a vb (at the expense of + * using the immediate interface). + */ + fallback_drawarrays( ctx, mode, start, count ); + } + else if (start >= (GLint) ctx->Array.LockFirst && + start + count <= (GLint)(ctx->Array.LockFirst + ctx->Array.LockCount)) { + + struct tnl_prim prim; + + /* Locked primitives which can fit in a single vertex buffer: + */ + FLUSH_CURRENT( ctx, 0 ); + + /* Locked drawarrays. Reuse any previously transformed data. + */ + _tnl_vb_bind_arrays( ctx, ctx->Array.LockFirst, + ctx->Array.LockFirst + ctx->Array.LockCount ); + + tnl->vb.Primitive = &prim; + tnl->vb.Primitive[0].mode = mode | PRIM_BEGIN | PRIM_END; + tnl->vb.Primitive[0].start = start; + tnl->vb.Primitive[0].count = count; + tnl->vb.PrimitiveCount = 1; + + tnl->Driver.RunPipeline( ctx ); + } + else { + int bufsz = 256; /* Use a small buffer for cache goodness */ + int j, nr; + int minimum, modulo, skip; + + /* Large primitives requiring decomposition to multiple vertex + * buffers: + */ + switch (mode) { + case GL_POINTS: + minimum = 0; + modulo = 1; + skip = 0; + break; + case GL_LINES: + minimum = 1; + modulo = 2; + skip = 1; + break; + case GL_LINE_STRIP: + minimum = 1; + modulo = 1; + skip = 0; + break; + case GL_TRIANGLES: + minimum = 2; + modulo = 3; + skip = 2; + break; + case GL_TRIANGLE_STRIP: + minimum = 2; + modulo = 1; + skip = 0; + break; + case GL_QUADS: + minimum = 3; + modulo = 4; + skip = 3; + break; + case GL_QUAD_STRIP: + minimum = 3; + modulo = 2; + skip = 0; + break; + case GL_LINE_LOOP: + case GL_TRIANGLE_FAN: + case GL_POLYGON: + default: + /* Primitives requiring a copied vertex (fan-like primitives) + * must use the slow path if they cannot fit in a single + * vertex buffer. + */ + if (count <= (GLint) ctx->Const.MaxArrayLockSize) { + bufsz = ctx->Const.MaxArrayLockSize; + minimum = 0; + modulo = 1; + skip = 0; + } + else { + fallback_drawarrays( ctx, mode, start, count ); + return; + } + } + + FLUSH_CURRENT( ctx, 0 ); + + bufsz -= bufsz % modulo; + bufsz -= minimum; + count += start; + + for (j = start + minimum ; j < count ; j += nr + skip ) { + + struct tnl_prim prim; + + nr = MIN2( bufsz, count - j ); + + /* XXX is the last parameter a count or index into the array??? */ + _tnl_vb_bind_arrays( ctx, j - minimum, j + nr ); + + tnl->vb.Primitive = &prim; + tnl->vb.Primitive[0].mode = mode; + + if (j == start + minimum) + tnl->vb.Primitive[0].mode |= PRIM_BEGIN; + + if (j + nr + skip >= count) + tnl->vb.Primitive[0].mode |= PRIM_END; + + tnl->vb.Primitive[0].start = 0; + tnl->vb.Primitive[0].count = nr + minimum; + tnl->vb.PrimitiveCount = 1; + + /* The lower 16 bits represent the conventional arrays while the + * upper 16 bits represent the generic arrays. OR those bits + * together to indicate which vertex attribs are in effect. + */ + enabledArrays = ctx->Array._Enabled | (ctx->Array._Enabled >> 16); + /* Note that arrays may have changed before/after execution. + */ + tnl->pipeline.run_input_changes |= enabledArrays; + tnl->Driver.RunPipeline( ctx ); + tnl->pipeline.run_input_changes |= enabledArrays; + } + } +} + + +/** + * Called via the GL API dispatcher. + */ +void GLAPIENTRY +_tnl_DrawRangeElements(GLenum mode, + GLuint start, GLuint end, + GLsizei count, GLenum type, const GLvoid *indices) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint *ui_indices; + + if (MESA_VERBOSE & VERBOSE_API) + _mesa_debug(NULL, "_tnl_DrawRangeElements %d %d %d\n", start, end, count); + + if (ctx->Array.ElementArrayBufferObj->Name) { + /* use indices in the buffer object */ + if (!ctx->Array.ElementArrayBufferObj->Data) { + _mesa_warning(ctx, + "DrawRangeElements with empty vertex elements buffer!"); + return; + } + /* actual address is the sum of pointers */ + indices = (const GLvoid *) + ADD_POINTERS(ctx->Array.ElementArrayBufferObj->Data, + (const GLubyte *) indices); + } + + /* Check arguments, etc. + */ + if (!_mesa_validate_DrawRangeElements( ctx, mode, start, end, count, + type, indices )) + return; + + ui_indices = (GLuint *)_ac_import_elements( ctx, GL_UNSIGNED_INT, + count, type, indices ); + + + assert(!ctx->CompileFlag); + + if (ctx->Array.LockCount) { + /* Are the arrays already locked? If so we currently have to look + * at the whole locked range. + */ + + if (start == 0 && ctx->Array.LockFirst == 0 && + end < (ctx->Array.LockFirst + ctx->Array.LockCount)) + _tnl_draw_range_elements( ctx, mode, + ctx->Array.LockCount, + count, ui_indices ); + else { + fallback_drawelements( ctx, mode, count, ui_indices ); + } + } + else if (start == 0 && end < ctx->Const.MaxArrayLockSize) { + /* The arrays aren't locked but we can still fit them inside a + * single vertexbuffer. + */ + _tnl_draw_range_elements( ctx, mode, end + 1, count, ui_indices ); + } + else { + /* Range is too big to optimize: + */ + fallback_drawelements( ctx, mode, count, ui_indices ); + } +} + + + +/** + * Called via the GL API dispatcher. + */ +void GLAPIENTRY +_tnl_DrawElements(GLenum mode, GLsizei count, GLenum type, + const GLvoid *indices) +{ + GET_CURRENT_CONTEXT(ctx); + GLuint *ui_indices; + + if (MESA_VERBOSE & VERBOSE_API) + _mesa_debug(NULL, "_tnl_DrawElements %d\n", count); + + /* Check arguments, etc. */ + if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices )) + return; + + if (ctx->Array.ElementArrayBufferObj->Name) { + /* actual address is the sum of pointers */ + indices = (const GLvoid *) + ADD_POINTERS(ctx->Array.ElementArrayBufferObj->Data, + (const GLubyte *) indices); + } + + ui_indices = (GLuint *)_ac_import_elements( ctx, GL_UNSIGNED_INT, + count, type, indices ); + + assert(!ctx->CompileFlag); + + if (ctx->Array.LockCount) { + if (ctx->Array.LockFirst == 0) + _tnl_draw_range_elements( ctx, mode, + ctx->Array.LockCount, + count, ui_indices ); + else + fallback_drawelements( ctx, mode, count, ui_indices ); + } + else { + /* Scan the index list and see if we can use the locked path anyway. + */ + GLuint max_elt = 0; + GLint i; + + for (i = 0 ; i < count ; i++) + if (ui_indices[i] > max_elt) + max_elt = ui_indices[i]; + + if (max_elt < ctx->Const.MaxArrayLockSize && /* can we use it? */ + max_elt < (GLuint) count) /* do we want to use it? */ + _tnl_draw_range_elements( ctx, mode, max_elt+1, count, ui_indices ); + else + fallback_drawelements( ctx, mode, count, ui_indices ); + } +} + + +/** + * Initialize context's vertex array fields. Called during T 'n L context + * creation. + */ +void _tnl_array_init( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct tnl_vertex_arrays *tmp = &tnl->array_inputs; + GLvertexformat *vfmt = &(TNL_CONTEXT(ctx)->exec_vtxfmt); + GLuint i; + + vfmt->DrawArrays = _tnl_DrawArrays; + vfmt->DrawElements = _tnl_DrawElements; + vfmt->DrawRangeElements = _tnl_DrawRangeElements; + + /* Setup vector pointers that will be used to bind arrays to VB's. + */ + _mesa_vector4f_init( &tmp->Obj, 0, 0 ); + _mesa_vector4f_init( &tmp->Normal, 0, 0 ); + _mesa_vector4f_init( &tmp->FogCoord, 0, 0 ); + _mesa_vector4f_init( &tmp->Index, 0, 0 ); + + for (i = 0; i < ctx->Const.MaxTextureUnits; i++) + _mesa_vector4f_init( &tmp->TexCoord[i], 0, 0); +} + + +/** + * Destroy the context's vertex array stuff. + * Called during T 'n L context destruction. + */ +void _tnl_array_destroy( GLcontext *ctx ) +{ + (void) ctx; +} diff --git a/src/mesa/tnl/t_array_api.h b/src/mesa/tnl/t_array_api.h new file mode 100644 index 0000000..61d1f69 --- /dev/null +++ b/src/mesa/tnl/t_array_api.h @@ -0,0 +1,46 @@ + +/* + * Mesa 3-D graphics library + * Version: 3.5 + * + * Copyright (C) 1999-2001 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef _T_VARRAY_H +#define _T_VARRAY_H + +#include "mtypes.h" +#include "t_context.h" + + +extern void GLAPIENTRY _tnl_DrawArrays(GLenum mode, GLint first, GLsizei count); + +extern void GLAPIENTRY _tnl_DrawElements(GLenum mode, GLsizei count, GLenum type, + const GLvoid *indices); + +extern void GLAPIENTRY _tnl_DrawRangeElements(GLenum mode, GLuint start, + GLuint end, GLsizei count, GLenum type, + const GLvoid *indices); + + +extern void _tnl_array_init( GLcontext *ctx ); +extern void _tnl_array_destroy( GLcontext *ctx ); + +#endif diff --git a/src/mesa/tnl/t_array_import.c b/src/mesa/tnl/t_array_import.c new file mode 100644 index 0000000..dac6463 --- /dev/null +++ b/src/mesa/tnl/t_array_import.c @@ -0,0 +1,361 @@ +/* + * Mesa 3-D graphics library + * Version: 6.1 + * + * Copyright (C) 1999-2004 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + +#include "glheader.h" +#include "context.h" +#include "macros.h" +#include "imports.h" +#include "state.h" +#include "mtypes.h" + +#include "array_cache/acache.h" +#include "math/m_translate.h" + +#include "t_array_import.h" +#include "t_context.h" + + +static void _tnl_import_vertex( GLcontext *ctx, + GLboolean writeable, + GLboolean stride ) +{ + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + const GLubyte *data; + + tmp = _ac_import_vertex(ctx, + GL_FLOAT, + stride ? 4*sizeof(GLfloat) : 0, + 0, + writeable, + &is_writeable); + + data = tmp->Ptr; + inputs->Obj.data = (GLfloat (*)[4]) data; + inputs->Obj.start = (GLfloat *) data; + inputs->Obj.stride = tmp->StrideB; + inputs->Obj.size = tmp->Size; +} + +static void _tnl_import_normal( GLcontext *ctx, + GLboolean writeable, + GLboolean stride ) +{ + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + const GLubyte *data; + + tmp = _ac_import_normal(ctx, GL_FLOAT, + stride ? 3*sizeof(GLfloat) : 0, writeable, + &is_writeable); + + data = tmp->Ptr; + inputs->Normal.data = (GLfloat (*)[4]) data; + inputs->Normal.start = (GLfloat *) data; + inputs->Normal.stride = tmp->StrideB; + inputs->Normal.size = 3; +} + + +static void _tnl_import_color( GLcontext *ctx, + GLboolean writeable, + GLboolean stride ) +{ + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + const GLubyte *data; + + tmp = _ac_import_color(ctx, + GL_FLOAT, + stride ? 4*sizeof(GLfloat) : 0, + 4, + writeable, + &is_writeable); + + data = tmp->Ptr; + inputs->Color.data = (GLfloat (*)[4]) data; + inputs->Color.start = (GLfloat *) data; + inputs->Color.stride = tmp->StrideB; + inputs->Color.size = tmp->Size; +} + + +static void _tnl_import_secondarycolor( GLcontext *ctx, + GLboolean writeable, + GLboolean stride ) +{ + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + const GLubyte *data; + + tmp = _ac_import_secondarycolor(ctx, + GL_FLOAT, + stride ? 4*sizeof(GLfloat) : 0, + 4, + writeable, + &is_writeable); + + data = tmp->Ptr; + inputs->SecondaryColor.data = (GLfloat (*)[4]) data; + inputs->SecondaryColor.start = (GLfloat *) data; + inputs->SecondaryColor.stride = tmp->StrideB; + inputs->SecondaryColor.size = tmp->Size; +} + +static void _tnl_import_fogcoord( GLcontext *ctx, + GLboolean writeable, + GLboolean stride ) +{ + struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + const GLubyte *data; + + tmp = _ac_import_fogcoord(ctx, GL_FLOAT, + stride ? sizeof(GLfloat) : 0, writeable, + &is_writeable); + + data = tmp->Ptr; + inputs->FogCoord.data = (GLfloat (*)[4]) data; + inputs->FogCoord.start = (GLfloat *) data; + inputs->FogCoord.stride = tmp->StrideB; +} + +static void _tnl_import_index( GLcontext *ctx, + GLboolean writeable, + GLboolean stride ) +{ + struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + const GLubyte *data; + + tmp = _ac_import_index(ctx, GL_FLOAT, + stride ? sizeof(GLfloat) : 0, writeable, + &is_writeable); + + data = tmp->Ptr; + inputs->Index.data = (GLfloat (*)[4]) data; + inputs->Index.start = (GLfloat *) data; + inputs->Index.stride = tmp->StrideB; +} + + +static void _tnl_import_texcoord( GLcontext *ctx, + GLuint unit, + GLboolean writeable, + GLboolean stride ) +{ + struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + const GLubyte *data; + + tmp = _ac_import_texcoord(ctx, unit, GL_FLOAT, + stride ? 4 * sizeof(GLfloat) : 0, + 0, + writeable, + &is_writeable); + + data = tmp->Ptr; + inputs->TexCoord[unit].data = (GLfloat (*)[4]) data; + inputs->TexCoord[unit].start = (GLfloat *) data; + inputs->TexCoord[unit].stride = tmp->StrideB; + inputs->TexCoord[unit].size = tmp->Size; +} + + +static void _tnl_import_edgeflag( GLcontext *ctx, + GLboolean writeable, + GLboolean stride ) +{ + struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + const GLubyte *data; + (void) writeable; (void) stride; + + tmp = _ac_import_edgeflag(ctx, GL_UNSIGNED_BYTE, + sizeof(GLubyte), + 0, + &is_writeable); + + data = tmp->Ptr; + inputs->EdgeFlag = (GLubyte *) data; +} + + + +static void _tnl_import_attrib( GLcontext *ctx, + GLuint index, + GLboolean writeable, + GLboolean stride ) +{ + struct tnl_vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + const GLubyte *data; + + tmp = _ac_import_attrib(ctx, index, GL_FLOAT, + stride ? 4 * sizeof(GLfloat) : 0, + 4, /* want GLfloat[4] */ + writeable, + &is_writeable); + + data = tmp->Ptr; + inputs->Attribs[index].data = (GLfloat (*)[4]) data; + inputs->Attribs[index].start = (GLfloat *) data; + inputs->Attribs[index].stride = tmp->StrideB; + inputs->Attribs[index].size = tmp->Size; +} + + + + +void _tnl_vb_bind_arrays( GLcontext *ctx, GLint start, GLint end) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + GLuint inputs = tnl->pipeline.inputs; + struct tnl_vertex_arrays *tmp = &tnl->array_inputs; + GLuint i, index; + + VB->Count = end - start; + VB->Elts = NULL; + + _ac_import_range( ctx, start, end ); + + /* When vertex program mode is enabled, the generic vertex program + * attribute arrays have priority over the conventional attributes. + * Try to use them now. + */ + for (index = 0; index < VERT_ATTRIB_MAX; index++) { + /* When vertex program mode is enabled, the generic vertex attribute + * arrays have priority over the conventional vertex arrays. + */ + if (ctx->VertexProgram._Enabled + && ctx->Array.VertexAttrib[index].Enabled) { + /* Use generic attribute array */ + _tnl_import_attrib( ctx, index, GL_FALSE, GL_TRUE ); + VB->AttribPtr[index] = &tmp->Attribs[index]; + } + /* use conventional arrays... */ + else if (index == VERT_ATTRIB_POS) { + if (inputs & _TNL_BIT_POS) { + _tnl_import_vertex( ctx, 0, 0 ); + tmp->Obj.count = VB->Count; + VB->AttribPtr[_TNL_ATTRIB_POS] = &tmp->Obj; + } + } + else if (index == VERT_ATTRIB_NORMAL) { + if (inputs & _TNL_BIT_NORMAL) { + _tnl_import_normal( ctx, 0, 0 ); + tmp->Normal.count = VB->Count; + VB->AttribPtr[_TNL_ATTRIB_NORMAL] = &tmp->Normal; + } + } + else if (index == VERT_ATTRIB_COLOR0) { + if (inputs & _TNL_BIT_COLOR0) { + _tnl_import_color( ctx, 0, 0 ); + tmp->Color.count = VB->Count; + VB->AttribPtr[_TNL_ATTRIB_COLOR0] = &tmp->Color; + } + } + else if (index == VERT_ATTRIB_COLOR1) { + if (inputs & _TNL_BIT_COLOR1) { + _tnl_import_secondarycolor( ctx, 0, 0 ); + tmp->SecondaryColor.count = VB->Count; + VB->AttribPtr[_TNL_ATTRIB_COLOR1] = &tmp->SecondaryColor; + } + } + else if (index == VERT_ATTRIB_FOG) { + if (inputs & _TNL_BIT_FOG) { + _tnl_import_fogcoord( ctx, 0, 0 ); + tmp->FogCoord.count = VB->Count; + VB->AttribPtr[_TNL_ATTRIB_FOG] = &tmp->FogCoord; + } + } + else if (index >= VERT_ATTRIB_TEX0 && index <= VERT_ATTRIB_TEX7) { + if (inputs & _TNL_BITS_TEX_ANY) { + for (i = 0; i < ctx->Const.MaxTextureUnits; i++) { + if (inputs & _TNL_BIT_TEX(i)) { + _tnl_import_texcoord( ctx, i, GL_FALSE, GL_FALSE ); + tmp->TexCoord[i].count = VB->Count; + VB->AttribPtr[_TNL_ATTRIB_TEX0 + i] = &tmp->TexCoord[i]; + } + } + } + } + } + + /* odd-ball vertex attributes */ + if (inputs & _TNL_BIT_INDEX) { + _tnl_import_index( ctx, 0, 0 ); + tmp->Index.count = VB->Count; + VB->AttribPtr[_TNL_ATTRIB_INDEX] = &tmp->Index; + } + + if (inputs & _TNL_BIT_EDGEFLAG) { + _tnl_import_edgeflag( ctx, GL_TRUE, sizeof(GLboolean) ); + VB->EdgeFlag = (GLboolean *) tmp->EdgeFlag; + } + + /* These are constant & can be precalculated: + */ + if (inputs & _TNL_BITS_MAT_ANY) { + for (i = _TNL_ATTRIB_MAT_FRONT_AMBIENT; i < _TNL_ATTRIB_INDEX; i++) { + tmp->Attribs[i].count = VB->Count; + tmp->Attribs[i].data = (GLfloat (*)[4]) tnl->vtx.current[i]; + tmp->Attribs[i].start = tnl->vtx.current[i]; + tmp->Attribs[i].size = 4; + tmp->Attribs[i].stride = 0; + VB->AttribPtr[i] = &tmp->Attribs[i]; + } + } + + + /* Legacy pointers -- remove one day. + */ + VB->ObjPtr = VB->AttribPtr[_TNL_ATTRIB_POS]; + VB->NormalPtr = VB->AttribPtr[_TNL_ATTRIB_NORMAL]; + VB->ColorPtr[0] = VB->AttribPtr[_TNL_ATTRIB_COLOR0]; + VB->ColorPtr[1] = 0; + VB->IndexPtr[0] = VB->AttribPtr[_TNL_ATTRIB_INDEX]; + VB->IndexPtr[1] = 0; + VB->SecondaryColorPtr[0] = VB->AttribPtr[_TNL_ATTRIB_COLOR1]; + VB->SecondaryColorPtr[1] = 0; + VB->FogCoordPtr = VB->AttribPtr[_TNL_ATTRIB_FOG]; + + for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) { + VB->TexCoordPtr[i] = VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]; + } + +} diff --git a/src/mesa/tnl/t_array_import.h b/src/mesa/tnl/t_array_import.h new file mode 100644 index 0000000..39b7764 --- /dev/null +++ b/src/mesa/tnl/t_array_import.h @@ -0,0 +1,36 @@ + +/* + * Mesa 3-D graphics library + * Version: 3.5 + * + * Copyright (C) 1999-2001 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef _T_ARRAY_IMPORT_H +#define _T_ARRAY_IMPORT_H + +#include "mtypes.h" +#include "t_context.h" + +extern void _tnl_vb_bind_arrays( GLcontext *ctx, GLint start, GLint end ); + +extern void _tnl_array_import_init( GLcontext *ctx ); + +#endif diff --git a/src/mesa/tnl/t_context.c b/src/mesa/tnl/t_context.c new file mode 100644 index 0000000..e4d0d04 --- /dev/null +++ b/src/mesa/tnl/t_context.c @@ -0,0 +1,290 @@ +/* + * Mesa 3-D graphics library + * Version: 6.1 + * + * Copyright (C) 1999-2004 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + + +#include "api_arrayelt.h" +#include "glheader.h" +#include "imports.h" +#include "context.h" +#include "macros.h" +#include "mtypes.h" +#include "dlist.h" +#include "light.h" +#include "vtxfmt.h" +#include "nvfragprog.h" + +#include "t_context.h" +#include "t_array_api.h" +#include "t_vtx_api.h" +#include "t_save_api.h" +#include "t_pipeline.h" +#include "tnl.h" + + + +void +_tnl_MakeCurrent( GLcontext *ctx, + GLframebuffer *drawBuffer, + GLframebuffer *readBuffer ) +{ + (void) ctx; (void) drawBuffer; (void) readBuffer; +} + + +static void +install_driver_callbacks( GLcontext *ctx ) +{ + ctx->Driver.NewList = _tnl_NewList; + ctx->Driver.EndList = _tnl_EndList; + ctx->Driver.FlushVertices = _tnl_FlushVertices; + ctx->Driver.SaveFlushVertices = _tnl_SaveFlushVertices; + ctx->Driver.MakeCurrent = _tnl_MakeCurrent; + ctx->Driver.BeginCallList = _tnl_BeginCallList; + ctx->Driver.EndCallList = _tnl_EndCallList; +} + + + +GLboolean +_tnl_CreateContext( GLcontext *ctx ) +{ + TNLcontext *tnl; + + /* Create the TNLcontext structure + */ + ctx->swtnl_context = tnl = (TNLcontext *) CALLOC( sizeof(TNLcontext) ); + + if (!tnl) { + return GL_FALSE; + } + + if (getenv("MESA_CODEGEN")) + tnl->AllowCodegen = GL_TRUE; + + /* Initialize the VB. + */ + tnl->vb.Size = ctx->Const.MaxArrayLockSize + MAX_CLIPPED_VERTICES; + + + /* Initialize tnl state and tnl->vtxfmt. + */ + _tnl_save_init( ctx ); + _tnl_array_init( ctx ); + _tnl_vtx_init( ctx ); + _tnl_install_pipeline( ctx, _tnl_default_pipeline ); + + /* Initialize the arrayelt helper + */ + if (!_ae_create_context( ctx )) + return GL_FALSE; + + + tnl->NeedNdcCoords = GL_TRUE; + tnl->LoopbackDListCassettes = GL_FALSE; + tnl->CalcDListNormalLengths = GL_TRUE; + tnl->AllowVertexFog = GL_TRUE; + tnl->AllowPixelFog = GL_TRUE; + + /* Hook our functions into exec and compile dispatch tables. + */ + _mesa_install_exec_vtxfmt( ctx, &tnl->exec_vtxfmt ); + + + /* Set a few default values in the driver struct. + */ + install_driver_callbacks(ctx); + ctx->Driver.NeedFlush = 0; + ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END; + ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN; + + tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts; + tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts; + tnl->Driver.NotifyMaterialChange = _mesa_validate_all_lighting_tables; + + return GL_TRUE; +} + + +void +_tnl_DestroyContext( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + + _tnl_array_destroy( ctx ); + _tnl_vtx_destroy( ctx ); + _tnl_save_destroy( ctx ); + _tnl_destroy_pipeline( ctx ); + _ae_destroy_context( ctx ); + + FREE(tnl); + ctx->swtnl_context = 0; +} + + +void +_tnl_InvalidateState( GLcontext *ctx, GLuint new_state ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + + if (new_state & (_NEW_HINT)) { + ASSERT(tnl->AllowVertexFog || tnl->AllowPixelFog); + tnl->_DoVertexFog = (tnl->AllowVertexFog && (ctx->Hint.Fog != GL_NICEST)) + || !tnl->AllowPixelFog; + } + + if (new_state & _NEW_ARRAY) { + tnl->pipeline.run_input_changes |= ctx->Array.NewState; /* overkill */ + } + + _ae_invalidate_state(ctx, new_state); + + tnl->pipeline.run_state_changes |= new_state; + tnl->pipeline.build_state_changes |= (new_state & + tnl->pipeline.build_state_trigger); + + tnl->vtx.eval.new_state |= new_state; + + /* Calculate tnl->render_inputs: + */ + if (ctx->Visual.rgbMode) { + tnl->render_inputs = (_TNL_BIT_POS| + _TNL_BIT_COLOR0| + (ctx->Texture._EnabledCoordUnits << _TNL_ATTRIB_TEX0)); + + if (NEED_SECONDARY_COLOR(ctx)) + tnl->render_inputs |= _TNL_BIT_COLOR1; + } + else { + tnl->render_inputs |= (_TNL_BIT_POS|_TNL_BIT_INDEX); + } + + if (ctx->Fog.Enabled || + (ctx->FragmentProgram.Enabled && + ctx->FragmentProgram.Current->FogOption != GL_NONE)) + tnl->render_inputs |= _TNL_BIT_FOG; + + if (ctx->Polygon.FrontMode != GL_FILL || + ctx->Polygon.BackMode != GL_FILL) + tnl->render_inputs |= _TNL_BIT_EDGEFLAG; + + if (ctx->RenderMode == GL_FEEDBACK) + tnl->render_inputs |= _TNL_BIT_TEX0; + + if (ctx->Point._Attenuated || + (ctx->VertexProgram._Enabled && ctx->VertexProgram.PointSizeEnabled)) + tnl->render_inputs |= _TNL_BIT_POINTSIZE; +} + + +void +_tnl_wakeup_exec( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + + install_driver_callbacks(ctx); + ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; + + /* Hook our functions into exec and compile dispatch tables. + */ + _mesa_install_exec_vtxfmt( ctx, &tnl->exec_vtxfmt ); + + /* Call all appropriate driver callbacks to revive state. + */ + _tnl_MakeCurrent( ctx, ctx->DrawBuffer, ctx->ReadBuffer ); + + /* Assume we haven't been getting state updates either: + */ + _tnl_InvalidateState( ctx, ~0 ); + tnl->pipeline.run_input_changes = ~0; + + if (ctx->Light.ColorMaterialEnabled) { + _mesa_update_color_material( ctx, + ctx->Current.Attrib[VERT_ATTRIB_COLOR0] ); + } +} + + +void +_tnl_wakeup_save_exec( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + + _tnl_wakeup_exec( ctx ); + _mesa_install_save_vtxfmt( ctx, &tnl->save_vtxfmt ); +} + + +/** + * Drivers call this function to tell the TCL module whether or not + * it wants Normalized Device Coords (NDC) computed. I.e. whether + * we should "Divide-by-W". Software renders will want that. + */ +void +_tnl_need_projected_coords( GLcontext *ctx, GLboolean mode ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + if (tnl->NeedNdcCoords != mode) { + tnl->NeedNdcCoords = mode; + _tnl_InvalidateState( ctx, _NEW_PROJECTION ); + } +} + +void +_tnl_need_dlist_loopback( GLcontext *ctx, GLboolean mode ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + tnl->LoopbackDListCassettes = mode; +} + +void +_tnl_need_dlist_norm_lengths( GLcontext *ctx, GLboolean mode ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + tnl->CalcDListNormalLengths = mode; +} + +void +_tnl_isolate_materials( GLcontext *ctx, GLboolean mode ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + tnl->IsolateMaterials = mode; +} + +void +_tnl_allow_vertex_fog( GLcontext *ctx, GLboolean value ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + tnl->AllowVertexFog = value; +} + +void +_tnl_allow_pixel_fog( GLcontext *ctx, GLboolean value ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + tnl->AllowPixelFog = value; +} + diff --git a/src/mesa/tnl/t_context.h b/src/mesa/tnl/t_context.h new file mode 100644 index 0000000..55b405e --- /dev/null +++ b/src/mesa/tnl/t_context.h @@ -0,0 +1,811 @@ +/* + * mesa 3-D graphics library + * Version: 6.2.2 + * + * Copyright (C) 1999-2005 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/** + * \file t_context.h + * \brief TnL module datatypes and definitions. + * \author Keith Whitwell + */ + + +/** + * \mainpage The TNL-module + * + * TNL stands for "transform and lighting", i.e. this module implements + * a pipeline that receives as input a buffer of vertices and does all + * necessary transformations (rotations, clipping, vertex shader etc.) + * and passes then the output to the rasterizer. + * + * The tnl_pipeline contains the array of all stages, which should be + * applied. Each stage is a black-box, which is described by an + * tnl_pipeline_stage. The function ::_tnl_run_pipeline applies all the + * stages to the vertex_buffer TNLcontext::vb, where the vertex data + * is stored. The last stage in the pipeline is the rasterizer. + * + * The initial vertex_buffer data may either come from an ::immediate + * structure or client vertex_arrays or display lists: + * + * + * - The ::immediate structure records all the GL commands issued between + * glBegin and glEnd. \n + * The structure accumulates data, until it is either full or it is + * flushed (usually by a state change). Before starting then the pipeline, + * the collected vertex data in ::immediate has to be pushed into + * TNLcontext::vb. + * This happens in ::_tnl_vb_bind_immediate. The pipeline is then run by + * calling tnl_device_driver::RunPipeline = ::_tnl_run_pipeline, which + * is stored in TNLcontext::Driver. \n + * An ::immediate does (for performance reasons) usually not finish with a + * glEnd, and hence it also does not need to start with a glBegin. + * This means that the last vertices of one ::immediate may need to be + * saved for the next one. + * + * + * - NOT SURE ABOUT THIS: The vertex_arrays structure is used to handle + * glDrawArrays etc. \n + * Here, the data of the vertex_arrays is copied by ::_tnl_vb_bind_arrays + * into TNLcontext::vb, so that the pipeline can be started. + */ + + +#ifndef _T_CONTEXT_H +#define _T_CONTEXT_H + +#include "glheader.h" +#include "mtypes.h" + +#include "math/m_matrix.h" +#include "math/m_vector.h" +#include "math/m_xform.h" + + +#define MAX_PIPELINE_STAGES 30 + + +/* + * Note: The first attributes match the VERT_ATTRIB_* definitions + * in mtypes.h. However, the tnl module has additional attributes + * for materials, color indexes, edge flags, etc. + */ +/* Note: These are currently being used to define both inputs and + * outputs from the tnl pipeline. A better solution (which would also + * releive the congestion to slightly prolong the life of the bitmask + * below) is to have the fixed function pipeline populate a set of + * arrays named after those produced by the vertex program stage, and + * have the rest the mesa backend work on those. + */ +enum { + _TNL_ATTRIB_POS = 0, + _TNL_ATTRIB_WEIGHT = 1, + _TNL_ATTRIB_NORMAL = 2, + _TNL_ATTRIB_COLOR0 = 3, + _TNL_ATTRIB_COLOR1 = 4, + _TNL_ATTRIB_FOG = 5, + _TNL_ATTRIB_SIX = 6, + _TNL_ATTRIB_SEVEN = 7, + _TNL_ATTRIB_TEX0 = 8, + _TNL_ATTRIB_TEX1 = 9, + _TNL_ATTRIB_TEX2 = 10, + _TNL_ATTRIB_TEX3 = 11, + _TNL_ATTRIB_TEX4 = 12, + _TNL_ATTRIB_TEX5 = 13, + _TNL_ATTRIB_TEX6 = 14, + _TNL_ATTRIB_TEX7 = 15, + _TNL_ATTRIB_MAT_FRONT_AMBIENT = 16, + _TNL_ATTRIB_MAT_BACK_AMBIENT = 17, + _TNL_ATTRIB_MAT_FRONT_DIFFUSE = 18, + _TNL_ATTRIB_MAT_BACK_DIFFUSE = 19, + _TNL_ATTRIB_MAT_FRONT_SPECULAR = 20, + _TNL_ATTRIB_MAT_BACK_SPECULAR = 21, + _TNL_ATTRIB_MAT_FRONT_EMISSION = 22, + _TNL_ATTRIB_MAT_BACK_EMISSION = 23, + _TNL_ATTRIB_MAT_FRONT_SHININESS = 24, + _TNL_ATTRIB_MAT_BACK_SHININESS = 25, + _TNL_ATTRIB_MAT_FRONT_INDEXES = 26, + _TNL_ATTRIB_MAT_BACK_INDEXES = 27, + _TNL_ATTRIB_INDEX = 28, + _TNL_ATTRIB_EDGEFLAG = 29, + _TNL_ATTRIB_POINTSIZE = 30, + _TNL_ATTRIB_MAX = 31 +} ; + +/* Will probably have to revise this scheme fairly shortly, eg. by + * compacting all the MAT flags down to one bit, or by using two + * dwords to store the flags. + */ +#define _TNL_BIT_POS (1<<0) +#define _TNL_BIT_WEIGHT (1<<1) +#define _TNL_BIT_NORMAL (1<<2) +#define _TNL_BIT_COLOR0 (1<<3) +#define _TNL_BIT_COLOR1 (1<<4) +#define _TNL_BIT_FOG (1<<5) +#define _TNL_BIT_SIX (1<<6) +#define _TNL_BIT_SEVEN (1<<7) +#define _TNL_BIT_TEX0 (1<<8) +#define _TNL_BIT_TEX1 (1<<9) +#define _TNL_BIT_TEX2 (1<<10) +#define _TNL_BIT_TEX3 (1<<11) +#define _TNL_BIT_TEX4 (1<<12) +#define _TNL_BIT_TEX5 (1<<13) +#define _TNL_BIT_TEX6 (1<<14) +#define _TNL_BIT_TEX7 (1<<15) +#define _TNL_BIT_MAT_FRONT_AMBIENT (1<<16) +#define _TNL_BIT_MAT_BACK_AMBIENT (1<<17) +#define _TNL_BIT_MAT_FRONT_DIFFUSE (1<<18) +#define _TNL_BIT_MAT_BACK_DIFFUSE (1<<19) +#define _TNL_BIT_MAT_FRONT_SPECULAR (1<<20) +#define _TNL_BIT_MAT_BACK_SPECULAR (1<<21) +#define _TNL_BIT_MAT_FRONT_EMISSION (1<<22) +#define _TNL_BIT_MAT_BACK_EMISSION (1<<23) +#define _TNL_BIT_MAT_FRONT_SHININESS (1<<24) +#define _TNL_BIT_MAT_BACK_SHININESS (1<<25) +#define _TNL_BIT_MAT_FRONT_INDEXES (1<<26) +#define _TNL_BIT_MAT_BACK_INDEXES (1<<27) +#define _TNL_BIT_INDEX (1<<28) +#define _TNL_BIT_EDGEFLAG (1<<29) +#define _TNL_BIT_POINTSIZE (1<<30) + +#define _TNL_BIT_TEX(u) (1 << (_TNL_ATTRIB_TEX0 + (u))) + + + +#define _TNL_BITS_MAT_ANY (_TNL_BIT_MAT_FRONT_AMBIENT | \ + _TNL_BIT_MAT_BACK_AMBIENT | \ + _TNL_BIT_MAT_FRONT_DIFFUSE | \ + _TNL_BIT_MAT_BACK_DIFFUSE | \ + _TNL_BIT_MAT_FRONT_SPECULAR | \ + _TNL_BIT_MAT_BACK_SPECULAR | \ + _TNL_BIT_MAT_FRONT_EMISSION | \ + _TNL_BIT_MAT_BACK_EMISSION | \ + _TNL_BIT_MAT_FRONT_SHININESS | \ + _TNL_BIT_MAT_BACK_SHININESS | \ + _TNL_BIT_MAT_FRONT_INDEXES | \ + _TNL_BIT_MAT_BACK_INDEXES) + + +#define _TNL_BITS_TEX_ANY (_TNL_BIT_TEX0 | \ + _TNL_BIT_TEX1 | \ + _TNL_BIT_TEX2 | \ + _TNL_BIT_TEX3 | \ + _TNL_BIT_TEX4 | \ + _TNL_BIT_TEX5 | \ + _TNL_BIT_TEX6 | \ + _TNL_BIT_TEX7) + + +#define _TNL_BITS_PROG_ANY (_TNL_BIT_POS | \ + _TNL_BIT_WEIGHT | \ + _TNL_BIT_NORMAL | \ + _TNL_BIT_COLOR0 | \ + _TNL_BIT_COLOR1 | \ + _TNL_BIT_FOG | \ + _TNL_BIT_SIX | \ + _TNL_BIT_SEVEN | \ + _TNL_BITS_TEX_ANY) + + + +#define PRIM_BEGIN 0x10 +#define PRIM_END 0x20 +#define PRIM_WEAK 0x40 +#define PRIM_MODE_MASK 0x0f + +/* + */ +struct tnl_prim { + GLuint mode; + GLuint start; + GLuint count; +}; + + + +struct tnl_eval1_map { + struct gl_1d_map *map; + GLuint sz; +}; + +struct tnl_eval2_map { + struct gl_2d_map *map; + GLuint sz; +}; + +struct tnl_eval { + GLuint new_state; + struct tnl_eval1_map map1[_TNL_ATTRIB_INDEX + 1]; + struct tnl_eval2_map map2[_TNL_ATTRIB_INDEX + 1]; +}; + + +#define TNL_MAX_PRIM 16 +#define TNL_MAX_COPIED_VERTS 3 + +struct tnl_copied_vtx { + GLfloat buffer[_TNL_ATTRIB_MAX * 4 * TNL_MAX_COPIED_VERTS]; + GLuint nr; +}; + +#define VERT_BUFFER_SIZE 2048 /* 8kbytes */ + + +typedef void (*tnl_attrfv_func)( const GLfloat * ); + +struct _tnl_dynfn { + struct _tnl_dynfn *next, *prev; + GLuint key; + char *code; +}; + +struct _tnl_dynfn_lists { + struct _tnl_dynfn Vertex[4]; + struct _tnl_dynfn Attribute[4]; +}; + +struct _tnl_dynfn_generators { + struct _tnl_dynfn *(*Vertex[4])( GLcontext *ctx, int key ); + struct _tnl_dynfn *(*Attribute[4])( GLcontext *ctx, int key ); +}; + +#define _TNL_MAX_ATTR_CODEGEN 16 + + +/* The assembly of vertices in immediate mode is separated from + * display list compilation. This allows a simpler immediate mode + * treatment and a display list compiler better suited to + * hardware-acceleration. + */ +struct tnl_vtx { + GLfloat buffer[VERT_BUFFER_SIZE]; + GLubyte attrsz[_TNL_ATTRIB_MAX]; + GLuint vertex_size; + struct tnl_prim prim[TNL_MAX_PRIM]; + GLuint prim_count; + GLfloat *vbptr; /* cursor, points into buffer */ + GLfloat vertex[_TNL_ATTRIB_MAX*4]; /* current vertex */ + GLfloat *attrptr[_TNL_ATTRIB_MAX]; /* points into vertex */ + GLfloat *current[_TNL_ATTRIB_MAX]; /* points into ctx->Current, etc */ + GLuint counter, initial_counter; + struct tnl_copied_vtx copied; + + tnl_attrfv_func tabfv[_TNL_MAX_ATTR_CODEGEN+1][4]; /* plus 1 for ERROR_ATTRIB */ + + struct _tnl_dynfn_lists cache; + struct _tnl_dynfn_generators gen; + + struct tnl_eval eval; + GLboolean *edgeflag_tmp; + GLboolean have_materials; +}; + + + + +/* For display lists, this structure holds a run of vertices of the + * same format, and a strictly well-formed set of begin/end pairs, + * starting on the first vertex and ending at the last. Vertex + * copying on buffer breaks is precomputed according to these + * primitives, though there are situations where the copying will need + * correction at execute-time, perhaps by replaying the list as + * immediate mode commands. + * + * On executing this list, the 'current' values may be updated with + * the values of the final vertex, and often no fixup of the start of + * the vertex list is required. + * + * Eval and other commands that don't fit into these vertex lists are + * compiled using the fallback opcode mechanism provided by dlist.c. + */ +struct tnl_vertex_list { + GLubyte attrsz[_TNL_ATTRIB_MAX]; + GLuint vertex_size; + + GLfloat *buffer; + GLuint count; + GLuint wrap_count; /* number of copied vertices at start */ + GLboolean have_materials; /* bit of a hack - quick check for materials */ + GLboolean dangling_attr_ref; /* current attr implicitly referenced + outside the list */ + + GLfloat *normal_lengths; + struct tnl_prim *prim; + GLuint prim_count; + + struct tnl_vertex_store *vertex_store; + struct tnl_primitive_store *prim_store; +}; + +/* These buffers should be a reasonable size to support upload to + * hardware? Maybe drivers should stitch them back together, or + * specify a desired size? + */ +#define SAVE_BUFFER_SIZE (16*1024) +#define SAVE_PRIM_SIZE 128 + +/* Storage to be shared among several vertex_lists. + */ +struct tnl_vertex_store { + GLfloat buffer[SAVE_BUFFER_SIZE]; + GLuint used; + GLuint refcount; +}; + +struct tnl_primitive_store { + struct tnl_prim buffer[SAVE_PRIM_SIZE]; + GLuint used; + GLuint refcount; +}; + + +struct tnl_save { + GLubyte attrsz[_TNL_ATTRIB_MAX]; + GLuint vertex_size; + + GLfloat *buffer; + GLuint count; + GLuint wrap_count; + + struct tnl_prim *prim; + GLuint prim_count, prim_max; + + struct tnl_vertex_store *vertex_store; + struct tnl_primitive_store *prim_store; + + GLfloat *vbptr; /* cursor, points into buffer */ + GLfloat vertex[_TNL_ATTRIB_MAX*4]; /* current values */ + GLfloat *attrptr[_TNL_ATTRIB_MAX]; + GLuint counter, initial_counter; + GLboolean dangling_attr_ref; + GLboolean have_materials; + + GLuint opcode_vertex_list; + + struct tnl_copied_vtx copied; + + GLfloat *current[_TNL_ATTRIB_MAX]; /* points into ctx->ListState */ + GLubyte *currentsz[_TNL_ATTRIB_MAX]; + + void (*tabfv[_TNL_ATTRIB_MAX][4])( const GLfloat * ); +}; + + +struct tnl_vertex_arrays +{ + /* Conventional vertex attribute arrays */ + GLvector4f Obj; + GLvector4f Normal; + GLvector4f Color; + GLvector4f SecondaryColor; + GLvector4f FogCoord; + GLvector4f TexCoord[MAX_TEXTURE_COORD_UNITS]; + GLvector4f Index; + + GLubyte *EdgeFlag; + GLuint *Elt; + + /* These attributes don't alias with the conventional attributes. + * The GL_NV_vertex_program extension defines 16 extra sets of vertex + * arrays which have precedent over the conventional arrays when enabled. + */ + GLvector4f Attribs[_TNL_ATTRIB_MAX]; +}; + + +/** + * Contains the current state of a running pipeline. + */ +struct vertex_buffer +{ + /* Constant over life of the vertex_buffer. + */ + GLuint Size; + + /* Constant over the pipeline. + */ + GLuint Count; /* for everything except Elts */ + + /* Pointers to current data. + */ + GLuint *Elts; + GLvector4f *ObjPtr; /* _TNL_BIT_POS */ + GLvector4f *EyePtr; /* _TNL_BIT_POS */ + GLvector4f *ClipPtr; /* _TNL_BIT_POS */ + GLvector4f *NdcPtr; /* _TNL_BIT_POS */ + GLubyte ClipOrMask; /* _TNL_BIT_POS */ + GLubyte ClipAndMask; /* _TNL_BIT_POS */ + GLubyte *ClipMask; /* _TNL_BIT_POS */ + GLvector4f *NormalPtr; /* _TNL_BIT_NORMAL */ + GLfloat *NormalLengthPtr; /* _TNL_BIT_NORMAL */ + GLboolean *EdgeFlag; /* _TNL_BIT_EDGEFLAG */ + GLvector4f *TexCoordPtr[MAX_TEXTURE_COORD_UNITS]; /* VERT_TEX_0..n */ + GLvector4f *IndexPtr[2]; /* _TNL_BIT_INDEX */ + GLvector4f *ColorPtr[2]; /* _TNL_BIT_COLOR0 */ + GLvector4f *SecondaryColorPtr[2]; /* _TNL_BIT_COLOR1 */ + GLvector4f *PointSizePtr; /* _TNL_BIT_POS */ + GLvector4f *FogCoordPtr; /* _TNL_BIT_FOG */ + + struct tnl_prim *Primitive; + GLuint PrimitiveCount; + + /* Inputs to the vertex program stage */ + GLvector4f *AttribPtr[_TNL_ATTRIB_MAX]; /* GL_NV_vertex_program */ + + GLuint LastClipped; + /* Private data from _tnl_render_stage that has no business being + * in this struct. + */ +}; + + +/** Describes an individual operation on the pipeline. + */ +struct tnl_pipeline_stage +{ + const char *name; + GLuint check_state; /* All state referenced in check() -- + * When is the pipeline_stage struct + * itself invalidated? Must be + * constant. + */ + + /* Usually constant or set by the 'check' callback: + */ + GLuint run_state; /* All state referenced in run() -- + * When is the cached output of the + * stage invalidated? + */ + + GLboolean active; /* True if runnable in current state */ + GLuint inputs; /* VERT_* inputs to the stage */ + GLuint outputs; /* VERT_* outputs of the stage */ + + /* Set in _tnl_run_pipeline(): + */ + GLuint changed_inputs; /* Generated value -- inputs to the + * stage that have changed since last + * call to 'run'. + */ + + + /* Private data for the pipeline stage: + */ + void *privatePtr; + + /* Free private data. May not be null. + */ + void (*destroy)( struct tnl_pipeline_stage * ); + + /* Called from _tnl_validate_pipeline(). Must update all fields in + * the pipeline_stage struct for the current state. + */ + void (*check)( GLcontext *ctx, struct tnl_pipeline_stage * ); + + /* Called from _tnl_run_pipeline(). The stage.changed_inputs value + * encodes all inputs to thee struct which have changed. If + * non-zero, recompute all affected outputs of the stage, otherwise + * execute any 'sideeffects' of the stage. + * + * Return value: GL_TRUE - keep going + * GL_FALSE - finished pipeline + */ + GLboolean (*run)( GLcontext *ctx, struct tnl_pipeline_stage * ); +}; + +/** Contains the array of all pipeline stages. + * The default values are defined at the end of t_pipeline.c */ +struct tnl_pipeline { + GLuint build_state_trigger; /**< state changes which require build */ + GLuint build_state_changes; /**< state changes since last build */ + GLuint run_state_changes; /**< state changes since last run */ + GLuint run_input_changes; /**< VERT_* changes since last run */ + GLuint inputs; /**< VERT_* inputs to pipeline */ + /** This array has to end with a NULL-pointer. */ + struct tnl_pipeline_stage stages[MAX_PIPELINE_STAGES+1]; + GLuint nr_stages; +}; + +struct tnl_clipspace; +struct tnl_clipspace_attr; + +typedef void (*tnl_extract_func)( const struct tnl_clipspace_attr *a, + GLfloat *out, + const GLubyte *v ); + +typedef void (*tnl_insert_func)( const struct tnl_clipspace_attr *a, + GLubyte *v, + const GLfloat *in ); + +typedef void (*tnl_emit_func)( GLcontext *ctx, + GLuint start, + GLuint end, void *dest ); + + +/** + * Describes how to convert/move a vertex attribute from a vertex array + * to a vertex structure. + */ +struct tnl_clipspace_attr +{ + GLuint attrib; /* which vertex attrib (0=position, etc) */ + GLuint format; + GLuint vertoffset; /* position of the attrib in the vertex struct */ + GLuint vertattrsize; /* size of the attribute in bytes */ + GLubyte *inputptr; + GLuint inputstride; + tnl_insert_func *insert; + tnl_insert_func emit; + tnl_extract_func extract; + const GLfloat *vp; /* NDC->Viewport mapping matrix */ +}; + + +struct tnl_clipspace_codegen { + GLboolean (*emit_header)( struct tnl_clipspace_codegen *, + struct tnl_clipspace *); + GLboolean (*emit_footer)( struct tnl_clipspace_codegen * ); + GLboolean (*emit_attr_header)( struct tnl_clipspace_codegen *, + struct tnl_clipspace_attr *, + GLint j, GLenum out_type, + GLboolean need_vp ); + GLboolean (*emit_attr_footer)( struct tnl_clipspace_codegen * ); + GLboolean (*emit_mov)( struct tnl_clipspace_codegen *, + GLint, GLint ); + GLboolean (*emit_const)( struct tnl_clipspace_codegen *, + GLint, GLfloat ); + GLboolean (*emit_mad)( struct tnl_clipspace_codegen *, + GLint, GLint, GLint, GLint ); + GLboolean (*emit_float_to_chan)( struct tnl_clipspace_codegen *, + GLint, GLint ); + GLboolean (*emit_const_chan)( struct tnl_clipspace_codegen *, + GLint, GLchan ); + GLboolean (*emit_float_to_ubyte)( struct tnl_clipspace_codegen *, + GLint, GLint ); + GLboolean (*emit_const_ubyte)( struct tnl_clipspace_codegen *, + GLint, GLubyte ); + tnl_emit_func (*emit_store_func)( struct tnl_clipspace_codegen * ); + + struct _tnl_dynfn codegen_list; + + char *buf; + int buf_size; + int buf_used; + int out_offset; +}; + + + +typedef void (*tnl_points_func)( GLcontext *ctx, GLuint first, GLuint last ); +typedef void (*tnl_line_func)( GLcontext *ctx, GLuint v1, GLuint v2 ); +typedef void (*tnl_triangle_func)( GLcontext *ctx, + GLuint v1, GLuint v2, GLuint v3 ); +typedef void (*tnl_quad_func)( GLcontext *ctx, GLuint v1, GLuint v2, + GLuint v3, GLuint v4 ); +typedef void (*tnl_render_func)( GLcontext *ctx, GLuint start, GLuint count, + GLuint flags ); +typedef void (*tnl_interp_func)( GLcontext *ctx, + GLfloat t, GLuint dst, GLuint out, GLuint in, + GLboolean force_boundary ); +typedef void (*tnl_copy_pv_func)( GLcontext *ctx, GLuint dst, GLuint src ); +typedef void (*tnl_setup_func)( GLcontext *ctx, + GLuint start, GLuint end, + GLuint new_inputs); + + +/** + * Used to describe conversion of vertex arrays to vertex structures. + * I.e. Structure of arrays to arrays of structs. + */ +struct tnl_clipspace +{ + GLboolean need_extras; + + GLuint new_inputs; + + GLubyte *vertex_buf; + GLuint vertex_size; + GLuint max_vertex_size; + + struct tnl_clipspace_attr attr[_TNL_ATTRIB_MAX]; + GLuint attr_count; + + tnl_emit_func emit; + tnl_interp_func interp; + tnl_copy_pv_func copy_pv; + + struct tnl_clipspace_codegen codegen; +}; + + +struct tnl_device_driver +{ + /*** + *** TNL Pipeline + ***/ + + void (*RunPipeline)(GLcontext *ctx); + /* Replaces PipelineStart/PipelineFinish -- intended to allow + * drivers to wrap _tnl_run_pipeline() with code to validate state + * and grab/release hardware locks. + */ + + void (*NotifyMaterialChange)(GLcontext *ctx); + /* Alert tnl-aware drivers of changes to material. + */ + + GLboolean (*NotifyBegin)(GLcontext *ctx, GLenum p); + /* Allow drivers to hook in optimized begin/end engines. + * Return value: GL_TRUE - driver handled the begin + * GL_FALSE - driver didn't handle the begin + */ + + /*** + *** Rendering -- These functions called only from t_vb_render.c + ***/ + struct + { + void (*Start)(GLcontext *ctx); + void (*Finish)(GLcontext *ctx); + /* Called before and after all rendering operations, including DrawPixels, + * ReadPixels, Bitmap, span functions, and CopyTexImage, etc commands. + * These are a suitable place for grabbing/releasing hardware locks. + */ + + void (*PrimitiveNotify)(GLcontext *ctx, GLenum mode); + /* Called between RenderStart() and RenderFinish() to indicate the + * type of primitive we're about to draw. Mode will be one of the + * modes accepted by glBegin(). + */ + + tnl_interp_func Interp; + /* The interp function is called by the clipping routines when we need + * to generate an interpolated vertex. All pertinant vertex ancilliary + * data should be computed by interpolating between the 'in' and 'out' + * vertices. + */ + + tnl_copy_pv_func CopyPV; + /* The copy function is used to make a copy of a vertex. All pertinant + * vertex attributes should be copied. + */ + + void (*ClippedPolygon)( GLcontext *ctx, const GLuint *elts, GLuint n ); + /* Render a polygon with <n> vertices whose indexes are in the <elts> + * array. + */ + + void (*ClippedLine)( GLcontext *ctx, GLuint v0, GLuint v1 ); + /* Render a line between the two vertices given by indexes v0 and v1. */ + + tnl_points_func Points; /* must now respect vb->elts */ + tnl_line_func Line; + tnl_triangle_func Triangle; + tnl_quad_func Quad; + /* These functions are called in order to render points, lines, + * triangles and quads. These are only called via the T&L module. + */ + + tnl_render_func *PrimTabVerts; + tnl_render_func *PrimTabElts; + /* Render whole unclipped primitives (points, lines, linestrips, + * lineloops, etc). The tables are indexed by the GL enum of the + * primitive to be rendered. RenderTabVerts is used for non-indexed + * arrays of vertices. RenderTabElts is used for indexed arrays of + * vertices. + */ + + void (*ResetLineStipple)( GLcontext *ctx ); + /* Reset the hardware's line stipple counter. + */ + + tnl_setup_func BuildVertices; + /* This function is called whenever new vertices are required for + * rendering. The vertices in question are those n such that start + * <= n < end. The new_inputs parameter indicates those fields of + * the vertex which need to be updated, if only a partial repair of + * the vertex is required. + * + * This function is called only from _tnl_render_stage in tnl/t_render.c. + */ + + + GLboolean (*Multipass)( GLcontext *ctx, GLuint passno ); + /* Driver may request additional render passes by returning GL_TRUE + * when this function is called. This function will be called + * after the first pass, and passes will be made until the function + * returns GL_FALSE. If no function is registered, only one pass + * is made. + * + * This function will be first invoked with passno == 1. + */ + } Render; +}; + + +/** + * Context state for T&L context. + */ +typedef struct +{ + /* Driver interface. + */ + struct tnl_device_driver Driver; + + /* Execute: + */ + struct tnl_vtx vtx; + + /* Compile: + */ + struct tnl_save save; + + /* Pipeline + */ + struct tnl_pipeline pipeline; + struct vertex_buffer vb; + + /* GLvectors for binding to vb: + */ + struct tnl_vertex_arrays vtx_inputs; + struct tnl_vertex_arrays save_inputs; + struct tnl_vertex_arrays current; + struct tnl_vertex_arrays array_inputs; + + /* Clipspace/ndc/window vertex managment: + */ + struct tnl_clipspace clipspace; + + /* Probably need a better configuration mechanism: + */ + GLboolean NeedNdcCoords; + GLboolean LoopbackDListCassettes; + GLboolean CalcDListNormalLengths; + GLboolean IsolateMaterials; + GLboolean AllowVertexFog; + GLboolean AllowPixelFog; + GLboolean AllowCodegen; + + GLboolean _DoVertexFog; /* eval fog function at each vertex? */ + + GLuint render_inputs; + + GLvertexformat exec_vtxfmt; + GLvertexformat save_vtxfmt; + +} TNLcontext; + + + +#define TNL_CONTEXT(ctx) ((TNLcontext *)((ctx)->swtnl_context)) + + +#define TYPE_IDX(t) ((t) & 0xf) +#define MAX_TYPES TYPE_IDX(GL_DOUBLE)+1 /* 0xa + 1 */ + +extern void _tnl_MakeCurrent( GLcontext *ctx, + GLframebuffer *drawBuffer, + GLframebuffer *readBuffer ); + + + + +#endif diff --git a/src/mesa/tnl/t_pipeline.c b/src/mesa/tnl/t_pipeline.c new file mode 100644 index 0000000..e90e21b --- /dev/null +++ b/src/mesa/tnl/t_pipeline.c @@ -0,0 +1,216 @@ + +/* + * Mesa 3-D graphics library + * Version: 5.1 + * + * 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + +#include "glheader.h" +#include "context.h" +#include "imports.h" +#include "state.h" +#include "mtypes.h" + +#include "math/m_translate.h" +#include "math/m_xform.h" + +#include "t_context.h" +#include "t_pipeline.h" + + +void _tnl_install_pipeline( GLcontext *ctx, + const struct tnl_pipeline_stage **stages ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct tnl_pipeline *pipe = &tnl->pipeline; + GLuint i; + + ASSERT(pipe->nr_stages == 0); + + pipe->run_state_changes = ~0; + pipe->run_input_changes = ~0; + pipe->build_state_changes = ~0; + pipe->build_state_trigger = 0; + pipe->inputs = 0; + + /* Create a writeable copy of each stage. + */ + for (i = 0 ; i < MAX_PIPELINE_STAGES && stages[i] ; i++) { + MEMCPY( &pipe->stages[i], stages[i], sizeof( **stages )); + pipe->build_state_trigger |= pipe->stages[i].check_state; + } + + MEMSET( &pipe->stages[i], 0, sizeof( **stages )); + + pipe->nr_stages = i; +} + +void _tnl_destroy_pipeline( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint i; + + for (i = 0 ; i < tnl->pipeline.nr_stages ; i++) + tnl->pipeline.stages[i].destroy( &tnl->pipeline.stages[i] ); + + tnl->pipeline.nr_stages = 0; +} + +/* TODO: merge validate with run. + */ +void _tnl_validate_pipeline( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct tnl_pipeline *pipe = &tnl->pipeline; + struct tnl_pipeline_stage *s = pipe->stages; + GLuint newstate = pipe->build_state_changes; + GLuint generated = 0; + GLuint changed_inputs = 0; + + pipe->inputs = 0; + pipe->build_state_changes = 0; + + for ( ; s->check ; s++) { + + s->changed_inputs |= s->inputs & changed_inputs; + + if (s->check_state & newstate) { + if (s->active) { + GLuint old_outputs = s->outputs; + s->check(ctx, s); + if (!s->active) + changed_inputs |= old_outputs; + } + else + s->check(ctx, s); + } + + if (s->active) { + pipe->inputs |= s->inputs & ~generated; + generated |= s->outputs; + } + } +} + + + +void _tnl_run_pipeline( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct tnl_pipeline *pipe = &tnl->pipeline; + struct tnl_pipeline_stage *s = pipe->stages; + GLuint changed_state = pipe->run_state_changes; + GLuint changed_inputs = pipe->run_input_changes; + GLboolean running = GL_TRUE; +#ifdef HAVE_FAST_MATH + unsigned short __tmp; +#endif + + if (!tnl->vb.Count) + return; + + pipe->run_state_changes = 0; + pipe->run_input_changes = 0; + + /* Done elsewhere. + */ + ASSERT(pipe->build_state_changes == 0); + +#ifdef HAVE_FAST_MATH + START_FAST_MATH(__tmp); +#endif + + /* If something changes in the pipeline, tag all subsequent stages + * using this value for recalculation. Inactive stages have their + * state and inputs examined to try to keep cached data alive over + * state-changes. + */ + for ( ; s->run ; s++) { + s->changed_inputs |= s->inputs & changed_inputs; + + if (s->run_state & changed_state) + s->changed_inputs = s->inputs; + + if (s->active && running) { + if (s->changed_inputs) + changed_inputs |= s->outputs; + + running = s->run( ctx, s ); + + s->changed_inputs = 0; + } + } + +#ifdef HAVE_FAST_MATH + END_FAST_MATH(__tmp); +#endif +} + + + +/* The default pipeline. This is useful for software rasterizers, and + * simple hardware rasterizers. For customization, I don't recommend + * tampering with the internals of these stages in the way that + * drivers did in Mesa 3.4. These stages are basically black boxes, + * and should be left intact. + * + * To customize the pipeline, consider: + * + * - removing redundant stages (making sure that the software rasterizer + * can cope with this on fallback paths). An example is fog + * coordinate generation, which is not required in the FX driver. + * + * - replacing general-purpose machine-independent stages with + * general-purpose machine-specific stages. There is no example of + * this to date, though it must be borne in mind that all subsequent + * stages that reference the output of the new stage must cope with + * any machine-specific data introduced. This may not be easy + * unless there are no such stages (ie the new stage is the last in + * the pipe). + * + * - inserting optimized (but specialized) stages ahead of the + * general-purpose fallback implementation. For example, the old + * fastpath mechanism, which only works when the VB->Elts input is + * available, can be duplicated by placing the fastpath stage at the + * head of this pipeline. Such specialized stages are currently + * constrained to have no outputs (ie. they must either finish the * + * pipeline by returning GL_FALSE from run(), or do nothing). + * + * Some work can be done to lift some of the restrictions in the final + * case, if it becomes necessary to do so. + */ +const struct tnl_pipeline_stage *_tnl_default_pipeline[] = { + &_tnl_vertex_transform_stage, + &_tnl_normal_transform_stage, + &_tnl_lighting_stage, + &_tnl_fog_coordinate_stage, + &_tnl_texgen_stage, + &_tnl_texture_transform_stage, + &_tnl_point_attenuation_stage, +#if defined(FEATURE_NV_vertex_program) || defined(FEATURE_ARB_vertex_program) + &_tnl_vertex_program_stage, +#endif + &_tnl_render_stage, + 0 +}; diff --git a/src/mesa/tnl/t_pipeline.h b/src/mesa/tnl/t_pipeline.h new file mode 100644 index 0000000..9efb5b8 --- /dev/null +++ b/src/mesa/tnl/t_pipeline.h @@ -0,0 +1,76 @@ + +/* + * Mesa 3-D graphics library + * Version: 3.5 + * + * Copyright (C) 1999-2001 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + + + +#ifndef _T_PIPELINE_H_ +#define _T_PIPELINE_H_ + +#include "mtypes.h" +#include "t_context.h" + +extern void _tnl_run_pipeline( GLcontext *ctx ); + +extern void _tnl_validate_pipeline( GLcontext *ctx ); + +extern void _tnl_destroy_pipeline( GLcontext *ctx ); + +extern void _tnl_install_pipeline( GLcontext *ctx, + const struct tnl_pipeline_stage **stages ); + + +/* These are implemented in the t_vb_*.c files: + */ +extern const struct tnl_pipeline_stage _tnl_vertex_transform_stage; +extern const struct tnl_pipeline_stage _tnl_vertex_cull_stage; +extern const struct tnl_pipeline_stage _tnl_normal_transform_stage; +extern const struct tnl_pipeline_stage _tnl_lighting_stage; +extern const struct tnl_pipeline_stage _tnl_fog_coordinate_stage; +extern const struct tnl_pipeline_stage _tnl_texgen_stage; +extern const struct tnl_pipeline_stage _tnl_texture_transform_stage; +extern const struct tnl_pipeline_stage _tnl_point_attenuation_stage; +extern const struct tnl_pipeline_stage _tnl_vertex_program_stage; +extern const struct tnl_pipeline_stage _tnl_render_stage; + +/* Shorthand to plug in the default pipeline: + */ +extern const struct tnl_pipeline_stage *_tnl_default_pipeline[]; + + +/* Convenience routines provided by t_vb_render.c: + */ +extern tnl_render_func _tnl_render_tab_elts[]; +extern tnl_render_func _tnl_render_tab_verts[]; + +extern void _tnl_RenderClippedPolygon( GLcontext *ctx, + const GLuint *elts, GLuint n ); + +extern void _tnl_RenderClippedLine( GLcontext *ctx, GLuint ii, GLuint jj ); + + +#endif diff --git a/src/mesa/tnl/t_save_api.c b/src/mesa/tnl/t_save_api.c new file mode 100644 index 0000000..5a7e6b5 --- /dev/null +++ b/src/mesa/tnl/t_save_api.c @@ -0,0 +1,1617 @@ +/* $XFree86$ */ +/************************************************************************** + +Copyright 2002 Tungsten Graphics Inc., Cedar Park, Texas. + +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"), +to deal in the Software without restriction, including without limitation +on the rights to use, copy, modify, merge, publish, distribute, sub +license, and/or sell copies of the Software, and to permit persons to whom +the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL +TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +USE OR OTHER DEALINGS IN THE SOFTWARE. + +**************************************************************************/ + +/* + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + + + +/* Display list compiler attempts to store lists of vertices with the + * same vertex layout. Additionally it attempts to minimize the need + * for execute-time fixup of these vertex lists, allowing them to be + * cached on hardware. + * + * There are still some circumstances where this can be thwarted, for + * example by building a list that consists of one very long primitive + * (eg Begin(Triangles), 1000 vertices, End), and calling that list + * from inside a different begin/end object (Begin(Lines), CallList, + * End). + * + * In that case the code will have to replay the list as individual + * commands through the Exec dispatch table, or fix up the copied + * vertices at execute-time. + * + * The other case where fixup is required is when a vertex attribute + * is introduced in the middle of a primitive. Eg: + * Begin(Lines) + * TexCoord1f() Vertex2f() + * TexCoord1f() Color3f() Vertex2f() + * End() + * + * If the current value of Color isn't known at compile-time, this + * primitive will require fixup. + * + * + * The list compiler currently doesn't attempt to compile lists + * containing EvalCoord or EvalPoint commands. On encountering one of + * these, compilation falls back to opcodes. + * + * This could be improved to fallback only when a mix of EvalCoord and + * Vertex commands are issued within a single primitive. + */ + + +#include "glheader.h" +#include "context.h" +#include "dlist.h" +#include "enums.h" +#include "macros.h" +#include "api_validate.h" +#include "api_arrayelt.h" +#include "vtxfmt.h" +#include "t_save_api.h" + +/* + * NOTE: Old 'parity' issue is gone, but copying can still be + * wrong-footed on replay. + */ +static GLuint _save_copy_vertices( GLcontext *ctx, + const struct tnl_vertex_list *node ) +{ + TNLcontext *tnl = TNL_CONTEXT( ctx ); + const struct tnl_prim *prim = &node->prim[node->prim_count-1]; + GLuint nr = prim->count; + GLuint sz = tnl->save.vertex_size; + const GLfloat *src = node->buffer + prim->start * sz; + GLfloat *dst = tnl->save.copied.buffer; + GLuint ovf, i; + + if (prim->mode & PRIM_END) + return 0; + + switch( prim->mode & PRIM_MODE_MASK ) + { + case GL_POINTS: + return 0; + case GL_LINES: + ovf = nr&1; + for (i = 0 ; i < ovf ; i++) + _mesa_memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) ); + return i; + case GL_TRIANGLES: + ovf = nr%3; + for (i = 0 ; i < ovf ; i++) + _mesa_memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) ); + return i; + case GL_QUADS: + ovf = nr&3; + for (i = 0 ; i < ovf ; i++) + _mesa_memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) ); + return i; + case GL_LINE_STRIP: + if (nr == 0) + return 0; + else { + _mesa_memcpy( dst, src+(nr-1)*sz, sz*sizeof(GLfloat) ); + return 1; + } + case GL_LINE_LOOP: + case GL_TRIANGLE_FAN: + case GL_POLYGON: + if (nr == 0) + return 0; + else if (nr == 1) { + _mesa_memcpy( dst, src+0, sz*sizeof(GLfloat) ); + return 1; + } else { + _mesa_memcpy( dst, src+0, sz*sizeof(GLfloat) ); + _mesa_memcpy( dst+sz, src+(nr-1)*sz, sz*sizeof(GLfloat) ); + return 2; + } + case GL_TRIANGLE_STRIP: + case GL_QUAD_STRIP: + switch (nr) { + case 0: ovf = 0; break; + case 1: ovf = 1; break; + default: ovf = 2 + (nr&1); break; + } + for (i = 0 ; i < ovf ; i++) + _mesa_memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) ); + return i; + default: + assert(0); + return 0; + } +} + + +static void +build_normal_lengths( struct tnl_vertex_list *node ) +{ + GLuint i; + GLfloat *len; + GLfloat *n = node->buffer; + GLuint stride = node->vertex_size; + GLuint count = node->count; + + len = node->normal_lengths = (GLfloat *) MALLOC( count * sizeof(GLfloat) ); + if (!len) + return; + + /* Find the normal of the first vertex: + */ + for (i = 0 ; i < _TNL_ATTRIB_NORMAL ; i++) + n += node->attrsz[i]; + + for (i = 0 ; i < count ; i++, n += stride) { + len[i] = LEN_3FV( n ); + if (len[i] > 0.0F) len[i] = 1.0F / len[i]; + } +} + +static struct tnl_vertex_store *alloc_vertex_store( GLcontext *ctx ) +{ + struct tnl_vertex_store *store = MALLOC_STRUCT(tnl_vertex_store); + (void) ctx; + store->used = 0; + store->refcount = 1; + return store; +} + +static struct tnl_primitive_store *alloc_prim_store( GLcontext *ctx ) +{ + struct tnl_primitive_store *store = MALLOC_STRUCT(tnl_primitive_store); + (void) ctx; + store->used = 0; + store->refcount = 1; + return store; +} + +static void _save_reset_counters( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + + tnl->save.prim = tnl->save.prim_store->buffer + tnl->save.prim_store->used; + tnl->save.buffer = (tnl->save.vertex_store->buffer + + tnl->save.vertex_store->used); + + if (tnl->save.vertex_size) + tnl->save.initial_counter = ((SAVE_BUFFER_SIZE - + tnl->save.vertex_store->used) / + tnl->save.vertex_size); + else + tnl->save.initial_counter = 0; + + if (tnl->save.initial_counter > ctx->Const.MaxArrayLockSize ) + tnl->save.initial_counter = ctx->Const.MaxArrayLockSize; + + tnl->save.counter = tnl->save.initial_counter; + tnl->save.prim_count = 0; + tnl->save.prim_max = SAVE_PRIM_SIZE - tnl->save.prim_store->used; + tnl->save.copied.nr = 0; + tnl->save.dangling_attr_ref = 0; +} + + +/* Insert the active immediate struct onto the display list currently + * being built. + */ +static void _save_compile_vertex_list( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct tnl_vertex_list *node; + + /* Allocate space for this structure in the display list currently + * being compiled. + */ + node = (struct tnl_vertex_list *) + _mesa_alloc_instruction(ctx, tnl->save.opcode_vertex_list, sizeof(*node)); + + if (!node) + return; + + /* Duplicate our template, increment refcounts to the storage structs: + */ + _mesa_memcpy(node->attrsz, tnl->save.attrsz, sizeof(node->attrsz)); + node->vertex_size = tnl->save.vertex_size; + node->buffer = tnl->save.buffer; + node->wrap_count = tnl->save.copied.nr; + node->count = tnl->save.initial_counter - tnl->save.counter; + node->prim = tnl->save.prim; + node->prim_count = tnl->save.prim_count; + node->vertex_store = tnl->save.vertex_store; + node->prim_store = tnl->save.prim_store; + node->dangling_attr_ref = tnl->save.dangling_attr_ref; + node->normal_lengths = 0; + + node->vertex_store->refcount++; + node->prim_store->refcount++; + + assert(node->attrsz[_TNL_ATTRIB_POS] != 0 || + node->count == 0); + + /* Maybe calculate normal lengths: + */ + if (tnl->CalcDListNormalLengths && + node->attrsz[_TNL_ATTRIB_NORMAL] == 3 && + !node->dangling_attr_ref) + build_normal_lengths( node ); + + tnl->save.vertex_store->used += tnl->save.vertex_size * node->count; + tnl->save.prim_store->used += node->prim_count; + + /* Decide whether the storage structs are full, or can be used for + * the next vertex lists as well. + */ + if (tnl->save.vertex_store->used > + SAVE_BUFFER_SIZE - 16 * (tnl->save.vertex_size + 4)) { + + tnl->save.vertex_store->refcount--; + assert(tnl->save.vertex_store->refcount != 0); + tnl->save.vertex_store = alloc_vertex_store( ctx ); + tnl->save.vbptr = tnl->save.vertex_store->buffer; + } + + if (tnl->save.prim_store->used > SAVE_PRIM_SIZE - 6) { + tnl->save.prim_store->refcount--; + assert(tnl->save.prim_store->refcount != 0); + tnl->save.prim_store = alloc_prim_store( ctx ); + } + + /* Reset our structures for the next run of vertices: + */ + _save_reset_counters( ctx ); + + /* Copy duplicated vertices + */ + tnl->save.copied.nr = _save_copy_vertices( ctx, node ); + + + /* Deal with GL_COMPILE_AND_EXECUTE: + */ + if (ctx->ExecuteFlag) { + _tnl_playback_vertex_list( ctx, (void *) node ); + } +} + + +/* TODO -- If no new vertices have been stored, don't bother saving + * it. + */ +static void _save_wrap_buffers( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLint i = tnl->save.prim_count - 1; + GLenum mode; + + assert(i < (GLint) tnl->save.prim_max); + assert(i >= 0); + + /* Close off in-progress primitive. + */ + tnl->save.prim[i].count = ((tnl->save.initial_counter - tnl->save.counter) - + tnl->save.prim[i].start); + mode = tnl->save.prim[i].mode & ~(PRIM_BEGIN|PRIM_END); + + /* store the copied vertices, and allocate a new list. + */ + _save_compile_vertex_list( ctx ); + + /* Restart interrupted primitive + */ + tnl->save.prim[0].mode = mode; + tnl->save.prim[0].start = 0; + tnl->save.prim[0].count = 0; + tnl->save.prim_count = 1; +} + + + +/* Called only when buffers are wrapped as the result of filling the + * vertex_store struct. + */ +static void _save_wrap_filled_vertex( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLfloat *data = tnl->save.copied.buffer; + GLuint i; + + /* Emit a glEnd to close off the last vertex list. + */ + _save_wrap_buffers( ctx ); + + /* Copy stored stored vertices to start of new list. + */ + assert(tnl->save.counter > tnl->save.copied.nr); + + for (i = 0 ; i < tnl->save.copied.nr ; i++) { + _mesa_memcpy( tnl->save.vbptr, data, tnl->save.vertex_size * sizeof(GLfloat)); + data += tnl->save.vertex_size; + tnl->save.vbptr += tnl->save.vertex_size; + tnl->save.counter--; + } +} + + +static void _save_copy_to_current( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint i; + + for (i = _TNL_ATTRIB_POS+1 ; i <= _TNL_ATTRIB_INDEX ; i++) { + if (tnl->save.attrsz[i]) { + tnl->save.currentsz[i][0] = tnl->save.attrsz[i]; + ASSIGN_4V(tnl->save.current[i], 0, 0, 0, 1); + COPY_SZ_4V(tnl->save.current[i], + tnl->save.attrsz[i], + tnl->save.attrptr[i]); + } + } + + /* Edgeflag requires special treatment: + */ + if (tnl->save.attrsz[_TNL_ATTRIB_EDGEFLAG]) { + ctx->ListState.ActiveEdgeFlag = 1; + ctx->ListState.CurrentEdgeFlag = + (tnl->save.attrptr[_TNL_ATTRIB_EDGEFLAG][0] == 1.0); + } +} + + +static void _save_copy_from_current( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLint i; + + for (i = _TNL_ATTRIB_POS+1 ; i <= _TNL_ATTRIB_INDEX ; i++) + switch (tnl->save.attrsz[i]) { + case 4: tnl->save.attrptr[i][3] = tnl->save.current[i][3]; + case 3: tnl->save.attrptr[i][2] = tnl->save.current[i][2]; + case 2: tnl->save.attrptr[i][1] = tnl->save.current[i][1]; + case 1: tnl->save.attrptr[i][0] = tnl->save.current[i][0]; + case 0: break; + } + + /* Edgeflag requires special treatment: + */ + if (tnl->save.attrsz[_TNL_ATTRIB_EDGEFLAG]) + tnl->save.attrptr[_TNL_ATTRIB_EDGEFLAG][0] = + (GLfloat)ctx->ListState.CurrentEdgeFlag; +} + + + + +/* Flush existing data, set new attrib size, replay copied vertices. + */ +static void _save_upgrade_vertex( GLcontext *ctx, + GLuint attr, + GLuint newsz ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint oldsz; + GLuint i; + GLfloat *tmp; + + /* Store the current run of vertices, and emit a GL_END. Emit a + * BEGIN in the new buffer. + */ + if (tnl->save.initial_counter != tnl->save.counter) + _save_wrap_buffers( ctx ); + else + assert( tnl->save.copied.nr == 0 ); + + /* Do a COPY_TO_CURRENT to ensure back-copying works for the case + * when the attribute already exists in the vertex and is having + * its size increased. + */ + _save_copy_to_current( ctx ); + + /* Fix up sizes: + */ + oldsz = tnl->save.attrsz[attr]; + tnl->save.attrsz[attr] = newsz; + + tnl->save.vertex_size += newsz - oldsz; + tnl->save.counter = ((SAVE_BUFFER_SIZE - tnl->save.vertex_store->used) / + tnl->save.vertex_size); + if (tnl->save.counter > ctx->Const.MaxArrayLockSize ) + tnl->save.counter = ctx->Const.MaxArrayLockSize; + tnl->save.initial_counter = tnl->save.counter; + + /* Recalculate all the attrptr[] values: + */ + for (i = 0, tmp = tnl->save.vertex ; i < _TNL_ATTRIB_MAX ; i++) { + if (tnl->save.attrsz[i]) { + tnl->save.attrptr[i] = tmp; + tmp += tnl->save.attrsz[i]; + } + else + tnl->save.attrptr[i] = 0; /* will not be dereferenced. */ + } + + /* Copy from current to repopulate the vertex with correct values. + */ + _save_copy_from_current( ctx ); + + /* Replay stored vertices to translate them to new format here. + * + * If there are copied vertices and the new (upgraded) attribute + * has not been defined before, this list is somewhat degenerate, + * and will need fixup at runtime. + */ + if (tnl->save.copied.nr) + { + GLfloat *data = tnl->save.copied.buffer; + GLfloat *dest = tnl->save.buffer; + GLuint j; + + /* Need to note this and fix up at runtime (or loopback): + */ + if (tnl->save.currentsz[attr][0] == 0) { + assert(oldsz == 0); + tnl->save.dangling_attr_ref = GL_TRUE; + _mesa_debug(0, "_save_upgrade_vertex: dangling reference attr %d\n", + attr); + +#if 0 + /* The current strategy is to punt these degenerate cases + * through _tnl_loopback_vertex_list(), a lower-performance + * option. To minimize the impact of this, artificially + * reduce the size of this vertex_list. + */ + if (t->save.counter > 10) { + t->save.initial_counter = 10; + t->save.counter = 10; + } +#endif + } + + for (i = 0 ; i < tnl->save.copied.nr ; i++) { + for (j = 0 ; j < _TNL_ATTRIB_MAX ; j++) { + if (tnl->save.attrsz[j]) { + if (j == attr) { + if (oldsz) { + ASSIGN_4V( dest, 0, 0, 0, 1 ); + COPY_SZ_4V( dest, oldsz, data ); + data += oldsz; + dest += newsz; + } + else { + COPY_SZ_4V( dest, newsz, tnl->save.current[attr] ); + dest += newsz; + } + } + else { + GLint sz = tnl->save.attrsz[j]; + COPY_SZ_4V( dest, sz, data ); + data += sz; + dest += sz; + } + } + } + } + + tnl->save.vbptr = dest; + tnl->save.counter -= tnl->save.copied.nr; + } +} + + + + +/* Helper function for 'CHOOSE' macro. Do what's necessary when an + * entrypoint is called for the first time. + */ +static void do_choose( GLuint attr, GLuint sz, + void (*attr_func)( const GLfloat *), + void (*choose1)( const GLfloat *), + void (*choose2)( const GLfloat *), + void (*choose3)( const GLfloat *), + void (*choose4)( const GLfloat *), + const GLfloat *v ) +{ + GET_CURRENT_CONTEXT( ctx ); + TNLcontext *tnl = TNL_CONTEXT(ctx); + static GLfloat id[4] = { 0, 0, 0, 1 }; + int i; + + if (tnl->save.attrsz[attr] < sz) { + /* New size is larger. Need to flush existing vertices and get + * an enlarged vertex format. + */ + _save_upgrade_vertex( ctx, attr, sz ); + } + else { + /* New size is equal or smaller - just need to fill in some + * zeros. + */ + for (i = sz ; i <= tnl->save.attrsz[attr] ; i++) + tnl->save.attrptr[attr][i-1] = id[i-1]; + } + + /* Reset any active pointers for this attribute + */ + tnl->save.tabfv[attr][0] = choose1; + tnl->save.tabfv[attr][1] = choose2; + tnl->save.tabfv[attr][2] = choose3; + tnl->save.tabfv[attr][3] = choose4; + + /* Update the secondary dispatch table with the new function + */ + tnl->save.tabfv[attr][sz-1] = attr_func; + + (*attr_func)(v); +} + + + +/* Only one size for each attribute may be active at once. Eg. if + * Color3f is installed/active, then Color4f may not be, even if the + * vertex actually contains 4 color coordinates. This is because the + * 3f version won't otherwise set color[3] to 1.0 -- this is the job + * of the chooser function when switching between Color4f and Color3f. + */ +#define ATTRFV( ATTR, N ) \ +static void save_choose_##ATTR##_##N( const GLfloat *v ); \ + \ +static void save_attrib_##ATTR##_##N( const GLfloat *v ) \ +{ \ + GET_CURRENT_CONTEXT( ctx ); \ + TNLcontext *tnl = TNL_CONTEXT(ctx); \ + \ + if ((ATTR) == 0) { \ + GLuint i; \ + \ + if (N>0) tnl->save.vbptr[0] = v[0]; \ + if (N>1) tnl->save.vbptr[1] = v[1]; \ + if (N>2) tnl->save.vbptr[2] = v[2]; \ + if (N>3) tnl->save.vbptr[3] = v[3]; \ + \ + for (i = N; i < tnl->save.vertex_size; i++) \ + tnl->save.vbptr[i] = tnl->save.vertex[i]; \ + \ + tnl->save.vbptr += tnl->save.vertex_size; \ + \ + if (--tnl->save.counter == 0) \ + _save_wrap_filled_vertex( ctx ); \ + } \ + else { \ + GLfloat *dest = tnl->save.attrptr[ATTR]; \ + if (N>0) dest[0] = v[0]; \ + if (N>1) dest[1] = v[1]; \ + if (N>2) dest[2] = v[2]; \ + if (N>3) dest[3] = v[3]; \ + } \ +} + +#define CHOOSE( ATTR, N ) \ +static void save_choose_##ATTR##_##N( const GLfloat *v ) \ +{ \ + do_choose(ATTR, N, \ + save_attrib_##ATTR##_##N, \ + save_choose_##ATTR##_1, \ + save_choose_##ATTR##_2, \ + save_choose_##ATTR##_3, \ + save_choose_##ATTR##_4, \ + v ); \ +} + +#define INIT(ATTR) \ +static void save_init_##ATTR( TNLcontext *tnl ) \ +{ \ + tnl->save.tabfv[ATTR][0] = save_choose_##ATTR##_1; \ + tnl->save.tabfv[ATTR][1] = save_choose_##ATTR##_2; \ + tnl->save.tabfv[ATTR][2] = save_choose_##ATTR##_3; \ + tnl->save.tabfv[ATTR][3] = save_choose_##ATTR##_4; \ +} + +#define ATTRS( ATTRIB ) \ + ATTRFV( ATTRIB, 1 ) \ + ATTRFV( ATTRIB, 2 ) \ + ATTRFV( ATTRIB, 3 ) \ + ATTRFV( ATTRIB, 4 ) \ + CHOOSE( ATTRIB, 1 ) \ + CHOOSE( ATTRIB, 2 ) \ + CHOOSE( ATTRIB, 3 ) \ + CHOOSE( ATTRIB, 4 ) \ + INIT( ATTRIB ) \ + + +/* Generate a lot of functions. These are the actual worker + * functions, which are equivalent to those generated via codegen + * elsewhere. + */ +ATTRS( 0 ) +ATTRS( 1 ) +ATTRS( 2 ) +ATTRS( 3 ) +ATTRS( 4 ) +ATTRS( 5 ) +ATTRS( 6 ) +ATTRS( 7 ) +ATTRS( 8 ) +ATTRS( 9 ) +ATTRS( 10 ) +ATTRS( 11 ) +ATTRS( 12 ) +ATTRS( 13 ) +ATTRS( 14 ) +ATTRS( 15 ) + + +static void _save_reset_vertex( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint i; + + save_init_0( tnl ); + save_init_1( tnl ); + save_init_2( tnl ); + save_init_3( tnl ); + save_init_4( tnl ); + save_init_5( tnl ); + save_init_6( tnl ); + save_init_7( tnl ); + save_init_8( tnl ); + save_init_9( tnl ); + save_init_10( tnl ); + save_init_11( tnl ); + save_init_12( tnl ); + save_init_13( tnl ); + save_init_14( tnl ); + save_init_15( tnl ); + + for (i = 0 ; i < _TNL_ATTRIB_MAX ; i++) + tnl->save.attrsz[i] = 0; + + tnl->save.vertex_size = 0; + tnl->save.have_materials = 0; + + _save_reset_counters( ctx ); +} + + + +/* Cope with aliasing of classic Vertex, Normal, etc. and the fan-out + * of glMultTexCoord and glProgramParamterNV by routing all these + * through a second level dispatch table. + */ +#define DISPATCH_ATTRFV( ATTR, COUNT, P ) \ +do { \ + GET_CURRENT_CONTEXT( ctx ); \ + TNLcontext *tnl = TNL_CONTEXT(ctx); \ + tnl->save.tabfv[ATTR][COUNT-1]( P ); \ +} while (0) + +#define DISPATCH_ATTR1FV( ATTR, V ) DISPATCH_ATTRFV( ATTR, 1, V ) +#define DISPATCH_ATTR2FV( ATTR, V ) DISPATCH_ATTRFV( ATTR, 2, V ) +#define DISPATCH_ATTR3FV( ATTR, V ) DISPATCH_ATTRFV( ATTR, 3, V ) +#define DISPATCH_ATTR4FV( ATTR, V ) DISPATCH_ATTRFV( ATTR, 4, V ) + +#define DISPATCH_ATTR1F( ATTR, S ) DISPATCH_ATTRFV( ATTR, 1, &(S) ) + +#if defined(USE_X86_ASM) && 0 /* will break register calling convention */ +/* Naughty cheat: + */ +#define DISPATCH_ATTR2F( ATTR, S,T ) DISPATCH_ATTRFV( ATTR, 2, &(S) ) +#define DISPATCH_ATTR3F( ATTR, S,T,R ) DISPATCH_ATTRFV( ATTR, 3, &(S) ) +#define DISPATCH_ATTR4F( ATTR, S,T,R,Q ) DISPATCH_ATTRFV( ATTR, 4, &(S) ) +#else +/* Safe: + */ +#define DISPATCH_ATTR2F( ATTR, S,T ) \ +do { \ + GLfloat v[2]; \ + v[0] = S; v[1] = T; \ + DISPATCH_ATTR2FV( ATTR, v ); \ +} while (0) +#define DISPATCH_ATTR3F( ATTR, S,T,R ) \ +do { \ + GLfloat v[3]; \ + v[0] = S; v[1] = T; v[2] = R; \ + DISPATCH_ATTR3FV( ATTR, v ); \ +} while (0) +#define DISPATCH_ATTR4F( ATTR, S,T,R,Q ) \ +do { \ + GLfloat v[4]; \ + v[0] = S; v[1] = T; v[2] = R; v[3] = Q; \ + DISPATCH_ATTR4FV( ATTR, v ); \ +} while (0) +#endif + + +static void enum_error( void ) +{ + GET_CURRENT_CONTEXT( ctx ); + _mesa_compile_error( ctx, GL_INVALID_ENUM, "glVertexAttrib" ); +} + +static void GLAPIENTRY _save_Vertex2f( GLfloat x, GLfloat y ) +{ + DISPATCH_ATTR2F( _TNL_ATTRIB_POS, x, y ); +} + +static void GLAPIENTRY _save_Vertex2fv( const GLfloat *v ) +{ + DISPATCH_ATTR2FV( _TNL_ATTRIB_POS, v ); +} + +static void GLAPIENTRY _save_Vertex3f( GLfloat x, GLfloat y, GLfloat z ) +{ + DISPATCH_ATTR3F( _TNL_ATTRIB_POS, x, y, z ); +} + +static void GLAPIENTRY _save_Vertex3fv( const GLfloat *v ) +{ + DISPATCH_ATTR3FV( _TNL_ATTRIB_POS, v ); +} + +static void GLAPIENTRY _save_Vertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) +{ + DISPATCH_ATTR4F( _TNL_ATTRIB_POS, x, y, z, w ); +} + +static void GLAPIENTRY _save_Vertex4fv( const GLfloat *v ) +{ + DISPATCH_ATTR4FV( _TNL_ATTRIB_POS, v ); +} + +static void GLAPIENTRY _save_TexCoord1f( GLfloat x ) +{ + DISPATCH_ATTR1F( _TNL_ATTRIB_TEX0, x ); +} + +static void GLAPIENTRY _save_TexCoord1fv( const GLfloat *v ) +{ + DISPATCH_ATTR1FV( _TNL_ATTRIB_TEX0, v ); +} + +static void GLAPIENTRY _save_TexCoord2f( GLfloat x, GLfloat y ) +{ + DISPATCH_ATTR2F( _TNL_ATTRIB_TEX0, x, y ); +} + +static void GLAPIENTRY _save_TexCoord2fv( const GLfloat *v ) +{ + DISPATCH_ATTR2FV( _TNL_ATTRIB_TEX0, v ); +} + +static void GLAPIENTRY _save_TexCoord3f( GLfloat x, GLfloat y, GLfloat z ) +{ + DISPATCH_ATTR3F( _TNL_ATTRIB_TEX0, x, y, z ); +} + +static void GLAPIENTRY _save_TexCoord3fv( const GLfloat *v ) +{ + DISPATCH_ATTR3FV( _TNL_ATTRIB_TEX0, v ); +} + +static void GLAPIENTRY _save_TexCoord4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) +{ + DISPATCH_ATTR4F( _TNL_ATTRIB_TEX0, x, y, z, w ); +} + +static void GLAPIENTRY _save_TexCoord4fv( const GLfloat *v ) +{ + DISPATCH_ATTR4FV( _TNL_ATTRIB_TEX0, v ); +} + +static void GLAPIENTRY _save_Normal3f( GLfloat x, GLfloat y, GLfloat z ) +{ + DISPATCH_ATTR3F( _TNL_ATTRIB_NORMAL, x, y, z ); +} + +static void GLAPIENTRY _save_Normal3fv( const GLfloat *v ) +{ + DISPATCH_ATTR3FV( _TNL_ATTRIB_NORMAL, v ); +} + +static void GLAPIENTRY _save_FogCoordfEXT( GLfloat x ) +{ + DISPATCH_ATTR1F( _TNL_ATTRIB_FOG, x ); +} + +static void GLAPIENTRY _save_FogCoordfvEXT( const GLfloat *v ) +{ + DISPATCH_ATTR1FV( _TNL_ATTRIB_FOG, v ); +} + +static void GLAPIENTRY _save_Color3f( GLfloat x, GLfloat y, GLfloat z ) +{ + DISPATCH_ATTR3F( _TNL_ATTRIB_COLOR0, x, y, z ); +} + +static void GLAPIENTRY _save_Color3fv( const GLfloat *v ) +{ + DISPATCH_ATTR3FV( _TNL_ATTRIB_COLOR0, v ); +} + +static void GLAPIENTRY _save_Color4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) +{ + DISPATCH_ATTR4F( _TNL_ATTRIB_COLOR0, x, y, z, w ); +} + +static void GLAPIENTRY _save_Color4fv( const GLfloat *v ) +{ + DISPATCH_ATTR4FV( _TNL_ATTRIB_COLOR0, v ); +} + +static void GLAPIENTRY _save_SecondaryColor3fEXT( GLfloat x, GLfloat y, GLfloat z ) +{ + DISPATCH_ATTR3F( _TNL_ATTRIB_COLOR1, x, y, z ); +} + +static void GLAPIENTRY _save_SecondaryColor3fvEXT( const GLfloat *v ) +{ + DISPATCH_ATTR3FV( _TNL_ATTRIB_COLOR1, v ); +} + +static void GLAPIENTRY _save_MultiTexCoord1f( GLenum target, GLfloat x ) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR1F( attr, x ); +} + +static void GLAPIENTRY _save_MultiTexCoord1fv( GLenum target, const GLfloat *v ) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR1FV( attr, v ); +} + +static void GLAPIENTRY _save_MultiTexCoord2f( GLenum target, GLfloat x, GLfloat y ) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR2F( attr, x, y ); +} + +static void GLAPIENTRY _save_MultiTexCoord2fv( GLenum target, const GLfloat *v ) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR2FV( attr, v ); +} + +static void GLAPIENTRY _save_MultiTexCoord3f( GLenum target, GLfloat x, GLfloat y, + GLfloat z) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR3F( attr, x, y, z ); +} + +static void GLAPIENTRY _save_MultiTexCoord3fv( GLenum target, const GLfloat *v ) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR3FV( attr, v ); +} + +static void GLAPIENTRY _save_MultiTexCoord4f( GLenum target, GLfloat x, GLfloat y, + GLfloat z, GLfloat w ) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR4F( attr, x, y, z, w ); +} + +static void GLAPIENTRY _save_MultiTexCoord4fv( GLenum target, const GLfloat *v ) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR4FV( attr, v ); +} + +static void GLAPIENTRY _save_VertexAttrib1fNV( GLuint index, GLfloat x ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR1F( index, x ); + else + enum_error(); +} + +static void GLAPIENTRY _save_VertexAttrib1fvNV( GLuint index, const GLfloat *v ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR1FV( index, v ); + else + enum_error(); +} + +static void GLAPIENTRY _save_VertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR2F( index, x, y ); + else + enum_error(); +} + +static void GLAPIENTRY _save_VertexAttrib2fvNV( GLuint index, const GLfloat *v ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR2FV( index, v ); + else + enum_error(); +} + +static void GLAPIENTRY _save_VertexAttrib3fNV( GLuint index, GLfloat x, GLfloat y, + GLfloat z ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR3F( index, x, y, z ); + else + enum_error(); +} + +static void GLAPIENTRY _save_VertexAttrib3fvNV( GLuint index, const GLfloat *v ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR3FV( index, v ); + else + enum_error(); +} + +static void GLAPIENTRY _save_VertexAttrib4fNV( GLuint index, GLfloat x, GLfloat y, + GLfloat z, GLfloat w ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR4F( index, x, y, z, w ); + else + enum_error(); +} + +static void GLAPIENTRY _save_VertexAttrib4fvNV( GLuint index, const GLfloat *v ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR4FV( index, v ); + else + enum_error(); +} + + +/* Materials: + * + * These are treated as per-vertex attributes, at indices above where + * the NV_vertex_program leaves off. There are a lot of good things + * about treating materials this way. + * + * However: I don't want to double the number of generated functions + * just to cope with this, so I unroll the 'C' varients of CHOOSE and + * ATTRF into this function, and dispense with codegen and + * second-level dispatch. + * + * There is no aliasing of material attributes with other entrypoints. + */ +#define MAT_ATTR( A, N, params ) \ +do { \ + if (tnl->save.attrsz[A] < N) { \ + _save_upgrade_vertex( ctx, A, N ); \ + tnl->save.have_materials = GL_TRUE; \ + } \ + \ + { \ + GLfloat *dest = tnl->save.attrptr[A]; \ + if (N>0) dest[0] = params[0]; \ + if (N>1) dest[1] = params[1]; \ + if (N>2) dest[2] = params[2]; \ + if (N>3) dest[3] = params[3]; \ + } \ +} while (0) + + +#define MAT( ATTR, N, face, params ) \ +do { \ + if (face != GL_BACK) \ + MAT_ATTR( ATTR, N, params ); /* front */ \ + if (face != GL_FRONT) \ + MAT_ATTR( ATTR + 1, N, params ); /* back */ \ +} while (0) + + +/* NOTE: Have to remove/deal-with colormaterial crossovers, probably + * later on - in the meantime just store everything. + */ +static void GLAPIENTRY _save_Materialfv( GLenum face, GLenum pname, + const GLfloat *params ) +{ + GET_CURRENT_CONTEXT( ctx ); + TNLcontext *tnl = TNL_CONTEXT(ctx); + + switch (pname) { + case GL_EMISSION: + MAT( _TNL_ATTRIB_MAT_FRONT_EMISSION, 4, face, params ); + break; + case GL_AMBIENT: + MAT( _TNL_ATTRIB_MAT_FRONT_AMBIENT, 4, face, params ); + break; + case GL_DIFFUSE: + MAT( _TNL_ATTRIB_MAT_FRONT_DIFFUSE, 4, face, params ); + break; + case GL_SPECULAR: + MAT( _TNL_ATTRIB_MAT_FRONT_SPECULAR, 4, face, params ); + break; + case GL_SHININESS: + MAT( _TNL_ATTRIB_MAT_FRONT_SHININESS, 1, face, params ); + break; + case GL_COLOR_INDEXES: + MAT( _TNL_ATTRIB_MAT_FRONT_INDEXES, 3, face, params ); + break; + case GL_AMBIENT_AND_DIFFUSE: + MAT( _TNL_ATTRIB_MAT_FRONT_AMBIENT, 4, face, params ); + MAT( _TNL_ATTRIB_MAT_FRONT_DIFFUSE, 4, face, params ); + break; + default: + _mesa_compile_error( ctx, GL_INVALID_ENUM, "glMaterialfv" ); + return; + } +} + + +#define IDX_ATTR( A, IDX ) \ +do { \ + GET_CURRENT_CONTEXT( ctx ); \ + TNLcontext *tnl = TNL_CONTEXT(ctx); \ + \ + if (tnl->save.attrsz[A] < 1) { \ + _save_upgrade_vertex( ctx, A, 1 ); \ + } \ + \ + { \ + GLfloat *dest = tnl->save.attrptr[A]; \ + dest[0] = IDX; \ + } \ +} while (0) + + +static void GLAPIENTRY _save_EdgeFlag( GLboolean b ) +{ + IDX_ATTR( _TNL_ATTRIB_EDGEFLAG, (GLfloat)b ); +} + +static void GLAPIENTRY _save_EdgeFlagv( const GLboolean *v ) +{ + IDX_ATTR( _TNL_ATTRIB_EDGEFLAG, (GLfloat)(v[0]) ); +} + +static void GLAPIENTRY _save_Indexf( GLfloat f ) +{ + IDX_ATTR( _TNL_ATTRIB_INDEX, f ); +} + +static void GLAPIENTRY _save_Indexfv( const GLfloat *f ) +{ + IDX_ATTR( _TNL_ATTRIB_INDEX, f[0] ); +} + + + + +/* Cope with EvalCoord/CallList called within a begin/end object: + * -- Flush current buffer + * -- Fallback to opcodes for the rest of the begin/end object. + */ +#define FALLBACK(ctx) \ +do { \ + TNLcontext *tnl = TNL_CONTEXT(ctx); \ + \ + /*fprintf(stderr, "fallback %s inside begin/end\n", __FUNCTION__);*/ \ + \ + if (tnl->save.initial_counter != tnl->save.counter || \ + tnl->save.prim_count) \ + _save_compile_vertex_list( ctx ); \ + \ + _save_copy_to_current( ctx ); \ + _save_reset_vertex( ctx ); \ + _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt ); \ + ctx->Driver.SaveNeedFlush = 0; \ +} while (0) + +static void GLAPIENTRY _save_EvalCoord1f( GLfloat u ) +{ + GET_CURRENT_CONTEXT(ctx); + FALLBACK(ctx); + ctx->Save->EvalCoord1f( u ); +} + +static void GLAPIENTRY _save_EvalCoord1fv( const GLfloat *v ) +{ + GET_CURRENT_CONTEXT(ctx); + FALLBACK(ctx); + ctx->Save->EvalCoord1fv( v ); +} + +static void GLAPIENTRY _save_EvalCoord2f( GLfloat u, GLfloat v ) +{ + GET_CURRENT_CONTEXT(ctx); + FALLBACK(ctx); + ctx->Save->EvalCoord2f( u, v ); +} + +static void GLAPIENTRY _save_EvalCoord2fv( const GLfloat *v ) +{ + GET_CURRENT_CONTEXT(ctx); + FALLBACK(ctx); + ctx->Save->EvalCoord2fv( v ); +} + +static void GLAPIENTRY _save_EvalPoint1( GLint i ) +{ + GET_CURRENT_CONTEXT(ctx); + FALLBACK(ctx); + ctx->Save->EvalPoint1( i ); +} + +static void GLAPIENTRY _save_EvalPoint2( GLint i, GLint j ) +{ + GET_CURRENT_CONTEXT(ctx); + FALLBACK(ctx); + ctx->Save->EvalPoint2( i, j ); +} + +static void GLAPIENTRY _save_CallList( GLuint l ) +{ + GET_CURRENT_CONTEXT(ctx); + FALLBACK(ctx); + ctx->Save->CallList( l ); +} + +static void GLAPIENTRY _save_CallLists( GLsizei n, GLenum type, const GLvoid *v ) +{ + GET_CURRENT_CONTEXT(ctx); + FALLBACK(ctx); + ctx->Save->CallLists( n, type, v ); +} + + + + +/* This begin is hooked into ... Updating of + * ctx->Driver.CurrentSavePrimitive is already taken care of. + */ +static GLboolean _save_NotifyBegin( GLcontext *ctx, GLenum mode ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + + if (1) { + GLuint i = tnl->save.prim_count++; + + assert(i < tnl->save.prim_max); + tnl->save.prim[i].mode = mode | PRIM_BEGIN; + tnl->save.prim[i].start = tnl->save.initial_counter - tnl->save.counter; + tnl->save.prim[i].count = 0; + + _mesa_install_save_vtxfmt( ctx, &tnl->save_vtxfmt ); + ctx->Driver.SaveNeedFlush = 1; + return GL_TRUE; + } + else + return GL_FALSE; +} + + + +static void GLAPIENTRY _save_End( void ) +{ + GET_CURRENT_CONTEXT( ctx ); + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLint i = tnl->save.prim_count - 1; + + ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END; + tnl->save.prim[i].mode |= PRIM_END; + tnl->save.prim[i].count = ((tnl->save.initial_counter - tnl->save.counter) - + tnl->save.prim[i].start); + + if (i == (GLint) tnl->save.prim_max - 1) { + _save_compile_vertex_list( ctx ); + assert(tnl->save.copied.nr == 0); + } + + /* Swap out this vertex format while outside begin/end. Any color, + * etc. received between here and the next begin will be compiled + * as opcodes. + */ + _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt ); +} + + +/* These are all errors as this vtxfmt is only installed inside + * begin/end pairs. + */ +static void GLAPIENTRY _save_DrawElements(GLenum mode, GLsizei count, GLenum type, + const GLvoid *indices) +{ + GET_CURRENT_CONTEXT(ctx); + (void) mode; (void) count; (void) type; (void) indices; + _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawElements" ); +} + + +static void GLAPIENTRY _save_DrawRangeElements(GLenum mode, + GLuint start, GLuint end, + GLsizei count, GLenum type, + const GLvoid *indices) +{ + GET_CURRENT_CONTEXT(ctx); + (void) mode; (void) start; (void) end; (void) count; (void) type; (void) indices; + _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawRangeElements" ); +} + +static void GLAPIENTRY _save_DrawArrays(GLenum mode, GLint start, GLsizei count) +{ + GET_CURRENT_CONTEXT(ctx); + (void) mode; (void) start; (void) count; + _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawArrays" ); +} + +static void GLAPIENTRY _save_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 ) +{ + GET_CURRENT_CONTEXT(ctx); + (void) x1; (void) y1; (void) x2; (void) y2; + _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glRectf" ); +} + +static void GLAPIENTRY _save_EvalMesh1( GLenum mode, GLint i1, GLint i2 ) +{ + GET_CURRENT_CONTEXT(ctx); + (void) mode; (void) i1; (void) i2; + _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glEvalMesh1" ); +} + +static void GLAPIENTRY _save_EvalMesh2( GLenum mode, GLint i1, GLint i2, + GLint j1, GLint j2 ) +{ + GET_CURRENT_CONTEXT(ctx); + (void) mode; (void) i1; (void) i2; (void) j1; (void) j2; + _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glEvalMesh2" ); +} + +static void GLAPIENTRY _save_Begin( GLenum mode ) +{ + GET_CURRENT_CONTEXT( ctx ); + (void) mode; + _mesa_compile_error( ctx, GL_INVALID_OPERATION, "Recursive glBegin" ); +} + + +/* Unlike the functions above, these are to be hooked into the vtxfmt + * maintained in ctx->ListState, active when the list is known or + * suspected to be outside any begin/end primitive. + */ +static void GLAPIENTRY _save_OBE_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 ) +{ + GET_CURRENT_CONTEXT(ctx); + _save_NotifyBegin( ctx, GL_QUADS | PRIM_WEAK ); + GL_CALL(Vertex2f)( x1, y1 ); + GL_CALL(Vertex2f)( x2, y1 ); + GL_CALL(Vertex2f)( x2, y2 ); + GL_CALL(Vertex2f)( x1, y2 ); + GL_CALL(End)(); +} + + +static void GLAPIENTRY _save_OBE_DrawArrays(GLenum mode, GLint start, GLsizei count) +{ + GET_CURRENT_CONTEXT(ctx); + GLint i; + + if (!_mesa_validate_DrawArrays( ctx, mode, start, count )) + return; + + _save_NotifyBegin( ctx, mode | PRIM_WEAK ); + for (i = 0; i < count; i++) + GL_CALL(ArrayElement)(start + i); + GL_CALL(End)(); +} + + +static void GLAPIENTRY _save_OBE_DrawElements(GLenum mode, GLsizei count, GLenum type, + const GLvoid *indices) +{ + GET_CURRENT_CONTEXT(ctx); + GLint i; + + if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices )) + return; + + _save_NotifyBegin( ctx, mode | PRIM_WEAK ); + + switch (type) { + case GL_UNSIGNED_BYTE: + for (i = 0 ; i < count ; i++) + GL_CALL(ArrayElement)( ((GLubyte *)indices)[i] ); + break; + case GL_UNSIGNED_SHORT: + for (i = 0 ; i < count ; i++) + GL_CALL(ArrayElement)( ((GLushort *)indices)[i] ); + break; + case GL_UNSIGNED_INT: + for (i = 0 ; i < count ; i++) + GL_CALL(ArrayElement)( ((GLuint *)indices)[i] ); + break; + default: + _mesa_error( ctx, GL_INVALID_ENUM, "glDrawElements(type)" ); + break; + } + + GL_CALL(End)(); +} + +static void GLAPIENTRY _save_OBE_DrawRangeElements(GLenum mode, + GLuint start, GLuint end, + GLsizei count, GLenum type, + const GLvoid *indices) +{ + GET_CURRENT_CONTEXT(ctx); + if (_mesa_validate_DrawRangeElements( ctx, mode, + start, end, + count, type, indices )) + _save_OBE_DrawElements( mode, count, type, indices ); +} + + + + + +static void _save_vtxfmt_init( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLvertexformat *vfmt = &tnl->save_vtxfmt; + + vfmt->ArrayElement = _ae_loopback_array_elt; /* generic helper */ + vfmt->Begin = _save_Begin; + vfmt->Color3f = _save_Color3f; + vfmt->Color3fv = _save_Color3fv; + vfmt->Color4f = _save_Color4f; + vfmt->Color4fv = _save_Color4fv; + vfmt->EdgeFlag = _save_EdgeFlag; + vfmt->EdgeFlagv = _save_EdgeFlagv; + vfmt->End = _save_End; + vfmt->FogCoordfEXT = _save_FogCoordfEXT; + vfmt->FogCoordfvEXT = _save_FogCoordfvEXT; + vfmt->Indexf = _save_Indexf; + vfmt->Indexfv = _save_Indexfv; + vfmt->Materialfv = _save_Materialfv; + vfmt->MultiTexCoord1fARB = _save_MultiTexCoord1f; + vfmt->MultiTexCoord1fvARB = _save_MultiTexCoord1fv; + vfmt->MultiTexCoord2fARB = _save_MultiTexCoord2f; + vfmt->MultiTexCoord2fvARB = _save_MultiTexCoord2fv; + vfmt->MultiTexCoord3fARB = _save_MultiTexCoord3f; + vfmt->MultiTexCoord3fvARB = _save_MultiTexCoord3fv; + vfmt->MultiTexCoord4fARB = _save_MultiTexCoord4f; + vfmt->MultiTexCoord4fvARB = _save_MultiTexCoord4fv; + vfmt->Normal3f = _save_Normal3f; + vfmt->Normal3fv = _save_Normal3fv; + vfmt->SecondaryColor3fEXT = _save_SecondaryColor3fEXT; + vfmt->SecondaryColor3fvEXT = _save_SecondaryColor3fvEXT; + vfmt->TexCoord1f = _save_TexCoord1f; + vfmt->TexCoord1fv = _save_TexCoord1fv; + vfmt->TexCoord2f = _save_TexCoord2f; + vfmt->TexCoord2fv = _save_TexCoord2fv; + vfmt->TexCoord3f = _save_TexCoord3f; + vfmt->TexCoord3fv = _save_TexCoord3fv; + vfmt->TexCoord4f = _save_TexCoord4f; + vfmt->TexCoord4fv = _save_TexCoord4fv; + vfmt->Vertex2f = _save_Vertex2f; + vfmt->Vertex2fv = _save_Vertex2fv; + vfmt->Vertex3f = _save_Vertex3f; + vfmt->Vertex3fv = _save_Vertex3fv; + vfmt->Vertex4f = _save_Vertex4f; + vfmt->Vertex4fv = _save_Vertex4fv; + vfmt->VertexAttrib1fNV = _save_VertexAttrib1fNV; + vfmt->VertexAttrib1fvNV = _save_VertexAttrib1fvNV; + vfmt->VertexAttrib2fNV = _save_VertexAttrib2fNV; + vfmt->VertexAttrib2fvNV = _save_VertexAttrib2fvNV; + vfmt->VertexAttrib3fNV = _save_VertexAttrib3fNV; + vfmt->VertexAttrib3fvNV = _save_VertexAttrib3fvNV; + vfmt->VertexAttrib4fNV = _save_VertexAttrib4fNV; + vfmt->VertexAttrib4fvNV = _save_VertexAttrib4fvNV; + + /* This will all require us to fallback to saving the list as opcodes: + */ + vfmt->CallList = _save_CallList; /* inside begin/end */ + vfmt->CallLists = _save_CallLists; /* inside begin/end */ + vfmt->EvalCoord1f = _save_EvalCoord1f; + vfmt->EvalCoord1fv = _save_EvalCoord1fv; + vfmt->EvalCoord2f = _save_EvalCoord2f; + vfmt->EvalCoord2fv = _save_EvalCoord2fv; + vfmt->EvalPoint1 = _save_EvalPoint1; + vfmt->EvalPoint2 = _save_EvalPoint2; + + /* These are all errors as we at least know we are in some sort of + * begin/end pair: + */ + vfmt->EvalMesh1 = _save_EvalMesh1; + vfmt->EvalMesh2 = _save_EvalMesh2; + vfmt->Begin = _save_Begin; + vfmt->Rectf = _save_Rectf; + vfmt->DrawArrays = _save_DrawArrays; + vfmt->DrawElements = _save_DrawElements; + vfmt->DrawRangeElements = _save_DrawRangeElements; + +} + + +void _tnl_SaveFlushVertices( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + + /* Noop when we are actually active: + */ + if (ctx->Driver.CurrentSavePrimitive == PRIM_INSIDE_UNKNOWN_PRIM || + ctx->Driver.CurrentSavePrimitive <= GL_POLYGON) + return; + + if (tnl->save.initial_counter != tnl->save.counter || + tnl->save.prim_count) + _save_compile_vertex_list( ctx ); + + _save_copy_to_current( ctx ); + _save_reset_vertex( ctx ); + ctx->Driver.SaveNeedFlush = 0; +} + +void _tnl_NewList( GLcontext *ctx, GLuint list, GLenum mode ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + + (void) list; (void) mode; + + if (!tnl->save.prim_store) + tnl->save.prim_store = alloc_prim_store( ctx ); + + if (!tnl->save.vertex_store) { + tnl->save.vertex_store = alloc_vertex_store( ctx ); + tnl->save.vbptr = tnl->save.vertex_store->buffer; + } + + _save_reset_vertex( ctx ); + ctx->Driver.SaveNeedFlush = 0; +} + +void _tnl_EndList( GLcontext *ctx ) +{ + (void) ctx; + assert(TNL_CONTEXT(ctx)->save.vertex_size == 0); +} + +void _tnl_BeginCallList( GLcontext *ctx, GLuint list ) +{ + (void) ctx; (void) list; +} + +void _tnl_EndCallList( GLcontext *ctx ) +{ + (void) ctx; +} + + +static void _tnl_destroy_vertex_list( GLcontext *ctx, void *data ) +{ + struct tnl_vertex_list *node = (struct tnl_vertex_list *)data; + (void) ctx; + + if ( --node->vertex_store->refcount == 0 ) + FREE( node->vertex_store ); + + if ( --node->prim_store->refcount == 0 ) + FREE( node->prim_store ); + + if ( node->normal_lengths ) + FREE( node->normal_lengths ); +} + + +static void _tnl_print_vertex_list( GLcontext *ctx, void *data ) +{ + struct tnl_vertex_list *node = (struct tnl_vertex_list *)data; + GLuint i; + (void) ctx; + + _mesa_debug(0, "TNL-VERTEX-LIST, %u vertices %d primitives, %d vertsize\n", + node->count, + node->prim_count, + node->vertex_size); + + for (i = 0 ; i < node->prim_count ; i++) { + struct tnl_prim *prim = &node->prim[i]; + _mesa_debug(0, " prim %d: %s %d..%d %s %s\n", + i, + _mesa_lookup_enum_by_nr(prim->mode & PRIM_MODE_MASK), + prim->start, + prim->start + prim->count, + (prim->mode & PRIM_BEGIN) ? "BEGIN" : "(wrap)", + (prim->mode & PRIM_END) ? "END" : "(wrap)"); + } +} + + +static void _save_current_init( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLint i; + + for (i = 0; i < _TNL_ATTRIB_MAT_FRONT_AMBIENT; i++) { + ASSERT(i < VERT_ATTRIB_MAX); + tnl->save.currentsz[i] = &ctx->ListState.ActiveAttribSize[i]; + tnl->save.current[i] = ctx->ListState.CurrentAttrib[i]; + } + + for (i = _TNL_ATTRIB_MAT_FRONT_AMBIENT; i < _TNL_ATTRIB_INDEX; i++) { + const GLuint j = i - _TNL_ATTRIB_MAT_FRONT_AMBIENT; + ASSERT(j < MAT_ATTRIB_MAX); + tnl->save.currentsz[i] = &ctx->ListState.ActiveMaterialSize[j]; + tnl->save.current[i] = ctx->ListState.CurrentMaterial[j]; + } + + tnl->save.currentsz[_TNL_ATTRIB_INDEX] = &ctx->ListState.ActiveIndex; + tnl->save.current[_TNL_ATTRIB_INDEX] = &ctx->ListState.CurrentIndex; + + /* Current edgeflag is handled individually */ +} + +/** + * Initialize the display list compiler + */ +void _tnl_save_init( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct tnl_vertex_arrays *tmp = &tnl->save_inputs; + GLuint i; + + + for (i = 0; i < _TNL_ATTRIB_MAX; i++) + _mesa_vector4f_init( &tmp->Attribs[i], 0, 0); + + tnl->save.opcode_vertex_list = + _mesa_alloc_opcode( ctx, + sizeof(struct tnl_vertex_list), + _tnl_playback_vertex_list, + _tnl_destroy_vertex_list, + _tnl_print_vertex_list ); + + ctx->Driver.NotifySaveBegin = _save_NotifyBegin; + + _save_vtxfmt_init( ctx ); + _save_current_init( ctx ); + + /* Hook our array functions into the outside-begin-end vtxfmt in + * ctx->ListState. + */ + ctx->ListState.ListVtxfmt.Rectf = _save_OBE_Rectf; + ctx->ListState.ListVtxfmt.DrawArrays = _save_OBE_DrawArrays; + ctx->ListState.ListVtxfmt.DrawElements = _save_OBE_DrawElements; + ctx->ListState.ListVtxfmt.DrawRangeElements = _save_OBE_DrawRangeElements; + _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt ); +} + + +/** + * Deallocate the immediate-mode buffer for the given context, if + * its reference count goes to zero. + */ +void _tnl_save_destroy( GLcontext *ctx ) +{ + (void) ctx; +} diff --git a/src/mesa/tnl/t_save_api.h b/src/mesa/tnl/t_save_api.h new file mode 100644 index 0000000..eec2d68 --- /dev/null +++ b/src/mesa/tnl/t_save_api.h @@ -0,0 +1,58 @@ +/* $XFree86$ */ +/************************************************************************** + +Copyright 2002 Tungsten Graphics Inc., Cedar Park, Texas. + +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"), +to deal in the Software without restriction, including without limitation +on the rights to use, copy, modify, merge, publish, distribute, sub +license, and/or sell copies of the Software, and to permit persons to whom +the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL +TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +USE OR OTHER DEALINGS IN THE SOFTWARE. + +**************************************************************************/ + +/* + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + * + */ + +#ifndef __T_SAVE_API_H__ +#define __T_SAVE_API_H__ + +#include "t_context.h" + +extern GLboolean _tnl_weak_begin( GLcontext *ctx, GLenum mode ); + +extern void _tnl_EndList( GLcontext *ctx ); +extern void _tnl_NewList( GLcontext *ctx, GLuint list, GLenum mode ); + +extern void _tnl_EndCallList( GLcontext *ctx ); +extern void _tnl_BeginCallList( GLcontext *ctx, GLuint list ); + +extern void _tnl_SaveFlushVertices( GLcontext *ctx ); + +extern void _tnl_save_init( GLcontext *ctx ); +extern void _tnl_save_destroy( GLcontext *ctx ); + +extern void _tnl_loopback_vertex_list( GLcontext *ctx, + const struct tnl_vertex_list *list ); + +extern void _tnl_playback_vertex_list( GLcontext *ctx, void *data ); + +#endif diff --git a/src/mesa/tnl/t_save_loopback.c b/src/mesa/tnl/t_save_loopback.c new file mode 100644 index 0000000..2e752c8 --- /dev/null +++ b/src/mesa/tnl/t_save_loopback.c @@ -0,0 +1,307 @@ + +/* + * Mesa 3-D graphics library + * Version: 5.1 + * + * 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* Author: + * Keith Whitwell <keith@tungstengraphics.com> + */ + +#include "glheader.h" +#include "context.h" +#include "enums.h" +#include "glapi.h" +#include "imports.h" +#include "macros.h" +#include "mtypes.h" +#include "t_context.h" +#include "t_save_api.h" + +/* If someone compiles a display list like: + * glBegin(Triangles) + * glVertex() + * ... lots of vertices ... + * glEnd() + * + * or: + * glDrawArrays(...) + * + * and then tries to execute it like this: + * + * glBegin(Lines) + * glCallList() + * glEnd() + * + * it will wind up in here, as the vertex copying used when wrapping + * buffers in list compilation (Triangles) won't be right for how the + * list is being executed (as Lines). + * + * This could be avoided by not compiling as vertex_lists until after + * the first glEnd() has been seen. However, that would miss an + * important category of display lists, for the sake of a degenerate + * usage. + * + * Further, replaying degenerately-called lists in this fashion is + * probably still faster than the replay using opcodes. + */ + +typedef void (*attr_func)( GLcontext *ctx, GLint target, const GLfloat * ); + + +/* Wrapper functions in case glVertexAttrib*fvNV doesn't exist */ +static void VertexAttrib1fvNV(GLcontext *ctx, GLint target, const GLfloat *v) +{ + ctx->Exec->VertexAttrib1fvNV(target, v); +} + +static void VertexAttrib2fvNV(GLcontext *ctx, GLint target, const GLfloat *v) +{ + ctx->Exec->VertexAttrib2fvNV(target, v); +} + +static void VertexAttrib3fvNV(GLcontext *ctx, GLint target, const GLfloat *v) +{ + ctx->Exec->VertexAttrib3fvNV(target, v); +} + +static void VertexAttrib4fvNV(GLcontext *ctx, GLint target, const GLfloat *v) +{ + ctx->Exec->VertexAttrib4fvNV(target, v); +} + +static attr_func vert_attrfunc[4] = { + VertexAttrib1fvNV, + VertexAttrib2fvNV, + VertexAttrib3fvNV, + VertexAttrib4fvNV +}; + + +static void mat_attr1fv( GLcontext *ctx, GLint target, const GLfloat *v ) +{ + switch (target) { + case _TNL_ATTRIB_MAT_FRONT_SHININESS: + ctx->Exec->Materialfv( GL_FRONT, GL_SHININESS, v ); + break; + case _TNL_ATTRIB_MAT_BACK_SHININESS: + ctx->Exec->Materialfv( GL_BACK, GL_SHININESS, v ); + break; + } +} + + +static void mat_attr3fv( GLcontext *ctx, GLint target, const GLfloat *v ) +{ + switch (target) { + case _TNL_ATTRIB_MAT_FRONT_INDEXES: + ctx->Exec->Materialfv( GL_FRONT, GL_COLOR_INDEXES, v ); + break; + case _TNL_ATTRIB_MAT_BACK_INDEXES: + ctx->Exec->Materialfv( GL_BACK, GL_COLOR_INDEXES, v ); + break; + } +} + + +static void mat_attr4fv( GLcontext *ctx, GLint target, const GLfloat *v ) +{ + switch (target) { + case _TNL_ATTRIB_MAT_FRONT_EMISSION: + ctx->Exec->Materialfv( GL_FRONT, GL_EMISSION, v ); + break; + case _TNL_ATTRIB_MAT_BACK_EMISSION: + ctx->Exec->Materialfv( GL_BACK, GL_EMISSION, v ); + break; + case _TNL_ATTRIB_MAT_FRONT_AMBIENT: + ctx->Exec->Materialfv( GL_FRONT, GL_AMBIENT, v ); + break; + case _TNL_ATTRIB_MAT_BACK_AMBIENT: + ctx->Exec->Materialfv( GL_BACK, GL_AMBIENT, v ); + break; + case _TNL_ATTRIB_MAT_FRONT_DIFFUSE: + ctx->Exec->Materialfv( GL_FRONT, GL_DIFFUSE, v ); + break; + case _TNL_ATTRIB_MAT_BACK_DIFFUSE: + ctx->Exec->Materialfv( GL_BACK, GL_DIFFUSE, v ); + break; + case _TNL_ATTRIB_MAT_FRONT_SPECULAR: + ctx->Exec->Materialfv( GL_FRONT, GL_SPECULAR, v ); + break; + case _TNL_ATTRIB_MAT_BACK_SPECULAR: + ctx->Exec->Materialfv( GL_BACK, GL_SPECULAR, v ); + break; + } +} + + +static attr_func mat_attrfunc[4] = { + mat_attr1fv, + 0, + mat_attr3fv, + mat_attr4fv +}; + + +static void index_attr1fv(GLcontext *ctx, GLint target, const GLfloat *v) +{ + (void) target; + ctx->Exec->Indexf(v[0]); +} + +static void edgeflag_attr1fv(GLcontext *ctx, GLint target, const GLfloat *v) +{ + (void) target; + ctx->Exec->EdgeFlag((GLboolean)(v[0] == 1.0)); +} + +struct loopback_attr { + GLint target; + GLint sz; + attr_func func; +}; + +/* Don't emit ends and begins on wrapped primitives. Don't replay + * wrapped vertices. If we get here, it's probably because the the + * precalculated wrapping is wrong. + */ +static void loopback_prim( GLcontext *ctx, + const struct tnl_vertex_list *list, GLuint i, + const struct loopback_attr *la, GLuint nr ) +{ + struct tnl_prim *prim = &list->prim[i]; + GLint begin = prim->start; + GLint end = begin + prim->count; + GLfloat *data; + GLint j; + GLuint k; + + if (prim->mode & PRIM_BEGIN) { + GL_CALL(Begin)( prim->mode & PRIM_MODE_MASK ); + } + else { + assert(i == 0); + assert(begin == 0); + begin += list->wrap_count; + } + + data = list->buffer + begin * list->vertex_size; + + for (j = begin ; j < end ; j++) { + GLfloat *tmp = data + la[0].sz; + + for (k = 1 ; k < nr ; k++) { + la[k].func( ctx, la[k].target, tmp ); + tmp += la[k].sz; + } + + /* Fire the vertex + */ + la[0].func( ctx, VERT_ATTRIB_POS, data ); + data = tmp; + } + + if (prim->mode & PRIM_END) { + GL_CALL(End)(); + } + else { + assert (i == list->prim_count-1); + } +} + +/* Primitives generated by DrawArrays/DrawElements/Rectf may be + * caught here. If there is no primitive in progress, execute them + * normally, otherwise need to track and discard the generated + * primitives. + */ +static void loopback_weak_prim( GLcontext *ctx, + const struct tnl_vertex_list *list, GLuint i, + const struct loopback_attr *la, GLuint nr ) +{ + if (ctx->Driver.CurrentExecPrimitive == PRIM_OUTSIDE_BEGIN_END) + loopback_prim( ctx, list, i, la, nr ); + else { + struct tnl_prim *prim = &list->prim[i]; + + /* Use the prim_weak flag to ensure that if this primitive + * wraps, we don't mistake future vertex_lists for part of the + * surrounding primitive. + * + * While this flag is set, we are simply disposing of data + * generated by an operation now known to be a noop. + */ + if (prim->mode & PRIM_BEGIN) + ctx->Driver.CurrentExecPrimitive |= PRIM_WEAK; + if (prim->mode & PRIM_END) + ctx->Driver.CurrentExecPrimitive &= ~PRIM_WEAK; + } +} + + + +void _tnl_loopback_vertex_list( GLcontext *ctx, + const struct tnl_vertex_list *list ) +{ + struct loopback_attr la[_TNL_ATTRIB_MAX]; + GLuint i, nr = 0; + + for (i = 0 ; i <= _TNL_ATTRIB_TEX7 ; i++) { + if (list->attrsz[i]) { + la[nr].target = i; + la[nr].sz = list->attrsz[i]; + la[nr].func = vert_attrfunc[list->attrsz[i]-1]; + nr++; + } + } + + for (i = _TNL_ATTRIB_MAT_FRONT_AMBIENT ; + i <= _TNL_ATTRIB_MAT_BACK_INDEXES ; + i++) { + if (list->attrsz[i]) { + la[nr].target = i; + la[nr].sz = list->attrsz[i]; + la[nr].func = mat_attrfunc[list->attrsz[i]-1]; + nr++; + } + } + + if (list->attrsz[_TNL_ATTRIB_EDGEFLAG]) { + la[nr].target = _TNL_ATTRIB_EDGEFLAG; + la[nr].sz = list->attrsz[_TNL_ATTRIB_EDGEFLAG]; + la[nr].func = edgeflag_attr1fv; + nr++; + } + + if (list->attrsz[_TNL_ATTRIB_INDEX]) { + la[nr].target = _TNL_ATTRIB_INDEX; + la[nr].sz = list->attrsz[_TNL_ATTRIB_INDEX]; + la[nr].func = index_attr1fv; + nr++; + } + + for (i = 0 ; i < list->prim_count ; i++) { + if (list->prim[i].mode & PRIM_WEAK) + loopback_weak_prim( ctx, list, i, la, nr ); + else + loopback_prim( ctx, list, i, la, nr ); + } +} diff --git a/src/mesa/tnl/t_save_playback.c b/src/mesa/tnl/t_save_playback.c new file mode 100644 index 0000000..dc9ffa8 --- /dev/null +++ b/src/mesa/tnl/t_save_playback.c @@ -0,0 +1,224 @@ +/* + * Mesa 3-D graphics library + * Version: 6.1 + * + * Copyright (C) 1999-2004 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* Author: + * Keith Whitwell <keith@tungstengraphics.com> + */ + +#include "glheader.h" +#include "context.h" +#include "imports.h" +#include "mtypes.h" +#include "macros.h" +#include "light.h" +#include "state.h" +#include "t_pipeline.h" +#include "t_save_api.h" +#include "t_vtx_api.h" + +static INLINE GLint get_size( const GLfloat *f ) +{ + if (f[3] != 1.0) return 4; + if (f[2] != 0.0) return 3; + return 2; +} + + +/* Some nasty stuff still hanging on here. + * + * TODO - remove VB->ColorPtr, etc and just use the AttrPtr's. + */ +static void _tnl_bind_vertex_list( GLcontext *ctx, + const struct tnl_vertex_list *node ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + struct tnl_vertex_arrays *tmp = &tnl->save_inputs; + GLfloat *data = node->buffer; + GLuint attr, i; + + /* Setup constant data in the VB. + */ + VB->Count = node->count; + VB->Primitive = node->prim; + VB->PrimitiveCount = node->prim_count; + VB->Elts = NULL; + VB->NormalLengthPtr = node->normal_lengths; + + for (attr = 0; attr <= _TNL_ATTRIB_INDEX; attr++) { + if (node->attrsz[attr]) { + tmp->Attribs[attr].count = node->count; + tmp->Attribs[attr].data = (GLfloat (*)[4]) data; + tmp->Attribs[attr].start = data; + tmp->Attribs[attr].size = node->attrsz[attr]; + tmp->Attribs[attr].stride = node->vertex_size * sizeof(GLfloat); + VB->AttribPtr[attr] = &tmp->Attribs[attr]; + data += node->attrsz[attr]; + } + else { + tmp->Attribs[attr].count = node->count; + tmp->Attribs[attr].data = (GLfloat (*)[4]) tnl->vtx.current[attr]; + tmp->Attribs[attr].start = tnl->vtx.current[attr]; + tmp->Attribs[attr].size = get_size( tnl->vtx.current[attr] ); + tmp->Attribs[attr].stride = 0; + VB->AttribPtr[attr] = &tmp->Attribs[attr]; + } + } + + + /* Copy edgeflag to a contiguous array + */ + if (ctx->Polygon.FrontMode != GL_FILL || ctx->Polygon.BackMode != GL_FILL) { + if (node->attrsz[_TNL_ATTRIB_EDGEFLAG]) { + VB->EdgeFlag = _tnl_translate_edgeflag( ctx, data, + node->count, + node->vertex_size ); + data++; + } + else + VB->EdgeFlag = _tnl_import_current_edgeflag( ctx, node->count ); + } + + /* Legacy pointers -- remove one day. + */ + VB->ObjPtr = VB->AttribPtr[_TNL_ATTRIB_POS]; + VB->NormalPtr = VB->AttribPtr[_TNL_ATTRIB_NORMAL]; + VB->ColorPtr[0] = VB->AttribPtr[_TNL_ATTRIB_COLOR0]; + VB->ColorPtr[1] = 0; + VB->IndexPtr[0] = VB->AttribPtr[_TNL_ATTRIB_INDEX]; + VB->IndexPtr[1] = 0; + VB->SecondaryColorPtr[0] = VB->AttribPtr[_TNL_ATTRIB_COLOR1]; + VB->SecondaryColorPtr[1] = 0; + VB->FogCoordPtr = VB->AttribPtr[_TNL_ATTRIB_FOG]; + + for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) { + VB->TexCoordPtr[i] = VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]; + } +} + +static void _playback_copy_to_current( GLcontext *ctx, + const struct tnl_vertex_list *node ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + const GLfloat *data; + GLuint i; + + if (node->count) + data = node->buffer + (node->count-1) * node->vertex_size; + else + data = node->buffer; + + for (i = _TNL_ATTRIB_POS+1 ; i <= _TNL_ATTRIB_INDEX ; i++) { + if (node->attrsz[i]) { + ASSIGN_4V(tnl->vtx.current[i], 0, 0, 0, 1); + COPY_SZ_4V(tnl->vtx.current[i], node->attrsz[i], data); + data += node->attrsz[i]; + } + } + + /* Edgeflag requires special treatment: + */ + if (node->attrsz[_TNL_ATTRIB_EDGEFLAG]) { + ctx->Current.EdgeFlag = (data[0] == 1.0); + } + + /* Colormaterial -- this kindof sucks. + */ + if (ctx->Light.ColorMaterialEnabled) { + _mesa_update_color_material(ctx, ctx->Current.Attrib[VERT_ATTRIB_COLOR0]); + } + + if (node->have_materials) { + tnl->Driver.NotifyMaterialChange( ctx ); + } + + /* CurrentExecPrimitive + */ + if (node->prim_count) { + GLenum mode = node->prim[node->prim_count - 1].mode; + if (mode & PRIM_END) + ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END; + else + ctx->Driver.CurrentExecPrimitive = (mode & PRIM_MODE_MASK); + } +} + + +/** + * Execute the buffer and save copied verts. + */ +void _tnl_playback_vertex_list( GLcontext *ctx, void *data ) +{ + const struct tnl_vertex_list *node = (const struct tnl_vertex_list *) data; + TNLcontext *tnl = TNL_CONTEXT(ctx); + + FLUSH_CURRENT(ctx, 0); + + if (node->prim_count > 0 && node->count > 0) { + + if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END && + (node->prim[0].mode & PRIM_BEGIN)) { + + /* Degenerate case: list is called inside begin/end pair and + * includes operations such as glBegin or glDrawArrays. + */ + _mesa_error( ctx, GL_INVALID_OPERATION, "displaylist recursive begin"); + _tnl_loopback_vertex_list( ctx, node ); + return; + } + else if (tnl->LoopbackDListCassettes || + node->dangling_attr_ref) { + /* Degenerate case: list references current data and would + * require fixup. Take the easier option & loop it back. + */ + _tnl_loopback_vertex_list( ctx, node ); + return; + } + + if (ctx->NewState) + _mesa_update_state( ctx ); + + if ((ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) || + (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glBegin (invalid vertex/fragment program)"); + return; + } + + if (tnl->pipeline.build_state_changes) + _tnl_validate_pipeline( ctx ); + + _tnl_bind_vertex_list( ctx, node ); + + /* Invalidate all stored data before and after run: + */ + tnl->pipeline.run_input_changes |= tnl->pipeline.inputs; + tnl->Driver.RunPipeline( ctx ); + tnl->pipeline.run_input_changes |= tnl->pipeline.inputs; + } + + /* Copy to current? + */ + _playback_copy_to_current( ctx, node ); +} diff --git a/src/mesa/tnl/t_vb_cliptmp.h b/src/mesa/tnl/t_vb_cliptmp.h new file mode 100644 index 0000000..1e3a6b0 --- /dev/null +++ b/src/mesa/tnl/t_vb_cliptmp.h @@ -0,0 +1,270 @@ + +/* + * Mesa 3-D graphics library + * Version: 3.5 + * + * Copyright (C) 1999-2001 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + + +#define CLIP_DOTPROD(K, A, B, C, D) X(K)*A + Y(K)*B + Z(K)*C + W(K)*D + +#define POLY_CLIP( PLANE, A, B, C, D ) \ +do { \ + if (mask & PLANE) { \ + GLuint idxPrev = inlist[0]; \ + GLfloat dpPrev = CLIP_DOTPROD(idxPrev, A, B, C, D ); \ + GLuint outcount = 0; \ + GLuint i; \ + \ + inlist[n] = inlist[0]; /* prevent rotation of vertices */ \ + for (i = 1; i <= n; i++) { \ + GLuint idx = inlist[i]; \ + GLfloat dp = CLIP_DOTPROD(idx, A, B, C, D ); \ + \ + clipmask[idxPrev] |= PLANE; \ + if (!IS_NEGATIVE(dpPrev)) { \ + outlist[outcount++] = idxPrev; \ + clipmask[idxPrev] &= ~PLANE; \ + } \ + \ + if (DIFFERENT_SIGNS(dp, dpPrev)) { \ + GLuint newvert = VB->LastClipped++; \ + VB->ClipMask[newvert] = 0; \ + outlist[outcount++] = newvert; \ + if (IS_NEGATIVE(dp)) { \ + /* Going out of bounds. Avoid division by zero as we \ + * know dp != dpPrev from DIFFERENT_SIGNS, above. \ + */ \ + GLfloat t = dp / (dp - dpPrev); \ + INTERP_4F( t, coord[newvert], coord[idx], coord[idxPrev]); \ + interp( ctx, t, newvert, idx, idxPrev, GL_TRUE ); \ + } else { \ + /* Coming back in. \ + */ \ + GLfloat t = dpPrev / (dpPrev - dp); \ + INTERP_4F( t, coord[newvert], coord[idxPrev], coord[idx]); \ + interp( ctx, t, newvert, idxPrev, idx, GL_FALSE ); \ + } \ + } \ + \ + idxPrev = idx; \ + dpPrev = dp; \ + } \ + \ + if (outcount < 3) \ + return; \ + \ + { \ + GLuint *tmp = inlist; \ + inlist = outlist; \ + outlist = tmp; \ + n = outcount; \ + } \ + } \ +} while (0) + + +#define LINE_CLIP(PLANE, A, B, C, D ) \ +do { \ + if (mask & PLANE) { \ + GLfloat dpI = CLIP_DOTPROD( ii, A, B, C, D ); \ + GLfloat dpJ = CLIP_DOTPROD( jj, A, B, C, D ); \ + \ + if (DIFFERENT_SIGNS(dpI, dpJ)) { \ + GLuint newvert = VB->LastClipped++; \ + VB->ClipMask[newvert] = 0; \ + if (IS_NEGATIVE(dpJ)) { \ + GLfloat t = dpI / (dpI - dpJ); \ + VB->ClipMask[jj] |= PLANE; \ + INTERP_4F( t, coord[newvert], coord[ii], coord[jj] ); \ + interp( ctx, t, newvert, ii, jj, GL_FALSE ); \ + jj = newvert; \ + } else { \ + GLfloat t = dpJ / (dpJ - dpI); \ + VB->ClipMask[ii] |= PLANE; \ + INTERP_4F( t, coord[newvert], coord[jj], coord[ii] ); \ + interp( ctx, t, newvert, jj, ii, GL_FALSE ); \ + ii = newvert; \ + } \ + } \ + else if (IS_NEGATIVE(dpI)) \ + return; \ + } \ +} while (0) + + + +/* Clip a line against the viewport and user clip planes. + */ +static INLINE void +TAG(clip_line)( GLcontext *ctx, GLuint i, GLuint j, GLubyte mask ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + tnl_interp_func interp = tnl->Driver.Render.Interp; + GLfloat (*coord)[4] = VB->ClipPtr->data; + GLuint ii = i, jj = j, p; + + VB->LastClipped = VB->Count; + + if (mask & 0x3f) { + LINE_CLIP( CLIP_RIGHT_BIT, -1, 0, 0, 1 ); + LINE_CLIP( CLIP_LEFT_BIT, 1, 0, 0, 1 ); + LINE_CLIP( CLIP_TOP_BIT, 0, -1, 0, 1 ); + LINE_CLIP( CLIP_BOTTOM_BIT, 0, 1, 0, 1 ); + LINE_CLIP( CLIP_FAR_BIT, 0, 0, -1, 1 ); + LINE_CLIP( CLIP_NEAR_BIT, 0, 0, 1, 1 ); + } + + if (mask & CLIP_USER_BIT) { + for (p=0;p<MAX_CLIP_PLANES;p++) { + if (ctx->Transform.ClipPlanesEnabled & (1 << p)) { + const GLfloat a = ctx->Transform._ClipUserPlane[p][0]; + const GLfloat b = ctx->Transform._ClipUserPlane[p][1]; + const GLfloat c = ctx->Transform._ClipUserPlane[p][2]; + const GLfloat d = ctx->Transform._ClipUserPlane[p][3]; + LINE_CLIP( CLIP_USER_BIT, a, b, c, d ); + } + } + } + + if ((ctx->_TriangleCaps & DD_FLATSHADE) && j != jj) + tnl->Driver.Render.CopyPV( ctx, jj, j ); + + tnl->Driver.Render.ClippedLine( ctx, ii, jj ); +} + + +/* Clip a triangle against the viewport and user clip planes. + */ +static INLINE void +TAG(clip_tri)( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLubyte mask ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + tnl_interp_func interp = tnl->Driver.Render.Interp; + GLfloat (*coord)[4] = VB->ClipPtr->data; + GLuint pv = v2; + GLuint vlist[2][MAX_CLIPPED_VERTICES]; + GLuint *inlist = vlist[0], *outlist = vlist[1]; + GLuint p; + GLubyte *clipmask = VB->ClipMask; + GLuint n = 3; + + ASSIGN_3V(inlist, v2, v0, v1 ); /* pv rotated to slot zero */ + + VB->LastClipped = VB->Count; + + if (mask & 0x3f) { + POLY_CLIP( CLIP_RIGHT_BIT, -1, 0, 0, 1 ); + POLY_CLIP( CLIP_LEFT_BIT, 1, 0, 0, 1 ); + POLY_CLIP( CLIP_TOP_BIT, 0, -1, 0, 1 ); + POLY_CLIP( CLIP_BOTTOM_BIT, 0, 1, 0, 1 ); + POLY_CLIP( CLIP_FAR_BIT, 0, 0, -1, 1 ); + POLY_CLIP( CLIP_NEAR_BIT, 0, 0, 1, 1 ); + } + + if (mask & CLIP_USER_BIT) { + for (p=0;p<MAX_CLIP_PLANES;p++) { + if (ctx->Transform.ClipPlanesEnabled & (1 << p)) { + const GLfloat a = ctx->Transform._ClipUserPlane[p][0]; + const GLfloat b = ctx->Transform._ClipUserPlane[p][1]; + const GLfloat c = ctx->Transform._ClipUserPlane[p][2]; + const GLfloat d = ctx->Transform._ClipUserPlane[p][3]; + POLY_CLIP( CLIP_USER_BIT, a, b, c, d ); + } + } + } + + if (ctx->_TriangleCaps & DD_FLATSHADE) { + if (pv != inlist[0]) { + ASSERT( inlist[0] >= VB->Count ); + tnl->Driver.Render.CopyPV( ctx, inlist[0], pv ); + } + } + + tnl->Driver.Render.ClippedPolygon( ctx, inlist, n ); +} + + +/* Clip a quad against the viewport and user clip planes. + */ +static INLINE void +TAG(clip_quad)( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint v3, + GLubyte mask ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + tnl_interp_func interp = tnl->Driver.Render.Interp; + GLfloat (*coord)[4] = VB->ClipPtr->data; + GLuint pv = v3; + GLuint vlist[2][MAX_CLIPPED_VERTICES]; + GLuint *inlist = vlist[0], *outlist = vlist[1]; + GLuint p; + GLubyte *clipmask = VB->ClipMask; + GLuint n = 4; + + ASSIGN_4V(inlist, v3, v0, v1, v2 ); /* pv rotated to slot zero */ + + VB->LastClipped = VB->Count; + + if (mask & 0x3f) { + POLY_CLIP( CLIP_RIGHT_BIT, -1, 0, 0, 1 ); + POLY_CLIP( CLIP_LEFT_BIT, 1, 0, 0, 1 ); + POLY_CLIP( CLIP_TOP_BIT, 0, -1, 0, 1 ); + POLY_CLIP( CLIP_BOTTOM_BIT, 0, 1, 0, 1 ); + POLY_CLIP( CLIP_FAR_BIT, 0, 0, -1, 1 ); + POLY_CLIP( CLIP_NEAR_BIT, 0, 0, 1, 1 ); + } + + if (mask & CLIP_USER_BIT) { + for (p=0;p<MAX_CLIP_PLANES;p++) { + if (ctx->Transform.ClipPlanesEnabled & (1 << p)) { + const GLfloat a = ctx->Transform._ClipUserPlane[p][0]; + const GLfloat b = ctx->Transform._ClipUserPlane[p][1]; + const GLfloat c = ctx->Transform._ClipUserPlane[p][2]; + const GLfloat d = ctx->Transform._ClipUserPlane[p][3]; + POLY_CLIP( CLIP_USER_BIT, a, b, c, d ); + } + } + } + + if (ctx->_TriangleCaps & DD_FLATSHADE) { + if (pv != inlist[0]) { + ASSERT( inlist[0] >= VB->Count ); + tnl->Driver.Render.CopyPV( ctx, inlist[0], pv ); + } + } + + tnl->Driver.Render.ClippedPolygon( ctx, inlist, n ); +} + +#undef W +#undef Z +#undef Y +#undef X +#undef SIZE +#undef TAG +#undef POLY_CLIP +#undef LINE_CLIP diff --git a/src/mesa/tnl/t_vb_cull.c b/src/mesa/tnl/t_vb_cull.c new file mode 100644 index 0000000..9527ead --- /dev/null +++ b/src/mesa/tnl/t_vb_cull.c @@ -0,0 +1,111 @@ +/* + * Mesa 3-D graphics library + * Version: 6.1 + * + * Copyright (C) 1999-2004 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + + +#include "glheader.h" +#include "colormac.h" +#include "context.h" +#include "macros.h" +#include "imports.h" +#include "mtypes.h" + +#include "math/m_xform.h" + +#include "t_context.h" +#include "t_pipeline.h" + + + +/* EXT_vertex_cull. Not really a big win, but probably depends on + * your application. This stage not included in the default pipeline. + */ +static GLboolean run_cull_stage( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + + const GLfloat a = ctx->Transform.CullObjPos[0]; + const GLfloat b = ctx->Transform.CullObjPos[1]; + const GLfloat c = ctx->Transform.CullObjPos[2]; + GLfloat *norm = (GLfloat *)VB->NormalPtr->data; + GLuint stride = VB->NormalPtr->stride; + GLuint count = VB->Count; + GLuint i; + + VB->ClipOrMask &= ~CLIP_CULL_BIT; + VB->ClipAndMask |= CLIP_CULL_BIT; + + for (i = 0 ; i < count ; i++) { + GLfloat dp = (norm[0] * a + + norm[1] * b + + norm[2] * c); + + if (dp < 0) { + VB->ClipMask[i] |= CLIP_CULL_BIT; + VB->ClipOrMask |= CLIP_CULL_BIT; + } + else { + VB->ClipMask[i] &= ~CLIP_CULL_BIT; + VB->ClipAndMask &= ~CLIP_CULL_BIT; + } + + STRIDE_F(norm, stride); + } + + return !(VB->ClipAndMask & CLIP_CULL_BIT); +} + + +static void check_cull( GLcontext *ctx, struct tnl_pipeline_stage *stage ) +{ + stage->active = (!ctx->VertexProgram._Enabled && + ctx->Transform.CullVertexFlag); +} + + +static void dtr( struct tnl_pipeline_stage *stage ) +{ +} + + +const struct tnl_pipeline_stage _tnl_vertex_cull_stage = +{ + "EXT_cull_vertex", + _NEW_PROGRAM | + _NEW_TRANSFORM, + _NEW_TRANSFORM, + GL_TRUE, /* active */ + _TNL_BIT_NORMAL | + _TNL_BIT_POS, /* inputs */ + _TNL_BIT_POS, /* outputs */ + 0, /* changed_inputs */ + NULL, /* private data */ + dtr, /* destructor */ + check_cull, /* check */ + run_cull_stage /* run -- initially set to init */ +}; diff --git a/src/mesa/tnl/t_vb_fog.c b/src/mesa/tnl/t_vb_fog.c new file mode 100644 index 0000000..13a2cbb --- /dev/null +++ b/src/mesa/tnl/t_vb_fog.c @@ -0,0 +1,278 @@ +/* + * Mesa 3-D graphics library + * Version: 6.1 + * + * Copyright (C) 1999-2004 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + + +#include "glheader.h" +#include "colormac.h" +#include "context.h" +#include "macros.h" +#include "imports.h" +#include "mtypes.h" + +#include "math/m_xform.h" + +#include "t_context.h" +#include "t_pipeline.h" + + +struct fog_stage_data { + GLvector4f fogcoord; /* has actual storage allocated */ + GLvector4f input; /* points into VB->EyePtr Z values */ +}; + +#define FOG_STAGE_DATA(stage) ((struct fog_stage_data *)stage->privatePtr) + +#define FOG_EXP_TABLE_SIZE 256 +#define FOG_MAX (10.0) +#define EXP_FOG_MAX .0006595 +#define FOG_INCR (FOG_MAX/FOG_EXP_TABLE_SIZE) +static GLfloat exp_table[FOG_EXP_TABLE_SIZE]; +static GLfloat inited = 0; + +#if 1 +#define NEG_EXP( result, narg ) \ +do { \ + GLfloat f = (GLfloat) (narg * (1.0/FOG_INCR)); \ + GLint k = (GLint) f; \ + if (k > FOG_EXP_TABLE_SIZE-2) \ + result = (GLfloat) EXP_FOG_MAX; \ + else \ + result = exp_table[k] + (f-k)*(exp_table[k+1]-exp_table[k]); \ +} while (0) +#else +#define NEG_EXP( result, narg ) \ +do { \ + result = exp(-narg); \ +} while (0) +#endif + + +/** + * Initialize the exp_table[] lookup table for approximating exp(). + */ +static void +init_static_data( void ) +{ + GLfloat f = 0.0F; + GLint i = 0; + for ( ; i < FOG_EXP_TABLE_SIZE ; i++, f += FOG_INCR) { + exp_table[i] = (GLfloat) exp(-f); + } + inited = 1; +} + + +/** + * Compute per-vertex fog blend factors from fog coordinates by + * evaluating the GL_LINEAR, GL_EXP or GL_EXP2 fog function. + * Fog coordinates are distances from the eye (typically between the + * near and far clip plane distances). + * Note the fog (eye Z) coords may be negative so we use ABS(z) below. + * Fog blend factors are in the range [0,1]. + */ +static void +compute_fog_blend_factors(GLcontext *ctx, GLvector4f *out, const GLvector4f *in) +{ + GLfloat end = ctx->Fog.End; + GLfloat *v = in->start; + GLuint stride = in->stride; + GLuint n = in->count; + GLfloat (*data)[4] = out->data; + GLfloat d; + GLuint i; + + out->count = in->count; + + switch (ctx->Fog.Mode) { + case GL_LINEAR: + if (ctx->Fog.Start == ctx->Fog.End) + d = 1.0F; + else + d = 1.0F / (ctx->Fog.End - ctx->Fog.Start); + for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) { + const GLfloat z = FABSF(*v); + GLfloat f = (end - z) * d; + data[i][0] = CLAMP(f, 0.0F, 1.0F); + } + break; + case GL_EXP: + d = ctx->Fog.Density; + for ( i = 0 ; i < n ; i++, STRIDE_F(v,stride)) { + const GLfloat z = FABSF(*v); + NEG_EXP( data[i][0], d * z ); + } + break; + case GL_EXP2: + d = ctx->Fog.Density*ctx->Fog.Density; + for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) { + const GLfloat z = FABSF(*v); + NEG_EXP( data[i][0], d * z * z ); + } + break; + default: + _mesa_problem(ctx, "Bad fog mode in make_fog_coord"); + return; + } +} + + +static GLboolean +run_fog_stage(GLcontext *ctx, struct tnl_pipeline_stage *stage) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + struct fog_stage_data *store = FOG_STAGE_DATA(stage); + GLvector4f *input; + + if (stage->changed_inputs == 0) + return GL_TRUE; + + if (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT) { + /* Fog is computed from vertex or fragment Z values */ + /* source = VB->ObjPtr or VB->EyePtr coords */ + /* dest = VB->FogCoordPtr = fog stage private storage */ + VB->FogCoordPtr = &store->fogcoord; + + if (!ctx->_NeedEyeCoords) { + /* compute fog coords from object coords */ + const GLfloat *m = ctx->ModelviewMatrixStack.Top->m; + GLfloat plane[4]; + + /* Use this to store calculated eye z values: + */ + input = &store->fogcoord; + + /* NOTE: negate plane here so we get positive fog coords! */ + plane[0] = -m[2]; + plane[1] = -m[6]; + plane[2] = -m[10]; + plane[3] = -m[14]; + /* Full eye coords weren't required, just calculate the + * eye Z values. + */ + _mesa_dotprod_tab[VB->ObjPtr->size]( (GLfloat *) input->data, + 4 * sizeof(GLfloat), + VB->ObjPtr, plane ); + + input->count = VB->ObjPtr->count; + } + else { + /* fog coordinates = eye Z coordinates (use ABS later) */ + input = &store->input; + + if (VB->EyePtr->size < 2) + _mesa_vector4f_clean_elem( VB->EyePtr, VB->Count, 2 ); + + input->data = (GLfloat (*)[4]) &(VB->EyePtr->data[0][2]); + input->start = VB->EyePtr->start+2; + input->stride = VB->EyePtr->stride; + input->count = VB->EyePtr->count; + } + } + else { + /* use glFogCoord() coordinates */ + input = VB->FogCoordPtr; /* source data */ + VB->FogCoordPtr = &store->fogcoord; /* dest data */ + } + + if (tnl->_DoVertexFog) { + /* compute blend factors from fog coordinates */ + compute_fog_blend_factors( ctx, VB->FogCoordPtr, input ); + } + else { + /* results = incoming fog coords (compute fog per-fragment later) */ + VB->FogCoordPtr = input; + } + + VB->AttribPtr[_TNL_ATTRIB_FOG] = VB->FogCoordPtr; + return GL_TRUE; +} + + +static void +check_fog_stage(GLcontext *ctx, struct tnl_pipeline_stage *stage) +{ + stage->active = ctx->Fog.Enabled && !ctx->VertexProgram._Enabled; + + if (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT) + stage->inputs = _TNL_BIT_POS; + else + stage->inputs = _TNL_BIT_FOG; +} + + +/* Called the first time stage->run() is invoked. + */ +static GLboolean +alloc_fog_data(GLcontext *ctx, struct tnl_pipeline_stage *stage) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct fog_stage_data *store; + stage->privatePtr = MALLOC(sizeof(*store)); + store = FOG_STAGE_DATA(stage); + if (!store) + return GL_FALSE; + + _mesa_vector4f_alloc( &store->fogcoord, 0, tnl->vb.Size, 32 ); + _mesa_vector4f_init( &store->input, 0, 0 ); + + if (!inited) + init_static_data(); + + /* Now run the stage. + */ + stage->run = run_fog_stage; + return stage->run( ctx, stage ); +} + + +static void +free_fog_data(struct tnl_pipeline_stage *stage) +{ + struct fog_stage_data *store = FOG_STAGE_DATA(stage); + if (store) { + _mesa_vector4f_free( &store->fogcoord ); + FREE( store ); + stage->privatePtr = NULL; + } +} + + +const struct tnl_pipeline_stage _tnl_fog_coordinate_stage = +{ + "build fog coordinates", /* name */ + _NEW_FOG|_NEW_PROGRAM, /* check_state */ + _NEW_FOG, /* run_state */ + GL_FALSE, /* active? */ + 0, /* inputs */ + _TNL_BIT_FOG, /* outputs */ + 0, /* changed_inputs */ + NULL, /* private_data */ + free_fog_data, /* dtr */ + check_fog_stage, /* check */ + alloc_fog_data /* run -- initially set to init. */ +}; diff --git a/src/mesa/tnl/t_vb_light.c b/src/mesa/tnl/t_vb_light.c new file mode 100644 index 0000000..1a89bf3 --- /dev/null +++ b/src/mesa/tnl/t_vb_light.c @@ -0,0 +1,368 @@ +/* + * Mesa 3-D graphics library + * Version: 6.2.2 + * + * Copyright (C) 1999-2005 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + + +#include "glheader.h" +#include "colormac.h" +#include "light.h" +#include "macros.h" +#include "imports.h" +#include "simple_list.h" +#include "mtypes.h" + +#include "math/m_translate.h" + +#include "t_context.h" +#include "t_pipeline.h" + +#define LIGHT_TWOSIDE 0x1 +#define LIGHT_MATERIAL 0x2 +#define MAX_LIGHT_FUNC 0x4 + +typedef void (*light_func)( GLcontext *ctx, + struct vertex_buffer *VB, + struct tnl_pipeline_stage *stage, + GLvector4f *input ); + +struct material_cursor { + const GLfloat *ptr; + GLuint stride; + GLfloat *current; + GLuint size; /* 1, 2, 3 or 4 */ +}; + +struct light_stage_data { + GLvector4f Input; + GLvector4f LitColor[2]; + GLvector4f LitSecondary[2]; + GLvector4f LitIndex[2]; + light_func *light_func_tab; + + struct material_cursor mat[MAT_ATTRIB_MAX]; + GLuint mat_count; + GLuint mat_bitmask; +}; + + +#define LIGHT_STAGE_DATA(stage) ((struct light_stage_data *)(stage->privatePtr)) + + + +/* In the case of colormaterial, the effected material attributes + * should already have been bound to point to the incoming color data, + * prior to running the pipeline. + */ +static void update_materials( GLcontext *ctx, + struct light_stage_data *store ) +{ + GLuint i; + + for (i = 0 ; i < store->mat_count ; i++) { + COPY_CLEAN_4V(store->mat[i].current, store->mat[i].size, store->mat[i].ptr); + STRIDE_F(store->mat[i].ptr, store->mat[i].stride); + } + + _mesa_update_material( ctx, store->mat_bitmask ); + _mesa_validate_all_lighting_tables( ctx ); +} + +static GLuint prepare_materials( GLcontext *ctx, + struct vertex_buffer *VB, + struct light_stage_data *store ) +{ + GLuint i; + + store->mat_count = 0; + store->mat_bitmask = 0; + + /* If ColorMaterial enabled, overwrite affected AttrPtr's with + * the color pointer. This could be done earlier. + */ + if (ctx->Light.ColorMaterialEnabled) { + GLuint bitmask = ctx->Light.ColorMaterialBitmask; + for (i = 0 ; i < MAT_ATTRIB_MAX ; i++) + if (bitmask & (1<<i)) + VB->AttribPtr[_TNL_ATTRIB_MAT_FRONT_AMBIENT + i] = VB->ColorPtr[0]; + } + + for (i = _TNL_ATTRIB_MAT_FRONT_AMBIENT ; i < _TNL_ATTRIB_INDEX ; i++) { + if (VB->AttribPtr[i]->stride) { + GLuint j = store->mat_count++; + GLuint attr = i - _TNL_ATTRIB_MAT_FRONT_AMBIENT; + store->mat[j].ptr = VB->AttribPtr[i]->start; + store->mat[j].stride = VB->AttribPtr[i]->stride; + store->mat[j].size = VB->AttribPtr[i]->size; + store->mat[j].current = ctx->Light.Material.Attrib[attr]; + store->mat_bitmask |= (1<<attr); + } + } + + + /* FIXME: Is this already done? + */ + _mesa_update_material( ctx, ~0 ); + _mesa_validate_all_lighting_tables( ctx ); + + return store->mat_count; +} + +/* Tables for all the shading functions. + */ +static light_func _tnl_light_tab[MAX_LIGHT_FUNC]; +static light_func _tnl_light_fast_tab[MAX_LIGHT_FUNC]; +static light_func _tnl_light_fast_single_tab[MAX_LIGHT_FUNC]; +static light_func _tnl_light_spec_tab[MAX_LIGHT_FUNC]; +static light_func _tnl_light_ci_tab[MAX_LIGHT_FUNC]; + +#define TAG(x) x +#define IDX (0) +#include "t_vb_lighttmp.h" + +#define TAG(x) x##_twoside +#define IDX (LIGHT_TWOSIDE) +#include "t_vb_lighttmp.h" + +#define TAG(x) x##_material +#define IDX (LIGHT_MATERIAL) +#include "t_vb_lighttmp.h" + +#define TAG(x) x##_twoside_material +#define IDX (LIGHT_TWOSIDE|LIGHT_MATERIAL) +#include "t_vb_lighttmp.h" + + +static void init_lighting( void ) +{ + static int done; + + if (!done) { + init_light_tab(); + init_light_tab_twoside(); + init_light_tab_material(); + init_light_tab_twoside_material(); + done = 1; + } +} + + +static GLboolean run_lighting( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + struct light_stage_data *store = LIGHT_STAGE_DATA(stage); + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + GLvector4f *input = ctx->_NeedEyeCoords ? VB->EyePtr : VB->ObjPtr; + GLuint idx; + + /* Make sure we can talk about position x,y and z: + */ + if (stage->changed_inputs & _TNL_BIT_POS) { + if (input->size <= 2 && input == VB->ObjPtr) { + + _math_trans_4f( store->Input.data, + VB->ObjPtr->data, + VB->ObjPtr->stride, + GL_FLOAT, + VB->ObjPtr->size, + 0, + VB->Count ); + + if (input->size <= 2) { + /* Clean z. + */ + _mesa_vector4f_clean_elem(&store->Input, VB->Count, 2); + } + + if (input->size <= 1) { + /* Clean y. + */ + _mesa_vector4f_clean_elem(&store->Input, VB->Count, 1); + } + + input = &store->Input; + } + } + + idx = 0; + + if (prepare_materials( ctx, VB, store )) + idx |= LIGHT_MATERIAL; + + if (ctx->Light.Model.TwoSide) + idx |= LIGHT_TWOSIDE; + + /* The individual functions know about replaying side-effects + * vs. full re-execution. + */ + store->light_func_tab[idx]( ctx, VB, stage, input ); + + VB->AttribPtr[_TNL_ATTRIB_COLOR0] = VB->ColorPtr[0]; + VB->AttribPtr[_TNL_ATTRIB_COLOR1] = VB->SecondaryColorPtr[0]; + VB->AttribPtr[_TNL_ATTRIB_INDEX] = VB->IndexPtr[0]; + + return GL_TRUE; +} + + +/* Called in place of do_lighting when the light table may have changed. + */ +static GLboolean run_validate_lighting( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + 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; + } + else { + if (ctx->Light.EnabledList.next == ctx->Light.EnabledList.prev) + tab = _tnl_light_fast_single_tab; + else + tab = _tnl_light_fast_tab; + } + } + else + tab = _tnl_light_ci_tab; + + + LIGHT_STAGE_DATA(stage)->light_func_tab = tab; + + /* This and the above should only be done on _NEW_LIGHT: + */ + TNL_CONTEXT(ctx)->Driver.NotifyMaterialChange( ctx ); + + /* Now run the stage... + */ + stage->run = run_lighting; + return stage->run( ctx, stage ); +} + + + +/* 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, + struct tnl_pipeline_stage *stage ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct light_stage_data *store; + GLuint size = tnl->vb.Size; + + stage->privatePtr = MALLOC(sizeof(*store)); + store = LIGHT_STAGE_DATA(stage); + if (!store) + return GL_FALSE; + + /* Do onetime init. + */ + init_lighting(); + + _mesa_vector4f_alloc( &store->Input, 0, size, 32 ); + _mesa_vector4f_alloc( &store->LitColor[0], 0, size, 32 ); + _mesa_vector4f_alloc( &store->LitColor[1], 0, size, 32 ); + _mesa_vector4f_alloc( &store->LitSecondary[0], 0, size, 32 ); + _mesa_vector4f_alloc( &store->LitSecondary[1], 0, size, 32 ); + _mesa_vector4f_alloc( &store->LitIndex[0], 0, size, 32 ); + _mesa_vector4f_alloc( &store->LitIndex[1], 0, size, 32 ); + + store->LitColor[0].size = 4; + store->LitColor[1].size = 4; + store->LitSecondary[0].size = 3; + store->LitSecondary[1].size = 3; + + store->LitIndex[0].size = 1; + store->LitIndex[0].stride = sizeof(GLfloat); + store->LitIndex[1].size = 1; + store->LitIndex[1].stride = sizeof(GLfloat); + + /* Now validate the stage derived data... + */ + stage->run = run_validate_lighting; + return stage->run( ctx, stage ); +} + + + +/* + * Check if lighting is enabled. If so, configure the pipeline stage's + * type, inputs, and outputs. + */ +static void check_lighting( GLcontext *ctx, struct tnl_pipeline_stage *stage ) +{ + stage->active = ctx->Light.Enabled && !ctx->VertexProgram._Enabled; + if (stage->active) { + if (stage->privatePtr) + stage->run = run_validate_lighting; + stage->inputs = _TNL_BIT_NORMAL|_TNL_BITS_MAT_ANY; + if (ctx->Light._NeedVertices) + stage->inputs |= _TNL_BIT_POS; + if (ctx->Light.ColorMaterialEnabled) + stage->inputs |= _TNL_BIT_COLOR0; + + stage->outputs = _TNL_BIT_COLOR0; + if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR) + stage->outputs |= _TNL_BIT_COLOR1; + } +} + + +static void dtr( struct tnl_pipeline_stage *stage ) +{ + struct light_stage_data *store = LIGHT_STAGE_DATA(stage); + + if (store) { + _mesa_vector4f_free( &store->Input ); + _mesa_vector4f_free( &store->LitColor[0] ); + _mesa_vector4f_free( &store->LitColor[1] ); + _mesa_vector4f_free( &store->LitSecondary[0] ); + _mesa_vector4f_free( &store->LitSecondary[1] ); + _mesa_vector4f_free( &store->LitIndex[0] ); + _mesa_vector4f_free( &store->LitIndex[1] ); + FREE( store ); + stage->privatePtr = NULL; + } +} + +const struct tnl_pipeline_stage _tnl_lighting_stage = +{ + "lighting", /* name */ + _NEW_LIGHT|_NEW_PROGRAM, /* recheck */ + _NEW_LIGHT|_NEW_MODELVIEW, /* recalc -- modelview dependency + * otherwise not captured by inputs + * (which may be _TNL_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 */ +}; diff --git a/src/mesa/tnl/t_vb_lighttmp.h b/src/mesa/tnl/t_vb_lighttmp.h new file mode 100644 index 0000000..d8094e2 --- /dev/null +++ b/src/mesa/tnl/t_vb_lighttmp.h @@ -0,0 +1,821 @@ +/* + * Mesa 3-D graphics library + * Version: 5.1 + * + * 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * Authors: + * Brian Paul + * Keith Whitwell <keith@tungstengraphics.com> + */ + + +#if IDX & LIGHT_TWOSIDE +# define NR_SIDES 2 +#else +# define NR_SIDES 1 +#endif + + +/* define TRACE to trace lighting code */ +/* #define TRACE 1 */ + +/* + * ctx is the current context + * VB is the vertex buffer + * stage is the lighting stage-private data + * input is the vector of eye or object-space vertex coordinates + */ +static void TAG(light_rgba_spec)( GLcontext *ctx, + struct vertex_buffer *VB, + struct tnl_pipeline_stage *stage, + GLvector4f *input ) +{ + struct light_stage_data *store = LIGHT_STAGE_DATA(stage); + GLfloat (*base)[3] = ctx->Light._BaseColor; + GLfloat sumA[2]; + GLuint j; + + const GLuint vstride = input->stride; + const GLfloat *vertex = (GLfloat *)input->data; + const GLuint nstride = VB->NormalPtr->stride; + const GLfloat *normal = (GLfloat *)VB->NormalPtr->data; + + GLfloat (*Fcolor)[4] = (GLfloat (*)[4]) store->LitColor[0].data; + GLfloat (*Fspec)[4] = (GLfloat (*)[4]) store->LitSecondary[0].data; +#if IDX & LIGHT_TWOSIDE + GLfloat (*Bcolor)[4] = (GLfloat (*)[4]) store->LitColor[1].data; + GLfloat (*Bspec)[4] = (GLfloat (*)[4]) store->LitSecondary[1].data; +#endif + + const GLuint nr = VB->Count; + + (void) nstride; + (void) vstride; + +#ifdef TRACE + fprintf(stderr, "%s\n", __FUNCTION__ ); +#endif + + VB->ColorPtr[0] = &store->LitColor[0]; + VB->SecondaryColorPtr[0] = &store->LitSecondary[0]; + sumA[0] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE][3]; + +#if IDX & LIGHT_TWOSIDE + VB->ColorPtr[1] = &store->LitColor[1]; + VB->SecondaryColorPtr[1] = &store->LitSecondary[1]; + sumA[1] = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_DIFFUSE][3]; +#endif + + /* Side-effects done, can we finish now? + */ + if (stage->changed_inputs == 0) + return; + + for (j = 0; j < nr; j++,STRIDE_F(vertex,vstride),STRIDE_F(normal,nstride)) { + GLfloat sum[2][3], spec[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]); + ZERO_3V(spec[0]); + +#if IDX & LIGHT_TWOSIDE + COPY_3V(sum[1], base[1]); + ZERO_3V(spec[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; + 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 gets the diffuse & specular terms? */ + 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; + } + + /* diffuse term */ + COPY_3V(contrib, light->_MatAmbient[side]); + ACC_SCALE_SCALAR_3V(contrib, n_dot_VP, light->_MatDiffuse[side]); + ACC_SCALE_SCALAR_3V(sum[side], attenuation, contrib ); + + /* 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 ); + + if (spec_coef > 1.0e-10) { + spec_coef *= attenuation; + ACC_SCALE_SCALAR_3V( spec[side], spec_coef, + light->_MatSpecular[side]); + } + } + } /*loop over lights*/ + + COPY_3V( Fcolor[j], sum[0] ); + COPY_3V( Fspec[j], spec[0] ); + Fcolor[j][3] = sumA[0]; + +#if IDX & LIGHT_TWOSIDE + COPY_3V( Bcolor[j], sum[1] ); + COPY_3V( Bspec[j], spec[1] ); + Bcolor[j][3] = sumA[1]; +#endif + } +} + + +static void TAG(light_rgba)( GLcontext *ctx, + struct vertex_buffer *VB, + struct tnl_pipeline_stage *stage, + GLvector4f *input ) +{ + 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->NormalPtr->stride; + const GLfloat *normal = (GLfloat *)VB->NormalPtr->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 + + (void) nstride; + (void) vstride; + + 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 + + if (stage->changed_inputs == 0) + return; + + 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 + } +} + + + + +/* As below, but with just a single light. + */ +static void TAG(light_fast_rgba_single)( GLcontext *ctx, + struct vertex_buffer *VB, + struct tnl_pipeline_stage *stage, + GLvector4f *input ) + +{ + struct light_stage_data *store = LIGHT_STAGE_DATA(stage); + const GLuint nstride = VB->NormalPtr->stride; + const GLfloat *normal = (GLfloat *)VB->NormalPtr->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 struct gl_light *light = ctx->Light.EnabledList.next; + GLuint j = 0; + GLfloat base[2][4]; + const GLuint nr = VB->Count; + +#ifdef TRACE + fprintf(stderr, "%s\n", __FUNCTION__ ); +#endif + + (void) input; /* doesn't refer to Eye or Obj */ + (void) nr; + (void) nstride; + + VB->ColorPtr[0] = &store->LitColor[0]; +#if IDX & LIGHT_TWOSIDE + VB->ColorPtr[1] = &store->LitColor[1]; +#endif + + if (stage->changed_inputs == 0) + return; + + for (j = 0; j < nr; j++, STRIDE_F(normal,nstride)) { + + GLfloat n_dot_VP; + +#if IDX & LIGHT_MATERIAL + update_materials( ctx, store ); +#endif + + /* No attenuation, so incoporate _MatAmbient into base color. + */ +#if !(IDX & LIGHT_MATERIAL) + if ( j == 0 ) +#endif + { + COPY_3V(base[0], light->_MatAmbient[0]); + ACC_3V(base[0], ctx->Light._BaseColor[0] ); + base[0][3] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE][3]; + +#if IDX & LIGHT_TWOSIDE + COPY_3V(base[1], light->_MatAmbient[1]); + ACC_3V(base[1], ctx->Light._BaseColor[1]); + base[1][3] = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_DIFFUSE][3]; +#endif + } + + n_dot_VP = DOT3(normal, light->_VP_inf_norm); + + if (n_dot_VP < 0.0F) { +#if IDX & LIGHT_TWOSIDE + GLfloat n_dot_h = -DOT3(normal, light->_h_inf_norm); + GLfloat sum[3]; + COPY_3V(sum, base[1]); + ACC_SCALE_SCALAR_3V(sum, -n_dot_VP, light->_MatDiffuse[1]); + if (n_dot_h > 0.0F) { + GLfloat spec; + GET_SHINE_TAB_ENTRY( ctx->_ShineTable[1], n_dot_h, spec ); + ACC_SCALE_SCALAR_3V(sum, spec, light->_MatSpecular[1]); + } + COPY_3V(Bcolor[j], sum ); + Bcolor[j][3] = base[1][3]; +#endif + COPY_4FV(Fcolor[j], base[0]); + } + else { + GLfloat n_dot_h = DOT3(normal, light->_h_inf_norm); + GLfloat sum[3]; + COPY_3V(sum, base[0]); + ACC_SCALE_SCALAR_3V(sum, n_dot_VP, light->_MatDiffuse[0]); + if (n_dot_h > 0.0F) { + GLfloat spec; + GET_SHINE_TAB_ENTRY( ctx->_ShineTable[0], n_dot_h, spec ); + ACC_SCALE_SCALAR_3V(sum, spec, light->_MatSpecular[0]); + + } + COPY_3V(Fcolor[j], sum ); + Fcolor[j][3] = base[0][3]; +#if IDX & LIGHT_TWOSIDE + COPY_4FV(Bcolor[j], base[1]); +#endif + } + } +} + + +/* Light infinite lights + */ +static void TAG(light_fast_rgba)( GLcontext *ctx, + struct vertex_buffer *VB, + struct tnl_pipeline_stage *stage, + GLvector4f *input ) +{ + struct light_stage_data *store = LIGHT_STAGE_DATA(stage); + GLfloat sumA[2]; + const GLuint nstride = VB->NormalPtr->stride; + const GLfloat *normal = (GLfloat *)VB->NormalPtr->data; + GLfloat (*Fcolor)[4] = (GLfloat (*)[4]) store->LitColor[0].data; +#if IDX & LIGHT_TWOSIDE + GLfloat (*Bcolor)[4] = (GLfloat (*)[4]) store->LitColor[1].data; +#endif + GLuint j = 0; + const GLuint nr = VB->Count; + const struct gl_light *light; + +#ifdef TRACE + fprintf(stderr, "%s %d\n", __FUNCTION__, nr ); +#endif + + (void) input; + (void) nr; + (void) nstride; + + sumA[0] = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_DIFFUSE][3]; + sumA[1] = ctx->Light.Material.Attrib[MAT_ATTRIB_BACK_DIFFUSE][3]; + + VB->ColorPtr[0] = &store->LitColor[0]; +#if IDX & LIGHT_TWOSIDE + VB->ColorPtr[1] = &store->LitColor[1]; +#endif + + if (stage->changed_inputs == 0) + return; + + for (j = 0; j < nr; j++, STRIDE_F(normal,nstride)) { + + GLfloat sum[2][3]; + +#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], ctx->Light._BaseColor[0]); +#if IDX & LIGHT_TWOSIDE + COPY_3V(sum[1], ctx->Light._BaseColor[1]); +#endif + + foreach (light, &ctx->Light.EnabledList) { + GLfloat n_dot_h, n_dot_VP, spec; + + ACC_3V(sum[0], light->_MatAmbient[0]); +#if IDX & LIGHT_TWOSIDE + ACC_3V(sum[1], light->_MatAmbient[1]); +#endif + + n_dot_VP = DOT3(normal, light->_VP_inf_norm); + + if (n_dot_VP > 0.0F) { + ACC_SCALE_SCALAR_3V(sum[0], n_dot_VP, light->_MatDiffuse[0]); + n_dot_h = DOT3(normal, light->_h_inf_norm); + if (n_dot_h > 0.0F) { + struct gl_shine_tab *tab = ctx->_ShineTable[0]; + GET_SHINE_TAB_ENTRY( tab, n_dot_h, spec ); + ACC_SCALE_SCALAR_3V( sum[0], spec, light->_MatSpecular[0]); + } + } +#if IDX & LIGHT_TWOSIDE + else { + ACC_SCALE_SCALAR_3V(sum[1], -n_dot_VP, light->_MatDiffuse[1]); + n_dot_h = -DOT3(normal, light->_h_inf_norm); + if (n_dot_h > 0.0F) { + struct gl_shine_tab *tab = ctx->_ShineTable[1]; + GET_SHINE_TAB_ENTRY( tab, n_dot_h, spec ); + ACC_SCALE_SCALAR_3V( sum[1], spec, light->_MatSpecular[1]); + } + } +#endif + } + + 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 + } +} + + + + + +/* + * Use current lighting/material settings to compute the color indexes + * for an array of vertices. + * Input: n - number of vertices to light + * side - 0=use front material, 1=use back material + * vertex - array of [n] vertex position in eye coordinates + * normal - array of [n] surface normal vector + * Output: indexResult - resulting array of [n] color indexes + */ +static void TAG(light_ci)( GLcontext *ctx, + struct vertex_buffer *VB, + struct tnl_pipeline_stage *stage, + GLvector4f *input ) +{ + struct light_stage_data *store = LIGHT_STAGE_DATA(stage); + GLuint j; + const GLuint vstride = input->stride; + const GLfloat *vertex = (GLfloat *) input->data; + const GLuint nstride = VB->NormalPtr->stride; + const GLfloat *normal = (GLfloat *)VB->NormalPtr->data; + GLfloat *indexResult[2]; + const GLuint nr = VB->Count; + +#ifdef TRACE + fprintf(stderr, "%s\n", __FUNCTION__ ); +#endif + + (void) nstride; + (void) vstride; + + VB->IndexPtr[0] = &store->LitIndex[0]; +#if IDX & LIGHT_TWOSIDE + VB->IndexPtr[1] = &store->LitIndex[1]; +#endif + + if (stage->changed_inputs == 0) + return; + + indexResult[0] = (GLfloat *)VB->IndexPtr[0]->data; +#if IDX & LIGHT_TWOSIDE + indexResult[1] = (GLfloat *)VB->IndexPtr[1]->data; +#endif + + /* loop over vertices */ + for (j=0; j<nr; j++,STRIDE_F(vertex,vstride),STRIDE_F(normal, nstride)) { + GLfloat diffuse[2], specular[2]; + GLuint side = 0; + struct gl_light *light; + +#if IDX & LIGHT_MATERIAL + update_materials( ctx, store ); +#endif + + diffuse[0] = specular[0] = 0.0F; + +#if IDX & LIGHT_TWOSIDE + diffuse[1] = specular[1] = 0.0F; +#endif + + /* Accumulate diffuse and specular from each light source */ + foreach (light, &ctx->Light.EnabledList) { + + GLfloat attenuation = 1.0F; + GLfloat VP[3]; /* unit vector from vertex to light */ + GLfloat n_dot_VP; /* dot product of l and n */ + GLfloat *h, n_dot_h, correction = 1.0; + + /* compute l and attenuation */ + if (!(light->_Flags & LIGHT_POSITIONAL)) { + /* directional light */ + COPY_3V(VP, light->_VP_inf_norm); + } + 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 */ + + n_dot_VP = DOT3( normal, VP ); + + /* which side are we lighting? */ + if (n_dot_VP < 0.0F) { +#if IDX & LIGHT_TWOSIDE + side = 1; + correction = -1; + n_dot_VP = -n_dot_VP; +#else + continue; +#endif + } + + /* accumulate diffuse term */ + diffuse[side] += n_dot_VP * light->_dli * attenuation; + + /* specular term */ + 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; + /* Strangely, disabling this addition fixes a conformance + * problem. If this code is enabled, l_sed.c fails. + */ + /*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); + specular[side] += spec_coef * light->_sli * attenuation; + } + } /*loop over lights*/ + + /* Now compute final color index */ + for (side = 0 ; side < NR_SIDES ; side++) { + const GLfloat *ind = ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_INDEXES + side]; + GLfloat index; + + if (specular[side] > 1.0F) { + index = ind[MAT_INDEX_SPECULAR]; + } + else { + GLfloat d_a = ind[MAT_INDEX_DIFFUSE] - ind[MAT_INDEX_AMBIENT]; + GLfloat s_a = ind[MAT_INDEX_SPECULAR] - ind[MAT_INDEX_AMBIENT]; + index = (ind[MAT_INDEX_AMBIENT] + + diffuse[side] * (1.0F-specular[side]) * d_a + + specular[side] * s_a); + if (index > ind[MAT_INDEX_SPECULAR]) { + index = ind[MAT_INDEX_SPECULAR]; + } + } + indexResult[side][j] = index; + } + } /*for vertex*/ +} + + + +static void TAG(init_light_tab)( void ) +{ + _tnl_light_tab[IDX] = TAG(light_rgba); + _tnl_light_fast_tab[IDX] = TAG(light_fast_rgba); + _tnl_light_fast_single_tab[IDX] = TAG(light_fast_rgba_single); + _tnl_light_spec_tab[IDX] = TAG(light_rgba_spec); + _tnl_light_ci_tab[IDX] = TAG(light_ci); +} + + +#undef TAG +#undef IDX +#undef NR_SIDES diff --git a/src/mesa/tnl/t_vb_normals.c b/src/mesa/tnl/t_vb_normals.c new file mode 100644 index 0000000..732e7c6 --- /dev/null +++ b/src/mesa/tnl/t_vb_normals.c @@ -0,0 +1,200 @@ +/* + * Mesa 3-D graphics library + * Version: 6.1 + * + * Copyright (C) 1999-2004 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + + +#include "glheader.h" +#include "colormac.h" +#include "context.h" +#include "macros.h" +#include "imports.h" +#include "mtypes.h" + +#include "math/m_xform.h" + +#include "t_context.h" +#include "t_pipeline.h" + + + +struct normal_stage_data { + normal_func NormalTransform; + GLvector4f normal; +}; + +#define NORMAL_STAGE_DATA(stage) ((struct normal_stage_data *)stage->privatePtr) + + + + +static GLboolean run_normal_stage( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + struct normal_stage_data *store = NORMAL_STAGE_DATA(stage); + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + + ASSERT(store->NormalTransform); + + if (stage->changed_inputs) { + /* We can only use the display list's saved normal lengths if we've + * got a transformation matrix with uniform scaling. + */ + const GLfloat *lengths; + if (ctx->ModelviewMatrixStack.Top->flags & MAT_FLAG_GENERAL_SCALE) + lengths = NULL; + else + lengths = VB->NormalLengthPtr; + + store->NormalTransform( ctx->ModelviewMatrixStack.Top, + ctx->_ModelViewInvScale, + VB->NormalPtr, /* input normals */ + lengths, + &store->normal ); /* resulting normals */ + } + + VB->NormalPtr = &store->normal; + VB->AttribPtr[_TNL_ATTRIB_NORMAL] = VB->NormalPtr; + + VB->NormalLengthPtr = 0; /* no longer valid */ + return GL_TRUE; +} + + +static GLboolean run_validate_normal_stage( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + struct normal_stage_data *store = NORMAL_STAGE_DATA(stage); + + + if (ctx->_NeedEyeCoords) { + GLuint transform = NORM_TRANSFORM_NO_ROT; + + if (ctx->ModelviewMatrixStack.Top->flags & (MAT_FLAG_GENERAL | + MAT_FLAG_ROTATION | + MAT_FLAG_GENERAL_3D | + MAT_FLAG_PERSPECTIVE)) + transform = NORM_TRANSFORM; + + + if (ctx->Transform.Normalize) { + store->NormalTransform = _mesa_normal_tab[transform | NORM_NORMALIZE]; + } + else if (ctx->Transform.RescaleNormals && + ctx->_ModelViewInvScale != 1.0) { + store->NormalTransform = _mesa_normal_tab[transform | NORM_RESCALE]; + } + else { + store->NormalTransform = _mesa_normal_tab[transform]; + } + } + else { + if (ctx->Transform.Normalize) { + store->NormalTransform = _mesa_normal_tab[NORM_NORMALIZE]; + } + else if (!ctx->Transform.RescaleNormals && + ctx->_ModelViewInvScale != 1.0) { + store->NormalTransform = _mesa_normal_tab[NORM_RESCALE]; + } + else { + store->NormalTransform = 0; + } + } + + if (store->NormalTransform) { + stage->run = run_normal_stage; + return stage->run( ctx, stage ); + } else { + stage->active = GL_FALSE; /* !!! */ + return GL_TRUE; + } +} + + +static void check_normal_transform( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + stage->active = !ctx->VertexProgram._Enabled && + (ctx->Light.Enabled || (ctx->Texture._GenFlags & TEXGEN_NEED_NORMALS)); + + /* Don't clobber the initialize function: + */ + if (stage->privatePtr) + stage->run = run_validate_normal_stage; +} + + +static GLboolean alloc_normal_data( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct normal_stage_data *store; + stage->privatePtr = MALLOC(sizeof(*store)); + store = NORMAL_STAGE_DATA(stage); + if (!store) + return GL_FALSE; + + _mesa_vector4f_alloc( &store->normal, 0, tnl->vb.Size, 32 ); + + /* Now run the stage. + */ + stage->run = run_validate_normal_stage; + return stage->run( ctx, stage ); +} + + + +static void free_normal_data( struct tnl_pipeline_stage *stage ) +{ + struct normal_stage_data *store = NORMAL_STAGE_DATA(stage); + if (store) { + _mesa_vector4f_free( &store->normal ); + FREE( store ); + stage->privatePtr = NULL; + } +} + +#define _TNL_NEW_NORMAL_TRANSFORM (_NEW_MODELVIEW| \ + _NEW_TRANSFORM| \ + _NEW_PROGRAM| \ + _MESA_NEW_NEED_NORMALS| \ + _MESA_NEW_NEED_EYE_COORDS) + + + +const struct tnl_pipeline_stage _tnl_normal_transform_stage = +{ + "normal transform", /* name */ + _TNL_NEW_NORMAL_TRANSFORM, /* re-check */ + _TNL_NEW_NORMAL_TRANSFORM, /* re-run */ + GL_FALSE, /* active? */ + _TNL_BIT_NORMAL, /* inputs */ + _TNL_BIT_NORMAL, /* outputs */ + 0, /* changed_inputs */ + NULL, /* private data */ + free_normal_data, /* destructor */ + check_normal_transform, /* check */ + alloc_normal_data /* run -- initially set to alloc */ +}; diff --git a/src/mesa/tnl/t_vb_points.c b/src/mesa/tnl/t_vb_points.c new file mode 100644 index 0000000..746ea8b --- /dev/null +++ b/src/mesa/tnl/t_vb_points.c @@ -0,0 +1,123 @@ +/* + * Mesa 3-D graphics library + * Version: 6.1 + * + * Copyright (C) 1999-2004 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Brian Paul + */ + +#include "mtypes.h" +#include "imports.h" +#include "t_context.h" +#include "t_pipeline.h" + + +struct point_stage_data { + GLvector4f PointSize; +}; + +#define POINT_STAGE_DATA(stage) ((struct point_stage_data *)stage->privatePtr) + + +/* + * Compute attenuated point sizes + */ +static GLboolean run_point_stage( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + struct point_stage_data *store = POINT_STAGE_DATA(stage); + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + const GLfloat (*eye)[4] = (const GLfloat (*)[4]) VB->EyePtr->data; + const GLfloat p0 = ctx->Point.Params[0]; + const GLfloat p1 = ctx->Point.Params[1]; + const GLfloat p2 = ctx->Point.Params[2]; + const GLfloat pointSize = ctx->Point._Size; + GLfloat (*size)[4] = store->PointSize.data; + GLuint i; + + if (stage->changed_inputs) { + /* XXX do threshold and min/max clamping here? */ + for (i = 0; i < VB->Count; i++) { + const GLfloat dist = -eye[i][2]; + /* GLfloat dist = SQRTF(pos[0]*pos[0]+pos[1]*pos[1]+pos[2]*pos[2]);*/ + size[i][0] = pointSize / (p0 + dist * (p1 + dist * p2)); + } + } + + VB->PointSizePtr = &store->PointSize; + VB->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->PointSize; + + return GL_TRUE; +} + + +/* If point size attenuation is on we'll compute the point size for + * each vertex in a special pipeline stage. + */ +static void check_point_size( GLcontext *ctx, struct tnl_pipeline_stage *d ) +{ + d->active = ctx->Point._Attenuated && !ctx->VertexProgram._Enabled; +} + +static GLboolean alloc_point_data( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + struct point_stage_data *store; + stage->privatePtr = MALLOC(sizeof(*store)); + store = POINT_STAGE_DATA(stage); + if (!store) + return GL_FALSE; + + _mesa_vector4f_alloc( &store->PointSize, 0, VB->Size, 32 ); + + /* Now run the stage. + */ + stage->run = run_point_stage; + return stage->run( ctx, stage ); +} + + +static void free_point_data( struct tnl_pipeline_stage *stage ) +{ + struct point_stage_data *store = POINT_STAGE_DATA(stage); + if (store) { + _mesa_vector4f_free( &store->PointSize ); + FREE( store ); + stage->privatePtr = 0; + } +} + +const struct tnl_pipeline_stage _tnl_point_attenuation_stage = +{ + "point size attenuation", /* name */ + _NEW_POINT|_NEW_PROGRAM, /* check_state */ + _NEW_POINT, /* run_state */ + GL_FALSE, /* active */ + _TNL_BIT_POS, /* inputs */ + _TNL_BIT_POS, /* outputs */ + 0, /* changed_inputs (temporary value) */ + NULL, /* stage private data */ + free_point_data, /* destructor */ + check_point_size, /* check */ + alloc_point_data /* run -- initially set to alloc data */ +}; diff --git a/src/mesa/tnl/t_vb_program.c b/src/mesa/tnl/t_vb_program.c new file mode 100644 index 0000000..38b04b4 --- /dev/null +++ b/src/mesa/tnl/t_vb_program.c @@ -0,0 +1,368 @@ +/* + * Mesa 3-D graphics library + * Version: 6.1 + * + * Copyright (C) 1999-2004 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +/** + * \file tnl/t_vb_program.c + * \brief Pipeline stage for executing NVIDIA vertex programs. + * \author Brian Paul, Keith Whitwell + */ + + +#include "glheader.h" +#include "api_noop.h" +#include "colormac.h" +#include "context.h" +#include "dlist.h" +#include "hash.h" +#include "light.h" +#include "macros.h" +#include "imports.h" +#include "simple_list.h" +#include "mtypes.h" +#include "nvvertprog.h" +#include "nvvertexec.h" +#include "nvprogram.h" + +#include "math/m_translate.h" + +#include "t_context.h" +#include "t_pipeline.h" + + +/** + * \warning These values _MUST_ match the values in the OutputRegisters[] + * array in vpparse.c!!! + */ +#define VERT_RESULT_HPOS 0 +#define VERT_RESULT_COL0 1 +#define VERT_RESULT_COL1 2 +#define VERT_RESULT_BFC0 3 +#define VERT_RESULT_BFC1 4 +#define VERT_RESULT_FOGC 5 +#define VERT_RESULT_PSIZ 6 +#define VERT_RESULT_TEX0 7 +#define VERT_RESULT_TEX1 8 +#define VERT_RESULT_TEX2 9 +#define VERT_RESULT_TEX3 10 +#define VERT_RESULT_TEX4 11 +#define VERT_RESULT_TEX5 12 +#define VERT_RESULT_TEX6 13 +#define VERT_RESULT_TEX7 14 + + +/*! + * Private storage for the vertex program pipeline stage. + */ +struct vp_stage_data { + /** The results of running the vertex program go into these arrays. */ + GLvector4f attribs[15]; + + GLvector4f ndcCoords; /**< normalized device coords */ + GLubyte *clipmask; /**< clip flags */ + GLubyte ormask, andmask; /**< for clipping */ +}; + + +#define VP_STAGE_DATA(stage) ((struct vp_stage_data *)(stage->privatePtr)) + + +/** + * This function executes vertex programs + */ +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 vertex_program *program = ctx->VertexProgram.Current; + GLuint i; + + /* load program parameter registers (they're read-only) */ + _mesa_init_vp_per_primitive_registers(ctx); + + for (i = 0; i < VB->Count; i++) { + GLuint attr; + + _mesa_init_vp_per_vertex_registers(ctx); + +#if 0 + printf("Input %d: %f, %f, %f, %f\n", i, + VB->AttribPtr[0]->data[i][0], + VB->AttribPtr[0]->data[i][1], + VB->AttribPtr[0]->data[i][2], + VB->AttribPtr[0]->data[i][3]); + printf(" color: %f, %f, %f, %f\n", + VB->AttribPtr[3]->data[i][0], + VB->AttribPtr[3]->data[i][1], + VB->AttribPtr[3]->data[i][2], + VB->AttribPtr[3]->data[i][3]); + printf(" normal: %f, %f, %f, %f\n", + VB->AttribPtr[2]->data[i][0], + VB->AttribPtr[2]->data[i][1], + VB->AttribPtr[2]->data[i][2], + VB->AttribPtr[2]->data[i][3]); +#endif + + /* 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); + + /* 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], + ctx->VertexProgram.Outputs[attr]); + } + } + + /* Setup the VB pointers so that the next pipeline stages get + * their data from the right place (the program output arrays). + */ + VB->ClipPtr = &store->attribs[VERT_RESULT_HPOS]; + VB->ClipPtr->size = 4; + VB->ClipPtr->count = VB->Count; + 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]; + + 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. + */ + store->ormask = 0; + store->andmask = CLIP_ALL_BITS; + + if (tnl->NeedNdcCoords) { + VB->NdcPtr = + _mesa_clip_tab[VB->ClipPtr->size]( VB->ClipPtr, + &store->ndcCoords, + store->clipmask, + &store->ormask, + &store->andmask ); + } + else { + VB->NdcPtr = 0; + _mesa_clip_np_tab[VB->ClipPtr->size]( VB->ClipPtr, + 0, + store->clipmask, + &store->ormask, + &store->andmask ); + } + + if (store->andmask) /* All vertices are outside the frustum */ + return GL_FALSE; + + + /* This is where we'd do clip testing against the user-defined + * clipping planes, but they're not supported by vertex programs. + */ + + VB->ClipOrMask = store->ormask; + VB->ClipMask = store->clipmask; + + return GL_TRUE; +} + + +/** + * This function validates stuff. + */ +static GLboolean run_validate_program( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ +#if 000 + /* XXX do we need any validation for vertex programs? */ + GLuint ind = 0; + 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; + } + else { + if (ctx->Light.EnabledList.next == ctx->Light.EnabledList.prev) + tab = _tnl_light_fast_single_tab; + else + tab = _tnl_light_fast_tab; + } + } + else + tab = _tnl_light_ci_tab; + + if (ctx->Light.ColorMaterialEnabled) + ind |= LIGHT_COLORMATERIAL; + + if (ctx->Light.Model.TwoSide) + ind |= LIGHT_TWOSIDE; + + VP_STAGE_DATA(stage)->light_func_tab = &tab[ind]; + + /* This and the above should only be done on _NEW_LIGHT: + */ + _mesa_validate_all_lighting_tables( ctx ); +#endif + + /* Now run the stage... + */ + stage->run = run_vp; + return stage->run( ctx, stage ); +} + + + +/** + * 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 tnl_pipeline_stage *stage ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &(tnl->vb); + struct vp_stage_data *store; + const GLuint size = VB->Size; + GLuint i; + + stage->privatePtr = MALLOC(sizeof(*store)); + store = VP_STAGE_DATA(stage); + if (!store) + return GL_FALSE; + + /* Allocate arrays of vertex output values */ + for (i = 0; i < 15; i++) { + _mesa_vector4f_alloc( &store->attribs[i], 0, size, 32 ); + store->attribs[i].size = 4; + } + + /* a few other misc allocations */ + _mesa_vector4f_alloc( &store->ndcCoords, 0, size, 32 ); + store->clipmask = (GLubyte *) ALIGN_MALLOC(sizeof(GLubyte)*size, 32 ); + + /* Now validate the stage derived data... + */ + stage->run = run_validate_program; + return stage->run( ctx, stage ); +} + + + +/** + * 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 tnl_pipeline_stage *stage ) +{ + stage->active = ctx->VertexProgram._Enabled; + + if (stage->active) { + /* Set stage->inputs equal to the bitmask of vertex attributes + * which the program needs for inputs. + */ + stage->inputs = ctx->VertexProgram.Current->InputsRead; + } +} + + +/** + * Destructor for this pipeline stage. + */ +static void dtr( struct tnl_pipeline_stage *stage ) +{ + struct vp_stage_data *store = VP_STAGE_DATA(stage); + + if (store) { + GLuint i; + + /* free the vertex program result arrays */ + for (i = 0; i < 15; i++) + _mesa_vector4f_free( &store->attribs[i] ); + + /* free misc arrays */ + _mesa_vector4f_free( &store->ndcCoords ); + ALIGN_FREE( store->clipmask ); + + FREE( store ); + stage->privatePtr = 0; + } +} + +/** + * Public description of this pipeline stage. + */ +const struct tnl_pipeline_stage _tnl_vertex_program_stage = +{ + "vertex-program", + _NEW_ALL, /*XXX FIX */ /* recheck */ + _NEW_ALL, /*XXX FIX */ /* recalc */ + GL_FALSE, /* active */ + 0, /* inputs - calculated on the fly */ + _TNL_BITS_PROG_ANY, /* outputs -- could calculate */ + 0, /* changed_inputs */ + NULL, /* private_data */ + dtr, /* destroy */ + check_vp, /* check */ + run_init_vp /* run -- initially set to ctr */ +}; diff --git a/src/mesa/tnl/t_vb_render.c b/src/mesa/tnl/t_vb_render.c new file mode 100644 index 0000000..44a09f5 --- /dev/null +++ b/src/mesa/tnl/t_vb_render.c @@ -0,0 +1,381 @@ + +/* + * Mesa 3-D graphics library + * Version: 5.1 + * + * 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + + +/* + * Render whole vertex buffers, including projection of vertices from + * clip space and clipping of primitives. + * + * This file makes calls to project vertices and to the point, line + * and triangle rasterizers via the function pointers: + * + * context->Driver.Render.* + * + */ + + +#include "glheader.h" +#include "context.h" +#include "enums.h" +#include "macros.h" +#include "imports.h" +#include "mtypes.h" +#include "nvfragprog.h" +#include "math/m_matrix.h" +#include "math/m_xform.h" + +#include "t_pipeline.h" + + + +/**********************************************************************/ +/* Clip single primitives */ +/**********************************************************************/ + + +#define W(i) coord[i][3] +#define Z(i) coord[i][2] +#define Y(i) coord[i][1] +#define X(i) coord[i][0] +#define SIZE 4 +#define TAG(x) x##_4 +#include "t_vb_cliptmp.h" + + + +/**********************************************************************/ +/* Clip and render whole begin/end objects */ +/**********************************************************************/ + +#define NEED_EDGEFLAG_SETUP (ctx->Polygon.FrontMode != GL_FILL || ctx->Polygon.BackMode != GL_FILL) +#define EDGEFLAG_GET(idx) VB->EdgeFlag[idx] +#define EDGEFLAG_SET(idx, val) VB->EdgeFlag[idx] = val + + +#define CLIPMASK (CLIP_ALL_BITS|CLIP_CULL_BIT) + + +/* Vertices, with the possibility of clipping. + */ +#define RENDER_POINTS( start, count ) \ + tnl->Driver.Render.Points( ctx, start, count ) + +#define RENDER_LINE( v1, v2 ) \ +do { \ + GLubyte c1 = mask[v1], c2 = mask[v2]; \ + GLubyte ormask = c1|c2; \ + if (!ormask) \ + LineFunc( ctx, v1, v2 ); \ + else if (!(c1 & c2 & CLIPMASK)) \ + clip_line_4( ctx, v1, v2, ormask ); \ +} while (0) + +#define RENDER_TRI( v1, v2, v3 ) \ +do { \ + GLubyte c1 = mask[v1], c2 = mask[v2], c3 = mask[v3]; \ + GLubyte ormask = c1|c2|c3; \ + if (!ormask) \ + TriangleFunc( ctx, v1, v2, v3 ); \ + else if (!(c1 & c2 & c3 & CLIPMASK)) \ + clip_tri_4( ctx, v1, v2, v3, ormask ); \ +} while (0) + +#define RENDER_QUAD( v1, v2, v3, v4 ) \ +do { \ + GLubyte c1 = mask[v1], c2 = mask[v2]; \ + GLubyte c3 = mask[v3], c4 = mask[v4]; \ + GLubyte ormask = c1|c2|c3|c4; \ + if (!ormask) \ + QuadFunc( ctx, v1, v2, v3, v4 ); \ + else if (!(c1 & c2 & c3 & c4 & CLIPMASK)) \ + clip_quad_4( ctx, v1, v2, v3, v4, ormask ); \ +} while (0) + + +#define LOCAL_VARS \ + TNLcontext *tnl = TNL_CONTEXT(ctx); \ + struct vertex_buffer *VB = &tnl->vb; \ + const GLuint * const elt = VB->Elts; \ + const GLubyte *mask = VB->ClipMask; \ + const GLuint sz = VB->ClipPtr->size; \ + const tnl_line_func LineFunc = tnl->Driver.Render.Line; \ + const tnl_triangle_func TriangleFunc = tnl->Driver.Render.Triangle; \ + const tnl_quad_func QuadFunc = tnl->Driver.Render.Quad; \ + const GLboolean stipple = ctx->Line.StippleFlag; \ + (void) (LineFunc && TriangleFunc && QuadFunc); \ + (void) elt; (void) mask; (void) sz; (void) stipple; + +#define TAG(x) clip_##x##_verts +#define INIT(x) tnl->Driver.Render.PrimitiveNotify( ctx, x ) +#define RESET_STIPPLE if (stipple) tnl->Driver.Render.ResetLineStipple( ctx ) +#define RESET_OCCLUSION ctx->OcclusionResult = GL_TRUE +#define PRESERVE_VB_DEFS +#include "t_vb_rendertmp.h" + + + +/* Elts, with the possibility of clipping. + */ +#undef ELT +#undef TAG +#define ELT(x) elt[x] +#define TAG(x) clip_##x##_elts +#include "t_vb_rendertmp.h" + +/* TODO: do this for all primitives, verts and elts: + */ +static void clip_elt_triangles( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint flags ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + tnl_render_func render_tris = tnl->Driver.Render.PrimTabElts[GL_TRIANGLES]; + struct vertex_buffer *VB = &tnl->vb; + const GLuint * const elt = VB->Elts; + GLubyte *mask = VB->ClipMask; + GLuint last = count-2; + GLuint j; + (void) flags; + + tnl->Driver.Render.PrimitiveNotify( ctx, GL_TRIANGLES ); + + for (j=start; j < last; j+=3 ) { + GLubyte c1 = mask[elt[j]]; + GLubyte c2 = mask[elt[j+1]]; + GLubyte c3 = mask[elt[j+2]]; + GLubyte ormask = c1|c2|c3; + if (ormask) { + if (start < j) + render_tris( ctx, start, j, 0 ); + if (!(c1&c2&c3&CLIPMASK)) + clip_tri_4( ctx, elt[j], elt[j+1], elt[j+2], ormask ); + start = j+3; + } + } + + if (start < j) + render_tris( ctx, start, j, 0 ); +} + +/**********************************************************************/ +/* Render whole begin/end objects */ +/**********************************************************************/ + +#define NEED_EDGEFLAG_SETUP (ctx->Polygon.FrontMode != GL_FILL || ctx->Polygon.BackMode != GL_FILL) +#define EDGEFLAG_GET(idx) VB->EdgeFlag[idx] +#define EDGEFLAG_SET(idx, val) VB->EdgeFlag[idx] = val + + +/* Vertices, no clipping. + */ +#define RENDER_POINTS( start, count ) \ + tnl->Driver.Render.Points( ctx, start, count ) + +#define RENDER_LINE( v1, v2 ) \ + LineFunc( ctx, v1, v2 ) + +#define RENDER_TRI( v1, v2, v3 ) \ + TriangleFunc( ctx, v1, v2, v3 ) + +#define RENDER_QUAD( v1, v2, v3, v4 ) \ + QuadFunc( ctx, v1, v2, v3, v4 ) + +#define TAG(x) _tnl_##x##_verts + +#define LOCAL_VARS \ + TNLcontext *tnl = TNL_CONTEXT(ctx); \ + struct vertex_buffer *VB = &tnl->vb; \ + const GLuint * const elt = VB->Elts; \ + const tnl_line_func LineFunc = tnl->Driver.Render.Line; \ + const tnl_triangle_func TriangleFunc = tnl->Driver.Render.Triangle; \ + const tnl_quad_func QuadFunc = tnl->Driver.Render.Quad; \ + const GLboolean stipple = ctx->Line.StippleFlag; \ + (void) (LineFunc && TriangleFunc && QuadFunc); \ + (void) elt; (void) stipple + +#define RESET_STIPPLE if (stipple) tnl->Driver.Render.ResetLineStipple( ctx ) +#define RESET_OCCLUSION ctx->OcclusionResult = GL_TRUE +#define INIT(x) tnl->Driver.Render.PrimitiveNotify( ctx, x ) +#define RENDER_TAB_QUALIFIER +#define PRESERVE_VB_DEFS +#include "t_vb_rendertmp.h" + + +/* Elts, no clipping. + */ +#undef ELT +#define TAG(x) _tnl_##x##_elts +#define ELT(x) elt[x] +#include "t_vb_rendertmp.h" + + +/**********************************************************************/ +/* Helper functions for drivers */ +/**********************************************************************/ + +void _tnl_RenderClippedPolygon( GLcontext *ctx, const GLuint *elts, GLuint n ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + GLuint *tmp = VB->Elts; + + VB->Elts = (GLuint *)elts; + tnl->Driver.Render.PrimTabElts[GL_POLYGON]( ctx, 0, n, PRIM_BEGIN|PRIM_END ); + VB->Elts = tmp; +} + +void _tnl_RenderClippedLine( GLcontext *ctx, GLuint ii, GLuint jj ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + tnl->Driver.Render.Line( ctx, ii, jj ); +} + + + +/**********************************************************************/ +/* Clip and render whole vertex buffers */ +/**********************************************************************/ + + +static GLboolean run_render( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + GLuint new_inputs = stage->changed_inputs; + tnl_render_func *tab; + GLint pass = 0; + + /* Allow the drivers to lock before projected verts are built so + * that window coordinates are guarenteed not to change before + * rendering. + */ + ASSERT(tnl->Driver.Render.Start); + + tnl->Driver.Render.Start( ctx ); + + ASSERT(tnl->Driver.Render.BuildVertices); + ASSERT(tnl->Driver.Render.PrimitiveNotify); + ASSERT(tnl->Driver.Render.Points); + ASSERT(tnl->Driver.Render.Line); + ASSERT(tnl->Driver.Render.Triangle); + ASSERT(tnl->Driver.Render.Quad); + ASSERT(tnl->Driver.Render.ResetLineStipple); + ASSERT(tnl->Driver.Render.Interp); + ASSERT(tnl->Driver.Render.CopyPV); + ASSERT(tnl->Driver.Render.ClippedLine); + ASSERT(tnl->Driver.Render.ClippedPolygon); + ASSERT(tnl->Driver.Render.Finish); + + tnl->Driver.Render.BuildVertices( ctx, 0, VB->Count, new_inputs ); + + if (VB->ClipOrMask) { + tab = VB->Elts ? clip_render_tab_elts : clip_render_tab_verts; + clip_render_tab_elts[GL_TRIANGLES] = clip_elt_triangles; + } + else { + tab = (VB->Elts ? + tnl->Driver.Render.PrimTabElts : + tnl->Driver.Render.PrimTabVerts); + } + + do + { + GLuint i; + + for (i = 0 ; i < VB->PrimitiveCount ; i++) + { + GLuint prim = VB->Primitive[i].mode; + GLuint start = VB->Primitive[i].start; + GLuint length = VB->Primitive[i].count; + + assert((prim & PRIM_MODE_MASK) < GL_POLYGON+1); + + if (MESA_VERBOSE & VERBOSE_PRIMS) + _mesa_debug(NULL, "MESA prim %s %d..%d\n", + _mesa_lookup_enum_by_nr(prim & PRIM_MODE_MASK), + start, start+length); + + if (length) + tab[prim & PRIM_MODE_MASK]( ctx, start, start + length, prim ); + } + } while (tnl->Driver.Render.Multipass && + tnl->Driver.Render.Multipass( ctx, ++pass )); + + tnl->Driver.Render.Finish( ctx ); + + return GL_FALSE; /* finished the pipe */ +} + + +/**********************************************************************/ +/* Render pipeline stage */ +/**********************************************************************/ + + + +/* Quite a bit of work involved in finding out the inputs for the + * render stage. + */ +static void check_render( GLcontext *ctx, struct tnl_pipeline_stage *stage ) +{ + stage->inputs = TNL_CONTEXT(ctx)->render_inputs; +} + + + + +static void dtr( struct tnl_pipeline_stage *stage ) +{ + (void) stage; +} + + +const struct tnl_pipeline_stage _tnl_render_stage = +{ + "render", /* name */ + (_NEW_BUFFERS | + _DD_NEW_SEPARATE_SPECULAR | + _DD_NEW_FLATSHADE | + _NEW_TEXTURE| + _NEW_LIGHT| + _NEW_POINT| + _NEW_FOG| + _DD_NEW_TRI_UNFILLED | + _NEW_RENDERMODE), /* re-check (new inputs, interp function) */ + 0, /* re-run (always runs) */ + GL_TRUE, /* active? */ + 0, /* inputs (set in check_render) */ + 0, /* outputs */ + 0, /* changed_inputs */ + NULL, /* private data */ + dtr, /* destructor */ + check_render, /* check */ + run_render /* run */ +}; diff --git a/src/mesa/tnl/t_vb_rendertmp.h b/src/mesa/tnl/t_vb_rendertmp.h new file mode 100644 index 0000000..3db94bc --- /dev/null +++ b/src/mesa/tnl/t_vb_rendertmp.h @@ -0,0 +1,440 @@ + +/* + * Mesa 3-D graphics library + * Version: 3.5 + * + * Copyright (C) 1999-2001 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + + +#ifndef POSTFIX +#define POSTFIX +#endif + +#ifndef INIT +#define INIT(x) +#endif + +#ifndef NEED_EDGEFLAG_SETUP +#define NEED_EDGEFLAG_SETUP 0 +#define EDGEFLAG_GET(a) 0 +#define EDGEFLAG_SET(a,b) (void)b +#endif + +#ifndef RESET_STIPPLE +#define RESET_STIPPLE +#endif + +#ifndef RESET_OCCLUSION +#define RESET_OCCLUSION +#endif + +#ifndef TEST_PRIM_END +#define TEST_PRIM_END(flags) (flags & PRIM_END) +#define TEST_PRIM_BEGIN(flags) (flags & PRIM_BEGIN) +#endif + +#ifndef ELT +#define ELT(x) x +#endif + +#ifndef RENDER_TAB_QUALIFIER +#define RENDER_TAB_QUALIFIER static +#endif + +static void TAG(render_points)( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint flags ) +{ + LOCAL_VARS; + (void) flags; + + RESET_OCCLUSION; + INIT(GL_POINTS); + RENDER_POINTS( start, count ); + POSTFIX; +} + +static void TAG(render_lines)( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint flags ) +{ + GLuint j; + LOCAL_VARS; + (void) flags; + + RESET_OCCLUSION; + INIT(GL_LINES); + for (j=start+1; j<count; j+=2 ) { + RESET_STIPPLE; + RENDER_LINE( ELT(j-1), ELT(j) ); + } + POSTFIX; +} + + +static void TAG(render_line_strip)( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint flags ) +{ + GLuint j; + LOCAL_VARS; + (void) flags; + + RESET_OCCLUSION; + INIT(GL_LINE_STRIP); + + if (TEST_PRIM_BEGIN(flags)) { + RESET_STIPPLE; + } + + for (j=start+1; j<count; j++ ) + RENDER_LINE( ELT(j-1), ELT(j) ); + + POSTFIX; +} + + +static void TAG(render_line_loop)( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint flags ) +{ + GLuint i; + LOCAL_VARS; + + (void) flags; + + RESET_OCCLUSION; + INIT(GL_LINE_LOOP); + + if (start+1 < count) { + if (TEST_PRIM_BEGIN(flags)) { + RESET_STIPPLE; + RENDER_LINE( ELT(start), ELT(start+1) ); + } + + for ( i = start+2 ; i < count ; i++) { + RENDER_LINE( ELT(i-1), ELT(i) ); + } + + if ( TEST_PRIM_END(flags)) { + RENDER_LINE( ELT(count-1), ELT(start) ); + } + } + + POSTFIX; +} + + +static void TAG(render_triangles)( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint flags ) +{ + GLuint j; + LOCAL_VARS; + (void) flags; + + INIT(GL_TRIANGLES); + if (NEED_EDGEFLAG_SETUP) { + for (j=start+2; j<count; j+=3) { + /* Leave the edgeflags as supplied by the user. + */ + RESET_STIPPLE; + RENDER_TRI( ELT(j-2), ELT(j-1), ELT(j) ); + } + } else { + for (j=start+2; j<count; j+=3) { + RENDER_TRI( ELT(j-2), ELT(j-1), ELT(j) ); + } + } + POSTFIX; +} + + + +static void TAG(render_tri_strip)( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint flags ) +{ + GLuint j; + GLuint parity = 0; + LOCAL_VARS; + + INIT(GL_TRIANGLE_STRIP); + if (NEED_EDGEFLAG_SETUP) { + for (j=start+2;j<count;j++,parity^=1) { + GLuint ej2 = ELT(j-2+parity); + GLuint ej1 = ELT(j-1-parity); + GLuint ej = ELT(j); + GLboolean ef2 = EDGEFLAG_GET( ej2 ); + GLboolean ef1 = EDGEFLAG_GET( ej1 ); + GLboolean ef = EDGEFLAG_GET( ej ); + if (TEST_PRIM_BEGIN(flags)) { + RESET_STIPPLE; + } + EDGEFLAG_SET( ej2, GL_TRUE ); + EDGEFLAG_SET( ej1, GL_TRUE ); + EDGEFLAG_SET( ej, GL_TRUE ); + RENDER_TRI( ej2, ej1, ej ); + EDGEFLAG_SET( ej2, ef2 ); + EDGEFLAG_SET( ej1, ef1 ); + EDGEFLAG_SET( ej, ef ); + } + } else { + for (j=start+2; j<count ; j++, parity^=1) { + RENDER_TRI( ELT(j-2+parity), ELT(j-1-parity), ELT(j) ); + } + } + POSTFIX; +} + + +static void TAG(render_tri_fan)( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint flags ) +{ + GLuint j; + LOCAL_VARS; + (void) flags; + + INIT(GL_TRIANGLE_FAN); + if (NEED_EDGEFLAG_SETUP) { + for (j=start+2;j<count;j++) { + /* For trifans, all edges are boundary. + */ + GLuint ejs = ELT(start); + GLuint ej1 = ELT(j-1); + GLuint ej = ELT(j); + GLboolean efs = EDGEFLAG_GET( ejs ); + GLboolean ef1 = EDGEFLAG_GET( ej1 ); + GLboolean ef = EDGEFLAG_GET( ej ); + if (TEST_PRIM_BEGIN(flags)) { + RESET_STIPPLE; + } + EDGEFLAG_SET( ejs, GL_TRUE ); + EDGEFLAG_SET( ej1, GL_TRUE ); + EDGEFLAG_SET( ej, GL_TRUE ); + RENDER_TRI( ejs, ej1, ej); + EDGEFLAG_SET( ejs, efs ); + EDGEFLAG_SET( ej1, ef1 ); + EDGEFLAG_SET( ej, ef ); + } + } else { + for (j=start+2;j<count;j++) { + RENDER_TRI( ELT(start), ELT(j-1), ELT(j) ); + } + } + + POSTFIX; +} + + +static void TAG(render_poly)( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint flags ) +{ + GLuint j = start+2; + LOCAL_VARS; + (void) flags; + + INIT(GL_POLYGON); + if (NEED_EDGEFLAG_SETUP) { + GLboolean efstart = EDGEFLAG_GET( ELT(start) ); + GLboolean efcount = EDGEFLAG_GET( ELT(count-1) ); + + /* If the primitive does not begin here, the first edge + * is non-boundary. + */ + if (!TEST_PRIM_BEGIN(flags)) + EDGEFLAG_SET( ELT(start), GL_FALSE ); + else { + RESET_STIPPLE; + } + + /* If the primitive does not end here, the final edge is + * non-boundary. + */ + if (!TEST_PRIM_END(flags)) + EDGEFLAG_SET( ELT(count-1), GL_FALSE ); + + /* Draw the first triangles (possibly zero) + */ + if (j+1<count) { + GLboolean ef = EDGEFLAG_GET( ELT(j) ); + EDGEFLAG_SET( ELT(j), GL_FALSE ); + RENDER_TRI( ELT(j-1), ELT(j), ELT(start) ); + EDGEFLAG_SET( ELT(j), ef ); + j++; + + /* Don't render the first edge again: + */ + EDGEFLAG_SET( ELT(start), GL_FALSE ); + + for (;j+1<count;j++) { + GLboolean efj = EDGEFLAG_GET( ELT(j) ); + EDGEFLAG_SET( ELT(j), GL_FALSE ); + RENDER_TRI( ELT(j-1), ELT(j), ELT(start) ); + EDGEFLAG_SET( ELT(j), efj ); + } + } + + /* Draw the last or only triangle + */ + if (j < count) + RENDER_TRI( ELT(j-1), ELT(j), ELT(start) ); + + /* Restore the first and last edgeflags: + */ + EDGEFLAG_SET( ELT(count-1), efcount ); + EDGEFLAG_SET( ELT(start), efstart ); + + } + else { + for (j=start+2;j<count;j++) { + RENDER_TRI( ELT(j-1), ELT(j), ELT(start) ); + } + } + POSTFIX; +} + +static void TAG(render_quads)( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint flags ) +{ + GLuint j; + LOCAL_VARS; + (void) flags; + + INIT(GL_QUADS); + if (NEED_EDGEFLAG_SETUP) { + for (j=start+3; j<count; j+=4) { + /* Use user-specified edgeflags for quads. + */ + RESET_STIPPLE; + RENDER_QUAD( ELT(j-3), ELT(j-2), ELT(j-1), ELT(j) ); + } + } else { + for (j=start+3; j<count; j+=4) { + RENDER_QUAD( ELT(j-3), ELT(j-2), ELT(j-1), ELT(j) ); + } + } + POSTFIX; +} + +static void TAG(render_quad_strip)( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint flags ) +{ + GLuint j; + LOCAL_VARS; + (void) flags; + + INIT(GL_QUAD_STRIP); + if (NEED_EDGEFLAG_SETUP) { + for (j=start+3;j<count;j+=2) { + /* All edges are boundary. Set edgeflags to 1, draw the + * quad, and restore them to the original values. + */ + GLboolean ef3 = EDGEFLAG_GET( ELT(j-3) ); + GLboolean ef2 = EDGEFLAG_GET( ELT(j-2) ); + GLboolean ef1 = EDGEFLAG_GET( ELT(j-1) ); + GLboolean ef = EDGEFLAG_GET( ELT(j) ); + if (TEST_PRIM_BEGIN(flags)) { + RESET_STIPPLE; + } + EDGEFLAG_SET( ELT(j-3), GL_TRUE ); + EDGEFLAG_SET( ELT(j-2), GL_TRUE ); + EDGEFLAG_SET( ELT(j-1), GL_TRUE ); + EDGEFLAG_SET( ELT(j), GL_TRUE ); + RENDER_QUAD( ELT(j-1), ELT(j-3), ELT(j-2), ELT(j) ); + EDGEFLAG_SET( ELT(j-3), ef3 ); + EDGEFLAG_SET( ELT(j-2), ef2 ); + EDGEFLAG_SET( ELT(j-1), ef1 ); + EDGEFLAG_SET( ELT(j), ef ); + } + } else { + for (j=start+3;j<count;j+=2) { + RENDER_QUAD( ELT(j-1), ELT(j-3), ELT(j-2), ELT(j) ); + } + } + POSTFIX; +} + +static void TAG(render_noop)( GLcontext *ctx, + GLuint start, + GLuint count, + GLuint flags ) +{ + (void)(ctx && start && count && flags); +} + +RENDER_TAB_QUALIFIER void (*TAG(render_tab)[GL_POLYGON+2])(GLcontext *, + GLuint, + GLuint, + GLuint) = +{ + TAG(render_points), + TAG(render_lines), + TAG(render_line_loop), + TAG(render_line_strip), + TAG(render_triangles), + TAG(render_tri_strip), + TAG(render_tri_fan), + TAG(render_quads), + TAG(render_quad_strip), + TAG(render_poly), + TAG(render_noop), +}; + + + +#ifndef PRESERVE_VB_DEFS +#undef RENDER_TRI +#undef RENDER_QUAD +#undef RENDER_LINE +#undef RENDER_POINTS +#undef LOCAL_VARS +#undef INIT +#undef POSTFIX +#undef RESET_STIPPLE +#undef DBG +#undef ELT +#undef RENDER_TAB_QUALIFIER +#endif + +#ifndef PRESERVE_TAG +#undef TAG +#endif + +#undef PRESERVE_VB_DEFS +#undef PRESERVE_TAG diff --git a/src/mesa/tnl/t_vb_texgen.c b/src/mesa/tnl/t_vb_texgen.c new file mode 100644 index 0000000..e9719b3 --- /dev/null +++ b/src/mesa/tnl/t_vb_texgen.c @@ -0,0 +1,691 @@ +/* + * Mesa 3-D graphics library + * Version: 6.1 + * + * Copyright (C) 1999-2004 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Brian Paul + * Keith Whitwell <keith@tungstengraphics.com> + */ + +/* + * Regarding GL_NV_texgen_reflection: + * + * Portions of this software may use or implement intellectual + * property owned and licensed by NVIDIA Corporation. NVIDIA disclaims + * any and all warranties with respect to such intellectual property, + * including any use thereof or modifications thereto. + */ + +#include "glheader.h" +#include "colormac.h" +#include "context.h" +#include "macros.h" +#include "imports.h" +#include "mtypes.h" + +#include "math/m_xform.h" + +#include "t_context.h" +#include "t_pipeline.h" + + +/*********************************************************************** + * Automatic texture coordinate generation (texgen) code. + */ + + +struct texgen_stage_data; + +typedef void (*texgen_func)( GLcontext *ctx, + struct texgen_stage_data *store, + GLuint unit); + + +struct texgen_stage_data { + + /* Per-texunit derived state. + */ + GLuint TexgenSize[MAX_TEXTURE_COORD_UNITS]; + GLuint TexgenHoles[MAX_TEXTURE_COORD_UNITS]; + texgen_func TexgenFunc[MAX_TEXTURE_COORD_UNITS]; + + /* Temporary values used in texgen. + */ + GLfloat (*tmp_f)[3]; + GLfloat *tmp_m; + + /* Buffered outputs of the stage. + */ + GLvector4f texcoord[MAX_TEXTURE_COORD_UNITS]; +}; + + +#define TEXGEN_STAGE_DATA(stage) ((struct texgen_stage_data *)stage->privatePtr) + + + +static GLuint all_bits[5] = { + 0, + VEC_SIZE_1, + VEC_SIZE_2, + VEC_SIZE_3, + VEC_SIZE_4, +}; + +#define VEC_SIZE_FLAGS (VEC_SIZE_1|VEC_SIZE_2|VEC_SIZE_3|VEC_SIZE_4) + +#define TEXGEN_NEED_M (TEXGEN_SPHERE_MAP) +#define TEXGEN_NEED_F (TEXGEN_SPHERE_MAP | \ + TEXGEN_REFLECTION_MAP_NV) + + + +static void build_m3( GLfloat f[][3], GLfloat m[], + const GLvector4f *normal, + const GLvector4f *eye ) +{ + GLuint stride = eye->stride; + GLfloat *coord = (GLfloat *)eye->start; + GLuint count = eye->count; + const GLfloat *norm = normal->start; + GLuint i; + + for (i=0;i<count;i++,STRIDE_F(coord,stride),STRIDE_F(norm,normal->stride)) { + GLfloat u[3], two_nu, fx, fy, fz; + COPY_3V( u, coord ); + NORMALIZE_3FV( u ); + two_nu = 2.0F * DOT3(norm,u); + fx = f[i][0] = u[0] - norm[0] * two_nu; + fy = f[i][1] = u[1] - norm[1] * two_nu; + fz = f[i][2] = u[2] - norm[2] * two_nu; + m[i] = fx * fx + fy * fy + (fz + 1.0F) * (fz + 1.0F); + if (m[i] != 0.0F) { + m[i] = 0.5F * _mesa_inv_sqrtf(m[i]); + } + } +} + + + +static void build_m2( GLfloat f[][3], GLfloat m[], + const GLvector4f *normal, + const GLvector4f *eye ) +{ + GLuint stride = eye->stride; + GLfloat *coord = eye->start; + GLuint count = eye->count; + + GLfloat *norm = normal->start; + GLuint i; + + for (i=0;i<count;i++,STRIDE_F(coord,stride),STRIDE_F(norm,normal->stride)) { + GLfloat u[3], two_nu, fx, fy, fz; + COPY_2V( u, coord ); + u[2] = 0; + NORMALIZE_3FV( u ); + two_nu = 2.0F * DOT3(norm,u); + fx = f[i][0] = u[0] - norm[0] * two_nu; + fy = f[i][1] = u[1] - norm[1] * two_nu; + fz = f[i][2] = u[2] - norm[2] * two_nu; + m[i] = fx * fx + fy * fy + (fz + 1.0F) * (fz + 1.0F); + if (m[i] != 0.0F) { + m[i] = 0.5F * _mesa_inv_sqrtf(m[i]); + } + } +} + + + +typedef void (*build_m_func)( GLfloat f[][3], + GLfloat m[], + const GLvector4f *normal, + const GLvector4f *eye ); + + +static build_m_func build_m_tab[5] = { + 0, + 0, + build_m2, + build_m3, + build_m3 +}; + + +/* This is unusual in that we respect the stride of the output vector + * (f). This allows us to pass in either a texcoord vector4f, or a + * temporary vector3f. + */ +static void build_f3( GLfloat *f, + GLuint fstride, + const GLvector4f *normal, + const GLvector4f *eye ) +{ + GLuint stride = eye->stride; + GLfloat *coord = eye->start; + GLuint count = eye->count; + + GLfloat *norm = normal->start; + GLuint i; + + for (i=0;i<count;i++) { + GLfloat u[3], two_nu; + COPY_3V( u, coord ); + NORMALIZE_3FV( u ); + two_nu = 2.0F * DOT3(norm,u); + f[0] = u[0] - norm[0] * two_nu; + f[1] = u[1] - norm[1] * two_nu; + f[2] = u[2] - norm[2] * two_nu; + STRIDE_F(coord,stride); + STRIDE_F(f,fstride); + STRIDE_F(norm, normal->stride); + } +} + + +static void build_f2( GLfloat *f, + GLuint fstride, + const GLvector4f *normal, + const GLvector4f *eye ) +{ + GLuint stride = eye->stride; + GLfloat *coord = eye->start; + GLuint count = eye->count; + GLfloat *norm = normal->start; + GLuint i; + + for (i=0;i<count;i++) { + + GLfloat u[3], two_nu; + COPY_2V( u, coord ); + u[2] = 0; + NORMALIZE_3FV( u ); + two_nu = 2.0F * DOT3(norm,u); + f[0] = u[0] - norm[0] * two_nu; + f[1] = u[1] - norm[1] * two_nu; + f[2] = u[2] - norm[2] * two_nu; + + STRIDE_F(coord,stride); + STRIDE_F(f,fstride); + STRIDE_F(norm, normal->stride); + } +} + +typedef void (*build_f_func)( GLfloat *f, + GLuint fstride, + const GLvector4f *normal_vec, + const GLvector4f *eye ); + + + +/* Just treat 4-vectors as 3-vectors. + */ +static build_f_func build_f_tab[5] = { + 0, + 0, + build_f2, + build_f3, + build_f3 +}; + + +/* Special case texgen functions. + */ +static void texgen_reflection_map_nv( GLcontext *ctx, + struct texgen_stage_data *store, + GLuint unit ) +{ + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + GLvector4f *in = VB->TexCoordPtr[unit]; + GLvector4f *out = &store->texcoord[unit]; + + build_f_tab[VB->EyePtr->size]( out->start, + out->stride, + VB->NormalPtr, + VB->EyePtr ); + + if (in) { + out->flags |= (in->flags & VEC_SIZE_FLAGS) | VEC_SIZE_3; + out->count = in->count; + out->size = MAX2(in->size, 3); + if (in->size == 4) + _mesa_copy_tab[0x8]( out, in ); + } + else { + out->flags |= VEC_SIZE_3; + out->size = 3; + out->count = in->count; + } + +} + + + +static void texgen_normal_map_nv( GLcontext *ctx, + struct texgen_stage_data *store, + GLuint unit ) +{ + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + GLvector4f *in = VB->TexCoordPtr[unit]; + GLvector4f *out = &store->texcoord[unit]; + GLvector4f *normal = VB->NormalPtr; + GLfloat (*texcoord)[4] = (GLfloat (*)[4])out->start; + GLuint count = VB->Count; + GLuint i; + const GLfloat *norm = normal->start; + + for (i=0;i<count;i++, STRIDE_F(norm, normal->stride)) { + texcoord[i][0] = norm[0]; + texcoord[i][1] = norm[1]; + texcoord[i][2] = norm[2]; + } + + + if (in) { + out->flags |= (in->flags & VEC_SIZE_FLAGS) | VEC_SIZE_3; + out->count = in->count; + out->size = MAX2(in->size, 3); + if (in->size == 4) + _mesa_copy_tab[0x8]( out, in ); + } + else { + out->flags |= VEC_SIZE_3; + out->size = 3; + out->count = in->count; + } +} + + +static void texgen_sphere_map( GLcontext *ctx, + struct texgen_stage_data *store, + GLuint unit ) +{ + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + GLvector4f *in = VB->TexCoordPtr[unit]; + GLvector4f *out = &store->texcoord[unit]; + GLfloat (*texcoord)[4] = (GLfloat (*)[4]) out->start; + GLuint count = VB->Count; + GLuint i; + GLfloat (*f)[3] = store->tmp_f; + GLfloat *m = store->tmp_m; + + (build_m_tab[VB->EyePtr->size])( store->tmp_f, + store->tmp_m, + VB->NormalPtr, + VB->EyePtr ); + + for (i=0;i<count;i++) { + texcoord[i][0] = f[i][0] * m[i] + 0.5F; + texcoord[i][1] = f[i][1] * m[i] + 0.5F; + } + + if (in) { + out->size = MAX2(in->size,2); + out->count = in->count; + out->flags |= (in->flags & VEC_SIZE_FLAGS) | VEC_SIZE_2; + if (in->size > 2) + _mesa_copy_tab[all_bits[in->size] & ~0x3]( out, in ); + } else { + out->size = 2; + out->flags |= VEC_SIZE_2; + out->count = in->count; + } +} + + + +static void texgen( GLcontext *ctx, + struct texgen_stage_data *store, + GLuint unit ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + GLvector4f *in = VB->TexCoordPtr[unit]; + GLvector4f *out = &store->texcoord[unit]; + const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; + const GLvector4f *obj = VB->ObjPtr; + const GLvector4f *eye = VB->EyePtr; + const GLvector4f *normal = VB->NormalPtr; + const GLfloat *m = store->tmp_m; + const GLuint count = VB->Count; + GLfloat (*texcoord)[4] = (GLfloat (*)[4])out->data; + GLfloat (*f)[3] = store->tmp_f; + GLuint holes = 0; + + if (texUnit->_GenFlags & TEXGEN_NEED_M) { + build_m_tab[eye->size]( store->tmp_f, store->tmp_m, normal, eye ); + } else if (texUnit->_GenFlags & TEXGEN_NEED_F) { + build_f_tab[eye->size]( (GLfloat *)store->tmp_f, 3, normal, eye ); + } + + if (!in) { + ASSERT(0); + in = out; + in->count = VB->Count; + + out->size = store->TexgenSize[unit]; + out->flags |= texUnit->TexGenEnabled; + out->count = VB->Count; + holes = store->TexgenHoles[unit]; + } + else { + GLuint copy = (all_bits[in->size] & ~texUnit->TexGenEnabled); + if (copy) + _mesa_copy_tab[copy]( out, in ); + + out->size = MAX2(in->size, store->TexgenSize[unit]); + out->flags |= (in->flags & VEC_SIZE_FLAGS) | texUnit->TexGenEnabled; + out->count = in->count; + + holes = ~all_bits[in->size] & store->TexgenHoles[unit]; + } + + if (holes) { + if (holes & VEC_DIRTY_3) _mesa_vector4f_clean_elem(out, count, 3); + if (holes & VEC_DIRTY_2) _mesa_vector4f_clean_elem(out, count, 2); + if (holes & VEC_DIRTY_1) _mesa_vector4f_clean_elem(out, count, 1); + if (holes & VEC_DIRTY_0) _mesa_vector4f_clean_elem(out, count, 0); + } + + if (texUnit->TexGenEnabled & S_BIT) { + GLuint i; + switch (texUnit->GenModeS) { + case GL_OBJECT_LINEAR: + _mesa_dotprod_tab[obj->size]( (GLfloat *)out->data, + sizeof(out->data[0]), obj, + texUnit->ObjectPlaneS ); + break; + case GL_EYE_LINEAR: + _mesa_dotprod_tab[eye->size]( (GLfloat *)out->data, + sizeof(out->data[0]), eye, + texUnit->EyePlaneS ); + break; + case GL_SPHERE_MAP: + for (i = 0; i < count; i++) + texcoord[i][0] = f[i][0] * m[i] + 0.5F; + break; + case GL_REFLECTION_MAP_NV: + for (i=0;i<count;i++) + texcoord[i][0] = f[i][0]; + break; + case GL_NORMAL_MAP_NV: { + const GLfloat *norm = normal->start; + for (i=0;i<count;i++, STRIDE_F(norm, normal->stride)) { + texcoord[i][0] = norm[0]; + } + break; + } + default: + _mesa_problem(ctx, "Bad S texgen"); + } + } + + if (texUnit->TexGenEnabled & T_BIT) { + GLuint i; + switch (texUnit->GenModeT) { + case GL_OBJECT_LINEAR: + _mesa_dotprod_tab[obj->size]( &(out->data[0][1]), + sizeof(out->data[0]), obj, + texUnit->ObjectPlaneT ); + break; + case GL_EYE_LINEAR: + _mesa_dotprod_tab[eye->size]( &(out->data[0][1]), + sizeof(out->data[0]), eye, + texUnit->EyePlaneT ); + break; + case GL_SPHERE_MAP: + for (i = 0; i < count; i++) + texcoord[i][1] = f[i][1] * m[i] + 0.5F; + break; + case GL_REFLECTION_MAP_NV: + for (i=0;i<count;i++) + texcoord[i][1] = f[i][1]; + break; + case GL_NORMAL_MAP_NV: { + const GLfloat *norm = normal->start; + for (i=0;i<count;i++, STRIDE_F(norm, normal->stride)) { + texcoord[i][1] = norm[1]; + } + break; + } + default: + _mesa_problem(ctx, "Bad T texgen"); + } + } + + if (texUnit->TexGenEnabled & R_BIT) { + GLuint i; + switch (texUnit->GenModeR) { + case GL_OBJECT_LINEAR: + _mesa_dotprod_tab[obj->size]( &(out->data[0][2]), + sizeof(out->data[0]), obj, + texUnit->ObjectPlaneR ); + break; + case GL_EYE_LINEAR: + _mesa_dotprod_tab[eye->size]( &(out->data[0][2]), + sizeof(out->data[0]), eye, + texUnit->EyePlaneR ); + break; + case GL_REFLECTION_MAP_NV: + for (i=0;i<count;i++) + texcoord[i][2] = f[i][2]; + break; + case GL_NORMAL_MAP_NV: { + const GLfloat *norm = normal->start; + for (i=0;i<count;i++,STRIDE_F(norm, normal->stride)) { + texcoord[i][2] = norm[2]; + } + break; + } + default: + _mesa_problem(ctx, "Bad R texgen"); + } + } + + if (texUnit->TexGenEnabled & Q_BIT) { + switch (texUnit->GenModeQ) { + case GL_OBJECT_LINEAR: + _mesa_dotprod_tab[obj->size]( &(out->data[0][3]), + sizeof(out->data[0]), obj, + texUnit->ObjectPlaneQ ); + break; + case GL_EYE_LINEAR: + _mesa_dotprod_tab[eye->size]( &(out->data[0][3]), + sizeof(out->data[0]), eye, + texUnit->EyePlaneQ ); + break; + default: + _mesa_problem(ctx, "Bad Q texgen"); + } + } +} + + + +static GLboolean run_texgen_stage( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + struct texgen_stage_data *store = TEXGEN_STAGE_DATA( stage ); + GLuint i; + + for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) + if (ctx->Texture._TexGenEnabled & ENABLE_TEXGEN(i)) { + if (stage->changed_inputs & (_TNL_BIT_POS | _TNL_BIT_NORMAL | _TNL_BIT_TEX(i))) + store->TexgenFunc[i]( ctx, store, i ); + + VB->AttribPtr[VERT_ATTRIB_TEX0+i] = + VB->TexCoordPtr[i] = &store->texcoord[i]; + } + + return GL_TRUE; +} + + + + +static GLboolean run_validate_texgen_stage( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + struct texgen_stage_data *store = TEXGEN_STAGE_DATA(stage); + GLuint i; + + for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) { + struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i]; + + if (texUnit->TexGenEnabled) { + GLuint sz; + + if (texUnit->TexGenEnabled & Q_BIT) + sz = 4; + else if (texUnit->TexGenEnabled & R_BIT) + sz = 3; + else if (texUnit->TexGenEnabled & T_BIT) + sz = 2; + else + sz = 1; + + store->TexgenSize[i] = sz; + store->TexgenHoles[i] = (all_bits[sz] & ~texUnit->TexGenEnabled); + store->TexgenFunc[i] = texgen; /* general solution */ + + /* look for special texgen cases */ + if (texUnit->TexGenEnabled == (S_BIT|T_BIT|R_BIT)) { + if (texUnit->_GenFlags == TEXGEN_REFLECTION_MAP_NV) { + store->TexgenFunc[i] = texgen_reflection_map_nv; + } + else if (texUnit->_GenFlags == TEXGEN_NORMAL_MAP_NV) { + store->TexgenFunc[i] = texgen_normal_map_nv; + } + } + else if (texUnit->TexGenEnabled == (S_BIT|T_BIT) && + texUnit->_GenFlags == TEXGEN_SPHERE_MAP) { + store->TexgenFunc[i] = texgen_sphere_map; + } + } + } + + stage->run = run_texgen_stage; + return stage->run( ctx, stage ); +} + + +static void check_texgen( GLcontext *ctx, struct tnl_pipeline_stage *stage ) +{ + GLuint i; + stage->active = 0; + + if (ctx->Texture._TexGenEnabled && !ctx->VertexProgram._Enabled) { + GLuint inputs = 0; + GLuint outputs = 0; + + if (ctx->Texture._GenFlags & (TEXGEN_OBJ_LINEAR | TEXGEN_NEED_EYE_COORD)) + inputs |= _TNL_BIT_POS; + + if (ctx->Texture._GenFlags & TEXGEN_NEED_NORMALS) + inputs |= _TNL_BIT_NORMAL; + + for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) + if (ctx->Texture._TexGenEnabled & ENABLE_TEXGEN(i)) + { + outputs |= _TNL_BIT_TEX(i); + + /* Need the original input in case it contains a Q coord: + * (sigh) + */ + inputs |= _TNL_BIT_TEX(i); + + /* Something for Feedback? */ + } + + if (stage->privatePtr) + stage->run = run_validate_texgen_stage; + stage->active = 1; + stage->inputs = inputs; + stage->outputs = outputs; + } +} + + + + +/* Called the first time stage->run() is invoked. + */ +static GLboolean alloc_texgen_data( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + struct texgen_stage_data *store; + GLuint i; + + stage->privatePtr = CALLOC(sizeof(*store)); + store = TEXGEN_STAGE_DATA(stage); + if (!store) + return GL_FALSE; + + for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) + _mesa_vector4f_alloc( &store->texcoord[i], 0, VB->Size, 32 ); + + store->tmp_f = (GLfloat (*)[3]) MALLOC(VB->Size * sizeof(GLfloat) * 3); + store->tmp_m = (GLfloat *) MALLOC(VB->Size * sizeof(GLfloat)); + + /* Now validate and run the stage. + */ + stage->run = run_validate_texgen_stage; + return stage->run( ctx, stage ); +} + + +static void free_texgen_data( struct tnl_pipeline_stage *stage ) + +{ + struct texgen_stage_data *store = TEXGEN_STAGE_DATA(stage); + GLuint i; + + if (store) { + for (i = 0 ; i < MAX_TEXTURE_COORD_UNITS ; i++) + if (store->texcoord[i].data) + _mesa_vector4f_free( &store->texcoord[i] ); + + + if (store->tmp_f) FREE( store->tmp_f ); + if (store->tmp_m) FREE( store->tmp_m ); + FREE( store ); + stage->privatePtr = NULL; + } +} + + + +const struct tnl_pipeline_stage _tnl_texgen_stage = +{ + "texgen", /* name */ + _NEW_TEXTURE|_NEW_PROGRAM, /* when to call check() */ + _NEW_TEXTURE, /* when to invalidate stored data */ + GL_FALSE, /* active? */ + 0, /* inputs */ + 0, /* outputs */ + 0, /* changed_inputs */ + NULL, /* private data */ + free_texgen_data, /* destructor */ + check_texgen, /* check */ + alloc_texgen_data /* run -- initially set to alloc data */ +}; diff --git a/src/mesa/tnl/t_vb_texmat.c b/src/mesa/tnl/t_vb_texmat.c new file mode 100644 index 0000000..8f6ca89 --- /dev/null +++ b/src/mesa/tnl/t_vb_texmat.c @@ -0,0 +1,150 @@ +/* + * Mesa 3-D graphics library + * Version: 6.1 + * + * Copyright (C) 1999-2004 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + + +#include "glheader.h" +#include "colormac.h" +#include "context.h" +#include "macros.h" +#include "imports.h" +#include "mtypes.h" + +#include "math/m_xform.h" + +#include "t_context.h" +#include "t_pipeline.h" + +/* Is there any real benefit seperating texmat from texgen? It means + * we need two lots of intermediate storage. Any changes to + * _NEW_TEXTURE will invalidate both sets -- it's only on changes to + * *only* _NEW_TEXTURE_MATRIX that texgen survives but texmat doesn't. + * + * However, the seperation of this code from the complex texgen stuff + * is very appealing. + */ +struct texmat_stage_data { + GLvector4f texcoord[MAX_TEXTURE_COORD_UNITS]; +}; + +#define TEXMAT_STAGE_DATA(stage) ((struct texmat_stage_data *)stage->privatePtr) + +static void check_texmat( GLcontext *ctx, struct tnl_pipeline_stage *stage ) +{ + GLuint i; + stage->active = 0; + + if (ctx->Texture._TexMatEnabled && !ctx->VertexProgram._Enabled) { + GLuint flags = 0; + + for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) + if (ctx->Texture._TexMatEnabled & ENABLE_TEXMAT(i)) + flags |= _TNL_BIT_TEX(i); + + stage->active = 1; + stage->inputs = flags; + stage->outputs = flags; + } +} + +static GLboolean run_texmat_stage( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + struct texmat_stage_data *store = TEXMAT_STAGE_DATA(stage); + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + GLuint i; + + /* ENABLE_TEXMAT implies that the texture matrix is not the + * identity, so we don't have to check that here. + */ + for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) + if (ctx->Texture._TexMatEnabled & ENABLE_TEXMAT(i)) { + if (stage->changed_inputs & _TNL_BIT_TEX(i)) + (void) TransformRaw( &store->texcoord[i], + ctx->TextureMatrixStack[i].Top, + VB->TexCoordPtr[i]); + + VB->AttribPtr[VERT_ATTRIB_TEX0+i] = + VB->TexCoordPtr[i] = &store->texcoord[i]; + } + return GL_TRUE; +} + + +/* Called the first time stage->run() is invoked. + */ +static GLboolean alloc_texmat_data( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + struct texmat_stage_data *store; + GLuint i; + + stage->privatePtr = CALLOC(sizeof(*store)); + store = TEXMAT_STAGE_DATA(stage); + if (!store) + return GL_FALSE; + + for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) + _mesa_vector4f_alloc( &store->texcoord[i], 0, VB->Size, 32 ); + + /* Now run the stage. + */ + stage->run = run_texmat_stage; + return stage->run( ctx, stage ); +} + + +static void free_texmat_data( struct tnl_pipeline_stage *stage ) +{ + struct texmat_stage_data *store = TEXMAT_STAGE_DATA(stage); + GLuint i; + + if (store) { + for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) + if (store->texcoord[i].data) + _mesa_vector4f_free( &store->texcoord[i] ); + FREE( store ); + stage->privatePtr = 0; + } +} + + + +const struct tnl_pipeline_stage _tnl_texture_transform_stage = +{ + "texture transform", /* name */ + _NEW_TEXTURE|_NEW_TEXTURE_MATRIX|_NEW_PROGRAM, /* check_state */ + _NEW_TEXTURE|_NEW_TEXTURE_MATRIX, /* run_state */ + GL_FALSE, /* active? */ + 0, /* inputs */ + 0, /* outputs */ + 0, /* changed_inputs */ + NULL, /* private data */ + free_texmat_data, /* destructor */ + check_texmat, /* check */ + alloc_texmat_data, /* run -- initially set to init */ +}; diff --git a/src/mesa/tnl/t_vb_vertex.c b/src/mesa/tnl/t_vb_vertex.c new file mode 100644 index 0000000..3951439 --- /dev/null +++ b/src/mesa/tnl/t_vb_vertex.c @@ -0,0 +1,331 @@ +/* + * Mesa 3-D graphics library + * Version: 6.1 + * + * Copyright (C) 1999-2004 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + + +#include "glheader.h" +#include "colormac.h" +#include "context.h" +#include "macros.h" +#include "imports.h" +#include "mtypes.h" + +#include "math/m_xform.h" + +#include "t_context.h" +#include "t_pipeline.h" + + + +struct vertex_stage_data { + GLvector4f eye; + GLvector4f clip; + GLvector4f proj; + GLubyte *clipmask; + GLubyte ormask; + GLubyte andmask; + + + /* Need these because it's difficult to replay the sideeffects + * analytically. + */ + GLvector4f *save_eyeptr; + GLvector4f *save_clipptr; + GLvector4f *save_ndcptr; +}; + +#define VERTEX_STAGE_DATA(stage) ((struct vertex_stage_data *)stage->privatePtr) + + + + +/* This function implements cliptesting for user-defined clip planes. + * The clipping of primitives to these planes is implemented in + * t_render_clip.h. + */ +#define USER_CLIPTEST(NAME, SZ) \ +static void NAME( GLcontext *ctx, \ + GLvector4f *clip, \ + GLubyte *clipmask, \ + GLubyte *clipormask, \ + GLubyte *clipandmask ) \ +{ \ + GLuint p; \ + \ + for (p = 0; p < ctx->Const.MaxClipPlanes; p++) \ + if (ctx->Transform.ClipPlanesEnabled & (1 << p)) { \ + GLuint nr, i; \ + const GLfloat a = ctx->Transform._ClipUserPlane[p][0]; \ + const GLfloat b = ctx->Transform._ClipUserPlane[p][1]; \ + const GLfloat c = ctx->Transform._ClipUserPlane[p][2]; \ + const GLfloat d = ctx->Transform._ClipUserPlane[p][3]; \ + GLfloat *coord = (GLfloat *)clip->data; \ + GLuint stride = clip->stride; \ + GLuint count = clip->count; \ + \ + for (nr = 0, i = 0 ; i < count ; i++) { \ + GLfloat dp = coord[0] * a + coord[1] * b; \ + if (SZ > 2) dp += coord[2] * c; \ + if (SZ > 3) dp += coord[3] * d; else dp += d; \ + \ + if (dp < 0) { \ + nr++; \ + clipmask[i] |= CLIP_USER_BIT; \ + } \ + \ + STRIDE_F(coord, stride); \ + } \ + \ + if (nr > 0) { \ + *clipormask |= CLIP_USER_BIT; \ + if (nr == count) { \ + *clipandmask |= CLIP_USER_BIT; \ + return; \ + } \ + } \ + } \ +} + + +USER_CLIPTEST(userclip2, 2) +USER_CLIPTEST(userclip3, 3) +USER_CLIPTEST(userclip4, 4) + +static void (*(usercliptab[5]))( GLcontext *, + GLvector4f *, GLubyte *, + GLubyte *, GLubyte * ) = +{ + 0, + 0, + userclip2, + userclip3, + userclip4 +}; + + + +static GLboolean run_vertex_stage( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + struct vertex_stage_data *store = (struct vertex_stage_data *)stage->privatePtr; + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + + ASSERT(!ctx->VertexProgram._Enabled); + + if (stage->changed_inputs) { + + if (ctx->_NeedEyeCoords) { + /* Separate modelview transformation: + * Use combined ModelProject to avoid some depth artifacts + */ + if (ctx->ModelviewMatrixStack.Top->type == MATRIX_IDENTITY) + VB->EyePtr = VB->ObjPtr; + else + VB->EyePtr = TransformRaw( &store->eye, + ctx->ModelviewMatrixStack.Top, + VB->ObjPtr); +#if 0 + /* examine some eye coordinates */ + { + GLuint i; + GLfloat *v = VB->EyePtr->start; + for (i = 0; i < 4; i++) { + _mesa_printf("eye[%d] = %g, %g, %g, %g\n", + i, v[0], v[1], v[2], v[3]); + v += 4; + } + } +#endif + } + + VB->ClipPtr = TransformRaw( &store->clip, + &ctx->_ModelProjectMatrix, + VB->ObjPtr ); + + /* Drivers expect this to be clean to element 4... + */ + switch (VB->ClipPtr->size) { + case 1: + /* impossible */ + case 2: + _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 2 ); + /* fall-through */ + case 3: + _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 3 ); + /* fall-through */ + case 4: + break; + } + +#if 0 + /* examine some clip coordinates */ + { + GLuint i; + GLfloat *v = VB->ClipPtr->start; + for (i = 0; i < 4; i++) { + _mesa_printf("clip[%d] = %g, %g, %g, %g\n", + i, v[0], v[1], v[2], v[3]); + v += 4; + } + } +#endif + + /* Cliptest and perspective divide. Clip functions must clear + * the clipmask. + */ + store->ormask = 0; + store->andmask = CLIP_ALL_BITS; + + if (tnl->NeedNdcCoords) { + VB->NdcPtr = + _mesa_clip_tab[VB->ClipPtr->size]( VB->ClipPtr, + &store->proj, + store->clipmask, + &store->ormask, + &store->andmask ); + } + else { + VB->NdcPtr = 0; + _mesa_clip_np_tab[VB->ClipPtr->size]( VB->ClipPtr, + 0, + store->clipmask, + &store->ormask, + &store->andmask ); + } + + if (store->andmask) + return GL_FALSE; + + + /* Test userclip planes. This contributes to VB->ClipMask, so + * is essentially required to be in this stage. + */ + if (ctx->Transform.ClipPlanesEnabled) { + usercliptab[VB->ClipPtr->size]( ctx, + VB->ClipPtr, + store->clipmask, + &store->ormask, + &store->andmask ); + + if (store->andmask) + return GL_FALSE; + } + + VB->ClipAndMask = store->andmask; + VB->ClipOrMask = store->ormask; + VB->ClipMask = store->clipmask; + + store->save_eyeptr = VB->EyePtr; + store->save_clipptr = VB->ClipPtr; + store->save_ndcptr = VB->NdcPtr; + } + else { + /* Replay the sideeffects. + */ + VB->EyePtr = store->save_eyeptr; + VB->ClipPtr = store->save_clipptr; + VB->NdcPtr = store->save_ndcptr; + VB->ClipMask = store->clipmask; + VB->ClipAndMask = store->andmask; + VB->ClipOrMask = store->ormask; + if (store->andmask) + return GL_FALSE; + } + + return GL_TRUE; +} + + +static void check_vertex( GLcontext *ctx, struct tnl_pipeline_stage *stage ) +{ + stage->active = !ctx->VertexProgram._Enabled; +} + +static GLboolean init_vertex_stage( GLcontext *ctx, + struct tnl_pipeline_stage *stage ) +{ + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + struct vertex_stage_data *store; + GLuint size = VB->Size; + + stage->privatePtr = CALLOC(sizeof(*store)); + store = VERTEX_STAGE_DATA(stage); + if (!store) + return GL_FALSE; + + _mesa_vector4f_alloc( &store->eye, 0, size, 32 ); + _mesa_vector4f_alloc( &store->clip, 0, size, 32 ); + _mesa_vector4f_alloc( &store->proj, 0, size, 32 ); + + store->clipmask = (GLubyte *) ALIGN_MALLOC(sizeof(GLubyte)*size, 32 ); + + if (!store->clipmask || + !store->eye.data || + !store->clip.data || + !store->proj.data) + return GL_FALSE; + + /* Now run the stage. + */ + stage->run = run_vertex_stage; + return stage->run( ctx, stage ); +} + +static void dtr( struct tnl_pipeline_stage *stage ) +{ + struct vertex_stage_data *store = VERTEX_STAGE_DATA(stage); + + if (store) { + _mesa_vector4f_free( &store->eye ); + _mesa_vector4f_free( &store->clip ); + _mesa_vector4f_free( &store->proj ); + ALIGN_FREE( store->clipmask ); + FREE(store); + stage->privatePtr = NULL; + stage->run = init_vertex_stage; + } +} + + +const struct tnl_pipeline_stage _tnl_vertex_transform_stage = +{ + "modelview/project/cliptest/divide", + _NEW_PROGRAM, /* check_state: only care about vertex prog */ + _MESA_NEW_NEED_EYE_COORDS | /* run_state: when to invalidate / re-run */ + _NEW_MODELVIEW| + _NEW_PROJECTION| + _NEW_PROGRAM| + _NEW_TRANSFORM, + GL_TRUE, /* active */ + _TNL_BIT_POS, /* inputs */ + _TNL_BIT_POS, /* outputs */ + 0, /* changed_inputs */ + NULL, /* private data */ + dtr, /* destructor */ + check_vertex, /* check */ + init_vertex_stage /* run -- initially set to init */ +}; diff --git a/src/mesa/tnl/t_vertex.c b/src/mesa/tnl/t_vertex.c new file mode 100644 index 0000000..900648a --- /dev/null +++ b/src/mesa/tnl/t_vertex.c @@ -0,0 +1,1294 @@ +/* + * Copyright 2003 Tungsten Graphics, inc. + * 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"), + * to deal in the Software without restriction, including without limitation + * on the rights to use, copy, modify, merge, publish, distribute, sub + * license, and/or sell copies of the Software, and to permit persons to whom + * the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keithw@tungstengraphics.com> + */ + +#include "glheader.h" +#include "context.h" +#include "colormac.h" + +#include "t_context.h" +#include "t_vertex.h" + + +/* Build and manage clipspace/ndc/window vertices. + * + * Another new mechanism designed and crying out for codegen. Before + * that, it would be very interesting to investigate the merger of + * these vertices and those built in t_vtx_*. + */ + + + + + + +/* + * These functions take the NDC coordinates pointed to by 'in', apply the + * NDC->Viewport mapping and store the results at 'v'. + */ + +static void +insert_4f_viewport_4( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)v; + const GLfloat * const vp = a->vp; + + out[0] = vp[0] * in[0] + vp[12]; + out[1] = vp[5] * in[1] + vp[13]; + out[2] = vp[10] * in[2] + vp[14]; + out[3] = in[3]; +} + +static void insert_4f_viewport_3( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)v; + const GLfloat * const vp = a->vp; + + out[0] = vp[0] * in[0] + vp[12]; + out[1] = vp[5] * in[1] + vp[13]; + out[2] = vp[10] * in[2] + vp[14]; + out[3] = 1; +} + +static void insert_4f_viewport_2( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)v; + const GLfloat * const vp = a->vp; + + out[0] = vp[0] * in[0] + vp[12]; + out[1] = vp[5] * in[1] + vp[13]; + out[2] = vp[14]; + out[3] = 1; +} + +static void insert_4f_viewport_1( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)v; + const GLfloat * const vp = a->vp; + + out[0] = vp[0] * in[0] + vp[12]; + out[1] = vp[13]; + out[2] = vp[14]; + out[3] = 1; +} + +static void insert_3f_viewport_3( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)v; + const GLfloat * const vp = a->vp; + + out[0] = vp[0] * in[0] + vp[12]; + out[1] = vp[5] * in[1] + vp[13]; + out[2] = vp[10] * in[2] + vp[14]; +} + +static void insert_3f_viewport_2( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)v; + const GLfloat * const vp = a->vp; + + out[0] = vp[0] * in[0] + vp[12]; + out[1] = vp[5] * in[1] + vp[13]; + out[2] = vp[10] * in[2] + vp[14]; +} + +static void insert_3f_viewport_1( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)v; + const GLfloat * const vp = a->vp; + + out[0] = vp[0] * in[0] + vp[12]; + out[1] = vp[13]; + out[2] = vp[14]; +} + +static void insert_2f_viewport_2( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)v; + const GLfloat * const vp = a->vp; + + out[0] = vp[0] * in[0] + vp[12]; + out[1] = vp[5] * in[1] + vp[13]; +} + +static void insert_2f_viewport_1( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)v; + const GLfloat * const vp = a->vp; + + out[0] = vp[0] * in[0] + vp[12]; + out[1] = vp[13]; +} + + +/* + * These functions do the same as above, except for the viewport mapping. + */ + +static void insert_4f_4( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)(v); + (void) a; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = in[2]; + out[3] = in[3]; +} + +static void insert_4f_3( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)(v); + (void) a; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = in[2]; + out[3] = 1; +} + +static void insert_4f_2( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)(v); + (void) a; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = 0; + out[3] = 1; +} + +static void insert_4f_1( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)(v); + (void) a; + + out[0] = in[0]; + out[1] = 0; + out[2] = 0; + out[3] = 1; +} + +static void insert_3f_xyw_4( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)(v); + (void) a; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = in[3]; +} + +static void insert_3f_xyw_err( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) +{ + (void) a; (void) v; (void) in; + abort(); +} + +static void insert_3f_3( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)(v); + (void) a; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = in[2]; +} + +static void insert_3f_2( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)(v); + (void) a; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = 0; +} + +static void insert_3f_1( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)(v); + (void) a; + + out[0] = in[0]; + out[1] = 0; + out[2] = 0; +} + + +static void insert_2f_2( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)(v); + (void) a; + + out[0] = in[0]; + out[1] = in[1]; +} + +static void insert_2f_1( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)(v); + (void) a; + + out[0] = in[0]; + out[1] = 0; +} + +static void insert_1f_1( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) +{ + GLfloat *out = (GLfloat *)(v); + (void) a; + + out[0] = in[0]; +} + +static void insert_4chan_4f_rgba_4( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + GLchan *c = (GLchan *)v; + (void) a; + UNCLAMPED_FLOAT_TO_CHAN(c[0], in[0]); + UNCLAMPED_FLOAT_TO_CHAN(c[1], in[1]); + UNCLAMPED_FLOAT_TO_CHAN(c[2], in[2]); + UNCLAMPED_FLOAT_TO_CHAN(c[3], in[3]); +} + +static void insert_4chan_4f_rgba_3( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + GLchan *c = (GLchan *)v; + (void) a; + UNCLAMPED_FLOAT_TO_CHAN(c[0], in[0]); + UNCLAMPED_FLOAT_TO_CHAN(c[1], in[1]); + UNCLAMPED_FLOAT_TO_CHAN(c[2], in[2]); + c[3] = CHAN_MAX; +} + +static void insert_4chan_4f_rgba_2( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + GLchan *c = (GLchan *)v; + (void) a; + UNCLAMPED_FLOAT_TO_CHAN(c[0], in[0]); + UNCLAMPED_FLOAT_TO_CHAN(c[1], in[1]); + c[2] = 0; + c[3] = CHAN_MAX; +} + +static void insert_4chan_4f_rgba_1( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + GLchan *c = (GLchan *)v; + (void) a; + UNCLAMPED_FLOAT_TO_CHAN(c[0], in[0]); + c[1] = 0; + c[2] = 0; + c[3] = CHAN_MAX; +} + +static void insert_4ub_4f_rgba_4( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[2]); + UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[3]); +} + +static void insert_4ub_4f_rgba_3( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[2]); + v[3] = 0xff; +} + +static void insert_4ub_4f_rgba_2( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); + v[2] = 0; + v[3] = 0xff; +} + +static void insert_4ub_4f_rgba_1( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); + v[1] = 0; + v[2] = 0; + v[3] = 0xff; +} + +static void insert_4ub_4f_bgra_4( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); + UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[2]); + UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[3]); +} + +static void insert_4ub_4f_bgra_3( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); + UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[2]); + v[3] = 0xff; +} + +static void insert_4ub_4f_bgra_2( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); + v[0] = 0; + v[3] = 0xff; +} + +static void insert_4ub_4f_bgra_1( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[0]); + v[1] = 0; + v[0] = 0; + v[3] = 0xff; +} + +static void insert_4ub_4f_argb_4( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[1]); + UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[2]); + UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[3]); +} + +static void insert_4ub_4f_argb_3( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[1]); + UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[2]); + v[0] = 0xff; +} + +static void insert_4ub_4f_argb_2( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[1]); + v[3] = 0x00; + v[0] = 0xff; +} + +static void insert_4ub_4f_argb_1( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[0]); + v[2] = 0x00; + v[3] = 0x00; + v[0] = 0xff; +} + +static void insert_4ub_4f_abgr_4( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[1]); + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[2]); + UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[3]); +} + +static void insert_4ub_4f_abgr_3( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[1]); + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[2]); + v[0] = 0xff; +} + +static void insert_4ub_4f_abgr_2( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[1]); + v[1] = 0x00; + v[0] = 0xff; +} + +static void insert_4ub_4f_abgr_1( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[0]); + v[2] = 0x00; + v[1] = 0x00; + v[0] = 0xff; +} + +static void insert_3ub_3f_rgb_3( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[2]); +} + +static void insert_3ub_3f_rgb_2( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); + v[2] = 0; +} + +static void insert_3ub_3f_rgb_1( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); + v[1] = 0; + v[2] = 0; +} + +static void insert_3ub_3f_bgr_3( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); + UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[2]); +} + +static void insert_3ub_3f_bgr_2( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[0]); + UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); + v[0] = 0; +} + +static void insert_3ub_3f_bgr_1( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[0]); + v[1] = 0; + v[0] = 0; +} + + +static void insert_1ub_1f_1( const struct tnl_clipspace_attr *a, GLubyte *v, + const GLfloat *in ) +{ + (void) a; + UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); +} + + +/*********************************************************************** + * Functions to perform the reverse operations to the above, for + * swrast translation and clip-interpolation. + * + * Currently always extracts a full 4 floats. + */ + +static void extract_4f_viewport( const struct tnl_clipspace_attr *a, GLfloat *out, + const GLubyte *v ) +{ + const GLfloat *in = (const GLfloat *)v; + const GLfloat * const vp = a->vp; + + /* Although included for completeness, the position coordinate is + * usually handled differently during clipping. + */ + out[0] = (in[0] - vp[12]) / vp[0]; + out[1] = (in[1] - vp[13]) / vp[5]; + out[2] = (in[2] - vp[14]) / vp[10]; + out[3] = in[3]; +} + +static void extract_3f_viewport( const struct tnl_clipspace_attr *a, GLfloat *out, + const GLubyte *v ) +{ + const GLfloat *in = (const GLfloat *)v; + const GLfloat * const vp = a->vp; + + out[0] = (in[0] - vp[12]) / vp[0]; + out[1] = (in[1] - vp[13]) / vp[5]; + out[2] = (in[2] - vp[14]) / vp[10]; + out[3] = 1; +} + + +static void extract_2f_viewport( const struct tnl_clipspace_attr *a, GLfloat *out, + const GLubyte *v ) +{ + const GLfloat *in = (const GLfloat *)v; + const GLfloat * const vp = a->vp; + + out[0] = (in[0] - vp[12]) / vp[0]; + out[1] = (in[1] - vp[13]) / vp[5]; + out[2] = 0; + out[3] = 1; +} + + +static void extract_4f( const struct tnl_clipspace_attr *a, GLfloat *out, const GLubyte *v ) +{ + const GLfloat *in = (const GLfloat *)v; + (void) a; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = in[2]; + out[3] = in[3]; +} + +static void extract_3f_xyw( const struct tnl_clipspace_attr *a, GLfloat *out, const GLubyte *v ) +{ + const GLfloat *in = (const GLfloat *)v; + (void) a; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = 0; + out[3] = in[2]; +} + + +static void extract_3f( const struct tnl_clipspace_attr *a, GLfloat *out, const GLubyte *v ) +{ + const GLfloat *in = (const GLfloat *)v; + (void) a; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = in[2]; + out[3] = 1; +} + + +static void extract_2f( const struct tnl_clipspace_attr *a, GLfloat *out, const GLubyte *v ) +{ + const GLfloat *in = (const GLfloat *)v; + (void) a; + + out[0] = in[0]; + out[1] = in[1]; + out[2] = 0; + out[3] = 1; +} + +static void extract_1f( const struct tnl_clipspace_attr *a, GLfloat *out, const GLubyte *v ) +{ + const GLfloat *in = (const GLfloat *)v; + (void) a; + + out[0] = in[0]; + out[1] = 0; + out[2] = 0; + out[3] = 1; +} + +static void extract_4chan_4f_rgba( const struct tnl_clipspace_attr *a, GLfloat *out, + const GLubyte *v ) +{ + GLchan *c = (GLchan *)v; + (void) a; + + out[0] = CHAN_TO_FLOAT(c[0]); + out[1] = CHAN_TO_FLOAT(c[1]); + out[2] = CHAN_TO_FLOAT(c[2]); + out[3] = CHAN_TO_FLOAT(c[3]); +} + +static void extract_4ub_4f_rgba( const struct tnl_clipspace_attr *a, GLfloat *out, + const GLubyte *v ) +{ + (void) a; + out[0] = UBYTE_TO_FLOAT(v[0]); + out[1] = UBYTE_TO_FLOAT(v[1]); + out[2] = UBYTE_TO_FLOAT(v[2]); + out[3] = UBYTE_TO_FLOAT(v[3]); +} + +static void extract_4ub_4f_bgra( const struct tnl_clipspace_attr *a, GLfloat *out, + const GLubyte *v ) +{ + (void) a; + out[2] = UBYTE_TO_FLOAT(v[0]); + out[1] = UBYTE_TO_FLOAT(v[1]); + out[0] = UBYTE_TO_FLOAT(v[2]); + out[3] = UBYTE_TO_FLOAT(v[3]); +} + +static void extract_4ub_4f_argb( const struct tnl_clipspace_attr *a, GLfloat *out, + const GLubyte *v ) +{ + (void) a; + out[3] = UBYTE_TO_FLOAT(v[0]); + out[0] = UBYTE_TO_FLOAT(v[1]); + out[1] = UBYTE_TO_FLOAT(v[2]); + out[2] = UBYTE_TO_FLOAT(v[3]); +} + +static void extract_4ub_4f_abgr( const struct tnl_clipspace_attr *a, GLfloat *out, + const GLubyte *v ) +{ + (void) a; + out[3] = UBYTE_TO_FLOAT(v[0]); + out[2] = UBYTE_TO_FLOAT(v[1]); + out[1] = UBYTE_TO_FLOAT(v[2]); + out[0] = UBYTE_TO_FLOAT(v[3]); +} + +static void extract_3ub_3f_rgb( const struct tnl_clipspace_attr *a, GLfloat *out, + const GLubyte *v ) +{ + (void) a; + out[0] = UBYTE_TO_FLOAT(v[0]); + out[1] = UBYTE_TO_FLOAT(v[1]); + out[2] = UBYTE_TO_FLOAT(v[2]); + out[3] = 1; +} + +static void extract_3ub_3f_bgr( const struct tnl_clipspace_attr *a, GLfloat *out, + const GLubyte *v ) +{ + (void) a; + out[2] = UBYTE_TO_FLOAT(v[0]); + out[1] = UBYTE_TO_FLOAT(v[1]); + out[0] = UBYTE_TO_FLOAT(v[2]); + out[3] = 1; +} + +static void extract_1ub_1f( const struct tnl_clipspace_attr *a, GLfloat *out, const GLubyte *v ) +{ + (void) a; + out[0] = UBYTE_TO_FLOAT(v[0]); + out[1] = 0; + out[2] = 0; + out[3] = 1; +} + + +static struct { + const char *name; + tnl_extract_func extract; + tnl_insert_func insert[4]; + const GLuint attrsize; +} format_info[EMIT_MAX] = { + + { "1f", + extract_1f, + { insert_1f_1, insert_1f_1, insert_1f_1, insert_1f_1 }, + sizeof(GLfloat) }, + + { "2f", + extract_2f, + { insert_2f_1, insert_2f_2, insert_2f_2, insert_2f_2 }, + 2 * sizeof(GLfloat) }, + + { "3f", + extract_3f, + { insert_3f_1, insert_3f_2, insert_3f_3, insert_3f_3 }, + 3 * sizeof(GLfloat) }, + + { "4f", + extract_4f, + { insert_4f_1, insert_4f_2, insert_4f_3, insert_4f_4 }, + 4 * sizeof(GLfloat) }, + + { "2f_viewport", + extract_2f_viewport, + { insert_2f_viewport_1, insert_2f_viewport_2, insert_2f_viewport_2, + insert_2f_viewport_2 }, + 2 * sizeof(GLfloat) }, + + { "3f_viewport", + extract_3f_viewport, + { insert_3f_viewport_1, insert_3f_viewport_2, insert_3f_viewport_3, + insert_3f_viewport_3 }, + 3 * sizeof(GLfloat) }, + + { "4f_viewport", + extract_4f_viewport, + { insert_4f_viewport_1, insert_4f_viewport_2, insert_4f_viewport_3, + insert_4f_viewport_4 }, + 4 * sizeof(GLfloat) }, + + { "3f_xyw", + extract_3f_xyw, + { insert_3f_xyw_err, insert_3f_xyw_err, insert_3f_xyw_err, + insert_3f_xyw_4 }, + 3 * sizeof(GLfloat) }, + + { "1ub_1f", + extract_1ub_1f, + { insert_1ub_1f_1, insert_1ub_1f_1, insert_1ub_1f_1, insert_1ub_1f_1 }, + sizeof(GLubyte) }, + + { "3ub_3f_rgb", + extract_3ub_3f_rgb, + { insert_3ub_3f_rgb_1, insert_3ub_3f_rgb_2, insert_3ub_3f_rgb_3, + insert_3ub_3f_rgb_3 }, + 3 * sizeof(GLubyte) }, + + { "3ub_3f_bgr", + extract_3ub_3f_bgr, + { insert_3ub_3f_bgr_1, insert_3ub_3f_bgr_2, insert_3ub_3f_bgr_3, + insert_3ub_3f_bgr_3 }, + 3 * sizeof(GLubyte) }, + + { "4ub_4f_rgba", + extract_4ub_4f_rgba, + { insert_4ub_4f_rgba_1, insert_4ub_4f_rgba_2, insert_4ub_4f_rgba_3, + insert_4ub_4f_rgba_4 }, + 4 * sizeof(GLubyte) }, + + { "4ub_4f_bgra", + extract_4ub_4f_bgra, + { insert_4ub_4f_bgra_1, insert_4ub_4f_bgra_2, insert_4ub_4f_bgra_3, + insert_4ub_4f_bgra_4 }, + 4 * sizeof(GLubyte) }, + + { "4ub_4f_argb", + extract_4ub_4f_argb, + { insert_4ub_4f_argb_1, insert_4ub_4f_argb_2, insert_4ub_4f_argb_3, + insert_4ub_4f_argb_4 }, + 4 * sizeof(GLubyte) }, + + { "4ub_4f_abgr", + extract_4ub_4f_abgr, + { insert_4ub_4f_abgr_1, insert_4ub_4f_abgr_2, insert_4ub_4f_abgr_3, + insert_4ub_4f_abgr_4 }, + 4 * sizeof(GLubyte) }, + + { "4chan_4f_rgba", + extract_4chan_4f_rgba, + { insert_4chan_4f_rgba_1, insert_4chan_4f_rgba_2, insert_4chan_4f_rgba_3, + insert_4chan_4f_rgba_4 }, + 4 * sizeof(GLchan) }, + + { "pad", + 0, + { 0, 0, 0, 0 }, + 0 } + +}; + + +/*********************************************************************** + * Generic (non-codegen) functions for whole vertices or groups of + * vertices + */ + +static void generic_emit( GLcontext *ctx, + GLuint start, GLuint end, + void *dest ) +{ + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + struct tnl_clipspace_attr *a = vtx->attr; + GLubyte *v = (GLubyte *)dest; + GLuint i, j; + const GLuint count = vtx->attr_count; + GLuint stride; + + for (j = 0; j < count; j++) { + GLvector4f *vptr = VB->AttribPtr[a[j].attrib]; + a[j].inputstride = vptr->stride; + a[j].inputptr = ((GLubyte *)vptr->data) + start * vptr->stride; + a[j].emit = a[j].insert[vptr->size - 1]; + } + + end -= start; + stride = vtx->vertex_size; + + for (i = 0 ; i < end ; i++, v += stride) { + for (j = 0; j < count; j++) { + GLfloat *in = (GLfloat *)a[j].inputptr; + a[j].inputptr += a[j].inputstride; + a[j].emit( &a[j], v + a[j].vertoffset, in ); + } + } +} + + +static void generic_interp( GLcontext *ctx, + GLfloat t, + GLuint edst, GLuint eout, GLuint ein, + GLboolean force_boundary ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + const GLubyte *vin = vtx->vertex_buf + ein * vtx->vertex_size; + const GLubyte *vout = vtx->vertex_buf + eout * vtx->vertex_size; + GLubyte *vdst = vtx->vertex_buf + edst * vtx->vertex_size; + const struct tnl_clipspace_attr *a = vtx->attr; + const GLuint attr_count = vtx->attr_count; + GLuint j; + (void) force_boundary; + + if (tnl->NeedNdcCoords) { + const GLfloat *dstclip = VB->ClipPtr->data[edst]; + if (dstclip[3] != 0.0) { + const GLfloat w = 1.0f / dstclip[3]; + GLfloat pos[4]; + + pos[0] = dstclip[0] * w; + pos[1] = dstclip[1] * w; + pos[2] = dstclip[2] * w; + pos[3] = w; + + a[0].insert[4-1]( &a[0], vdst, pos ); + } + } + else { + a[0].insert[4-1]( &a[0], vdst, VB->ClipPtr->data[edst] ); + } + + + for (j = 1; j < attr_count; j++) { + GLfloat fin[4], fout[4], fdst[4]; + + a[j].extract( &a[j], fin, vin + a[j].vertoffset ); + a[j].extract( &a[j], fout, vout + a[j].vertoffset ); + + INTERP_F( t, fdst[3], fout[3], fin[3] ); + INTERP_F( t, fdst[2], fout[2], fin[2] ); + INTERP_F( t, fdst[1], fout[1], fin[1] ); + INTERP_F( t, fdst[0], fout[0], fin[0] ); + + a[j].insert[4-1]( &a[j], vdst + a[j].vertoffset, fdst ); + } +} + + +/* Extract color attributes from one vertex and insert them into + * another. (Shortcircuit extract/insert with memcpy). + */ +static void generic_copy_pv( GLcontext *ctx, GLuint edst, GLuint esrc ) +{ + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + GLubyte *vsrc = vtx->vertex_buf + esrc * vtx->vertex_size; + GLubyte *vdst = vtx->vertex_buf + edst * vtx->vertex_size; + const struct tnl_clipspace_attr *a = vtx->attr; + const GLuint attr_count = vtx->attr_count; + GLuint j; + + for (j = 0; j < attr_count; j++) { + if (a[j].attrib == VERT_ATTRIB_COLOR0 || + a[j].attrib == VERT_ATTRIB_COLOR1) { + + _mesa_memcpy( vdst + a[j].vertoffset, + vsrc + a[j].vertoffset, + a[j].vertattrsize ); + } + } +} + + +/* Helper functions for hardware which doesn't put back colors and/or + * edgeflags into vertices. + */ +static void generic_interp_extras( GLcontext *ctx, + GLfloat t, + GLuint dst, GLuint out, GLuint in, + GLboolean force_boundary ) +{ + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + + if (VB->ColorPtr[1]) { + assert(VB->ColorPtr[1]->stride == 4 * sizeof(GLfloat)); + + INTERP_4F( t, + VB->ColorPtr[1]->data[dst], + VB->ColorPtr[1]->data[out], + VB->ColorPtr[1]->data[in] ); + + if (VB->SecondaryColorPtr[1]) { + INTERP_3F( t, + VB->SecondaryColorPtr[1]->data[dst], + VB->SecondaryColorPtr[1]->data[out], + VB->SecondaryColorPtr[1]->data[in] ); + } + } + else if (VB->IndexPtr[1]) { + VB->IndexPtr[1]->data[dst][0] = LINTERP( t, + VB->IndexPtr[1]->data[out][0], + VB->IndexPtr[1]->data[in][0] ); + } + + if (VB->EdgeFlag) { + VB->EdgeFlag[dst] = VB->EdgeFlag[out] || force_boundary; + } + + generic_interp(ctx, t, dst, out, in, force_boundary); +} + +static void generic_copy_pv_extras( GLcontext *ctx, + GLuint dst, GLuint src ) +{ + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + + if (VB->ColorPtr[1]) { + COPY_4FV( VB->ColorPtr[1]->data[dst], + VB->ColorPtr[1]->data[src] ); + + if (VB->SecondaryColorPtr[1]) { + COPY_4FV( VB->SecondaryColorPtr[1]->data[dst], + VB->SecondaryColorPtr[1]->data[src] ); + } + } + else if (VB->IndexPtr[1]) { + VB->IndexPtr[1]->data[dst][0] = VB->IndexPtr[1]->data[src][0]; + } + + generic_copy_pv(ctx, dst, src); +} + + + + +/*********************************************************************** + * Build codegen functions or return generic ones: + */ + + +static void do_emit( GLcontext *ctx, GLuint start, GLuint end, + void *dest) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + struct tnl_clipspace_attr *a = vtx->attr; + const GLuint count = vtx->attr_count; + GLuint j; + + for (j = 0; j < count; j++) { + GLvector4f *vptr = VB->AttribPtr[a[j].attrib]; + a[j].inputstride = vptr->stride; + a[j].inputptr = ((GLubyte *)vptr->data) + start * vptr->stride; + a[j].emit = a[j].insert[vptr->size - 1]; + } + + vtx->emit = 0; + + if (0) + vtx->emit = _tnl_codegen_emit(ctx); + + if (!vtx->emit) + vtx->emit = generic_emit; + + vtx->emit( ctx, start, end, dest ); +} + + + +static void choose_interp_func( GLcontext *ctx, + GLfloat t, + GLuint edst, GLuint eout, GLuint ein, + GLboolean force_boundary ) +{ + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + + if (vtx->need_extras && + (ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED))) { + vtx->interp = generic_interp_extras; + } else { + vtx->interp = generic_interp; + } + + vtx->interp( ctx, t, edst, eout, ein, force_boundary ); +} + + +static void choose_copy_pv_func( GLcontext *ctx, GLuint edst, GLuint esrc ) +{ + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + + if (vtx->need_extras && + (ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED))) { + vtx->copy_pv = generic_copy_pv_extras; + } else { + vtx->copy_pv = generic_copy_pv; + } + + vtx->copy_pv( ctx, edst, esrc ); +} + + +/*********************************************************************** + * Public entrypoints, mostly dispatch to the above: + */ + + +/* Interpolate between two vertices to produce a third: + */ +void _tnl_interp( GLcontext *ctx, + GLfloat t, + GLuint edst, GLuint eout, GLuint ein, + GLboolean force_boundary ) +{ + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + vtx->interp( ctx, t, edst, eout, ein, force_boundary ); +} + +/* Copy colors from one vertex to another: + */ +void _tnl_copy_pv( GLcontext *ctx, GLuint edst, GLuint esrc ) +{ + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + vtx->copy_pv( ctx, edst, esrc ); +} + + +/* Extract a named attribute from a hardware vertex. Will have to + * reverse any viewport transformation, swizzling or other conversions + * which may have been applied: + */ +void _tnl_get_attr( GLcontext *ctx, const void *vin, + GLenum attr, GLfloat *dest ) +{ + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + const struct tnl_clipspace_attr *a = vtx->attr; + const GLuint attr_count = vtx->attr_count; + GLuint j; + + for (j = 0; j < attr_count; j++) { + if (a[j].attrib == attr) { + a[j].extract( &a[j], dest, (GLubyte *)vin + a[j].vertoffset ); + return; + } + } + + /* Else return the value from ctx->Current -- dangerous??? + */ + _mesa_memcpy( dest, ctx->Current.Attrib[attr], 4*sizeof(GLfloat)); +} + + +/* Complementary operation to the above. + */ +void _tnl_set_attr( GLcontext *ctx, void *vout, + GLenum attr, const GLfloat *src ) +{ + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + const struct tnl_clipspace_attr *a = vtx->attr; + const GLuint attr_count = vtx->attr_count; + GLuint j; + + for (j = 0; j < attr_count; j++) { + if (a[j].attrib == attr) { + a[j].insert[4-1]( &a[j], (GLubyte *)vout + a[j].vertoffset, src ); + return; + } + } +} + + +void *_tnl_get_vertex( GLcontext *ctx, GLuint nr ) +{ + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + + return vtx->vertex_buf + nr * vtx->vertex_size; +} + +void _tnl_invalidate_vertex_state( GLcontext *ctx, GLuint new_state ) +{ + if (new_state & (_DD_NEW_TRI_LIGHT_TWOSIDE|_DD_NEW_TRI_UNFILLED) ) { + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + vtx->new_inputs = ~0; + vtx->interp = choose_interp_func; + vtx->copy_pv = choose_copy_pv_func; + } +} + + +GLuint _tnl_install_attrs( GLcontext *ctx, const struct tnl_attr_map *map, + GLuint nr, const GLfloat *vp, + GLuint unpacked_size ) +{ + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + GLuint offset = 0; + GLuint i, j; + + assert(nr < _TNL_ATTRIB_MAX); + assert(nr == 0 || map[0].attrib == VERT_ATTRIB_POS); + + vtx->emit = 0; + vtx->interp = choose_interp_func; + vtx->copy_pv = choose_copy_pv_func; + vtx->new_inputs = ~0; + + for (j = 0, i = 0; i < nr; i++) { + const GLuint format = map[i].format; + if (format == EMIT_PAD) { + /* + fprintf(stderr, "%d: pad %d, offset %d\n", i, + map[i].offset, offset); + */ + offset += map[i].offset; + + } + else { + vtx->attr[j].attrib = map[i].attrib; + vtx->attr[j].format = format; + vtx->attr[j].vp = vp; + vtx->attr[j].insert = format_info[format].insert; + vtx->attr[j].extract = format_info[format].extract; + vtx->attr[j].vertattrsize = format_info[format].attrsize; + + if (unpacked_size) + vtx->attr[j].vertoffset = map[i].offset; + else + vtx->attr[j].vertoffset = offset; + + /* + fprintf(stderr, "%d: %s, vp %p, offset %d\n", i, + format_info[format].name, (void *)vp, + vtx->attr[j].vertoffset); + */ + offset += format_info[format].attrsize; + j++; + } + } + + vtx->attr_count = j; + + if (unpacked_size) + vtx->vertex_size = unpacked_size; + else + vtx->vertex_size = offset; + + assert(vtx->vertex_size <= vtx->max_vertex_size); + + return vtx->vertex_size; +} + + + +void _tnl_invalidate_vertices( GLcontext *ctx, GLuint newinputs ) +{ + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + vtx->new_inputs |= newinputs; +} + + +void _tnl_build_vertices( GLcontext *ctx, + GLuint start, + GLuint end, + GLuint newinputs ) +{ + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + const GLuint stride = vtx->vertex_size; + GLubyte *vDest = ((GLubyte *)vtx->vertex_buf + (start*stride)); + + newinputs |= vtx->new_inputs; + vtx->new_inputs = 0; + + if (newinputs) + do_emit( ctx, start, end, vDest ); +} + + +void *_tnl_emit_vertices_to_buffer( GLcontext *ctx, + GLuint start, + GLuint end, + void *dest ) +{ + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + do_emit( ctx, start, end, dest ); + return (void *)((GLubyte *)dest + vtx->vertex_size * (end - start)); +} + + +void _tnl_init_vertices( GLcontext *ctx, + GLuint vb_size, + GLuint max_vertex_size ) +{ + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + + _tnl_install_attrs( ctx, 0, 0, 0, 0 ); + + vtx->need_extras = GL_TRUE; + if (max_vertex_size > vtx->max_vertex_size) { + _tnl_free_vertices( ctx ); + vtx->max_vertex_size = max_vertex_size; + vtx->vertex_buf = (GLubyte *)ALIGN_CALLOC(vb_size * max_vertex_size, 32 ); + } + + _tnl_init_c_codegen( &vtx->codegen ); +} + + +void _tnl_free_vertices( GLcontext *ctx ) +{ + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + if (vtx->vertex_buf) { + ALIGN_FREE(vtx->vertex_buf); + vtx->vertex_buf = 0; + if (vtx->codegen.buf) { + _mesa_free(vtx->codegen.buf); + vtx->codegen.buf = NULL; + } + } +} diff --git a/src/mesa/tnl/t_vertex.h b/src/mesa/tnl/t_vertex.h new file mode 100644 index 0000000..caa2220 --- /dev/null +++ b/src/mesa/tnl/t_vertex.h @@ -0,0 +1,150 @@ +/* + * Copyright 2003 Tungsten Graphics, inc. + * 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"), + * to deal in the Software without restriction, including without limitation + * on the rights to use, copy, modify, merge, publish, distribute, sub + * license, and/or sell copies of the Software, and to permit persons to whom + * the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keithw@tungstengraphics.com> + */ + +#ifndef _TNL_VERTEX_H +#define _TNL_VERTEX_H + +#include "mtypes.h" +#include "t_context.h" + +/* New mechanism to specify hardware vertices so that tnl can build + * and manipulate them directly. + */ + + +/* It will probably be necessary to allow drivers to specify new + * emit-styles to cover all the wierd and wacky things out there. + */ +enum tnl_attr_format { + EMIT_1F, + EMIT_2F, + EMIT_3F, + EMIT_4F, + EMIT_2F_VIEWPORT, /* do viewport transform and emit */ + EMIT_3F_VIEWPORT, /* do viewport transform and emit */ + EMIT_4F_VIEWPORT, /* do viewport transform and emit */ + EMIT_3F_XYW, /* for projective texture */ + EMIT_1UB_1F, /* for fog coordinate */ + EMIT_3UB_3F_RGB, /* for specular color */ + EMIT_3UB_3F_BGR, /* for specular color */ + EMIT_4UB_4F_RGBA, /* for color */ + EMIT_4UB_4F_BGRA, /* for color */ + EMIT_4UB_4F_ARGB, /* for color */ + EMIT_4UB_4F_ABGR, /* for color */ + EMIT_4CHAN_4F_RGBA, /* for swrast color */ + EMIT_PAD, /* leave a hole of 'offset' bytes */ + EMIT_MAX +}; + +struct tnl_attr_map { + GLuint attrib; /* _TNL_ATTRIB_ enum */ + enum tnl_attr_format format; + GLuint offset; +}; + + + +/* Interpolate between two vertices to produce a third: + */ +extern void _tnl_interp( GLcontext *ctx, + GLfloat t, + GLuint edst, GLuint eout, GLuint ein, + GLboolean force_boundary ); + +/* Copy colors from one vertex to another: + */ +extern void _tnl_copy_pv( GLcontext *ctx, GLuint edst, GLuint esrc ); + + +/* Extract a named attribute from a hardware vertex. Will have to + * reverse any viewport transformation, swizzling or other conversions + * which may have been applied: + */ +extern void _tnl_get_attr( GLcontext *ctx, const void *vertex, GLenum attrib, + GLfloat *dest ); + +/* Complementary to the above. + */ +extern void _tnl_set_attr( GLcontext *ctx, void *vout, GLenum attrib, + const GLfloat *src ); + + +extern void *_tnl_get_vertex( GLcontext *ctx, GLuint nr ); + + +/* + */ +extern GLuint _tnl_install_attrs( GLcontext *ctx, + const struct tnl_attr_map *map, + GLuint nr, const GLfloat *vp, + GLuint unpacked_size ); + + + + + +extern void _tnl_free_vertices( GLcontext *ctx ); + +extern void _tnl_init_vertices( GLcontext *ctx, + GLuint vb_size, + GLuint max_vertex_size ); + +extern void *_tnl_emit_vertices_to_buffer( GLcontext *ctx, + GLuint start, + GLuint end, + void *dest ); + +extern void _tnl_build_vertices( GLcontext *ctx, + GLuint start, + GLuint end, + GLuint newinputs ); + +extern void _tnl_invalidate_vertices( GLcontext *ctx, GLuint newinputs ); + +extern void _tnl_invalidate_vertex_state( GLcontext *ctx, GLuint new_state ); + +extern tnl_emit_func _tnl_codegen_emit( GLcontext *ctx ); + +#define REG_IN (0<<16) +#define REG_OUT (1<<16) +#define REG_VP (2<<16) +#define REG_TMP (3<<16) +#define REG_MASK (3<<16) + +#define REG_OFFSET_MASK 0xffff + +#define in( offset ) (REG_IN | (offset)) +#define out( offset ) (REG_OUT | (offset)) +#define vp( offset ) (REG_VP | (offset)) +#define tmp( offset ) (REG_TMP | (offset)) + + +extern void _tnl_init_c_codegen( struct tnl_clipspace_codegen *p ); + +#define GET_VERTEX_STATE(ctx) &(TNL_CONTEXT(ctx)->clipspace) + +#endif diff --git a/src/mesa/tnl/t_vertex_c.c b/src/mesa/tnl/t_vertex_c.c new file mode 100644 index 0000000..5109026 --- /dev/null +++ b/src/mesa/tnl/t_vertex_c.c @@ -0,0 +1,259 @@ +/* + * Copyright 2003 Tungsten Graphics, inc. + * 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"), + * to deal in the Software without restriction, including without limitation + * on the rights to use, copy, modify, merge, publish, distribute, sub + * license, and/or sell copies of the Software, and to permit persons to whom + * the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keithw@tungstengraphics.com> + */ + +#include "glheader.h" +#include "context.h" +#include "colormac.h" + +#include "t_context.h" +#include "t_vertex.h" + +#include "simple_list.h" + +#ifdef WIN32 +#define vsnprintf _vsnprintf +#endif + +/* A version of code generation for t_clipspace_codegen.c which prints + * out 'c' code to implement the generated function. A useful + * debugging tool, and in concert with something like tcc or a + * library-ized gcc, could do the whole job. + */ + + +static GLboolean emit( struct tnl_clipspace_codegen *p, + const char *fmt, + ... ) +{ + if (p->buf_used < p->buf_size) { + va_list ap; + va_start( ap, fmt ); + p->buf_used += vsnprintf( p->buf + p->buf_used, + p->buf_size - p->buf_used, + fmt, ap ); + va_end( ap ); + } + + return p->buf_used < p->buf_size; +} + + +static GLboolean print_header( struct tnl_clipspace_codegen *p, + struct tnl_clipspace *vtx ) +{ + p->buf_used = 0; + p->out_offset = 0; + + return + emit(p, + "struct tnl_clipspace_attr\n" + "{\n" + " unsigned int attrib; \n" + " unsigned int format;\n" + " unsigned int vertoffset; \n" + " unsigned int vertattrsize; \n" + " char *inputptr;\n" + " unsigned int inputstride;\n" + " void *insert;\n" + " void *emit;\n" + " void * extract;\n" + " const float *vp; \n" + "};\n" + "\n" + ) && + emit(p, + "void emit_vertices( int start, int end, char *dest, \n" + " struct tnl_clipspace_attr *a) \n" + "{\n" + " int i;" + " for (i = start ; i < end ; i++, dest += %d) {\n", + vtx->vertex_size); + +} + +static GLboolean print_footer( struct tnl_clipspace_codegen *p ) +{ + return + emit(p, + " }\n" + "}\n" + ); +} + +static GLboolean emit_reg( struct tnl_clipspace_codegen *p, GLint reg ) +{ + int idx = reg & REG_OFFSET_MASK; + + switch (reg & REG_MASK) { + case REG_IN: return emit(p, "in[%d]", idx); + case REG_VP: return emit(p, "vp[%d]", idx); + case REG_TMP: return emit(p, "temp[%d]", idx); /* not used? */ + case REG_OUT: return emit(p, "out[%d]", idx); + } + + return GL_FALSE; +} + +static GLboolean print_mov( struct tnl_clipspace_codegen *p, GLint dest, GLint src ) +{ + return + emit(p, " ") && + emit_reg(p, dest) && + emit(p, " = ") && + emit_reg(p, src) && + emit(p, ";\n"); +} + + +static GLboolean print_const( struct tnl_clipspace_codegen *p, + GLint dest, GLfloat c ) +{ + return + emit(p, " ") && + emit_reg(p, dest) && + emit(p, " = %g;\n", c); +} + +static GLboolean print_const_chan( struct tnl_clipspace_codegen *p, + GLint dest, GLchan c ) +{ + return + emit(p, " ") && + emit_reg(p, dest) && + emit(p, " = ") && +#if CHAN_TYPE == GL_FLOAT + emit(p, "%f", c) && +#else + emit(p, "%d", c) && +#endif + emit(p, ";\n"); +} + +static GLboolean print_const_ubyte( struct tnl_clipspace_codegen *p, + GLint dest, GLubyte c ) +{ + return + emit(p, " ") && + emit_reg(p, dest) && + emit(p, " = %x;\n", c); +} + +static GLboolean print_mad( struct tnl_clipspace_codegen *p, + GLint dest, GLint src0, GLint src1, GLint src2 ) +{ + return + emit(p, " ") && + emit_reg(p, dest) && + emit(p, " = ") && + emit_reg(p, src0) && + emit(p, " * ") && + emit_reg(p, src1) && + emit(p, " + ") && + emit_reg(p, src2) && + emit(p, ";\n"); +} + +static GLboolean print_float_to_ubyte( struct tnl_clipspace_codegen *p, + GLint dest, GLint src ) +{ + return + emit(p, " ") && + emit(p, "UNCLAMPED_FLOAT_TO_UBYTE(") && + emit_reg(p, dest) && + emit(p, ", ") && + emit_reg(p, src) && + emit(p, ");\n"); +} + +static GLboolean print_float_to_chan( struct tnl_clipspace_codegen *p, + GLint dest, GLint src ) +{ + return + emit(p, " ") && + emit(p, "UNCLAMPED_FLOAT_TO_CHAN(") && + emit_reg(p, dest) && + emit(p, ", ") && + emit_reg(p, src) && + emit(p, ");\n"); +} + + +static GLboolean print_attr_header( struct tnl_clipspace_codegen *p, + struct tnl_clipspace_attr *a, + GLint j, + GLenum out_type, + GLboolean need_vp) +{ + char *out_type_str = "void"; + + switch(out_type) { + case GL_FLOAT: out_type_str = "float"; break; + case GL_UNSIGNED_BYTE: out_type_str = "unsigned char"; break; + case GL_UNSIGNED_SHORT: out_type_str = "unsigned short"; break; + } + + return + emit(p, " {\n") && + (need_vp ? emit(p, " const float *vp = a[%d].vp;\n", j) : 1) && + emit(p, " %s *out = (%s *)(dest + %d);\n", + out_type_str, out_type_str, a[j].vertoffset) && + emit(p, " const float *in = (const float *)a[%d].inputptr;\n", + j) && + emit(p, " a[%d].inputptr += a[%d].inputstride;\n", j, j); +} + +static GLboolean print_attr_footer( struct tnl_clipspace_codegen *p ) +{ + return emit(p, " }\n"); +} + +static tnl_emit_func print_store_func( struct tnl_clipspace_codegen *p ) +{ + fprintf(stderr, "print_store_func: emitted:\n%s\n", p->buf); + return 0; +} + +void _tnl_init_c_codegen( struct tnl_clipspace_codegen *p ) +{ + p->emit_header = print_header; + p->emit_footer = print_footer; + p->emit_attr_header = print_attr_header; + p->emit_attr_footer = print_attr_footer; + p->emit_mov = print_mov; + p->emit_const = print_const; + p->emit_mad = print_mad; + p->emit_float_to_chan = print_float_to_chan; + p->emit_const_chan = print_const_chan; + p->emit_float_to_ubyte = print_float_to_ubyte; + p->emit_const_ubyte = print_const_ubyte; + p->emit_store_func = print_store_func; + + make_empty_list(&p->codegen_list); + + p->buf_size = 2048; + p->buf = MALLOC(p->buf_size); +} diff --git a/src/mesa/tnl/t_vertex_codegen.c b/src/mesa/tnl/t_vertex_codegen.c new file mode 100644 index 0000000..4ff9643 --- /dev/null +++ b/src/mesa/tnl/t_vertex_codegen.c @@ -0,0 +1,510 @@ +/* + * Copyright 2003 Tungsten Graphics, inc. + * 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"), + * to deal in the Software without restriction, including without limitation + * on the rights to use, copy, modify, merge, publish, distribute, sub + * license, and/or sell copies of the Software, and to permit persons to whom + * the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keithw@tungstengraphics.com> + */ + +#include "glheader.h" +#include "context.h" +#include "colormac.h" + +#include "t_context.h" +#include "t_vertex.h" + +#include "simple_list.h" + +/* Another codegen scheme, hopefully portable to a few different + * architectures without too much work. + */ + + + + +static GLboolean emit_4f_viewport_4( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mad(p, out(0), vp(0), in(0), vp(12)) && + p->emit_mad(p, out(1), vp(5), in(1), vp(13)) && + p->emit_mad(p, out(2), vp(10), in(2), vp(14)) && + p->emit_mov(p, out(3), in(3)); +} + +static GLboolean emit_4f_viewport_3( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mad(p, out(0), vp(0), in(0), vp(12)) && + p->emit_mad(p, out(1), vp(5), in(1), vp(13)) && + p->emit_mad(p, out(2), vp(10), in(2), vp(14)) && + p->emit_const(p, out(3), 1.0); +} + +static GLboolean emit_4f_viewport_2( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mad(p, out(0), vp(0), in(0), vp(12)) && + p->emit_mad(p, out(1), vp(5), in(1), vp(13)) && + p->emit_mov(p, out(2), vp(14)) && + p->emit_const(p, out(3), 1.0); +} + +static GLboolean emit_4f_viewport_1( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mad(p, out(0), vp(0), in(0), vp(12)) && + p->emit_mov(p, out(1), vp(13)) && + p->emit_mov(p, out(2), vp(14)) && + p->emit_const(p, out(3), 1.0); +} + +static GLboolean emit_3f_viewport_3( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mad(p, out(0), vp(0), in(0), vp(12)) && + p->emit_mad(p, out(1), vp(5), in(1), vp(13)) && + p->emit_mad(p, out(2), vp(10), in(2), vp(14)); +} + +static GLboolean emit_3f_viewport_2( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mad(p, out(0), vp(0), in(0), vp(12)) && + p->emit_mad(p, out(1), vp(5), in(1), vp(13)) && + p->emit_mov(p, out(2), vp(14)); +} + +static GLboolean emit_3f_viewport_1( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mad(p, out(0), vp(0), in(0), vp(12)) && + p->emit_mov(p, out(1), vp(13)) && + p->emit_mov(p, out(2), vp(14)); +} + +static GLboolean emit_2f_viewport_2( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mad(p, out(0), vp(0), in(0), vp(12)) && + p->emit_mad(p, out(1), vp(5), in(1), vp(13)); +} + +static GLboolean emit_2f_viewport_1( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mad(p, out(0), vp(0), in(0), vp(12)); +} + + +static GLboolean emit_4f_4( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mov(p, out(0), in(0)) && + p->emit_mov(p, out(1), in(1)) && + p->emit_mov(p, out(2), in(2)) && + p->emit_mov(p, out(3), in(3)); +} + +static GLboolean emit_4f_3( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mov(p, out(0), in(0)) && + p->emit_mov(p, out(1), in(1)) && + p->emit_mov(p, out(2), in(2)) && + p->emit_const(p, out(3), 1.0); +} + +static GLboolean emit_4f_2( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mov(p, out(0), in(0)) && + p->emit_mov(p, out(1), in(1)) && + p->emit_const(p, out(2), 0.0) && + p->emit_const(p, out(3), 1.0); +} + +static GLboolean emit_4f_1( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mov(p, out(0), in(0)) && + p->emit_const(p, out(1), 0.0) && + p->emit_const(p, out(2), 0.0) && + p->emit_const(p, out(3), 1.0); +} + +static GLboolean emit_3f_xyw_4( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mov(p, out(0), in(0)) && + p->emit_mov(p, out(1), in(1)) && + p->emit_mov(p, out(2), in(3)); +} + +static GLboolean emit_3f_xyw_err( struct tnl_clipspace_codegen *p ) +{ + (void) p; + assert(0); + return GL_FALSE; +} + +static GLboolean emit_3f_3( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mov(p, out(0), in(0)) && + p->emit_mov(p, out(1), in(1)) && + p->emit_mov(p, out(2), in(2)); +} + +static GLboolean emit_3f_2( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mov(p, out(0), in(0)) && + p->emit_mov(p, out(1), in(1)) && + p->emit_const(p, out(2), 0.0); +} + +static GLboolean emit_3f_1( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mov(p, out(0), in(0)) && + p->emit_const(p, out(1), 0.0) && + p->emit_const(p, out(2), 0.0); +} + + +static GLboolean emit_2f_2( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mov(p, out(0), in(0)) && + p->emit_mov(p, out(1), in(1)); +} + +static GLboolean emit_2f_1( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mov(p, out(0), in(0)) && + p->emit_const(p, out(1), 0.0); +} + +static GLboolean emit_1f_1( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_mov(p, out(0), in(0)); +} + +static GLboolean emit_4chan_4f_rgba_4( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_chan(p, out(0), in(0)) && + p->emit_float_to_chan(p, out(1), in(1)) && + p->emit_float_to_chan(p, out(2), in(2)) && + p->emit_float_to_chan(p, out(3), in(3)); +} + +static GLboolean emit_4chan_4f_rgba_3( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_chan(p, out(0), in(0)) && + p->emit_float_to_chan(p, out(1), in(1)) && + p->emit_float_to_chan(p, out(2), in(2)) && + p->emit_const_chan(p, out(3), CHAN_MAX); +} + +static GLboolean emit_4chan_4f_rgba_2( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_chan(p, out(0), in(0)) && + p->emit_float_to_chan(p, out(1), in(1)) && + p->emit_const_chan(p, out(2), 0) && + p->emit_const_chan(p, out(3), CHAN_MAX); +} + +static GLboolean emit_4chan_4f_rgba_1( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_chan(p, out(0), in(0)) && + p->emit_const_chan(p, out(1), 0) && + p->emit_const_chan(p, out(2), 0) && + p->emit_const_chan(p, out(3), CHAN_MAX); +} + +static GLboolean emit_4ub_4f_rgba_4( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_ubyte(p, out(0), in(0)) && + p->emit_float_to_ubyte(p, out(1), in(1)) && + p->emit_float_to_ubyte(p, out(2), in(2)) && + p->emit_float_to_ubyte(p, out(3), in(3)); +} + +static GLboolean emit_4ub_4f_rgba_3( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_ubyte(p, out(0), in(0)) && + p->emit_float_to_ubyte(p, out(1), in(1)) && + p->emit_float_to_ubyte(p, out(2), in(2)) && + p->emit_const_ubyte(p, out(3), 0xff); +} + +static GLboolean emit_4ub_4f_rgba_2( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_ubyte(p, out(0), in(0)) && + p->emit_float_to_ubyte(p, out(1), in(1)) && + p->emit_const_ubyte(p, out(2), 0) && + p->emit_const_ubyte(p, out(3), 0xff); +} + +static GLboolean emit_4ub_4f_rgba_1( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_ubyte(p, out(0), in(0)) && + p->emit_const_ubyte(p, out(1), 0) && + p->emit_const_ubyte(p, out(2), 0) && + p->emit_const_ubyte(p, out(3), 0xff); +} + +static GLboolean emit_4ub_4f_bgra_4( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_ubyte(p, out(2), in(0)) && + p->emit_float_to_ubyte(p, out(1), in(1)) && + p->emit_float_to_ubyte(p, out(0), in(2)) && + p->emit_float_to_ubyte(p, out(3), in(3)); +} + +static GLboolean emit_4ub_4f_bgra_3( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_ubyte(p, out(2), in(0)) && + p->emit_float_to_ubyte(p, out(1), in(1)) && + p->emit_float_to_ubyte(p, out(0), in(2)) && + p->emit_const_ubyte(p, out(3), 0xff); +} + +static GLboolean emit_4ub_4f_bgra_2( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_ubyte(p, out(2), in(0)) && + p->emit_float_to_ubyte(p, out(1), in(1)) && + p->emit_const_ubyte(p, out(0), 0) && + p->emit_const_ubyte(p, out(3), 0xff); +} + +static GLboolean emit_4ub_4f_bgra_1( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_ubyte(p, out(2), in(0)) && + p->emit_const_ubyte(p, out(1), 0) && + p->emit_const_ubyte(p, out(0), 0) && + p->emit_const_ubyte(p, out(3), 0xff); +} + +static GLboolean emit_3ub_3f_rgb_3( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_ubyte(p, out(0), in(0)) && + p->emit_float_to_ubyte(p, out(1), in(1)) && + p->emit_float_to_ubyte(p, out(2), in(2)); +} + +static GLboolean emit_3ub_3f_rgb_2( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_ubyte(p, out(0), in(0)) && + p->emit_float_to_ubyte(p, out(1), in(1)) && + p->emit_const_ubyte(p, out(2), 0); +} + +static GLboolean emit_3ub_3f_rgb_1( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_ubyte(p, out(0), in(0)) && + p->emit_const_ubyte(p, out(1), 0) && + p->emit_const_ubyte(p, out(2), 0); +} + +static GLboolean emit_3ub_3f_bgr_3( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_ubyte(p, out(2), in(0)) && + p->emit_float_to_ubyte(p, out(1), in(1)) && + p->emit_float_to_ubyte(p, out(0), in(2)); +} + +static GLboolean emit_3ub_3f_bgr_2( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_ubyte(p, out(2), in(0)) && + p->emit_float_to_ubyte(p, out(1), in(1)) && + p->emit_const_ubyte(p, out(0), 0); +} + +static GLboolean emit_3ub_3f_bgr_1( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_ubyte(p, out(2), in(0)) && + p->emit_const_ubyte(p, out(1), 0) && + p->emit_const_ubyte(p, out(0), 0); +} + + +static GLboolean emit_1ub_1f_1( struct tnl_clipspace_codegen *p ) +{ + return + p->emit_float_to_ubyte(p, out(0), in(0)); +} + + + + +static struct { + const char *name; + GLenum out_type; + GLboolean need_vp; + GLboolean (*emit[4])( struct tnl_clipspace_codegen * ); +} emit_info[EMIT_MAX] = { + + { "1f", GL_FLOAT, GL_FALSE, + { emit_1f_1, emit_1f_1, emit_1f_1, emit_1f_1 } }, + + { "2f", GL_FLOAT, GL_FALSE, + { emit_2f_1, emit_2f_2, emit_2f_2, emit_2f_2 } }, + + { "3f", GL_FLOAT, GL_FALSE, + { emit_3f_1, emit_3f_2, emit_3f_3, emit_3f_3 } }, + + { "4f", GL_FLOAT, GL_FALSE, + { emit_4f_1, emit_4f_2, emit_4f_3, emit_4f_4 } }, + + { "2f_viewport", GL_FLOAT, GL_TRUE, + { emit_2f_viewport_1, emit_2f_viewport_2, emit_2f_viewport_2, + emit_2f_viewport_2 } }, + + { "3f_viewport", GL_FLOAT, GL_TRUE, + { emit_3f_viewport_1, emit_3f_viewport_2, emit_3f_viewport_3, + emit_3f_viewport_3 } }, + + { "4f_viewport", GL_FLOAT, GL_TRUE, + { emit_4f_viewport_1, emit_4f_viewport_2, emit_4f_viewport_3, + emit_4f_viewport_4 } }, + + { "3f_xyw", GL_FLOAT, GL_FALSE, + { emit_3f_xyw_err, emit_3f_xyw_err, emit_3f_xyw_err, + emit_3f_xyw_4 } }, + + { "1ub_1f", GL_UNSIGNED_BYTE, GL_FALSE, + { emit_1ub_1f_1, emit_1ub_1f_1, emit_1ub_1f_1, emit_1ub_1f_1 } }, + + { "3ub_3f_rgb", GL_UNSIGNED_BYTE, GL_FALSE, + { emit_3ub_3f_rgb_1, emit_3ub_3f_rgb_2, emit_3ub_3f_rgb_3, + emit_3ub_3f_rgb_3 } }, + + { "3ub_3f_bgr", GL_UNSIGNED_BYTE, GL_FALSE, + { emit_3ub_3f_bgr_1, emit_3ub_3f_bgr_2, emit_3ub_3f_bgr_3, + emit_3ub_3f_bgr_3 } }, + + { "4ub_4f_rgba", GL_UNSIGNED_BYTE, GL_FALSE, + { emit_4ub_4f_rgba_1, emit_4ub_4f_rgba_2, emit_4ub_4f_rgba_3, + emit_4ub_4f_rgba_4 } }, + + { "4ub_4f_bgra", GL_UNSIGNED_BYTE, GL_FALSE, + { emit_4ub_4f_bgra_1, emit_4ub_4f_bgra_2, emit_4ub_4f_bgra_3, + emit_4ub_4f_bgra_4 } }, + + { "4chan_4f_rgba", CHAN_TYPE, GL_FALSE, + { emit_4chan_4f_rgba_1, emit_4chan_4f_rgba_2, emit_4chan_4f_rgba_3, + emit_4chan_4f_rgba_4 } }, + + { "pad", 0, 0, + { 0, 0, 0, 0 } } + +}; + + +/*********************************************************************** + * list(attrib, size) --> function + * + * Because of the dependence of size, this all has to take place after + * the pipeline has been run. + */ + +tnl_emit_func _tnl_codegen_emit( GLcontext *ctx ) +{ + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); + struct tnl_clipspace_attr *a = vtx->attr; + struct tnl_clipspace_codegen *p = &vtx->codegen; + const GLuint count = vtx->attr_count; + GLuint j; + + /* Need a faster lookup, or is this linear scan of an MRU list good + * enough? MRU chosen based on the guess that consecutive VB's are + * likely to be of the same format. A hash of attributes and sizes + * might be a better technique. + * + * With the vtx code now in place, it should be possible to track + * changes to the sizes of input arrays (and state, of course) and + * only invalidate this function when those sizes have changed. + */ +#if 0 + foreach (l, p->codegen_list) { + if (l->attr_count != count) + continue; + + /* Assumptions: + * a[j].vp will not change for a given attrib + * a[j].vertex_offset will not change nothing else has changed. + */ + for (j = 0; j < count; j++) + if (a[j].attrib != l->a[j].attrib || + a[j].sz != l->a[j].sz) + break; + + if (j == count) { + move_to_head(l, p->codegen_list); + return l->func; + } + } +#endif + + p->emit_header( p, vtx ); + + for (j = 0; j < count; j++) { + GLuint sz = VB->AttribPtr[a[j].attrib]->size - 1; + p->emit_attr_header( p, a, j, + emit_info[a[j].format].out_type, + emit_info[a[j].format].need_vp ); + + if (!emit_info[a[j].format].emit[sz]( p )) { + fprintf(stderr, "codegen failed\n"); + return 0; + } + + p->emit_attr_footer( p ); + } + + p->emit_footer( p ); + + return p->emit_store_func( p ); +} + diff --git a/src/mesa/tnl/t_vtx_api.c b/src/mesa/tnl/t_vtx_api.c new file mode 100644 index 0000000..56b1e9f --- /dev/null +++ b/src/mesa/tnl/t_vtx_api.c @@ -0,0 +1,975 @@ +/* $XFree86$ */ +/************************************************************************** + +Copyright 2002 Tungsten Graphics Inc., Cedar Park, Texas. + +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"), +to deal in the Software without restriction, including without limitation +on the rights to use, copy, modify, merge, publish, distribute, sub +license, and/or sell copies of the Software, and to permit persons to whom +the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL +TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +USE OR OTHER DEALINGS IN THE SOFTWARE. + +**************************************************************************/ + +/* + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + +#include "glheader.h" +#include "context.h" +#include "macros.h" +#include "vtxfmt.h" +#include "dlist.h" +#include "state.h" +#include "light.h" +#include "api_arrayelt.h" +#include "api_noop.h" +#include "t_vtx_api.h" +#include "simple_list.h" + +static void reset_attrfv( TNLcontext *tnl ); + +static tnl_attrfv_func choose[_TNL_MAX_ATTR_CODEGEN+1][4]; /* +1 for ERROR_ATTRIB */ +static tnl_attrfv_func generic_attr_func[_TNL_MAX_ATTR_CODEGEN][4]; + + +/* Close off the last primitive, execute the buffer, restart the + * primitive. + */ +static void _tnl_wrap_buffers( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + + + if (tnl->vtx.prim_count == 0) { + tnl->vtx.copied.nr = 0; + tnl->vtx.counter = tnl->vtx.initial_counter; + tnl->vtx.vbptr = tnl->vtx.buffer; + } + else { + GLuint last_prim = tnl->vtx.prim[tnl->vtx.prim_count-1].mode; + GLuint last_count = tnl->vtx.prim[tnl->vtx.prim_count-1].count; + + if (ctx->Driver.CurrentExecPrimitive != GL_POLYGON+1) { + GLint i = tnl->vtx.prim_count - 1; + assert(i >= 0); + tnl->vtx.prim[i].count = ((tnl->vtx.initial_counter - + tnl->vtx.counter) - + tnl->vtx.prim[i].start); + } + + /* Execute the buffer and save copied vertices. + */ + if (tnl->vtx.counter != tnl->vtx.initial_counter) + _tnl_flush_vtx( ctx ); + else { + tnl->vtx.prim_count = 0; + tnl->vtx.copied.nr = 0; + } + + /* Emit a glBegin to start the new list. + */ + assert(tnl->vtx.prim_count == 0); + + if (ctx->Driver.CurrentExecPrimitive != GL_POLYGON+1) { + tnl->vtx.prim[0].mode = ctx->Driver.CurrentExecPrimitive; + tnl->vtx.prim[0].start = 0; + tnl->vtx.prim[0].count = 0; + tnl->vtx.prim_count++; + + if (tnl->vtx.copied.nr == last_count) + tnl->vtx.prim[0].mode |= last_prim & PRIM_BEGIN; + } + } +} + + +/* Deal with buffer wrapping where provoked by the vertex buffer + * filling up, as opposed to upgrade_vertex(). + * + * Make it GLAPIENTRY, so we can tail from the codegen'ed Vertex*fv + */ +void GLAPIENTRY _tnl_wrap_filled_vertex( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLfloat *data = tnl->vtx.copied.buffer; + GLuint i; + + /* Run pipeline on current vertices, copy wrapped vertices + * to tnl->copied. + */ + _tnl_wrap_buffers( ctx ); + + /* Copy stored stored vertices to start of new list. + */ + assert(tnl->vtx.counter > tnl->vtx.copied.nr); + + for (i = 0 ; i < tnl->vtx.copied.nr ; i++) { + _mesa_memcpy( tnl->vtx.vbptr, data, + tnl->vtx.vertex_size * sizeof(GLfloat)); + tnl->vtx.vbptr += tnl->vtx.vertex_size; + data += tnl->vtx.vertex_size; + tnl->vtx.counter--; + } + + tnl->vtx.copied.nr = 0; +} + + +/* + * Copy the active vertex's values to the ctx->Current fields. + */ +static void _tnl_copy_to_current( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint i; + + for (i = _TNL_ATTRIB_POS+1 ; i < _TNL_ATTRIB_INDEX ; i++) { + if (tnl->vtx.attrsz[i]) { + /* Note: the tnl->vtx.current[i] pointers points to + * the ctx->Current fields. The first 16 or so, anyway. + */ + ASSIGN_4V( tnl->vtx.current[i], 0, 0, 0, 1 ); + COPY_SZ_4V(tnl->vtx.current[i], + tnl->vtx.attrsz[i], + tnl->vtx.attrptr[i]); + } + } + + /* color index is special (it's not a float[4] so COPY_CLEAN_4V above + * will trash adjacent memory!) + */ + if (tnl->vtx.attrsz[_TNL_ATTRIB_INDEX]) { + ctx->Current.Index = tnl->vtx.attrptr[_TNL_ATTRIB_INDEX][0]; + } + + /* Edgeflag requires special treatment: + */ + if (tnl->vtx.attrsz[_TNL_ATTRIB_EDGEFLAG]) + ctx->Current.EdgeFlag = + (tnl->vtx.attrptr[_TNL_ATTRIB_EDGEFLAG][0] == 1.0); + + + /* Colormaterial -- this kindof sucks. + */ + if (ctx->Light.ColorMaterialEnabled) { + _mesa_update_color_material(ctx, + ctx->Current.Attrib[VERT_ATTRIB_COLOR0]); + } + + if (tnl->vtx.have_materials) { + tnl->Driver.NotifyMaterialChange( ctx ); + } + + ctx->Driver.NeedFlush &= ~FLUSH_UPDATE_CURRENT; +} + + +static void _tnl_copy_from_current( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLint i; + + for (i = _TNL_ATTRIB_POS+1 ; i <= _TNL_ATTRIB_INDEX ; i++) + switch (tnl->vtx.attrsz[i]) { + case 4: tnl->vtx.attrptr[i][3] = tnl->vtx.current[i][3]; + case 3: tnl->vtx.attrptr[i][2] = tnl->vtx.current[i][2]; + case 2: tnl->vtx.attrptr[i][1] = tnl->vtx.current[i][1]; + case 1: tnl->vtx.attrptr[i][0] = tnl->vtx.current[i][0]; + break; + } + + /* Edgeflag requires special treatment: + */ + if (tnl->vtx.attrsz[_TNL_ATTRIB_EDGEFLAG]) + tnl->vtx.attrptr[_TNL_ATTRIB_EDGEFLAG][0] = + (GLfloat)ctx->Current.EdgeFlag; + + + ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; +} + + +/* Flush existing data, set new attrib size, replay copied vertices. + */ +static void _tnl_wrap_upgrade_vertex( GLcontext *ctx, + GLuint attr, + GLuint newsz ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint oldsz; + GLuint i; + GLfloat *tmp; + GLint lastcount = tnl->vtx.initial_counter - tnl->vtx.counter; + + /* Run pipeline on current vertices, copy wrapped vertices + * to tnl->vtx.copied. + */ + _tnl_wrap_buffers( ctx ); + + + /* Do a COPY_TO_CURRENT to ensure back-copying works for the case + * when the attribute already exists in the vertex and is having + * its size increased. + */ + _tnl_copy_to_current( ctx ); + + + /* Heuristic: Attempt to isolate attributes received outside + * begin/end so that they don't bloat the vertices. + */ + if (ctx->Driver.CurrentExecPrimitive == PRIM_OUTSIDE_BEGIN_END && + tnl->vtx.attrsz[attr] == 0 && + lastcount > 8 && + tnl->vtx.vertex_size) { + reset_attrfv( tnl ); + } + + /* Fix up sizes: + */ + oldsz = tnl->vtx.attrsz[attr]; + tnl->vtx.attrsz[attr] = newsz; + + tnl->vtx.vertex_size += newsz - oldsz; + tnl->vtx.counter = MIN2( VERT_BUFFER_SIZE / tnl->vtx.vertex_size, + ctx->Const.MaxArrayLockSize ); + tnl->vtx.initial_counter = tnl->vtx.counter; + tnl->vtx.vbptr = tnl->vtx.buffer; + + + /* Recalculate all the attrptr[] values + */ + for (i = 0, tmp = tnl->vtx.vertex ; i < _TNL_ATTRIB_MAX ; i++) { + if (tnl->vtx.attrsz[i]) { + tnl->vtx.attrptr[i] = tmp; + tmp += tnl->vtx.attrsz[i]; + } + else + tnl->vtx.attrptr[i] = 0; /* will not be dereferenced */ + } + + /* Copy from current to repopulate the vertex with correct values. + */ + _tnl_copy_from_current( ctx ); + + /* Replay stored vertices to translate them + * to new format here. + * + * -- No need to replay - just copy piecewise + */ + if (tnl->vtx.copied.nr) + { + GLfloat *data = tnl->vtx.copied.buffer; + GLfloat *dest = tnl->vtx.buffer; + GLuint j; + + for (i = 0 ; i < tnl->vtx.copied.nr ; i++) { + for (j = 0 ; j < _TNL_ATTRIB_MAX ; j++) { + if (tnl->vtx.attrsz[j]) { + if (j == attr) { + if (oldsz) { + ASSIGN_4V( dest, 0, 0, 0, 1 ); + COPY_SZ_4V( dest, oldsz, data ); + data += oldsz; + dest += newsz; + } else { + COPY_SZ_4V( dest, newsz, tnl->vtx.current[j] ); + dest += newsz; + } + } + else { + GLuint sz = tnl->vtx.attrsz[j]; + COPY_SZ_4V( dest, sz, data ); + dest += sz; + data += sz; + } + } + } + } + + tnl->vtx.vbptr = dest; + tnl->vtx.counter -= tnl->vtx.copied.nr; + tnl->vtx.copied.nr = 0; + } + + /* For codegen - attrptr's may have changed, so need to redo + * codegen. Might be a reasonable place to try & detect attributes + * in the vertex which aren't being submitted any more. + */ + for (i = 0 ; i < _TNL_ATTRIB_MAX ; i++) + if (tnl->vtx.attrsz[i]) { + GLuint j = tnl->vtx.attrsz[i] - 1; + + if (i < _TNL_MAX_ATTR_CODEGEN) + tnl->vtx.tabfv[i][j] = choose[i][j]; + } + +} + + +static void _tnl_fixup_vertex( GLcontext *ctx, GLuint attr, GLuint sz ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + static const GLfloat id[4] = { 0, 0, 0, 1 }; + int i; + + if (tnl->vtx.attrsz[attr] < sz) { + /* New size is larger. Need to flush existing vertices and get + * an enlarged vertex format. + */ + _tnl_wrap_upgrade_vertex( ctx, attr, sz ); + } + else if (tnl->vtx.attrsz[attr] > sz) { + /* New size is smaller - just need to fill in some + * zeros. Don't need to flush or wrap. + */ + for (i = sz ; i <= tnl->vtx.attrsz[attr] ; i++) + tnl->vtx.attrptr[attr][i-1] = id[i-1]; + } + + /* Does setting NeedFlush belong here? Necessitates resetting + * vtxfmt on each flush (otherwise flags won't get reset + * afterwards). + */ + if (attr == 0) + ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; + else + ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; +} + +#ifdef USE_X86_ASM + +static struct _tnl_dynfn *lookup( struct _tnl_dynfn *l, GLuint key ) +{ + struct _tnl_dynfn *f; + + foreach( f, l ) { + if (f->key == key) + return f; + } + + return 0; +} + + +static tnl_attrfv_func do_codegen( GLcontext *ctx, GLuint attr, GLuint sz ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct _tnl_dynfn *dfn = 0; + + if (attr == 0) { + GLuint key = tnl->vtx.vertex_size; + + dfn = lookup( &tnl->vtx.cache.Vertex[sz-1], key ); + + if (!dfn) + dfn = tnl->vtx.gen.Vertex[sz-1]( ctx, key ); + } + else { + GLuint key = (GLuint) tnl->vtx.attrptr[attr]; + + dfn = lookup( &tnl->vtx.cache.Attribute[sz-1], key ); + + if (!dfn) + dfn = tnl->vtx.gen.Attribute[sz-1]( ctx, key ); + } + + if (dfn) + return *(tnl_attrfv_func *) &dfn->code; + else + return 0; +} + +#endif /* USE_X86_ASM */ + +/* Helper function for 'CHOOSE' macro. Do what's necessary when an + * entrypoint is called for the first time. + */ + +static tnl_attrfv_func do_choose( GLuint attr, GLuint sz ) +{ + GET_CURRENT_CONTEXT( ctx ); + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint oldsz = tnl->vtx.attrsz[attr]; + + assert(attr < _TNL_MAX_ATTR_CODEGEN); + + if (oldsz != sz) { + /* Reset any active pointers for this attribute + */ + if (oldsz) + tnl->vtx.tabfv[attr][oldsz-1] = choose[attr][oldsz-1]; + + _tnl_fixup_vertex( ctx, attr, sz ); + + } + + + /* Try to use codegen: + */ +#ifdef USE_X86_ASM + if (tnl->AllowCodegen) + tnl->vtx.tabfv[attr][sz-1] = do_codegen( ctx, attr, sz ); + else +#endif + tnl->vtx.tabfv[attr][sz-1] = 0; + + /* Else use generic version: + */ + if (!tnl->vtx.tabfv[attr][sz-1]) + tnl->vtx.tabfv[attr][sz-1] = generic_attr_func[attr][sz-1]; + + return tnl->vtx.tabfv[attr][sz-1]; +} + + + +#define CHOOSE( ATTR, N ) \ +static void choose_##ATTR##_##N( const GLfloat *v ) \ +{ \ + tnl_attrfv_func f = do_choose(ATTR, N); \ + f( v ); \ +} + +#define CHOOSERS( ATTRIB ) \ + CHOOSE( ATTRIB, 1 ) \ + CHOOSE( ATTRIB, 2 ) \ + CHOOSE( ATTRIB, 3 ) \ + CHOOSE( ATTRIB, 4 ) \ + + +#define INIT_CHOOSERS(ATTR) \ + choose[ATTR][0] = choose_##ATTR##_1; \ + choose[ATTR][1] = choose_##ATTR##_2; \ + choose[ATTR][2] = choose_##ATTR##_3; \ + choose[ATTR][3] = choose_##ATTR##_4; + +CHOOSERS( 0 ) +CHOOSERS( 1 ) +CHOOSERS( 2 ) +CHOOSERS( 3 ) +CHOOSERS( 4 ) +CHOOSERS( 5 ) +CHOOSERS( 6 ) +CHOOSERS( 7 ) +CHOOSERS( 8 ) +CHOOSERS( 9 ) +CHOOSERS( 10 ) +CHOOSERS( 11 ) +CHOOSERS( 12 ) +CHOOSERS( 13 ) +CHOOSERS( 14 ) +CHOOSERS( 15 ) + +static void error_attrib( const GLfloat *unused ) +{ + GET_CURRENT_CONTEXT( ctx ); + (void) unused; + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib" ); +} + + + +static void reset_attrfv( TNLcontext *tnl ) +{ + GLuint i; + + for (i = 0 ; i < _TNL_ATTRIB_MAX ; i++) + if (tnl->vtx.attrsz[i]) { + GLint j = tnl->vtx.attrsz[i] - 1; + tnl->vtx.attrsz[i] = 0; + + if (i < _TNL_MAX_ATTR_CODEGEN) { + while (j >= 0) { + tnl->vtx.tabfv[i][j] = choose[i][j]; + j--; + } + } + } + + tnl->vtx.vertex_size = 0; + tnl->vtx.have_materials = 0; +} + + + +/* Materials: + * + * These are treated as per-vertex attributes, at indices above where + * the NV_vertex_program leaves off. There are a lot of good things + * about treating materials this way. + * + * However: I don't want to double the number of generated functions + * just to cope with this, so I unroll the 'C' varients of CHOOSE and + * ATTRF into this function, and dispense with codegen and + * second-level dispatch. + * + * There is no aliasing of material attributes with other entrypoints. + */ +#define OTHER_ATTR( A, N, params ) \ +do { \ + if (tnl->vtx.attrsz[A] != N) { \ + _tnl_fixup_vertex( ctx, A, N ); \ + } \ + \ + { \ + GLfloat *dest = tnl->vtx.attrptr[A]; \ + if (N>0) dest[0] = (params)[0]; \ + if (N>1) dest[1] = (params)[1]; \ + if (N>2) dest[2] = (params)[2]; \ + if (N>3) dest[3] = (params)[3]; \ + } \ +} while (0) + + +#define MAT( ATTR, N, face, params ) \ +do { \ + if (face != GL_BACK) \ + OTHER_ATTR( ATTR, N, params ); /* front */ \ + if (face != GL_FRONT) \ + OTHER_ATTR( ATTR + 1, N, params ); /* back */ \ +} while (0) + + +/* Colormaterial is dealt with later on. + */ +static void GLAPIENTRY _tnl_Materialfv( GLenum face, GLenum pname, + const GLfloat *params ) +{ + GET_CURRENT_CONTEXT( ctx ); + TNLcontext *tnl = TNL_CONTEXT(ctx); + + switch (face) { + case GL_FRONT: + case GL_BACK: + case GL_FRONT_AND_BACK: + break; + + default: + _mesa_error( ctx, GL_INVALID_ENUM, "glMaterialfv" ); + return; + } + + switch (pname) { + case GL_EMISSION: + MAT( _TNL_ATTRIB_MAT_FRONT_EMISSION, 4, face, params ); + break; + case GL_AMBIENT: + MAT( _TNL_ATTRIB_MAT_FRONT_AMBIENT, 4, face, params ); + break; + case GL_DIFFUSE: + MAT( _TNL_ATTRIB_MAT_FRONT_DIFFUSE, 4, face, params ); + break; + case GL_SPECULAR: + MAT( _TNL_ATTRIB_MAT_FRONT_SPECULAR, 4, face, params ); + break; + case GL_SHININESS: + MAT( _TNL_ATTRIB_MAT_FRONT_SHININESS, 1, face, params ); + break; + case GL_COLOR_INDEXES: + MAT( _TNL_ATTRIB_MAT_FRONT_INDEXES, 3, face, params ); + break; + case GL_AMBIENT_AND_DIFFUSE: + MAT( _TNL_ATTRIB_MAT_FRONT_AMBIENT, 4, face, params ); + MAT( _TNL_ATTRIB_MAT_FRONT_DIFFUSE, 4, face, params ); + break; + default: + _mesa_error( ctx, GL_INVALID_ENUM, "glMaterialfv" ); + return; + } + + tnl->vtx.have_materials = GL_TRUE; +} + + +static void GLAPIENTRY _tnl_EdgeFlag( GLboolean b ) +{ + GET_CURRENT_CONTEXT( ctx ); + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLfloat f = (GLfloat)b; + + OTHER_ATTR( _TNL_ATTRIB_EDGEFLAG, 1, &f ); +} + +static void GLAPIENTRY _tnl_EdgeFlagv( const GLboolean *v ) +{ + GET_CURRENT_CONTEXT( ctx ); + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLfloat f = (GLfloat)v[0]; + + OTHER_ATTR( _TNL_ATTRIB_EDGEFLAG, 1, &f ); +} + +static void GLAPIENTRY _tnl_Indexf( GLfloat f ) +{ + GET_CURRENT_CONTEXT( ctx ); + TNLcontext *tnl = TNL_CONTEXT(ctx); + + OTHER_ATTR( _TNL_ATTRIB_INDEX, 1, &f ); +} + +static void GLAPIENTRY _tnl_Indexfv( const GLfloat *v ) +{ + GET_CURRENT_CONTEXT( ctx ); + TNLcontext *tnl = TNL_CONTEXT(ctx); + + OTHER_ATTR( _TNL_ATTRIB_INDEX, 1, v ); +} + +/* Eval + */ +static void GLAPIENTRY _tnl_EvalCoord1f( GLfloat u ) +{ + GET_CURRENT_CONTEXT( ctx ); + TNLcontext *tnl = TNL_CONTEXT(ctx); + + /* TODO: use a CHOOSE() function for this: */ + { + GLint i; + if (tnl->vtx.eval.new_state) + _tnl_update_eval( ctx ); + + for (i = 0 ; i <= _TNL_ATTRIB_INDEX ; i++) { + if (tnl->vtx.eval.map1[i].map) + if (tnl->vtx.attrsz[i] != tnl->vtx.eval.map1[i].sz) + _tnl_fixup_vertex( ctx, i, tnl->vtx.eval.map1[i].sz ); + } + } + + + _mesa_memcpy( tnl->vtx.copied.buffer, tnl->vtx.vertex, + tnl->vtx.vertex_size * sizeof(GLfloat)); + + _tnl_do_EvalCoord1f( ctx, u ); + + _mesa_memcpy( tnl->vtx.vertex, tnl->vtx.copied.buffer, + tnl->vtx.vertex_size * sizeof(GLfloat)); +} + +static void GLAPIENTRY _tnl_EvalCoord2f( GLfloat u, GLfloat v ) +{ + GET_CURRENT_CONTEXT( ctx ); + TNLcontext *tnl = TNL_CONTEXT(ctx); + + /* TODO: use a CHOOSE() function for this: */ + { + GLint i; + if (tnl->vtx.eval.new_state) + _tnl_update_eval( ctx ); + + for (i = 0 ; i <= _TNL_ATTRIB_INDEX ; i++) { + if (tnl->vtx.eval.map2[i].map) + if (tnl->vtx.attrsz[i] != tnl->vtx.eval.map2[i].sz) + _tnl_fixup_vertex( ctx, i, tnl->vtx.eval.map2[i].sz ); + } + + if (ctx->Eval.AutoNormal) + if (tnl->vtx.attrsz[_TNL_ATTRIB_NORMAL] != 3) + _tnl_fixup_vertex( ctx, _TNL_ATTRIB_NORMAL, 3 ); + } + + _mesa_memcpy( tnl->vtx.copied.buffer, tnl->vtx.vertex, + tnl->vtx.vertex_size * sizeof(GLfloat)); + + _tnl_do_EvalCoord2f( ctx, u, v ); + + _mesa_memcpy( tnl->vtx.vertex, tnl->vtx.copied.buffer, + tnl->vtx.vertex_size * sizeof(GLfloat)); +} + +static void GLAPIENTRY _tnl_EvalCoord1fv( const GLfloat *u ) +{ + _tnl_EvalCoord1f( u[0] ); +} + +static void GLAPIENTRY _tnl_EvalCoord2fv( const GLfloat *u ) +{ + _tnl_EvalCoord2f( u[0], u[1] ); +} + +static void GLAPIENTRY _tnl_EvalPoint1( GLint i ) +{ + GET_CURRENT_CONTEXT( ctx ); + GLfloat du = ((ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1) / + (GLfloat) ctx->Eval.MapGrid1un); + GLfloat u = i * du + ctx->Eval.MapGrid1u1; + + _tnl_EvalCoord1f( u ); +} + + +static void GLAPIENTRY _tnl_EvalPoint2( GLint i, GLint j ) +{ + GET_CURRENT_CONTEXT( ctx ); + GLfloat du = ((ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1) / + (GLfloat) ctx->Eval.MapGrid2un); + GLfloat dv = ((ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1) / + (GLfloat) ctx->Eval.MapGrid2vn); + GLfloat u = i * du + ctx->Eval.MapGrid2u1; + GLfloat v = j * dv + ctx->Eval.MapGrid2v1; + + _tnl_EvalCoord2f( u, v ); +} + + +/* Build a list of primitives on the fly. Keep + * ctx->Driver.CurrentExecPrimitive uptodate as well. + */ +static void GLAPIENTRY _tnl_Begin( GLenum mode ) +{ + GET_CURRENT_CONTEXT( ctx ); + + if (ctx->Driver.CurrentExecPrimitive == GL_POLYGON+1) { + TNLcontext *tnl = TNL_CONTEXT(ctx); + int i; + + if (ctx->NewState) { + _mesa_update_state( ctx ); + + if ((ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) || + (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glBegin (invalid vertex/fragment program)"); + return; + } + + if (!(tnl->Driver.NotifyBegin && + tnl->Driver.NotifyBegin( ctx, mode ))) + ctx->Exec->Begin(mode); + return; + } + + /* Heuristic: attempt to isolate attributes occuring outside + * begin/end pairs. + */ + if (tnl->vtx.vertex_size && !tnl->vtx.attrsz[0]) + _tnl_FlushVertices( ctx, ~0 ); + + i = tnl->vtx.prim_count++; + tnl->vtx.prim[i].mode = mode | PRIM_BEGIN; + tnl->vtx.prim[i].start = tnl->vtx.initial_counter - tnl->vtx.counter; + tnl->vtx.prim[i].count = 0; + + ctx->Driver.CurrentExecPrimitive = mode; + } + else + _mesa_error( ctx, GL_INVALID_OPERATION, "glBegin" ); + +} + +static void GLAPIENTRY _tnl_End( void ) +{ + GET_CURRENT_CONTEXT( ctx ); + + if (ctx->Driver.CurrentExecPrimitive != GL_POLYGON+1) { + TNLcontext *tnl = TNL_CONTEXT(ctx); + int idx = tnl->vtx.initial_counter - tnl->vtx.counter; + int i = tnl->vtx.prim_count - 1; + + tnl->vtx.prim[i].mode |= PRIM_END; + tnl->vtx.prim[i].count = idx - tnl->vtx.prim[i].start; + + ctx->Driver.CurrentExecPrimitive = GL_POLYGON+1; + + /* Two choices which effect the way vertex attributes are + * carried over (or not) between adjacent primitives. + */ +#if 0 + if (tnl->vtx.prim_count == TNL_MAX_PRIM) + _tnl_FlushVertices( ctx, ~0 ); +#else + if (tnl->vtx.prim_count == TNL_MAX_PRIM) + _tnl_flush_vtx( ctx ); +#endif + + } + else + _mesa_error( ctx, GL_INVALID_OPERATION, "glEnd" ); +} + + +static void _tnl_exec_vtxfmt_init( GLcontext *ctx ) +{ + GLvertexformat *vfmt = &(TNL_CONTEXT(ctx)->exec_vtxfmt); + + vfmt->ArrayElement = _ae_loopback_array_elt; /* generic helper */ + vfmt->Begin = _tnl_Begin; + vfmt->CallList = _mesa_CallList; + vfmt->CallLists = _mesa_CallLists; + vfmt->EdgeFlag = _tnl_EdgeFlag; + vfmt->EdgeFlagv = _tnl_EdgeFlagv; + vfmt->End = _tnl_End; + vfmt->EvalCoord1f = _tnl_EvalCoord1f; + vfmt->EvalCoord1fv = _tnl_EvalCoord1fv; + vfmt->EvalCoord2f = _tnl_EvalCoord2f; + vfmt->EvalCoord2fv = _tnl_EvalCoord2fv; + vfmt->EvalPoint1 = _tnl_EvalPoint1; + vfmt->EvalPoint2 = _tnl_EvalPoint2; + vfmt->Indexf = _tnl_Indexf; + vfmt->Indexfv = _tnl_Indexfv; + vfmt->Materialfv = _tnl_Materialfv; + + vfmt->Rectf = _mesa_noop_Rectf; + vfmt->EvalMesh1 = _mesa_noop_EvalMesh1; + vfmt->EvalMesh2 = _mesa_noop_EvalMesh2; +} + + + +void _tnl_FlushVertices( GLcontext *ctx, GLuint flags ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + (void) flags; + + if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) + return; + + if (tnl->vtx.counter != tnl->vtx.initial_counter) { + _tnl_flush_vtx( ctx ); + } + + if (tnl->vtx.vertex_size) { + _tnl_copy_to_current( ctx ); + reset_attrfv( tnl ); + } + + ctx->Driver.NeedFlush = 0; +} + + +static void _tnl_current_init( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLint i; + + /* setup the pointers for the typical 16 vertex attributes */ + for (i = 0; i < VERT_ATTRIB_MAX; i++) + tnl->vtx.current[i] = ctx->Current.Attrib[i]; + + /* setup pointers for the 12 material attributes */ + for (i = 0; i < MAT_ATTRIB_MAX; i++) + tnl->vtx.current[_TNL_ATTRIB_MAT_FRONT_AMBIENT + i] = + ctx->Light.Material.Attrib[i]; + + tnl->vtx.current[_TNL_ATTRIB_INDEX] = &ctx->Current.Index; +} + +static struct _tnl_dynfn *no_codegen( GLcontext *ctx, int key ) +{ + (void) ctx; (void) key; + return 0; +} + +void _tnl_vtx_init( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct tnl_vertex_arrays *tmp = &tnl->vtx_inputs; + GLuint i; + static int firsttime = 1; + + if (firsttime) { + firsttime = 0; + + INIT_CHOOSERS( 0 ); + INIT_CHOOSERS( 1 ); + INIT_CHOOSERS( 2 ); + INIT_CHOOSERS( 3 ); + INIT_CHOOSERS( 4 ); + INIT_CHOOSERS( 5 ); + INIT_CHOOSERS( 6 ); + INIT_CHOOSERS( 7 ); + INIT_CHOOSERS( 8 ); + INIT_CHOOSERS( 9 ); + INIT_CHOOSERS( 10 ); + INIT_CHOOSERS( 11 ); + INIT_CHOOSERS( 12 ); + INIT_CHOOSERS( 13 ); + INIT_CHOOSERS( 14 ); + INIT_CHOOSERS( 15 ); + + choose[ERROR_ATTRIB][0] = error_attrib; + choose[ERROR_ATTRIB][1] = error_attrib; + choose[ERROR_ATTRIB][2] = error_attrib; + choose[ERROR_ATTRIB][3] = error_attrib; + +#ifdef USE_X86_ASM + if (tnl->AllowCodegen) { + _tnl_x86choosers(choose, do_choose); /* x86 INIT_CHOOSERS */ + } +#endif + + _tnl_generic_attr_table_init( generic_attr_func ); + } + + for (i = 0; i < _TNL_ATTRIB_INDEX; i++) + _mesa_vector4f_init( &tmp->Attribs[i], 0, 0); + + for (i = 0; i < 4; i++) { + make_empty_list( &tnl->vtx.cache.Vertex[i] ); + make_empty_list( &tnl->vtx.cache.Attribute[i] ); + tnl->vtx.gen.Vertex[i] = no_codegen; + tnl->vtx.gen.Attribute[i] = no_codegen; + } + +#ifdef USE_X86_ASM + _tnl_InitX86Codegen( &tnl->vtx.gen ); +#endif + + _tnl_current_init( ctx ); + _tnl_exec_vtxfmt_init( ctx ); + _tnl_generic_exec_vtxfmt_init( ctx ); +#ifdef USE_X86_ASM + if (tnl->AllowCodegen) { + _tnl_x86_exec_vtxfmt_init( ctx ); /* x86 DISPATCH_ATTRFV */ + } +#endif + + _mesa_install_exec_vtxfmt( ctx, &tnl->exec_vtxfmt ); + + memcpy( tnl->vtx.tabfv, choose, sizeof(choose) ); + + for (i = 0 ; i < _TNL_ATTRIB_MAX ; i++) + tnl->vtx.attrsz[i] = 0; + + tnl->vtx.vertex_size = 0; + tnl->vtx.have_materials = 0; +} + +static void free_funcs( struct _tnl_dynfn *l ) +{ + struct _tnl_dynfn *f, *tmp; + foreach_s (f, tmp, l) { + remove_from_list( f ); + ALIGN_FREE( f->code ); + FREE( f ); + } +} + + +void _tnl_vtx_destroy( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint i; + + for (i = 0; i < 4; i++) { + free_funcs( &tnl->vtx.cache.Vertex[i] ); + free_funcs( &tnl->vtx.cache.Attribute[i] ); + } +} + diff --git a/src/mesa/tnl/t_vtx_api.h b/src/mesa/tnl/t_vtx_api.h new file mode 100644 index 0000000..9818c08 --- /dev/null +++ b/src/mesa/tnl/t_vtx_api.h @@ -0,0 +1,90 @@ +/* $XFree86$ */ +/************************************************************************** + +Copyright 2002 Tungsten Graphics Inc., Cedar Park, Texas. + +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"), +to deal in the Software without restriction, including without limitation +on the rights to use, copy, modify, merge, publish, distribute, sub +license, and/or sell copies of the Software, and to permit persons to whom +the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL +TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +USE OR OTHER DEALINGS IN THE SOFTWARE. + +**************************************************************************/ + +/* + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + * + */ + +#ifndef __T_VTX_API_H__ +#define __T_VTX_API_H__ + +#include "t_context.h" + +#define ERROR_ATTRIB 16 + + + +/* t_vtx_api.c: + */ +extern void _tnl_vtx_init( GLcontext *ctx ); +extern void _tnl_vtx_destroy( GLcontext *ctx ); + +extern void _tnl_FlushVertices( GLcontext *ctx, GLuint flags ); +extern void _tnl_flush_vtx( GLcontext *ctx ); + +extern void GLAPIENTRY _tnl_wrap_filled_vertex( GLcontext *ctx ); + +/* t_vtx_exec.c: + */ + +extern void _tnl_do_EvalCoord2f( GLcontext* ctx, GLfloat u, GLfloat v ); +extern void _tnl_do_EvalCoord1f(GLcontext* ctx, GLfloat u); +extern void _tnl_update_eval( GLcontext *ctx ); + +extern GLboolean *_tnl_translate_edgeflag( GLcontext *ctx, + const GLfloat *data, + GLuint count, + GLuint stride ); + +extern GLboolean *_tnl_import_current_edgeflag( GLcontext *ctx, + GLuint count ); + + + +/* t_vtx_generic.c: + */ +extern void _tnl_generic_exec_vtxfmt_init( GLcontext *ctx ); + +extern void _tnl_generic_attr_table_init( tnl_attrfv_func (*tab)[4] ); + +/* t_vtx_x86.c: + */ +extern void _tnl_InitX86Codegen( struct _tnl_dynfn_generators *gen ); + +extern void _tnl_x86_exec_vtxfmt_init( GLcontext *ctx ); + +extern void _tnl_x86choosers( tnl_attrfv_func (*choose)[4], + tnl_attrfv_func (*do_choose)( GLuint attr, + GLuint sz )); + + + + +#endif diff --git a/src/mesa/tnl/t_vtx_eval.c b/src/mesa/tnl/t_vtx_eval.c new file mode 100644 index 0000000..5a24c70 --- /dev/null +++ b/src/mesa/tnl/t_vtx_eval.c @@ -0,0 +1,253 @@ +/* + * Mesa 3-D graphics library + * Version: 6.1 + * + * Copyright (C) 1999-2004 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + +#include "glheader.h" +#include "api_eval.h" +#include "context.h" +#include "macros.h" +#include "math/m_eval.h" +#include "t_vtx_api.h" + + +static void clear_active_eval1( TNLcontext *tnl, GLuint attr ) +{ + tnl->vtx.eval.map1[attr].map = 0; +} + +static void clear_active_eval2( TNLcontext *tnl, GLuint attr ) +{ + tnl->vtx.eval.map2[attr].map = 0; +} + +static void set_active_eval1( TNLcontext *tnl, GLuint attr, GLuint dim, + struct gl_1d_map *map ) +{ + if (!tnl->vtx.eval.map1[attr].map) { + tnl->vtx.eval.map1[attr].map = map; + tnl->vtx.eval.map1[attr].sz = dim; + } +} + +static void set_active_eval2( TNLcontext *tnl, GLuint attr, GLuint dim, + struct gl_2d_map *map ) +{ + if (!tnl->vtx.eval.map2[attr].map) { + tnl->vtx.eval.map2[attr].map = map; + tnl->vtx.eval.map2[attr].sz = dim; + } +} + +void _tnl_update_eval( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint attr; + + /* Vertex program maps have priority over conventional attribs */ + + for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) { + clear_active_eval1( tnl, attr ); + clear_active_eval2( tnl, attr ); + } + + if (ctx->VertexProgram._Enabled) { + for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) { + if (ctx->Eval.Map1Attrib[attr]) + set_active_eval1( tnl, attr, 4, &ctx->EvalMap.Map1Attrib[attr] ); + + if (ctx->Eval.Map2Attrib[attr]) + set_active_eval2( tnl, attr, 4, &ctx->EvalMap.Map2Attrib[attr] ); + } + } + + if (ctx->Eval.Map1Color4) + set_active_eval1( tnl, VERT_ATTRIB_COLOR0, 4, &ctx->EvalMap.Map1Color4 ); + + if (ctx->Eval.Map2Color4) + set_active_eval2( tnl, VERT_ATTRIB_COLOR0, 4, &ctx->EvalMap.Map2Color4 ); + + if (ctx->Eval.Map1TextureCoord4) + set_active_eval1( tnl, VERT_ATTRIB_TEX0, 4, &ctx->EvalMap.Map1Texture4 ); + else if (ctx->Eval.Map1TextureCoord3) + set_active_eval1( tnl, VERT_ATTRIB_TEX0, 3, &ctx->EvalMap.Map1Texture3 ); + else if (ctx->Eval.Map1TextureCoord2) + set_active_eval1( tnl, VERT_ATTRIB_TEX0, 2, &ctx->EvalMap.Map1Texture2 ); + else if (ctx->Eval.Map1TextureCoord1) + set_active_eval1( tnl, VERT_ATTRIB_TEX0, 1, &ctx->EvalMap.Map1Texture1 ); + + if (ctx->Eval.Map2TextureCoord4) + set_active_eval2( tnl, VERT_ATTRIB_TEX0, 4, &ctx->EvalMap.Map2Texture4 ); + else if (ctx->Eval.Map2TextureCoord3) + set_active_eval2( tnl, VERT_ATTRIB_TEX0, 3, &ctx->EvalMap.Map2Texture3 ); + else if (ctx->Eval.Map2TextureCoord2) + set_active_eval2( tnl, VERT_ATTRIB_TEX0, 2, &ctx->EvalMap.Map2Texture2 ); + else if (ctx->Eval.Map2TextureCoord1) + set_active_eval2( tnl, VERT_ATTRIB_TEX0, 1, &ctx->EvalMap.Map2Texture1 ); + + if (ctx->Eval.Map1Normal) + set_active_eval1( tnl, VERT_ATTRIB_NORMAL, 3, &ctx->EvalMap.Map1Normal ); + + if (ctx->Eval.Map2Normal) + set_active_eval2( tnl, VERT_ATTRIB_NORMAL, 3, &ctx->EvalMap.Map2Normal ); + + if (ctx->Eval.Map1Vertex4) + set_active_eval1( tnl, VERT_ATTRIB_POS, 4, &ctx->EvalMap.Map1Vertex4 ); + else if (ctx->Eval.Map1Vertex3) + set_active_eval1( tnl, VERT_ATTRIB_POS, 3, &ctx->EvalMap.Map1Vertex3 ); + + if (ctx->Eval.Map2Vertex4) + set_active_eval2( tnl, VERT_ATTRIB_POS, 4, &ctx->EvalMap.Map2Vertex4 ); + else if (ctx->Eval.Map2Vertex3) + set_active_eval2( tnl, VERT_ATTRIB_POS, 3, &ctx->EvalMap.Map2Vertex3 ); + + tnl->vtx.eval.new_state = 0; +} + + + +void _tnl_do_EvalCoord1f(GLcontext* ctx, GLfloat u) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint attr; + + for (attr = 1; attr <= _TNL_ATTRIB_INDEX; attr++) { + struct gl_1d_map *map = tnl->vtx.eval.map1[attr].map; + if (map) { + GLfloat uu = (u - map->u1) * map->du; + GLfloat data[4]; + + ASSIGN_4V(data, 0, 0, 0, 1); + + _math_horner_bezier_curve(map->Points, data, uu, + tnl->vtx.eval.map1[attr].sz, + map->Order); + + COPY_SZ_4V( tnl->vtx.attrptr[attr], + tnl->vtx.attrsz[attr], + data ); + } + } + + /** Vertex -- EvalCoord1f is a noop if this map not enabled: + **/ + if (tnl->vtx.eval.map1[0].map) { + struct gl_1d_map *map = tnl->vtx.eval.map1[0].map; + GLfloat uu = (u - map->u1) * map->du; + GLfloat vertex[4]; + + ASSIGN_4V(vertex, 0, 0, 0, 1); + + _math_horner_bezier_curve(map->Points, vertex, uu, + tnl->vtx.eval.map1[0].sz, + map->Order); + + if (tnl->vtx.eval.map1[0].sz == 4) + GL_CALL(Vertex4fv)( vertex ); + else + GL_CALL(Vertex3fv)( vertex ); + } +} + + + +void _tnl_do_EvalCoord2f( GLcontext* ctx, GLfloat u, GLfloat v ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint attr; + + for (attr = 1; attr <= _TNL_ATTRIB_INDEX; attr++) { + struct gl_2d_map *map = tnl->vtx.eval.map2[attr].map; + if (map) { + GLfloat uu = (u - map->u1) * map->du; + GLfloat vv = (v - map->v1) * map->dv; + GLfloat data[4]; + + ASSIGN_4V(data, 0, 0, 0, 1); + + _math_horner_bezier_surf(map->Points, + data, + uu, vv, + tnl->vtx.eval.map2[attr].sz, + map->Uorder, map->Vorder); + + COPY_SZ_4V( tnl->vtx.attrptr[attr], + tnl->vtx.attrsz[attr], + data ); + } + } + + /** Vertex -- EvalCoord2f is a noop if this map not enabled: + **/ + if (tnl->vtx.eval.map2[0].map) { + struct gl_2d_map *map = tnl->vtx.eval.map2[0].map; + GLfloat uu = (u - map->u1) * map->du; + GLfloat vv = (v - map->v1) * map->dv; + GLfloat vertex[4]; + + ASSIGN_4V(vertex, 0, 0, 0, 1); + + if (ctx->Eval.AutoNormal) { + GLfloat normal[4]; + GLfloat du[4], dv[4]; + + _math_de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, + tnl->vtx.eval.map2[0].sz, + map->Uorder, map->Vorder); + + if (tnl->vtx.eval.map2[0].sz == 4) { + du[0] = du[0]*vertex[3] - du[3]*vertex[0]; + du[1] = du[1]*vertex[3] - du[3]*vertex[1]; + du[2] = du[2]*vertex[3] - du[3]*vertex[2]; + + dv[0] = dv[0]*vertex[3] - dv[3]*vertex[0]; + dv[1] = dv[1]*vertex[3] - dv[3]*vertex[1]; + dv[2] = dv[2]*vertex[3] - dv[3]*vertex[2]; + } + + + CROSS3(normal, du, dv); + NORMALIZE_3FV(normal); + normal[3] = 1.0; + + COPY_SZ_4V( tnl->vtx.attrptr[_TNL_ATTRIB_NORMAL], + tnl->vtx.attrsz[_TNL_ATTRIB_NORMAL], + normal ); + + } + else { + _math_horner_bezier_surf(map->Points, vertex, uu, vv, + tnl->vtx.eval.map2[0].sz, + map->Uorder, map->Vorder); + } + + if (tnl->vtx.attrsz[0] == 4) + GL_CALL(Vertex4fv)( vertex ); + else + GL_CALL(Vertex3fv)( vertex ); + } +} + + diff --git a/src/mesa/tnl/t_vtx_exec.c b/src/mesa/tnl/t_vtx_exec.c new file mode 100644 index 0000000..6925850 --- /dev/null +++ b/src/mesa/tnl/t_vtx_exec.c @@ -0,0 +1,289 @@ +/* + * Mesa 3-D graphics library + * Version: 5.1 + * + * 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + +#include "glheader.h" +#include "api_eval.h" +#include "context.h" +#include "enums.h" +#include "state.h" +#include "macros.h" +#include "math/m_eval.h" +#include "t_vtx_api.h" +#include "t_pipeline.h" + + +static void _tnl_print_vtx( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint count = tnl->vtx.initial_counter - tnl->vtx.counter; + GLuint i; + + _mesa_debug(ctx, "_tnl_print_vtx: %u vertices %d primitives, %d vertsize\n", + count, + tnl->vtx.prim_count, + tnl->vtx.vertex_size); + + for (i = 0 ; i < tnl->vtx.prim_count ; i++) { + struct tnl_prim *prim = &tnl->vtx.prim[i]; + _mesa_debug(0, " prim %d: %s %d..%d %s %s\n", + i, + _mesa_lookup_enum_by_nr(prim->mode & PRIM_MODE_MASK), + prim->start, + prim->start + prim->count, + (prim->mode & PRIM_BEGIN) ? "BEGIN" : "(wrap)", + (prim->mode & PRIM_END) ? "END" : "(wrap)"); + } +} + +GLboolean *_tnl_translate_edgeflag( GLcontext *ctx, const GLfloat *data, + GLuint count, GLuint stride ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLboolean *ef = tnl->vtx.edgeflag_tmp; + GLuint i; + + if (!ef) + ef = tnl->vtx.edgeflag_tmp = (GLboolean *) MALLOC( tnl->vb.Size ); + + for (i = 0 ; i < count ; i++, data += stride) + ef[i] = (data[0] == 1.0); + + return ef; +} + + +GLboolean *_tnl_import_current_edgeflag( GLcontext *ctx, + GLuint count ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLboolean *ef = tnl->vtx.edgeflag_tmp; + GLboolean tmp = ctx->Current.EdgeFlag; + GLuint i; + + if (!ef) + ef = tnl->vtx.edgeflag_tmp = (GLboolean *) MALLOC( tnl->vb.Size ); + + for (i = 0 ; i < count ; i++) + ef[i] = tmp; + + return ef; +} + +static INLINE GLint get_size( const GLfloat *f ) +{ + if (f[3] != 1.0) return 4; + if (f[2] != 0.0) return 3; + return 2; +} + +/* Some nasty stuff still hanging on here. + * + * TODO - remove VB->NormalPtr, etc and just use the AttrPtr's. + */ +static void _tnl_vb_bind_vtx( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + struct tnl_vertex_arrays *tmp = &tnl->vtx_inputs; + GLfloat *data = tnl->vtx.buffer; + GLuint count = tnl->vtx.initial_counter - tnl->vtx.counter; + GLuint attr, i; + + if (0) fprintf(stderr, "_tnl_vb_bind_vtx(): %d verts %d vertsize\n", + count, tnl->vtx.vertex_size); + + + /* Setup constant data in the VB. + */ + VB->Count = count; + VB->Primitive = tnl->vtx.prim; + VB->PrimitiveCount = tnl->vtx.prim_count; + VB->Elts = NULL; + VB->NormalLengthPtr = NULL; + + for (attr = 0; attr <= _TNL_ATTRIB_INDEX ; attr++) { + if (tnl->vtx.attrsz[attr]) { + tmp->Attribs[attr].count = count; + tmp->Attribs[attr].data = (GLfloat (*)[4]) data; + tmp->Attribs[attr].start = data; + tmp->Attribs[attr].size = tnl->vtx.attrsz[attr]; + tmp->Attribs[attr].stride = tnl->vtx.vertex_size * sizeof(GLfloat); + VB->AttribPtr[attr] = &tmp->Attribs[attr]; + data += tnl->vtx.attrsz[attr]; + } + else { +/* VB->AttribPtr[attr] = &tnl->current.Attribs[attr]; */ + + + tmp->Attribs[attr].count = count; + tmp->Attribs[attr].data = (GLfloat (*)[4]) tnl->vtx.current[attr]; + tmp->Attribs[attr].start = tnl->vtx.current[attr]; + tmp->Attribs[attr].size = get_size( tnl->vtx.current[attr] ); + tmp->Attribs[attr].stride = 0; + VB->AttribPtr[attr] = &tmp->Attribs[attr]; + } + } + + + /* Copy and translate EdgeFlag to a contiguous array of GLbooleans + */ + if (ctx->Polygon.FrontMode != GL_FILL || ctx->Polygon.BackMode != GL_FILL) { + if (tnl->vtx.attrsz[_TNL_ATTRIB_EDGEFLAG]) { + VB->EdgeFlag = _tnl_translate_edgeflag( ctx, data, count, + tnl->vtx.vertex_size ); + data++; + } + else + VB->EdgeFlag = _tnl_import_current_edgeflag( ctx, count ); + } + + /* Legacy pointers -- remove one day. + */ + VB->ObjPtr = VB->AttribPtr[_TNL_ATTRIB_POS]; + VB->NormalPtr = VB->AttribPtr[_TNL_ATTRIB_NORMAL]; + VB->ColorPtr[0] = VB->AttribPtr[_TNL_ATTRIB_COLOR0]; + VB->ColorPtr[1] = 0; + VB->IndexPtr[0] = VB->AttribPtr[_TNL_ATTRIB_INDEX]; + VB->IndexPtr[1] = 0; + VB->SecondaryColorPtr[0] = VB->AttribPtr[_TNL_ATTRIB_COLOR1]; + VB->SecondaryColorPtr[1] = 0; + VB->FogCoordPtr = VB->AttribPtr[_TNL_ATTRIB_FOG]; + + for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) { + VB->TexCoordPtr[i] = VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]; + } +} + + +/* + * NOTE: Need to have calculated primitives by this point -- do it on the fly. + * NOTE: Old 'parity' issue is gone. + */ +static GLuint _tnl_copy_vertices( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT( ctx ); + GLuint nr = tnl->vtx.prim[tnl->vtx.prim_count-1].count; + GLuint ovf, i; + GLuint sz = tnl->vtx.vertex_size; + GLfloat *dst = tnl->vtx.copied.buffer; + GLfloat *src = (tnl->vtx.buffer + + tnl->vtx.prim[tnl->vtx.prim_count-1].start * + tnl->vtx.vertex_size); + + + switch( ctx->Driver.CurrentExecPrimitive ) + { + case GL_POINTS: + return 0; + case GL_LINES: + ovf = nr&1; + for (i = 0 ; i < ovf ; i++) + _mesa_memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); + return i; + case GL_TRIANGLES: + ovf = nr%3; + for (i = 0 ; i < ovf ; i++) + _mesa_memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); + return i; + case GL_QUADS: + ovf = nr&3; + for (i = 0 ; i < ovf ; i++) + _mesa_memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); + return i; + case GL_LINE_STRIP: + if (nr == 0) + return 0; + else { + _mesa_memcpy( dst, src+(nr-1)*sz, sz * sizeof(GLfloat) ); + return 1; + } + case GL_LINE_LOOP: + case GL_TRIANGLE_FAN: + case GL_POLYGON: + if (nr == 0) + return 0; + else if (nr == 1) { + _mesa_memcpy( dst, src+0, sz * sizeof(GLfloat) ); + return 1; + } else { + _mesa_memcpy( dst, src+0, sz * sizeof(GLfloat) ); + _mesa_memcpy( dst+sz, src+(nr-1)*sz, sz * sizeof(GLfloat) ); + return 2; + } + case GL_TRIANGLE_STRIP: + case GL_QUAD_STRIP: + switch (nr) { + case 0: ovf = 0; break; + case 1: ovf = 1; break; + default: ovf = 2 + (nr&1); break; + } + for (i = 0 ; i < ovf ; i++) + _mesa_memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz * sizeof(GLfloat) ); + return i; + case GL_POLYGON+1: + return 0; + default: + assert(0); + return 0; + } +} + + +/** + * Execute the buffer and save copied verts. + */ +void _tnl_flush_vtx( GLcontext *ctx ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + + if (0) + _tnl_print_vtx( ctx ); + + if (tnl->vtx.prim_count && + tnl->vtx.counter != tnl->vtx.initial_counter) { + + tnl->vtx.copied.nr = _tnl_copy_vertices( ctx ); + + if (ctx->NewState) + _mesa_update_state( ctx ); + + if (tnl->pipeline.build_state_changes) + _tnl_validate_pipeline( ctx ); + + _tnl_vb_bind_vtx( ctx ); + + /* Invalidate all stored data before and after run: + */ + tnl->pipeline.run_input_changes |= tnl->pipeline.inputs; + tnl->Driver.RunPipeline( ctx ); + tnl->pipeline.run_input_changes |= tnl->pipeline.inputs; + } + + tnl->vtx.prim_count = 0; + tnl->vtx.counter = tnl->vtx.initial_counter; + tnl->vtx.vbptr = tnl->vtx.buffer; +} diff --git a/src/mesa/tnl/t_vtx_generic.c b/src/mesa/tnl/t_vtx_generic.c new file mode 100644 index 0000000..daa7dea --- /dev/null +++ b/src/mesa/tnl/t_vtx_generic.c @@ -0,0 +1,468 @@ +/************************************************************************** + +Copyright 2004 Tungsten Graphics Inc., Cedar Park, Texas. + +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"), +to deal in the Software without restriction, including without limitation +on the rights to use, copy, modify, merge, publish, distribute, sub +license, and/or sell copies of the Software, and to permit persons to whom +the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL +ATI, TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +USE OR OTHER DEALINGS IN THE SOFTWARE. + +**************************************************************************/ + +/* + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + +#include "glheader.h" +#include "context.h" +#include "macros.h" +#include "vtxfmt.h" +#include "dlist.h" +#include "state.h" +#include "light.h" +#include "api_arrayelt.h" +#include "api_noop.h" +#include "t_vtx_api.h" + + +/* Versions of all the entrypoints for situations where codegen isn't + * available. + * + * Note: Only one size for each attribute may be active at once. + * Eg. if Color3f is installed/active, then Color4f may not be, even + * if the vertex actually contains 4 color coordinates. This is + * because the 3f version won't otherwise set color[3] to 1.0 -- this + * is the job of the chooser function when switching between Color4f + * and Color3f. + */ +#define ATTRFV( ATTR, N ) \ +static void attrib_##ATTR##_##N( const GLfloat *v ) \ +{ \ + GET_CURRENT_CONTEXT( ctx ); \ + TNLcontext *tnl = TNL_CONTEXT(ctx); \ + \ + if ((ATTR) == 0) { \ + GLuint i; \ + \ + if (N>0) tnl->vtx.vbptr[0] = v[0]; \ + if (N>1) tnl->vtx.vbptr[1] = v[1]; \ + if (N>2) tnl->vtx.vbptr[2] = v[2]; \ + if (N>3) tnl->vtx.vbptr[3] = v[3]; \ + \ + for (i = N; i < tnl->vtx.vertex_size; i++) \ + tnl->vtx.vbptr[i] = tnl->vtx.vertex[i]; \ + \ + tnl->vtx.vbptr += tnl->vtx.vertex_size; \ + \ + if (--tnl->vtx.counter == 0) \ + _tnl_wrap_filled_vertex( ctx ); \ + } \ + else { \ + GLfloat *dest = tnl->vtx.attrptr[ATTR]; \ + if (N>0) dest[0] = v[0]; \ + if (N>1) dest[1] = v[1]; \ + if (N>2) dest[2] = v[2]; \ + if (N>3) dest[3] = v[3]; \ + } \ +} + +#define INIT(TAB, ATTR) \ + TAB[ATTR][0] = attrib_##ATTR##_1; \ + TAB[ATTR][1] = attrib_##ATTR##_2; \ + TAB[ATTR][2] = attrib_##ATTR##_3; \ + TAB[ATTR][3] = attrib_##ATTR##_4; + + +#define ATTRS( ATTRIB ) \ + ATTRFV( ATTRIB, 1 ) \ + ATTRFV( ATTRIB, 2 ) \ + ATTRFV( ATTRIB, 3 ) \ + ATTRFV( ATTRIB, 4 ) + +ATTRS( 0 ) +ATTRS( 1 ) +ATTRS( 2 ) +ATTRS( 3 ) +ATTRS( 4 ) +ATTRS( 5 ) +ATTRS( 6 ) +ATTRS( 7 ) +ATTRS( 8 ) +ATTRS( 9 ) +ATTRS( 10 ) +ATTRS( 11 ) +ATTRS( 12 ) +ATTRS( 13 ) +ATTRS( 14 ) +ATTRS( 15 ) + +void _tnl_generic_attr_table_init( tnl_attrfv_func (*tab)[4] ) +{ + INIT( tab, 0 ); + INIT( tab, 1 ); + INIT( tab, 2 ); + INIT( tab, 3 ); + INIT( tab, 4 ); + INIT( tab, 5 ); + INIT( tab, 6 ); + INIT( tab, 7 ); + INIT( tab, 8 ); + INIT( tab, 9 ); + INIT( tab, 10 ); + INIT( tab, 11 ); + INIT( tab, 12 ); + INIT( tab, 13 ); + INIT( tab, 14 ); + INIT( tab, 15 ); +} + +/* These can be made efficient with codegen. Further, by adding more + * logic to do_choose(), the double-dispatch for legacy entrypoints + * like glVertex3f() can be removed. + */ +#define DISPATCH_ATTRFV( ATTR, COUNT, P ) \ +do { \ + GET_CURRENT_CONTEXT( ctx ); \ + TNLcontext *tnl = TNL_CONTEXT(ctx); \ + tnl->vtx.tabfv[ATTR][COUNT-1]( P ); \ +} while (0) + +#define DISPATCH_ATTR1FV( ATTR, V ) DISPATCH_ATTRFV( ATTR, 1, V ) +#define DISPATCH_ATTR2FV( ATTR, V ) DISPATCH_ATTRFV( ATTR, 2, V ) +#define DISPATCH_ATTR3FV( ATTR, V ) DISPATCH_ATTRFV( ATTR, 3, V ) +#define DISPATCH_ATTR4FV( ATTR, V ) DISPATCH_ATTRFV( ATTR, 4, V ) + +#define DISPATCH_ATTR1F( ATTR, S ) DISPATCH_ATTRFV( ATTR, 1, &(S) ) + +#if defined(USE_X86_ASM) && 0 /* will break register calling convention */ +/* Naughty cheat: + */ +#define DISPATCH_ATTR2F( ATTR, S,T ) DISPATCH_ATTRFV( ATTR, 2, &(S) ) +#define DISPATCH_ATTR3F( ATTR, S,T,R ) DISPATCH_ATTRFV( ATTR, 3, &(S) ) +#define DISPATCH_ATTR4F( ATTR, S,T,R,Q ) DISPATCH_ATTRFV( ATTR, 4, &(S) ) +#else +/* Safe: + */ +#define DISPATCH_ATTR2F( ATTR, S,T ) \ +do { \ + GLfloat v[2]; \ + v[0] = S; v[1] = T; \ + DISPATCH_ATTR2FV( ATTR, v ); \ +} while (0) +#define DISPATCH_ATTR3F( ATTR, S,T,R ) \ +do { \ + GLfloat v[3]; \ + v[0] = S; v[1] = T; v[2] = R; \ + DISPATCH_ATTR3FV( ATTR, v ); \ +} while (0) +#define DISPATCH_ATTR4F( ATTR, S,T,R,Q ) \ +do { \ + GLfloat v[4]; \ + v[0] = S; v[1] = T; v[2] = R; v[3] = Q; \ + DISPATCH_ATTR4FV( ATTR, v ); \ +} while (0) +#endif + + +static void GLAPIENTRY _tnl_Vertex2f( GLfloat x, GLfloat y ) +{ + DISPATCH_ATTR2F( _TNL_ATTRIB_POS, x, y ); +} + +static void GLAPIENTRY _tnl_Vertex2fv( const GLfloat *v ) +{ + DISPATCH_ATTR2FV( _TNL_ATTRIB_POS, v ); +} + +static void GLAPIENTRY _tnl_Vertex3f( GLfloat x, GLfloat y, GLfloat z ) +{ + DISPATCH_ATTR3F( _TNL_ATTRIB_POS, x, y, z ); +} + +static void GLAPIENTRY _tnl_Vertex3fv( const GLfloat *v ) +{ + DISPATCH_ATTR3FV( _TNL_ATTRIB_POS, v ); +} + +static void GLAPIENTRY _tnl_Vertex4f( GLfloat x, GLfloat y, GLfloat z, + GLfloat w ) +{ + DISPATCH_ATTR4F( _TNL_ATTRIB_POS, x, y, z, w ); +} + +static void GLAPIENTRY _tnl_Vertex4fv( const GLfloat *v ) +{ + DISPATCH_ATTR4FV( _TNL_ATTRIB_POS, v ); +} + +static void GLAPIENTRY _tnl_TexCoord1f( GLfloat x ) +{ + DISPATCH_ATTR1F( _TNL_ATTRIB_TEX0, x ); +} + +static void GLAPIENTRY _tnl_TexCoord1fv( const GLfloat *v ) +{ + DISPATCH_ATTR1FV( _TNL_ATTRIB_TEX0, v ); +} + +static void GLAPIENTRY _tnl_TexCoord2f( GLfloat x, GLfloat y ) +{ + DISPATCH_ATTR2F( _TNL_ATTRIB_TEX0, x, y ); +} + +static void GLAPIENTRY _tnl_TexCoord2fv( const GLfloat *v ) +{ + DISPATCH_ATTR2FV( _TNL_ATTRIB_TEX0, v ); +} + +static void GLAPIENTRY _tnl_TexCoord3f( GLfloat x, GLfloat y, GLfloat z ) +{ + DISPATCH_ATTR3F( _TNL_ATTRIB_TEX0, x, y, z ); +} + +static void GLAPIENTRY _tnl_TexCoord3fv( const GLfloat *v ) +{ + DISPATCH_ATTR3FV( _TNL_ATTRIB_TEX0, v ); +} + +static void GLAPIENTRY _tnl_TexCoord4f( GLfloat x, GLfloat y, GLfloat z, + GLfloat w ) +{ + DISPATCH_ATTR4F( _TNL_ATTRIB_TEX0, x, y, z, w ); +} + +static void GLAPIENTRY _tnl_TexCoord4fv( const GLfloat *v ) +{ + DISPATCH_ATTR4FV( _TNL_ATTRIB_TEX0, v ); +} + +static void GLAPIENTRY _tnl_Normal3f( GLfloat x, GLfloat y, GLfloat z ) +{ + DISPATCH_ATTR3F( _TNL_ATTRIB_NORMAL, x, y, z ); +} + +static void GLAPIENTRY _tnl_Normal3fv( const GLfloat *v ) +{ + DISPATCH_ATTR3FV( _TNL_ATTRIB_NORMAL, v ); +} + +static void GLAPIENTRY _tnl_FogCoordfEXT( GLfloat x ) +{ + DISPATCH_ATTR1F( _TNL_ATTRIB_FOG, x ); +} + +static void GLAPIENTRY _tnl_FogCoordfvEXT( const GLfloat *v ) +{ + DISPATCH_ATTR1FV( _TNL_ATTRIB_FOG, v ); +} + +static void GLAPIENTRY _tnl_Color3f( GLfloat x, GLfloat y, GLfloat z ) +{ + DISPATCH_ATTR3F( _TNL_ATTRIB_COLOR0, x, y, z ); +} + +static void GLAPIENTRY _tnl_Color3fv( const GLfloat *v ) +{ + DISPATCH_ATTR3FV( _TNL_ATTRIB_COLOR0, v ); +} + +static void GLAPIENTRY _tnl_Color4f( GLfloat x, GLfloat y, GLfloat z, + GLfloat w ) +{ + DISPATCH_ATTR4F( _TNL_ATTRIB_COLOR0, x, y, z, w ); +} + +static void GLAPIENTRY _tnl_Color4fv( const GLfloat *v ) +{ + DISPATCH_ATTR4FV( _TNL_ATTRIB_COLOR0, v ); +} + +static void GLAPIENTRY _tnl_SecondaryColor3fEXT( GLfloat x, GLfloat y, + GLfloat z ) +{ + DISPATCH_ATTR3F( _TNL_ATTRIB_COLOR1, x, y, z ); +} + +static void GLAPIENTRY _tnl_SecondaryColor3fvEXT( const GLfloat *v ) +{ + DISPATCH_ATTR3FV( _TNL_ATTRIB_COLOR1, v ); +} + +static void GLAPIENTRY _tnl_MultiTexCoord1f( GLenum target, GLfloat x ) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR1F( attr, x ); +} + +static void GLAPIENTRY _tnl_MultiTexCoord1fv( GLenum target, + const GLfloat *v ) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR1FV( attr, v ); +} + +static void GLAPIENTRY _tnl_MultiTexCoord2f( GLenum target, GLfloat x, + GLfloat y ) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR2F( attr, x, y ); +} + +static void GLAPIENTRY _tnl_MultiTexCoord2fv( GLenum target, + const GLfloat *v ) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR2FV( attr, v ); +} + +static void GLAPIENTRY _tnl_MultiTexCoord3f( GLenum target, GLfloat x, + GLfloat y, GLfloat z) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR3F( attr, x, y, z ); +} + +static void GLAPIENTRY _tnl_MultiTexCoord3fv( GLenum target, + const GLfloat *v ) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR3FV( attr, v ); +} + +static void GLAPIENTRY _tnl_MultiTexCoord4f( GLenum target, GLfloat x, + GLfloat y, GLfloat z, + GLfloat w ) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR4F( attr, x, y, z, w ); +} + +static void GLAPIENTRY _tnl_MultiTexCoord4fv( GLenum target, + const GLfloat *v ) +{ + GLuint attr = (target & 0x7) + _TNL_ATTRIB_TEX0; + DISPATCH_ATTR4FV( attr, v ); +} + +static void GLAPIENTRY _tnl_VertexAttrib1fNV( GLuint index, GLfloat x ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR1F( index, x ); +} + +static void GLAPIENTRY _tnl_VertexAttrib1fvNV( GLuint index, + const GLfloat *v ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR1FV( index, v ); +} + +static void GLAPIENTRY _tnl_VertexAttrib2fNV( GLuint index, GLfloat x, + GLfloat y ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR2F( index, x, y ); +} + +static void GLAPIENTRY _tnl_VertexAttrib2fvNV( GLuint index, + const GLfloat *v ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR2FV( index, v ); +} + +static void GLAPIENTRY _tnl_VertexAttrib3fNV( GLuint index, GLfloat x, + GLfloat y, GLfloat z ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR3F( index, x, y, z ); +} + +static void GLAPIENTRY _tnl_VertexAttrib3fvNV( GLuint index, + const GLfloat *v ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR3FV( index, v ); +} + +static void GLAPIENTRY _tnl_VertexAttrib4fNV( GLuint index, GLfloat x, + GLfloat y, GLfloat z, + GLfloat w ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR4F( index, x, y, z, w ); +} + +static void GLAPIENTRY _tnl_VertexAttrib4fvNV( GLuint index, + const GLfloat *v ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR4FV( index, v ); +} + + +/* Install the generic versions of the 2nd level dispatch + * functions. Some of these have a codegen alternative. + */ +void _tnl_generic_exec_vtxfmt_init( GLcontext *ctx ) +{ + GLvertexformat *vfmt = &(TNL_CONTEXT(ctx)->exec_vtxfmt); + + vfmt->Color3f = _tnl_Color3f; + vfmt->Color3fv = _tnl_Color3fv; + vfmt->Color4f = _tnl_Color4f; + vfmt->Color4fv = _tnl_Color4fv; + vfmt->FogCoordfEXT = _tnl_FogCoordfEXT; + vfmt->FogCoordfvEXT = _tnl_FogCoordfvEXT; + vfmt->MultiTexCoord1fARB = _tnl_MultiTexCoord1f; + vfmt->MultiTexCoord1fvARB = _tnl_MultiTexCoord1fv; + vfmt->MultiTexCoord2fARB = _tnl_MultiTexCoord2f; + vfmt->MultiTexCoord2fvARB = _tnl_MultiTexCoord2fv; + vfmt->MultiTexCoord3fARB = _tnl_MultiTexCoord3f; + vfmt->MultiTexCoord3fvARB = _tnl_MultiTexCoord3fv; + vfmt->MultiTexCoord4fARB = _tnl_MultiTexCoord4f; + vfmt->MultiTexCoord4fvARB = _tnl_MultiTexCoord4fv; + vfmt->Normal3f = _tnl_Normal3f; + vfmt->Normal3fv = _tnl_Normal3fv; + vfmt->SecondaryColor3fEXT = _tnl_SecondaryColor3fEXT; + vfmt->SecondaryColor3fvEXT = _tnl_SecondaryColor3fvEXT; + vfmt->TexCoord1f = _tnl_TexCoord1f; + vfmt->TexCoord1fv = _tnl_TexCoord1fv; + vfmt->TexCoord2f = _tnl_TexCoord2f; + vfmt->TexCoord2fv = _tnl_TexCoord2fv; + vfmt->TexCoord3f = _tnl_TexCoord3f; + vfmt->TexCoord3fv = _tnl_TexCoord3fv; + vfmt->TexCoord4f = _tnl_TexCoord4f; + vfmt->TexCoord4fv = _tnl_TexCoord4fv; + vfmt->Vertex2f = _tnl_Vertex2f; + vfmt->Vertex2fv = _tnl_Vertex2fv; + vfmt->Vertex3f = _tnl_Vertex3f; + vfmt->Vertex3fv = _tnl_Vertex3fv; + vfmt->Vertex4f = _tnl_Vertex4f; + vfmt->Vertex4fv = _tnl_Vertex4fv; + vfmt->VertexAttrib1fNV = _tnl_VertexAttrib1fNV; + vfmt->VertexAttrib1fvNV = _tnl_VertexAttrib1fvNV; + vfmt->VertexAttrib2fNV = _tnl_VertexAttrib2fNV; + vfmt->VertexAttrib2fvNV = _tnl_VertexAttrib2fvNV; + vfmt->VertexAttrib3fNV = _tnl_VertexAttrib3fNV; + vfmt->VertexAttrib3fvNV = _tnl_VertexAttrib3fvNV; + vfmt->VertexAttrib4fNV = _tnl_VertexAttrib4fNV; + vfmt->VertexAttrib4fvNV = _tnl_VertexAttrib4fvNV; +} diff --git a/src/mesa/tnl/t_vtx_x86.c b/src/mesa/tnl/t_vtx_x86.c new file mode 100644 index 0000000..59a8698 --- /dev/null +++ b/src/mesa/tnl/t_vtx_x86.c @@ -0,0 +1,384 @@ +/************************************************************************** + +Copyright 2004 Tungsten Graphics Inc., Cedar Park, Texas. + +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"), +to deal in the Software without restriction, including without limitation +on the rights to use, copy, modify, merge, publish, distribute, sub +license, and/or sell copies of the Software, and to permit persons to whom +the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL +ATI, TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +USE OR OTHER DEALINGS IN THE SOFTWARE. + +**************************************************************************/ + +/* + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + * Daniel Borca <dborca@yahoo.com> + */ + + +#include "glheader.h" +#include "context.h" +#include "macros.h" +#include "vtxfmt.h" +#include "dlist.h" +#include "state.h" +#include "light.h" +#include "api_arrayelt.h" +#include "api_noop.h" +#include "t_vtx_api.h" +#include "simple_list.h" + + +#if defined(USE_X86_ASM) && !defined(HAVE_NONSTANDARD_GLAPIENTRY) + +#define EXTERN( FUNC ) \ +extern const char *FUNC; \ +extern const char *FUNC##_end + +EXTERN( _tnl_x86_Attribute1fv ); +EXTERN( _tnl_x86_Attribute2fv ); +EXTERN( _tnl_x86_Attribute3fv ); +EXTERN( _tnl_x86_Attribute4fv ); +EXTERN( _tnl_x86_Vertex1fv ); +EXTERN( _tnl_x86_Vertex2fv ); +EXTERN( _tnl_x86_Vertex3fv ); +EXTERN( _tnl_x86_Vertex4fv ); + +EXTERN( _tnl_x86_dispatch_attrf1 ); +EXTERN( _tnl_x86_dispatch_attrf2 ); +EXTERN( _tnl_x86_dispatch_attrf3 ); +EXTERN( _tnl_x86_dispatch_attrf4 ); +EXTERN( _tnl_x86_dispatch_attrfv ); +EXTERN( _tnl_x86_dispatch_multitexcoordf1 ); +EXTERN( _tnl_x86_dispatch_multitexcoordf2 ); +EXTERN( _tnl_x86_dispatch_multitexcoordf3 ); +EXTERN( _tnl_x86_dispatch_multitexcoordf4 ); +EXTERN( _tnl_x86_dispatch_multitexcoordfv ); +EXTERN( _tnl_x86_dispatch_vertexattribf1 ); +EXTERN( _tnl_x86_dispatch_vertexattribf2 ); +EXTERN( _tnl_x86_dispatch_vertexattribf3 ); +EXTERN( _tnl_x86_dispatch_vertexattribf4 ); +EXTERN( _tnl_x86_dispatch_vertexattribfv ); + +EXTERN( _tnl_x86_choose_fv ); + + +#define DONT_KNOW_OFFSETS 1 + + +#define DFN( FUNC, CACHE, KEY ) \ + struct _tnl_dynfn *dfn = MALLOC_STRUCT( _tnl_dynfn );\ + char *start = (char *)&FUNC; \ + char *end = (char *)&FUNC##_end; \ + int offset = 0; \ + insert_at_head( &CACHE, dfn ); \ + dfn->key = KEY; \ + dfn->code = ALIGN_MALLOC( end - start, 16 ); \ + memcpy (dfn->code, start, end - start) + + + +#define FIXUP( CODE, KNOWN_OFFSET, CHECKVAL, NEWVAL ) \ +do { \ + GLint subst = 0x10101010 + CHECKVAL; \ + \ + if (DONT_KNOW_OFFSETS) { \ + while (*(int *)(CODE+offset) != subst) offset++; \ + *(int *)(CODE+offset) = (int)(NEWVAL); \ + if (0) fprintf(stderr, "%s/%d: offset %d, new value: 0x%x\n", __FILE__, __LINE__, offset, (int)(NEWVAL)); \ + offset += 4; \ + } \ + else { \ + int *icode = (int *)(CODE+KNOWN_OFFSET); \ + assert (*icode == subst); \ + *icode = (int)NEWVAL; \ + } \ +} while (0) + + + +#define FIXUPREL( CODE, KNOWN_OFFSET, CHECKVAL, NEWVAL )\ +do { \ + GLint subst = 0x10101010 + CHECKVAL; \ + \ + if (DONT_KNOW_OFFSETS) { \ + while (*(int *)(CODE+offset) != subst) offset++; \ + *(int *)(CODE+offset) = (int)(NEWVAL) - ((int)(CODE)+offset) - 4; \ + if (0) fprintf(stderr, "%s/%d: offset %d, new value: 0x%x\n", __FILE__, __LINE__, offset, (int)(NEWVAL) - ((int)(CODE)+offset) - 4); \ + offset += 4; \ + } \ + else { \ + int *icode = (int *)(CODE+KNOWN_OFFSET); \ + assert (*icode == subst); \ + *icode = (int)(NEWVAL) - (int)(icode) - 4; \ + } \ +} while (0) + + + + +/* Build specialized versions of the immediate calls on the fly for + * the current state. Generic x86 versions. + */ + +static struct _tnl_dynfn *makeX86Vertex1fv( GLcontext *ctx, int vertex_size ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + DFN ( _tnl_x86_Vertex1fv, tnl->vtx.cache.Vertex[1-1], vertex_size ); + + FIXUP(dfn->code, 0, 0, (int)&tnl->vtx.vbptr); + FIXUP(dfn->code, 0, 1, vertex_size - 1); + FIXUP(dfn->code, 0, 2, (int)&tnl->vtx.vertex[1]); + FIXUP(dfn->code, 0, 0, (int)&tnl->vtx.vbptr); + FIXUP(dfn->code, 0, 3, (int)&tnl->vtx.counter); + FIXUP(dfn->code, 0, 3, (int)&tnl->vtx.counter); + FIXUP(dfn->code, 0, 4, (int)ctx); + FIXUPREL(dfn->code, 0, 5, (int)&_tnl_wrap_filled_vertex); + + return dfn; +} + +static struct _tnl_dynfn *makeX86Vertex2fv( GLcontext *ctx, int vertex_size ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + DFN ( _tnl_x86_Vertex2fv, tnl->vtx.cache.Vertex[2-1], vertex_size ); + + FIXUP(dfn->code, 0, 0, (int)&tnl->vtx.vbptr); + FIXUP(dfn->code, 0, 1, vertex_size - 2); + FIXUP(dfn->code, 0, 2, (int)&tnl->vtx.vertex[2]); + FIXUP(dfn->code, 0, 0, (int)&tnl->vtx.vbptr); + FIXUP(dfn->code, 0, 3, (int)&tnl->vtx.counter); + FIXUP(dfn->code, 0, 3, (int)&tnl->vtx.counter); + FIXUP(dfn->code, 0, 4, (int)ctx); + FIXUPREL(dfn->code, 0, 5, (int)&_tnl_wrap_filled_vertex); + + return dfn; +} + +static struct _tnl_dynfn *makeX86Vertex3fv( GLcontext *ctx, int vertex_size ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + DFN ( _tnl_x86_Vertex3fv, tnl->vtx.cache.Vertex[3-1], vertex_size ); + + switch (vertex_size) { + default: { + FIXUP(dfn->code, 0, 0, (int)&tnl->vtx.vbptr); + FIXUP(dfn->code, 0, 1, vertex_size - 3); + FIXUP(dfn->code, 0, 2, (int)&tnl->vtx.vertex[3]); + FIXUP(dfn->code, 0, 0, (int)&tnl->vtx.vbptr); + FIXUP(dfn->code, 0, 3, (int)&tnl->vtx.counter); + FIXUP(dfn->code, 0, 3, (int)&tnl->vtx.counter); + FIXUP(dfn->code, 0, 4, (int)ctx); + FIXUPREL(dfn->code, 0, 5, (int)&_tnl_wrap_filled_vertex); + return dfn; + } + } +} + +static struct _tnl_dynfn *makeX86Vertex4fv( GLcontext *ctx, int vertex_size ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + DFN ( _tnl_x86_Vertex4fv, tnl->vtx.cache.Vertex[4-1], vertex_size ); + + FIXUP(dfn->code, 0, 0, (int)&tnl->vtx.vbptr); + FIXUP(dfn->code, 0, 1, vertex_size - 4); + FIXUP(dfn->code, 0, 2, (int)&tnl->vtx.vertex[4]); + FIXUP(dfn->code, 0, 0, (int)&tnl->vtx.vbptr); + FIXUP(dfn->code, 0, 3, (int)&tnl->vtx.counter); + FIXUP(dfn->code, 0, 3, (int)&tnl->vtx.counter); + FIXUP(dfn->code, 0, 4, (int)ctx); + FIXUPREL(dfn->code, 0, 5, (int)&_tnl_wrap_filled_vertex); + + return dfn; +} + + +static struct _tnl_dynfn *makeX86Attribute1fv( GLcontext *ctx, int dest ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + DFN ( _tnl_x86_Attribute1fv, tnl->vtx.cache.Attribute[1-1], dest ); + + FIXUP(dfn->code, 0, 0, dest); + + return dfn; +} + +static struct _tnl_dynfn *makeX86Attribute2fv( GLcontext *ctx, int dest ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + DFN ( _tnl_x86_Attribute2fv, tnl->vtx.cache.Attribute[2-1], dest ); + + FIXUP(dfn->code, 0, 0, dest); + FIXUP(dfn->code, 0, 1, 4+dest); + + return dfn; +} + +static struct _tnl_dynfn *makeX86Attribute3fv( GLcontext *ctx, int dest ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + DFN ( _tnl_x86_Attribute3fv, tnl->vtx.cache.Attribute[3-1], dest ); + + FIXUP(dfn->code, 0, 0, dest); + FIXUP(dfn->code, 0, 1, 4+dest); + FIXUP(dfn->code, 0, 2, 8+dest); + + return dfn; +} + +static struct _tnl_dynfn *makeX86Attribute4fv( GLcontext *ctx, int dest ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + DFN ( _tnl_x86_Attribute4fv, tnl->vtx.cache.Attribute[4-1], dest ); + + FIXUP(dfn->code, 0, 0, dest); + FIXUP(dfn->code, 0, 1, 4+dest); + FIXUP(dfn->code, 0, 2, 8+dest); + FIXUP(dfn->code, 0, 3, 12+dest); + + return dfn; +} + + +void _tnl_InitX86Codegen( struct _tnl_dynfn_generators *gen ) +{ + gen->Vertex[0] = makeX86Vertex1fv; + gen->Vertex[1] = makeX86Vertex2fv; + gen->Vertex[2] = makeX86Vertex3fv; + gen->Vertex[3] = makeX86Vertex4fv; + gen->Attribute[0] = makeX86Attribute1fv; + gen->Attribute[1] = makeX86Attribute2fv; + gen->Attribute[2] = makeX86Attribute3fv; + gen->Attribute[3] = makeX86Attribute4fv; +} + + +#define MKDISP(FUNC, SIZE, ATTR, WARP) \ +do { \ + char *code; \ + char *start = (char *)&WARP; \ + char *end = (char *)&WARP##_end; \ + int offset = 0; \ + code = ALIGN_MALLOC( end - start, 16 ); \ + memcpy (code, start, end - start); \ + FIXUP(code, 0, 0, (int)&(TNL_CONTEXT(ctx)->vtx.tabfv[ATTR][SIZE-1]));\ + *(void **)&vfmt->FUNC = code; \ +} while (0) + + +/* Install the codegen'ed versions of the 2nd level dispatch + * functions. We should keep a list and free them in the end... + */ +void _tnl_x86_exec_vtxfmt_init( GLcontext *ctx ) +{ + GLvertexformat *vfmt = &(TNL_CONTEXT(ctx)->exec_vtxfmt); + + MKDISP(Color3f, 3, _TNL_ATTRIB_COLOR0, _tnl_x86_dispatch_attrf3); + MKDISP(Color3fv, 3, _TNL_ATTRIB_COLOR0, _tnl_x86_dispatch_attrfv); + MKDISP(Color4f, 4, _TNL_ATTRIB_COLOR0, _tnl_x86_dispatch_attrf4); + MKDISP(Color4fv, 4, _TNL_ATTRIB_COLOR0, _tnl_x86_dispatch_attrfv); + MKDISP(FogCoordfEXT, 1, _TNL_ATTRIB_FOG, _tnl_x86_dispatch_attrf1); + MKDISP(FogCoordfvEXT, 1, _TNL_ATTRIB_FOG, _tnl_x86_dispatch_attrfv); + MKDISP(Normal3f, 3, _TNL_ATTRIB_NORMAL, _tnl_x86_dispatch_attrf3); + MKDISP(Normal3fv, 3, _TNL_ATTRIB_NORMAL, _tnl_x86_dispatch_attrfv); + MKDISP(SecondaryColor3fEXT, 3, _TNL_ATTRIB_COLOR1, _tnl_x86_dispatch_attrf3); + MKDISP(SecondaryColor3fvEXT,3, _TNL_ATTRIB_COLOR1, _tnl_x86_dispatch_attrfv); + MKDISP(TexCoord1f, 1, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_attrf1); + MKDISP(TexCoord1fv, 1, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_attrfv); + MKDISP(TexCoord2f, 2, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_attrf2); + MKDISP(TexCoord2fv, 2, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_attrfv); + MKDISP(TexCoord3f, 3, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_attrf3); + MKDISP(TexCoord3fv, 3, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_attrfv); + MKDISP(TexCoord4f, 4, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_attrf4); + MKDISP(TexCoord4fv, 4, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_attrfv); + MKDISP(Vertex2f, 2, _TNL_ATTRIB_POS, _tnl_x86_dispatch_attrf2); + MKDISP(Vertex2fv, 2, _TNL_ATTRIB_POS, _tnl_x86_dispatch_attrfv); + MKDISP(Vertex3f, 3, _TNL_ATTRIB_POS, _tnl_x86_dispatch_attrf3); + MKDISP(Vertex3fv, 3, _TNL_ATTRIB_POS, _tnl_x86_dispatch_attrfv); + MKDISP(Vertex4f, 4, _TNL_ATTRIB_POS, _tnl_x86_dispatch_attrf4); + MKDISP(Vertex4fv, 4, _TNL_ATTRIB_POS, _tnl_x86_dispatch_attrfv); + + MKDISP(MultiTexCoord1fARB, 1, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_multitexcoordf1); + MKDISP(MultiTexCoord1fvARB, 1, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_multitexcoordfv); + MKDISP(MultiTexCoord2fARB, 2, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_multitexcoordf2); + MKDISP(MultiTexCoord2fvARB, 2, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_multitexcoordfv); + MKDISP(MultiTexCoord3fARB, 3, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_multitexcoordf3); + MKDISP(MultiTexCoord3fvARB, 3, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_multitexcoordfv); + MKDISP(MultiTexCoord4fARB, 4, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_multitexcoordf4); + MKDISP(MultiTexCoord4fvARB, 4, _TNL_ATTRIB_TEX0, _tnl_x86_dispatch_multitexcoordfv); + + MKDISP(VertexAttrib1fNV, 1, 0, _tnl_x86_dispatch_vertexattribf1); + MKDISP(VertexAttrib1fvNV, 1, 0, _tnl_x86_dispatch_vertexattribfv); + MKDISP(VertexAttrib2fNV, 2, 0, _tnl_x86_dispatch_vertexattribf2); + MKDISP(VertexAttrib2fvNV, 2, 0, _tnl_x86_dispatch_vertexattribfv); + MKDISP(VertexAttrib3fNV, 3, 0, _tnl_x86_dispatch_vertexattribf3); + MKDISP(VertexAttrib3fvNV, 3, 0, _tnl_x86_dispatch_vertexattribfv); + MKDISP(VertexAttrib4fNV, 4, 0, _tnl_x86_dispatch_vertexattribf4); + MKDISP(VertexAttrib4fvNV, 4, 0, _tnl_x86_dispatch_vertexattribfv); +} + + +/* Install the codegen'ed choosers. + * We should keep a list and free them in the end... + */ +void _tnl_x86choosers( tnl_attrfv_func (*choose)[4], + tnl_attrfv_func (*do_choose)( GLuint attr, + GLuint sz )) +{ + int attr, size; + + for (attr = 0; attr < _TNL_MAX_ATTR_CODEGEN; attr++) { + for (size = 0; size < 4; size++) { + char *code; + char *start = (char *)&_tnl_x86_choose_fv; + char *end = (char *)&_tnl_x86_choose_fv_end; + int offset = 0; + code = ALIGN_MALLOC( end - start, 16 ); + memcpy (code, start, end - start); + FIXUP(code, 0, 0, attr); + FIXUP(code, 0, 1, size + 1); + FIXUPREL(code, 0, 2, do_choose); + choose[attr][size] = (tnl_attrfv_func)code; + } + } +} + +#else + +void _tnl_InitX86Codegen( struct _tnl_dynfn_generators *gen ) +{ + (void) gen; +} + + +void _tnl_x86_exec_vtxfmt_init( GLcontext *ctx ) +{ + (void) ctx; +} + + +void _tnl_x86choosers( tnl_attrfv_func (*choose)[4], + tnl_attrfv_func (*do_choose)( GLuint attr, + GLuint sz )) +{ + (void) choose; + (void) do_choose; +} + +#endif diff --git a/src/mesa/tnl/t_vtx_x86_gcc.S b/src/mesa/tnl/t_vtx_x86_gcc.S new file mode 100644 index 0000000..5f79197 --- /dev/null +++ b/src/mesa/tnl/t_vtx_x86_gcc.S @@ -0,0 +1,557 @@ +/************************************************************************** + +Copyright 2004 Tungsten Graphics Inc., Cedar Park, Texas. + +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"), +to deal in the Software without restriction, including without limitation +on the rights to use, copy, modify, merge, publish, distribute, sub +license, and/or sell copies of the Software, and to permit persons to whom +the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL +ATI, TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +USE OR OTHER DEALINGS IN THE SOFTWARE. + +**************************************************************************/ + +/* + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + * Daniel Borca <dborca@yahoo.com> + */ + +#if defined (__DJGPP__) || defined (__MINGW32__) || defined (__CYGWIN__) +#define GLOBL( x ) \ +.globl _##x; \ +_##x: +#else /* !defined (__DJGPP__) && !defined (__MINGW32__) && !defined (__CYGWIN__) */ +#define GLOBL( x ) \ +.globl x; \ +x: +#endif /* !defined (__DJGPP__) && !defined (__MINGW32__) && !defined (__CYGWIN__) */ + + +#if !defined (STDCALL_API) +#define RETCLEAN( x ) ret +#else +#define RETCLEAN( x ) ret $x +#endif + + +#define _JMP(x) \ +.byte 0xe9; \ +.long x + +#define _CALL(x) \ +.byte 0xe8; \ +.long x + + +/* Someone who knew a lot about this sort of thing would use this + * macro to note current offsets, etc in a special region of the + * object file & just make everything work out neat. I don't know + * enough to do that... + */ + +#define SUBST( x ) (0x10101010 + x) + + +.data + + +/* [dBorca] TODO + * Unfold functions for each vertex size? + * Build super-specialized SSE versions? + * + * There is a trick in Vertex*fv: under certain conditions, + * we tail to _tnl_wrap_filled_vertex(ctx). This means that + * if Vertex*fv is STDCALL, then _tnl_wrap_filled_vertex must + * be STDCALL as well, because (GLcontext *) and (GLfloat *) + * have the same size. + */ +.align 4 +GLOBL ( _tnl_x86_Vertex1fv ) + movl 4(%esp), %ecx + push %edi + push %esi + movl SUBST(0), %edi /* 0x0 --> tnl->vtx.vbptr */ + movl (%ecx), %edx /* load v[0] */ + movl %edx, (%edi) /* tnl->vtx.vbptr[0] = v[0] */ + addl $4, %edi /* tnl->vtx.vbptr += 1 */ + movl $SUBST(1), %ecx /* 0x1 --> (tnl->vtx.vertex_size - 1) */ + movl $SUBST(2), %esi /* 0x2 --> (tnl->vtx.vertex + 1) */ + repz + movsl %ds:(%esi), %es:(%edi) + movl %edi, SUBST(0) /* 0x0 --> tnl->vtx.vbptr */ + movl SUBST(3), %edx /* 0x3 --> counter */ + pop %esi + pop %edi + dec %edx /* counter-- */ + movl %edx, SUBST(3) /* 0x3 --> counter */ + je .0 /* if (counter == 0) goto .0 */ + RETCLEAN(4) /* return */ + .balign 16 +.0: + movl $SUBST(4), %eax /* load ctx */ + movl %eax, 4(%esp) /* push ctx */ + _JMP (SUBST(5)) /* jmp _tnl_wrap_filled_vertex */ +GLOBL ( _tnl_x86_Vertex1fv_end ) + +.align 4 +GLOBL ( _tnl_x86_Vertex2fv ) + movl 4(%esp), %ecx + push %edi + push %esi + movl SUBST(0), %edi /* load tnl->vtx.vbptr */ + movl (%ecx), %edx /* load v[0] */ + movl 4(%ecx), %eax /* load v[1] */ + movl %edx, (%edi) /* tnl->vtx.vbptr[0] = v[0] */ + movl %eax, 4(%edi) /* tnl->vtx.vbptr[1] = v[1] */ + addl $8, %edi /* tnl->vtx.vbptr += 2 */ + movl $SUBST(1), %ecx /* vertex_size - 2 */ + movl $SUBST(2), %esi /* tnl->vtx.vertex + 2 */ + repz + movsl %ds:(%esi), %es:(%edi) + movl %edi, SUBST(0) /* save tnl->vtx.vbptr */ + movl SUBST(3), %edx /* load counter */ + pop %esi + pop %edi + dec %edx /* counter-- */ + movl %edx, SUBST(3) /* save counter */ + je .1 /* if (counter == 0) goto .1 */ + RETCLEAN(4) /* return */ + .balign 16 +.1: + movl $SUBST(4), %eax /* load ctx */ + movl %eax, 4(%esp) /* push ctx */ + _JMP (SUBST(5)) /* jmp _tnl_wrap_filled_vertex */ +GLOBL ( _tnl_x86_Vertex2fv_end ) + +.align 4 +GLOBL ( _tnl_x86_Vertex3fv ) + movl 4(%esp), %ecx + push %edi + push %esi + movl SUBST(0), %edi /* load tnl->vtx.vbptr */ + movl (%ecx), %edx /* load v[0] */ + movl 4(%ecx), %eax /* load v[1] */ + movl 8(%ecx), %esi /* load v[2] */ + movl %edx, (%edi) /* tnl->vtx.vbptr[0] = v[0] */ + movl %eax, 4(%edi) /* tnl->vtx.vbptr[1] = v[1] */ + movl %esi, 8(%edi) /* tnl->vtx.vbptr[2] = v[2] */ + addl $12, %edi /* tnl->vtx.vbptr += 3 */ + movl $SUBST(1), %ecx /* vertex_size - 3 */ + movl $SUBST(2), %esi /* tnl->vtx.vertex + 3 */ + repz + movsl %ds:(%esi), %es:(%edi) + movl %edi, SUBST(0) /* save tnl->vtx.vbptr */ + movl SUBST(3), %edx /* load counter */ + pop %esi + pop %edi + dec %edx /* counter-- */ + movl %edx, SUBST(3) /* save counter */ + je .2 /* if (counter == 0) goto .2 */ + RETCLEAN(4) /* return */ + .balign 16 +.2: + movl $SUBST(4), %eax /* load ctx */ + movl %eax, 4(%esp) /* push ctx */ + _JMP (SUBST(5)) /* jmp _tnl_wrap_filled_vertex */ +GLOBL ( _tnl_x86_Vertex3fv_end ) + +.align 4 +GLOBL ( _tnl_x86_Vertex4fv ) + movl 4(%esp), %ecx + push %edi + push %esi + movl SUBST(0), %edi /* load tnl->vtx.vbptr */ + movl (%ecx), %edx /* load v[0] */ + movl 4(%ecx), %eax /* load v[1] */ + movl 8(%ecx), %esi /* load v[2] */ + movl 12(%ecx), %ecx /* load v[3] */ + movl %edx, (%edi) /* tnl->vtx.vbptr[0] = v[0] */ + movl %eax, 4(%edi) /* tnl->vtx.vbptr[1] = v[1] */ + movl %esi, 8(%edi) /* tnl->vtx.vbptr[2] = v[2] */ + movl %ecx, 12(%edi) /* tnl->vtx.vbptr[3] = v[3] */ + addl $16, %edi /* tnl->vtx.vbptr += 4 */ + movl $SUBST(1), %ecx /* vertex_size - 4 */ + movl $SUBST(2), %esi /* tnl->vtx.vertex + 4 */ + repz + movsl %ds:(%esi), %es:(%edi) + movl %edi, SUBST(0) /* save tnl->vtx.vbptr */ + movl SUBST(3), %edx /* load counter */ + pop %esi + pop %edi + dec %edx /* counter-- */ + movl %edx, SUBST(3) /* save counter */ + je .3 /* if (counter == 0) goto .3 */ + RETCLEAN(4) /* return */ + .balign 16 +.3: + movl $SUBST(4), %eax /* load ctx */ + movl %eax, 4(%esp) /* push ctx */ + _JMP (SUBST(5)) /* jmp _tnl_wrap_filled_vertex */ +GLOBL ( _tnl_x86_Vertex4fv_end ) + + +/** + * Generic handlers for vector format data. + */ +GLOBL( _tnl_x86_Attribute1fv ) + movl 4(%esp), %ecx + movl (%ecx), %eax /* load v[0] */ + movl %eax, SUBST(0) /* store v[0] to current vertex */ + RETCLEAN(4) +GLOBL ( _tnl_x86_Attribute1fv_end ) + +GLOBL( _tnl_x86_Attribute2fv ) + movl 4(%esp), %ecx + movl (%ecx), %eax /* load v[0] */ + movl 4(%ecx), %edx /* load v[1] */ + movl %eax, SUBST(0) /* store v[0] to current vertex */ + movl %edx, SUBST(1) /* store v[1] to current vertex */ + RETCLEAN(4) +GLOBL ( _tnl_x86_Attribute2fv_end ) + +GLOBL( _tnl_x86_Attribute3fv ) + movl 4(%esp), %ecx + movl (%ecx), %eax /* load v[0] */ + movl 4(%ecx), %edx /* load v[1] */ + movl 8(%ecx), %ecx /* load v[2] */ + movl %eax, SUBST(0) /* store v[0] to current vertex */ + movl %edx, SUBST(1) /* store v[1] to current vertex */ + movl %ecx, SUBST(2) /* store v[2] to current vertex */ + RETCLEAN(4) +GLOBL ( _tnl_x86_Attribute3fv_end ) + +GLOBL( _tnl_x86_Attribute4fv ) + movl 4(%esp), %ecx + movl (%ecx), %eax /* load v[0] */ + movl 4(%ecx), %edx /* load v[1] */ + movl %eax, SUBST(0) /* store v[0] to current vertex */ + movl %edx, SUBST(1) /* store v[1] to current vertex */ + movl 8(%ecx), %eax /* load v[2] */ + movl 12(%ecx), %edx /* load v[3] */ + movl %eax, SUBST(2) /* store v[2] to current vertex */ + movl %edx, SUBST(3) /* store v[3] to current vertex */ + RETCLEAN(4) +GLOBL ( _tnl_x86_Attribute4fv_end ) + + +/* Choosers: + * + * Must generate all of these ahead of first usage. Generate at + * compile-time? + */ +GLOBL( _tnl_x86_choose_fv ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + movl $SUBST(0), (%esp) /* arg 0 - attrib */ + movl $SUBST(1), 4(%esp) /* arg 1 - N */ + _CALL (SUBST(2)) /* call do_choose */ + add $12, %esp /* tear down stack frame */ + jmp *%eax /* jump to new func */ +GLOBL ( _tnl_x86_choose_fv_end ) + + +/* FIRST LEVEL FUNCTIONS -- these are plugged directly into GL dispatch. + * + * In the 1st level dispatch functions, switch to a different + * calling convention -- (const GLfloat *v) in %ecx. + * + * As with regular (x86) dispatch, don't create a new stack frame - + * just let the 'ret' in the dispatched function return straight + * back to the original caller. + * + * Vertex/Normal/Color, etc: the address of the function pointer + * is known at codegen time. + */ + +/* Unfortunately, have to play with the stack in the non-fv case: + */ +#if !defined (STDCALL_API) +GLOBL( _tnl_x86_dispatch_attrf1 ) +GLOBL( _tnl_x86_dispatch_attrf2 ) +GLOBL( _tnl_x86_dispatch_attrf3 ) +GLOBL( _tnl_x86_dispatch_attrf4 ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + leal 16(%esp), %edx /* address of first float on stack */ + movl %edx, (%esp) /* save as 'v' */ + call *SUBST(0) /* 0x0 --> tabfv[attr][n] */ + addl $12, %esp /* tear down frame */ + ret /* return */ +GLOBL( _tnl_x86_dispatch_attrf4_end ) +GLOBL( _tnl_x86_dispatch_attrf3_end ) +GLOBL( _tnl_x86_dispatch_attrf2_end ) +GLOBL( _tnl_x86_dispatch_attrf1_end ) + +#else /* defined(STDCALL_API) */ + +GLOBL( _tnl_x86_dispatch_attrf1 ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + leal 16(%esp), %edx /* address of first float on stack */ + movl %edx, (%esp) /* save as 'v' */ + call *SUBST(0) /* 0x0 --> tabfv[attr][n] */ + addl $8, %esp /* tear down frame (4 shaved off by the callee) */ + ret $4 /* return */ +GLOBL( _tnl_x86_dispatch_attrf1_end ) + +GLOBL( _tnl_x86_dispatch_attrf2 ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + leal 16(%esp), %edx /* address of first float on stack */ + movl %edx, (%esp) /* save as 'v' */ + call *SUBST(0) /* 0x0 --> tabfv[attr][n] */ + addl $8, %esp /* tear down frame (4 shaved off by the callee) */ + ret $8 /* return */ +GLOBL( _tnl_x86_dispatch_attrf2_end ) + +GLOBL( _tnl_x86_dispatch_attrf3 ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + leal 16(%esp), %edx /* address of first float on stack */ + movl %edx, (%esp) /* save as 'v' */ + call *SUBST(0) /* 0x0 --> tabfv[attr][n] */ + addl $8, %esp /* tear down frame (4 shaved off by the callee) */ + ret $12 /* return */ +GLOBL( _tnl_x86_dispatch_attrf3_end ) + +GLOBL( _tnl_x86_dispatch_attrf4 ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + leal 16(%esp), %edx /* address of first float on stack */ + movl %edx, (%esp) /* save as 'v' */ + call *SUBST(0) /* 0x0 --> tabfv[attr][n] */ + addl $8, %esp /* tear down frame (4 shaved off by the callee) */ + ret $16 /* return */ +GLOBL( _tnl_x86_dispatch_attrf4_end ) +#endif /* defined(STDCALL_API) */ + +/* The fv case is simpler: + */ +GLOBL( _tnl_x86_dispatch_attrfv ) + jmp *SUBST(0) /* 0x0 --> tabfv[attr][n] */ +GLOBL( _tnl_x86_dispatch_attrfv_end ) + + +/* MultiTexcoord: the address of the function pointer must be + * calculated, but can use the index argument slot to hold 'v', and + * avoid setting up a new stack frame. + * + * [dBorca] + * right, this would be the preferred approach, but gcc does not + * clean up the stack after each function call when optimizing (-fdefer-pop); + * can it make assumptions about what's already on the stack? I dunno, + * but in this case, we can't mess with the caller's stack frame, and + * we must use a model like `_x86_dispatch_attrfv' above. Caveat emptor! + */ + +/* Also, will only need a maximum of four of each of these per context: + */ +#if !defined (STDCALL_API) +GLOBL( _tnl_x86_dispatch_multitexcoordf1 ) +GLOBL( _tnl_x86_dispatch_multitexcoordf2 ) +GLOBL( _tnl_x86_dispatch_multitexcoordf3 ) +GLOBL( _tnl_x86_dispatch_multitexcoordf4 ) + movl 4(%esp), %ecx + leal 8(%esp), %edx + andl $7, %ecx + movl %edx, 4(%esp) + sall $4, %ecx + jmp *SUBST(0)(%ecx) /* 0x0 - tabfv[tex0][n] */ +GLOBL( _tnl_x86_dispatch_multitexcoordf4_end ) +GLOBL( _tnl_x86_dispatch_multitexcoordf3_end ) +GLOBL( _tnl_x86_dispatch_multitexcoordf2_end ) +GLOBL( _tnl_x86_dispatch_multitexcoordf1_end ) + +GLOBL( _tnl_x86_dispatch_multitexcoordfv ) + movl 4(%esp), %ecx + movl 8(%esp), %edx + andl $7, %ecx + movl %edx, 4(%esp) + sall $4, %ecx + jmp *SUBST(0)(%ecx) /* 0x0 - tabfv[tex0][n] */ +GLOBL( _tnl_x86_dispatch_multitexcoordfv_end ) + +#else /* defined (STDCALL_API) */ + +GLOBL( _tnl_x86_dispatch_multitexcoordf1 ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + movl 16(%esp), %ecx + leal 20(%esp), %edx + andl $7, %ecx + movl %edx, (%esp) + sall $4, %ecx + call *SUBST(0)(%ecx) /* 0x0 - tabfv[tex0][n] */ + addl $8, %esp /* tear down frame (4 shaved off by the callee) */ + ret $8 /* return */ +GLOBL( _tnl_x86_dispatch_multitexcoordf1_end ) + +GLOBL( _tnl_x86_dispatch_multitexcoordf2 ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + movl 16(%esp), %ecx + leal 20(%esp), %edx + andl $7, %ecx + movl %edx, (%esp) + sall $4, %ecx + call *SUBST(0)(%ecx) /* 0x0 - tabfv[tex0][n] */ + addl $8, %esp /* tear down frame (4 shaved off by the callee) */ + ret $12 /* return */ +GLOBL( _tnl_x86_dispatch_multitexcoordf2_end ) + +GLOBL( _tnl_x86_dispatch_multitexcoordf3 ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + movl 16(%esp), %ecx + leal 20(%esp), %edx + andl $7, %ecx + movl %edx, (%esp) + sall $4, %ecx + call *SUBST(0)(%ecx) /* 0x0 - tabfv[tex0][n] */ + addl $8, %esp /* tear down frame (4 shaved off by the callee) */ + ret $16 /* return */ +GLOBL( _tnl_x86_dispatch_multitexcoordf3_end ) + +GLOBL( _tnl_x86_dispatch_multitexcoordf4 ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + movl 16(%esp), %ecx + leal 20(%esp), %edx + andl $7, %ecx + movl %edx, (%esp) + sall $4, %ecx + call *SUBST(0)(%ecx) /* 0x0 - tabfv[tex0][n] */ + addl $8, %esp /* tear down frame (4 shaved off by the callee) */ + ret $20 /* return */ +GLOBL( _tnl_x86_dispatch_multitexcoordf4_end ) + +GLOBL( _tnl_x86_dispatch_multitexcoordfv ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + movl 16(%esp), %ecx + movl 20(%esp), %edx + andl $7, %ecx + movl %edx, (%esp) + sall $4, %ecx + call *SUBST(0)(%ecx) /* 0x0 - tabfv[tex0][n] */ + addl $8, %esp /* tear down frame (4 shaved off by the callee) */ + ret $8 /* return */ +GLOBL( _tnl_x86_dispatch_multitexcoordfv_end ) +#endif /* defined (STDCALL_API) */ + + +/* VertexAttrib: the address of the function pointer must be + * calculated. + */ +#if !defined (STDCALL_API) +GLOBL( _tnl_x86_dispatch_vertexattribf1 ) +GLOBL( _tnl_x86_dispatch_vertexattribf2 ) +GLOBL( _tnl_x86_dispatch_vertexattribf3 ) +GLOBL( _tnl_x86_dispatch_vertexattribf4 ) + movl 4(%esp), %eax + cmpl $16, %eax + jb .8 /* "cmovge" is not supported on all CPUs */ + movl $16, %eax +.8: + leal 8(%esp), %ecx /* calculate 'v' */ + movl %ecx, 4(%esp) /* save in 1st arg slot */ + sall $4, %eax + jmp *SUBST(0)(%eax) /* 0x0 - tabfv[0][n] */ +GLOBL( _tnl_x86_dispatch_vertexattribf4_end ) +GLOBL( _tnl_x86_dispatch_vertexattribf3_end ) +GLOBL( _tnl_x86_dispatch_vertexattribf2_end ) +GLOBL( _tnl_x86_dispatch_vertexattribf1_end ) + +GLOBL( _tnl_x86_dispatch_vertexattribfv ) + movl 4(%esp), %eax + cmpl $16, %eax + jb .9 /* "cmovge" is not supported on all CPUs */ + movl $16, %eax +.9: + movl 8(%esp), %ecx /* load 'v' */ + movl %ecx, 4(%esp) /* save in 1st arg slot */ + sall $4, %eax + jmp *SUBST(0)(%eax) /* 0x0 - tabfv[0][n] */ +GLOBL( _tnl_x86_dispatch_vertexattribfv_end ) + +#else /* defined (STDCALL_API) */ + +GLOBL( _tnl_x86_dispatch_vertexattribf1 ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + movl 16(%esp), %eax + cmpl $16, %eax + jb .81 /* "cmovge" is not supported on all CPUs */ + movl $16, %eax +.81: + leal 20(%esp), %ecx /* load 'v' */ + movl %ecx, (%esp) /* save in 1st arg slot */ + sall $4, %eax + call *SUBST(0)(%eax) /* 0x0 - tabfv[0][n] */ + addl $8, %esp /* tear down frame (4 shaved off by the callee) */ + ret $8 /* return */ +GLOBL( _tnl_x86_dispatch_vertexattribf1_end ) + +GLOBL( _tnl_x86_dispatch_vertexattribf2 ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + movl 16(%esp), %eax + cmpl $16, %eax + jb .82 /* "cmovge" is not supported on all CPUs */ + movl $16, %eax +.82: + leal 20(%esp), %ecx /* load 'v' */ + movl %ecx, (%esp) /* save in 1st arg slot */ + sall $4, %eax + call *SUBST(0)(%eax) /* 0x0 - tabfv[0][n] */ + addl $8, %esp /* tear down frame (4 shaved off by the callee) */ + ret $12 /* return */ +GLOBL( _tnl_x86_dispatch_vertexattribf2_end ) + +GLOBL( _tnl_x86_dispatch_vertexattribf3 ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + movl 16(%esp), %eax + cmpl $16, %eax + jb .83 /* "cmovge" is not supported on all CPUs */ + movl $16, %eax +.83: + leal 20(%esp), %ecx /* load 'v' */ + movl %ecx, (%esp) /* save in 1st arg slot */ + sall $4, %eax + call *SUBST(0)(%eax) /* 0x0 - tabfv[0][n] */ + addl $8, %esp /* tear down frame (4 shaved off by the callee) */ + ret $16 /* return */ +GLOBL( _tnl_x86_dispatch_vertexattribf3_end ) + +GLOBL( _tnl_x86_dispatch_vertexattribf4 ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + movl 16(%esp), %eax + cmpl $16, %eax + jb .84 /* "cmovge" is not supported on all CPUs */ + movl $16, %eax +.84: + leal 20(%esp), %ecx /* load 'v' */ + movl %ecx, (%esp) /* save in 1st arg slot */ + sall $4, %eax + call *SUBST(0)(%eax) /* 0x0 - tabfv[0][n] */ + addl $8, %esp /* tear down frame (4 shaved off by the callee) */ + ret $20 /* return */ +GLOBL( _tnl_x86_dispatch_vertexattribf4_end ) + +GLOBL( _tnl_x86_dispatch_vertexattribfv ) + subl $12, %esp /* gcc does 16 byte alignment of stack frames? */ + movl 16(%esp), %eax + cmpl $16, %eax + jb .9 /* "cmovge" is not supported on all CPUs */ + movl $16, %eax +.9: + movl 20(%esp), %ecx /* load 'v' */ + movl %ecx, (%esp) /* save in 1st arg slot */ + sall $4, %eax + call *SUBST(0)(%eax) /* 0x0 - tabfv[0][n] */ + addl $8, %esp /* tear down frame (4 shaved off by the callee) */ + ret $8 /* return */ +GLOBL( _tnl_x86_dispatch_vertexattribfv_end ) +#endif /* defined (STDCALL_API) */ diff --git a/src/mesa/tnl/tnl.dsp b/src/mesa/tnl/tnl.dsp new file mode 100644 index 0000000..0499d12 --- /dev/null +++ b/src/mesa/tnl/tnl.dsp @@ -0,0 +1,228 @@ +# Microsoft Developer Studio Project File - Name="tnl" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=tnl - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "tnl.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "tnl.mak" CFG="tnl - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "tnl - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "tnl - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "tnl - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /I "../../../include" /I "../" /I "../main" /I "../glapi" /I "../shader" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF "$(CFG)" == "tnl - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../../../include" /I "../" /I "../main" /I "../glapi" /I "../shader" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FR /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ENDIF
+
+# Begin Target
+
+# Name "tnl - Win32 Release"
+# Name "tnl - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\t_array_api.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_array_import.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_context.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_pipeline.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_save_api.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_save_loopback.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_save_playback.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vb_cull.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vb_fog.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vb_light.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vb_normals.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vb_points.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vb_program.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vb_render.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vb_texgen.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vb_texmat.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vb_vertex.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vertex.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vertex_c.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vertex_codegen.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vtx_api.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vtx_eval.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vtx_exec.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vtx_generic.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\t_array_api.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_array_import.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_context.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_pipeline.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_save_api.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vb_cliptmp.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vb_lighttmp.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vb_rendertmp.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\t_vtx_api.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\tnl.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/src/mesa/tnl/tnl.h b/src/mesa/tnl/tnl.h new file mode 100644 index 0000000..d04310f --- /dev/null +++ b/src/mesa/tnl/tnl.h @@ -0,0 +1,87 @@ + +/* + * Mesa 3-D graphics library + * Version: 3.5 + * + * Copyright (C) 1999-2001 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"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: + * Keith Whitwell <keith@tungstengraphics.com> + */ + +#ifndef _TNL_H +#define _TNL_H + +#include "mtypes.h" + + + +/* These are the public-access functions exported from tnl. (A few + * more are currently hooked into dispatch directly by the module + * itself.) + */ +extern GLboolean +_tnl_CreateContext( GLcontext *ctx ); + +extern void +_tnl_DestroyContext( GLcontext *ctx ); + +extern void +_tnl_InvalidateState( GLcontext *ctx, GLuint new_state ); + +/* Functions to revive the tnl module after being unhooked from + * dispatch and/or driver callbacks. + */ + +/* Restore just the ctx->Exec table: + */ +extern void +_tnl_wakeup_exec( GLcontext *ctx ); + +/* Restore both ctx->Exec and ctx->Save: + */ +extern void +_tnl_wakeup_save_exec( GLcontext *ctx ); + +/* Driver configuration options: + */ +extern void +_tnl_need_projected_coords( GLcontext *ctx, GLboolean flag ); + +extern void +_tnl_need_dlist_loopback( GLcontext *ctx, GLboolean flag ); + +extern void +_tnl_need_dlist_norm_lengths( GLcontext *ctx, GLboolean flag ); + +extern void +_tnl_isolate_materials( GLcontext *ctx, GLboolean flag ); + + +/* Control whether T&L does per-vertex fog + */ +extern void +_tnl_allow_vertex_fog( GLcontext *ctx, GLboolean value ); + +extern void +_tnl_allow_pixel_fog( GLcontext *ctx, GLboolean value ); + + +#endif |