diff options
Diffstat (limited to 'src/mesa/tnl/t_array_import.c')
-rw-r--r-- | src/mesa/tnl/t_array_import.c | 521 |
1 files changed, 521 insertions, 0 deletions
diff --git a/src/mesa/tnl/t_array_import.c b/src/mesa/tnl/t_array_import.c new file mode 100644 index 0000000000..16a669dc28 --- /dev/null +++ b/src/mesa/tnl/t_array_import.c @@ -0,0 +1,521 @@ +/* $Id: t_array_import.c,v 1.1 2000/12/26 05:09:32 keithw Exp $ */ + +/* + * Mesa 3-D graphics library + * Version: 3.5 + * + * Copyright (C) 1999-2000 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 <keithw@valinux.com> + */ + +#include "glheader.h" +#include "context.h" +#include "macros.h" +#include "mem.h" +#include "mmath.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 vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + + tmp = _ac_import_vertex(ctx, + GL_FLOAT, + stride ? 4*sizeof(GLfloat) : 0, + 0, + writeable, + &is_writeable); + + inputs->Obj.data = tmp->Ptr; + inputs->Obj.start = (GLfloat *)tmp->Ptr; + inputs->Obj.stride = tmp->StrideB; + inputs->Obj.size = tmp->Size; + inputs->Obj.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE); + if (stride != 4*sizeof(GLfloat)) + inputs->Obj.flags |= VEC_BAD_STRIDE; + if (!is_writeable) + inputs->Obj.flags |= VEC_NOT_WRITEABLE; +} + +static void _tnl_import_normal( GLcontext *ctx, + GLboolean writeable, + GLboolean stride ) +{ + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + + tmp = _ac_import_normal(ctx, GL_FLOAT, + stride ? 3*sizeof(GLfloat) : 0, writeable, + &is_writeable); + + inputs->Normal.data = tmp->Ptr; + inputs->Normal.start = (GLfloat *)tmp->Ptr; + inputs->Normal.stride = tmp->StrideB; + inputs->Normal.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE); + if (stride != 3*sizeof(GLfloat)) + inputs->Normal.flags |= VEC_BAD_STRIDE; + if (!is_writeable) + inputs->Normal.flags |= VEC_NOT_WRITEABLE; +} + + +static void _tnl_import_color( GLcontext *ctx, + GLboolean writeable, + GLboolean stride ) +{ + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + + tmp = _ac_import_color(ctx, + GL_UNSIGNED_BYTE, + stride ? 4*sizeof(GLubyte) : 0, + 4, + writeable, + &is_writeable); + + inputs->Color.data = tmp->Ptr; + inputs->Color.start = (GLubyte *)tmp->Ptr; + inputs->Color.stride = tmp->StrideB; + inputs->Color.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE); + if (stride != 4*sizeof(GLubyte)) + inputs->Color.flags |= VEC_BAD_STRIDE; + if (!is_writeable) + inputs->Color.flags |= VEC_NOT_WRITEABLE; +} + + +static void _tnl_import_secondarycolor( GLcontext *ctx, + GLboolean writeable, + GLboolean stride ) +{ + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + + tmp = _ac_import_secondarycolor(ctx, GL_UNSIGNED_BYTE, + stride ? 4*sizeof(GLubyte) : 0, + 4, + writeable, + &is_writeable); + + inputs->SecondaryColor.data = tmp->Ptr; + inputs->SecondaryColor.start = (GLubyte *)tmp->Ptr; + inputs->SecondaryColor.stride = tmp->StrideB; + inputs->SecondaryColor.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE); + if (stride != 4*sizeof(GLubyte)) + inputs->SecondaryColor.flags |= VEC_BAD_STRIDE; + if (!is_writeable) + inputs->SecondaryColor.flags |= VEC_NOT_WRITEABLE; +} + +static void _tnl_import_fogcoord( GLcontext *ctx, + GLboolean writeable, + GLboolean stride ) +{ + struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + + tmp = _ac_import_fogcoord(ctx, GL_FLOAT, + stride ? sizeof(GLfloat) : 0, writeable, + &is_writeable); + + inputs->FogCoord.data = tmp->Ptr; + inputs->FogCoord.start = (GLfloat *)tmp->Ptr; + inputs->FogCoord.stride = tmp->StrideB; + inputs->FogCoord.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE); + if (stride != sizeof(GLfloat)) + inputs->FogCoord.flags |= VEC_BAD_STRIDE; + if (!is_writeable) + inputs->FogCoord.flags |= VEC_NOT_WRITEABLE; +} + +static void _tnl_import_index( GLcontext *ctx, + GLboolean writeable, + GLboolean stride ) +{ + struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + + tmp = _ac_import_index(ctx, GL_UNSIGNED_INT, + stride ? sizeof(GLuint) : 0, writeable, + &is_writeable); + + inputs->Index.data = tmp->Ptr; + inputs->Index.start = (GLuint *)tmp->Ptr; + inputs->Index.stride = tmp->StrideB; + inputs->Index.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE); + if (stride != sizeof(GLuint)) + inputs->Index.flags |= VEC_BAD_STRIDE; + if (!is_writeable) + inputs->Index.flags |= VEC_NOT_WRITEABLE; +} + + +static void _tnl_import_texcoord( GLcontext *ctx, + GLuint i, + GLboolean writeable, + GLboolean stride ) +{ + struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + + tmp = _ac_import_texcoord(ctx, i, GL_FLOAT, + stride ? 4*sizeof(GLfloat) : 0, + 0, + writeable, + &is_writeable); + + inputs->TexCoord[i].data = tmp->Ptr; + inputs->TexCoord[i].start = (GLfloat *)tmp->Ptr; + inputs->TexCoord[i].stride = tmp->StrideB; + inputs->TexCoord[i].size = tmp->Size; + inputs->TexCoord[i].flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE); + if (stride != 4*sizeof(GLfloat)) + inputs->TexCoord[i].flags |= VEC_BAD_STRIDE; + if (!is_writeable) + inputs->TexCoord[i].flags |= VEC_NOT_WRITEABLE; +} + + +static void _tnl_import_edgeflag( GLcontext *ctx, + GLboolean writeable, + GLboolean stride ) +{ + struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + struct gl_client_array *tmp; + GLboolean is_writeable = 0; + + tmp = _ac_import_edgeflag(ctx, GL_UNSIGNED_BYTE, + stride ? sizeof(GLubyte) : 0, + 0, + &is_writeable); + + inputs->EdgeFlag.data = tmp->Ptr; + inputs->EdgeFlag.start = (GLubyte *)tmp->Ptr; + inputs->EdgeFlag.stride = tmp->StrideB; + inputs->EdgeFlag.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE); + if (stride != sizeof(GLubyte)) + inputs->EdgeFlag.flags |= VEC_BAD_STRIDE; + if (!is_writeable) + inputs->EdgeFlag.flags |= VEC_NOT_WRITEABLE; +} + + + +/* Callback for VB stages that need to improve the quality of arrays + * bound to the VB. This is only necessary for client arrays which + * have not been transformed at any point in the pipeline. + */ +static void _tnl_upgrade_client_data( GLcontext *ctx, + GLuint required, + GLuint flags ) +{ + GLuint i; + struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; + struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs; + GLboolean writeable = (flags & VEC_NOT_WRITEABLE) != 0; + GLboolean stride = (flags & VEC_BAD_STRIDE) != 0; + + if ((required & VERT_CLIP) && VB->ClipPtr == VB->ObjPtr) + required |= VERT_OBJ; + + if ((required & VERT_OBJ) && (VB->ObjPtr->flags & flags)) { + ASSERT(VB->ObjPtr == &inputs->Obj); + _tnl_import_vertex( ctx, writeable, stride ); + } + + if ((required & VERT_NORM) && (VB->NormalPtr->flags & flags)) { + ASSERT(VB->NormalPtr == &inputs->Normal); + _tnl_import_normal( ctx, writeable, stride ); + } + + if ((required & VERT_RGBA) && (VB->ColorPtr[0]->flags & flags)) { + ASSERT(VB->ColorPtr[0] == &inputs->Color); + _tnl_import_color( ctx, writeable, stride ); + } + + if ((required & VERT_SPEC_RGB) && (VB->SecondaryColorPtr[0]->flags&flags)) { + ASSERT(VB->SecondaryColorPtr[0] == &inputs->SecondaryColor); + _tnl_import_secondarycolor( ctx, writeable, stride ); + } + + if ((required & VERT_FOG_COORD) && (VB->FogCoordPtr->flags & flags)) { + ASSERT(VB->FogCoordPtr == &inputs->FogCoord); + _tnl_import_fogcoord( ctx, writeable, stride ); + } + + if ((required & VERT_INDEX) && (VB->IndexPtr[0]->flags & flags)) { + ASSERT(VB->IndexPtr[0] == &inputs->Index); + _tnl_import_index( ctx, writeable, stride ); + } + + if (required & VERT_TEX_ANY) + for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) + if ((required & VERT_TEX(i)) && (VB->TexCoordPtr[i]->flags & flags)) { + ASSERT(VB->TexCoordPtr[i] == &inputs->TexCoord[i]); + _tnl_import_texcoord( ctx, i, writeable, stride ); + } + + if ((required & VERT_EDGE) && (VB->EdgeFlagPtr->flags & flags)) { + ASSERT(VB->EdgeFlagPtr == &inputs->EdgeFlag); + _tnl_import_edgeflag( ctx, writeable, stride ); + } + + VB->importable_data &= ~required; +} + + + + + +void _tnl_vb_bind_arrays( GLcontext *ctx, GLint start, GLsizei count ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + struct vertex_buffer *VB = &tnl->vb; + GLuint inputs = tnl->pipeline.inputs; + GLuint imports; + struct vertex_arrays *tmp = &tnl->array_inputs; + + if (ctx->Array.LockCount) { + ASSERT(start == ctx->Array.LockFirst); + ASSERT(count == ctx->Array.LockCount); + } + + imports = tnl->pipeline.inputs; + + _ac_import_range( ctx, start, count ); + + VB->Count = count - start; + VB->FirstClipped = VB->Count; + + VB->Elts = 0; + VB->MaterialMask = 0; + VB->Material = 0; + VB->Flag = 0; + +/* _tnl_print_vert_flags("_tnl_print_vert_flags: inputs", inputs); */ +/* _tnl_print_vert_flags("_tnl_print_vert_flags: imports", imports); */ +/* _tnl_print_vert_flags("_tnl_print_vert_flags: _Enabled", ctx->Array._Enabled); */ + + if (inputs & VERT_OBJ) { + if (imports & VERT_OBJ) { + _tnl_import_vertex( ctx, 0, 0 ); + tmp->Obj.count = VB->Count; + } + VB->ObjPtr = &tmp->Obj; + } + + if (inputs & VERT_NORM) { + if (imports & VERT_NORM) { + _tnl_import_normal( ctx, 0, 0 ); + tmp->Normal.count = VB->Count; + } + VB->NormalPtr = &tmp->Normal; + } + + if (inputs & VERT_RGBA) { + if (imports & VERT_RGBA) { + _tnl_import_color( ctx, 0, 0 ); + tmp->Color.count = VB->Count; + } + VB->ColorPtr[0] = &tmp->Color; + VB->ColorPtr[1] = 0; + } + + if (inputs & VERT_INDEX) { + if (imports & VERT_INDEX) { + _tnl_import_index( ctx, 0, 0 ); + tmp->Index.count = VB->Count; + } + VB->IndexPtr[0] = &tmp->Index; + VB->IndexPtr[1] = 0; + } + + + if (inputs & VERT_FOG_COORD) { + if (imports & VERT_FOG_COORD) { + _tnl_import_fogcoord( ctx, 0, 0 ); + tmp->FogCoord.count = VB->Count; + } + VB->FogCoordPtr = &tmp->FogCoord; + } + + if (inputs & VERT_EDGE) { + if (imports & VERT_EDGE) { + _tnl_import_edgeflag( ctx, 0, 0 ); + tmp->EdgeFlag.count = VB->Count; + } + VB->EdgeFlagPtr = &tmp->EdgeFlag; + } + + if (inputs & VERT_SPEC_RGB) { + if (imports & VERT_SPEC_RGB) { + _tnl_import_secondarycolor( ctx, 0, 0 ); + tmp->SecondaryColor.count = VB->Count; + } + VB->SecondaryColorPtr[0] = &tmp->SecondaryColor; + VB->SecondaryColorPtr[1] = 0; + } + + if (inputs & VERT_TEX_ANY) { + GLuint i; + for (i = 0; i < ctx->Const.MaxTextureUnits ; i++) + if (inputs & VERT_TEX(i)) { + if (imports & VERT_TEX(i)) { + _tnl_import_texcoord( ctx, i, 0, 0 ); + tmp->TexCoord[i].count = VB->Count; + } + VB->TexCoordPtr[i] = &tmp->TexCoord[i]; + } + } + + VB->Primitive = tnl->tmp_primitive; + VB->PrimitiveLength = tnl->tmp_primitive_length; + VB->import_data = _tnl_upgrade_client_data; + VB->importable_data = imports; +} + + + + +/* Function to fill an immediate struct with the effects of + * consecutive calls to ArrayElement with consecutive indices. + */ +void _tnl_fill_immediate_drawarrays( GLcontext *ctx, struct immediate *IM, + GLuint start, GLuint count ) +{ + TNLcontext *tnl = TNL_CONTEXT(ctx); + GLuint required = ctx->Array._Enabled; + GLuint n = count - start; + GLuint i; + + if (!ctx->CompileFlag) + required &= tnl->pipeline.inputs; + + if (MESA_VERBOSE&VERBOSE_IMMEDIATE) + fprintf(stderr, "exec_full_array_elements %d .. %d\n", start, count); + + _math_trans_4f( IM->Obj + IM->Start, + ctx->Array.Vertex.Ptr, + ctx->Array.Vertex.StrideB, + ctx->Array.Vertex.Type, + ctx->Array.Vertex.Size, + start, n ); + + if (ctx->Array.Vertex.Size == 4) + required |= VERT_OBJ_234; + else if (ctx->Array.Vertex.Size == 3) + required |= VERT_OBJ_23; + + + if (required & VERT_NORM) { + _math_trans_3f( IM->Normal + IM->Start, + ctx->Array.Normal.Ptr, + ctx->Array.Normal.StrideB, + ctx->Array.Normal.Type, + start, n ); + } + + if (required & VERT_EDGE) { + _math_trans_1ub( IM->EdgeFlag + IM->Start, + ctx->Array.EdgeFlag.Ptr, + ctx->Array.EdgeFlag.StrideB, + ctx->Array.EdgeFlag.Type, + start, n ); + } + + if (required & VERT_RGBA) { + _math_trans_4ub( IM->Color + IM->Start, + ctx->Array.Color.Ptr, + ctx->Array.Color.StrideB, + ctx->Array.Color.Type, + ctx->Array.Color.Size, + start, n ); + } + + if (required & VERT_SPEC_RGB) { + _math_trans_4ub( IM->SecondaryColor + IM->Start, + ctx->Array.SecondaryColor.Ptr, + ctx->Array.SecondaryColor.StrideB, + ctx->Array.SecondaryColor.Type, + ctx->Array.SecondaryColor.Size, + start, n ); + } + + if (required & VERT_FOG_COORD) { + _math_trans_1f( IM->FogCoord + IM->Start, + ctx->Array.FogCoord.Ptr, + ctx->Array.FogCoord.StrideB, + ctx->Array.FogCoord.Type, + start, n ); + } + + if (required & VERT_INDEX) { + _math_trans_1ui( IM->Index + IM->Start, + ctx->Array.Index.Ptr, + ctx->Array.Index.StrideB, + ctx->Array.Index.Type, + start, n ); + } + + if (required & VERT_TEX_ANY) { + for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) { + if (required & VERT_TEX(i)) { + _math_trans_4f( IM->TexCoord[i] + IM->Start, + ctx->Array.TexCoord[i].Ptr, + ctx->Array.TexCoord[i].StrideB, + ctx->Array.TexCoord[i].Size, + ctx->Array.TexCoord[i].Type, + start, n ); + + if (ctx->Array.TexCoord[i].Size == 4) + IM->TexSize |= TEX_SIZE_4(i); + else if (ctx->Array.TexCoord[i].Size == 3) + IM->TexSize |= TEX_SIZE_3(i); + } + } + } + + IM->Count = IM->Start + n; + IM->Flag[IM->Start] |= required; + for (i = IM->Start+1 ; i < IM->Count ; i++) + IM->Flag[i] = required; +} + + |