From f4092abdf94af6a99aff944d6264bc1284e8bdd4 Mon Sep 17 00:00:00 2001 From: Reinhard Tartler Date: Mon, 10 Oct 2011 17:43:39 +0200 Subject: Imported nx-X11-3.1.0-1.tar.gz Summary: Imported nx-X11-3.1.0-1.tar.gz Keywords: Imported nx-X11-3.1.0-1.tar.gz into Git repository --- .../extras/Mesa/src/mesa/array_cache/ac_context.c | 375 +++++++++ .../extras/Mesa/src/mesa/array_cache/ac_context.h | 99 +++ .../extras/Mesa/src/mesa/array_cache/ac_import.c | 902 +++++++++++++++++++++ nx-X11/extras/Mesa/src/mesa/array_cache/acache.h | 132 +++ .../extras/Mesa/src/mesa/array_cache/descrip.mms | 37 + 5 files changed, 1545 insertions(+) create mode 100644 nx-X11/extras/Mesa/src/mesa/array_cache/ac_context.c create mode 100644 nx-X11/extras/Mesa/src/mesa/array_cache/ac_context.h create mode 100644 nx-X11/extras/Mesa/src/mesa/array_cache/ac_import.c create mode 100644 nx-X11/extras/Mesa/src/mesa/array_cache/acache.h create mode 100644 nx-X11/extras/Mesa/src/mesa/array_cache/descrip.mms (limited to 'nx-X11/extras/Mesa/src/mesa/array_cache') diff --git a/nx-X11/extras/Mesa/src/mesa/array_cache/ac_context.c b/nx-X11/extras/Mesa/src/mesa/array_cache/ac_context.c new file mode 100644 index 000000000..ebf3a3dc4 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/array_cache/ac_context.c @@ -0,0 +1,375 @@ +/* + * Mesa 3-D graphics library + * Version: 5.1 + * + * Copyright (C) 1999-2002 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 + */ + +#include "glheader.h" +#include "macros.h" +#include "imports.h" +#include "mtypes.h" + +#include "array_cache/ac_context.h" + + +/* + * Initialize the array fallbacks. That is, by default the fallback arrays + * point into the current vertex attribute values in ctx->Current.Attrib[] + */ +static void _ac_fallbacks_init( GLcontext *ctx ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + struct gl_client_array *cl; + GLuint i; + + cl = &ac->Fallback.Normal; + cl->Size = 3; + cl->Type = GL_FLOAT; + cl->Stride = 0; + cl->StrideB = 0; + cl->Ptr = (GLubyte *) ctx->Current.Attrib[VERT_ATTRIB_NORMAL]; + cl->Enabled = 1; + cl->Flags = CA_CLIENT_DATA; /* hack */ +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + + cl = &ac->Fallback.Color; + cl->Size = 4; + cl->Type = GL_FLOAT; + cl->Stride = 0; + cl->StrideB = 0; + cl->Ptr = (GLubyte *) ctx->Current.Attrib[VERT_ATTRIB_COLOR0]; + cl->Enabled = 1; + cl->Flags = CA_CLIENT_DATA; /* hack */ +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + + cl = &ac->Fallback.SecondaryColor; + cl->Size = 3; + cl->Type = GL_FLOAT; + cl->Stride = 0; + cl->StrideB = 0; + cl->Ptr = (GLubyte *) ctx->Current.Attrib[VERT_ATTRIB_COLOR1]; + cl->Enabled = 1; + cl->Flags = CA_CLIENT_DATA; /* hack */ +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + + cl = &ac->Fallback.FogCoord; + cl->Size = 1; + cl->Type = GL_FLOAT; + cl->Stride = 0; + cl->StrideB = 0; + cl->Ptr = (GLubyte *) &ctx->Current.Attrib[VERT_ATTRIB_FOG]; + cl->Enabled = 1; + cl->Flags = CA_CLIENT_DATA; /* hack */ +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + + cl = &ac->Fallback.Index; + cl->Size = 1; + cl->Type = GL_FLOAT; + cl->Stride = 0; + cl->StrideB = 0; + cl->Ptr = (GLubyte *) &ctx->Current.Index; + cl->Enabled = 1; + cl->Flags = CA_CLIENT_DATA; /* hack */ +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + + for (i = 0 ; i < MAX_TEXTURE_COORD_UNITS ; i++) { + cl = &ac->Fallback.TexCoord[i]; + cl->Size = 4; + cl->Type = GL_FLOAT; + cl->Stride = 0; + cl->StrideB = 0; + cl->Ptr = (GLubyte *) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + i]; + cl->Enabled = 1; + cl->Flags = CA_CLIENT_DATA; /* hack */ +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + } + + cl = &ac->Fallback.EdgeFlag; + cl->Size = 1; + cl->Type = GL_UNSIGNED_BYTE; + cl->Stride = 0; + cl->StrideB = 0; + cl->Ptr = (GLubyte *) &ctx->Current.EdgeFlag; + cl->Enabled = 1; + cl->Flags = CA_CLIENT_DATA; /* hack */ +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + + for (i = 0; i < VERT_ATTRIB_MAX; i++) { + cl = &ac->Fallback.Attrib[i]; + cl->Size = 4; + cl->Type = GL_FLOAT; + cl->Stride = 0; + cl->StrideB = 0; + cl->Ptr = (GLubyte *) ctx->Current.Attrib[i]; + cl->Enabled = 1; + cl->Flags = CA_CLIENT_DATA; /* hack */ +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + } +} + + +/* + * Initialize the array cache pointers, types, strides, etc. + */ +static void _ac_cache_init( GLcontext *ctx ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + struct gl_client_array *cl; + GLuint size = ctx->Const.MaxArrayLockSize + MAX_CLIPPED_VERTICES; + GLuint i; + + cl = &ac->Cache.Vertex; + cl->Size = 4; + cl->Type = GL_FLOAT; + cl->Stride = 0; + cl->StrideB = 4 * sizeof(GLfloat); + cl->Ptr = (GLubyte *) MALLOC( cl->StrideB * size ); + cl->Enabled = 1; + cl->Flags = 0; +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + + cl = &ac->Cache.Normal; + cl->Size = 3; + cl->Type = GL_FLOAT; + cl->Stride = 0; + cl->StrideB = 3 * sizeof(GLfloat); + cl->Ptr = (GLubyte *) MALLOC( cl->StrideB * size ); + cl->Enabled = 1; + cl->Flags = 0; +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + + cl = &ac->Cache.Color; + cl->Size = 4; + cl->Type = GL_FLOAT; + cl->Stride = 0; + cl->StrideB = 4 * sizeof(GLfloat); + cl->Ptr = (GLubyte *) MALLOC( cl->StrideB * size ); + cl->Enabled = 1; + cl->Flags = 0; +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + + cl = &ac->Cache.SecondaryColor; + cl->Size = 3; + cl->Type = GL_FLOAT; + cl->Stride = 0; + cl->StrideB = 4 * sizeof(GLfloat); + cl->Ptr = (GLubyte *) MALLOC( cl->StrideB * size ); + cl->Enabled = 1; + cl->Flags = 0; +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + + cl = &ac->Cache.FogCoord; + cl->Size = 1; + cl->Type = GL_FLOAT; + cl->Stride = 0; + cl->StrideB = sizeof(GLfloat); + cl->Ptr = (GLubyte *) MALLOC( cl->StrideB * size ); + cl->Enabled = 1; + cl->Flags = 0; +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + + cl = &ac->Cache.Index; + cl->Size = 1; + cl->Type = GL_FLOAT; + cl->Stride = 0; + cl->StrideB = sizeof(GLfloat); + cl->Ptr = (GLubyte *) MALLOC( cl->StrideB * size ); + cl->Enabled = 1; + cl->Flags = 0; +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + + for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) { + cl = &ac->Cache.TexCoord[i]; + cl->Size = 4; + cl->Type = GL_FLOAT; + cl->Stride = 0; + cl->StrideB = 4 * sizeof(GLfloat); + cl->Ptr = (GLubyte *) MALLOC( cl->StrideB * size ); + cl->Enabled = 1; + cl->Flags = 0; +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + } + + cl = &ac->Cache.EdgeFlag; + cl->Size = 1; + cl->Type = GL_UNSIGNED_BYTE; + cl->Stride = 0; + cl->StrideB = sizeof(GLubyte); + cl->Ptr = (GLubyte *) MALLOC( cl->StrideB * size ); + cl->Enabled = 1; + cl->Flags = 0; +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + + for (i = 0 ; i < VERT_ATTRIB_MAX; i++) { + cl = &ac->Cache.Attrib[i]; + cl->Size = 4; + cl->Type = GL_FLOAT; + cl->Stride = 0; + cl->StrideB = 4 * sizeof(GLfloat); + cl->Ptr = (GLubyte *) MALLOC( cl->StrideB * size ); + cl->Enabled = 1; + cl->Flags = 0; +#if FEATURE_ARB_vertex_buffer_object + cl->BufferObj = ctx->Array.NullBufferObj; +#endif + } +} + + +/* This storage used to hold translated client data if type or stride + * need to be fixed. + */ +static void _ac_elts_init( GLcontext *ctx ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + GLuint size = 1000; + + ac->Elts = (GLuint *)MALLOC( sizeof(GLuint) * size ); + ac->elt_size = size; +} + +static void _ac_raw_init( GLcontext *ctx ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + GLuint i; + + ac->Raw.Color = ac->Fallback.Color; + ac->Raw.EdgeFlag = ac->Fallback.EdgeFlag; + ac->Raw.FogCoord = ac->Fallback.FogCoord; + ac->Raw.Index = ac->Fallback.Index; + ac->Raw.Normal = ac->Fallback.Normal; + ac->Raw.SecondaryColor = ac->Fallback.SecondaryColor; + ac->Raw.Vertex = ctx->Array.Vertex; + + ac->IsCached.Color = GL_FALSE; + ac->IsCached.EdgeFlag = GL_FALSE; + ac->IsCached.FogCoord = GL_FALSE; + ac->IsCached.Index = GL_FALSE; + ac->IsCached.Normal = GL_FALSE; + ac->IsCached.SecondaryColor = GL_FALSE; + ac->IsCached.Vertex = GL_FALSE; + + for (i = 0 ; i < MAX_TEXTURE_COORD_UNITS ; i++) { + ac->Raw.TexCoord[i] = ac->Fallback.TexCoord[i]; + ac->IsCached.TexCoord[i] = GL_FALSE; + } + + for (i = 0 ; i < VERT_ATTRIB_MAX ; i++) { + ac->Raw.Attrib[i] = ac->Fallback.Attrib[i]; + ac->IsCached.Attrib[i] = GL_FALSE; + } +} + +GLboolean _ac_CreateContext( GLcontext *ctx ) +{ + ctx->acache_context = CALLOC(sizeof(ACcontext)); + if (ctx->acache_context) { + _ac_cache_init( ctx ); + _ac_fallbacks_init( ctx ); + _ac_raw_init( ctx ); + _ac_elts_init( ctx ); + return GL_TRUE; + } + return GL_FALSE; +} + +void _ac_DestroyContext( GLcontext *ctx ) +{ + struct gl_buffer_object *nullObj = ctx->Array.NullBufferObj; + ACcontext *ac = AC_CONTEXT(ctx); + GLint i; + + /* only free vertex data if it's really a pointer to vertex data and + * not an offset into a buffer object. + */ + if (ac->Cache.Vertex.Ptr && ac->Cache.Vertex.BufferObj == nullObj) + FREE( (void *) ac->Cache.Vertex.Ptr ); + if (ac->Cache.Normal.Ptr && ac->Cache.Normal.BufferObj == nullObj) + FREE( (void *) ac->Cache.Normal.Ptr ); + if (ac->Cache.Color.Ptr && ac->Cache.Color.BufferObj == nullObj) + FREE( (void *) ac->Cache.Color.Ptr ); + if (ac->Cache.SecondaryColor.Ptr && ac->Cache.SecondaryColor.BufferObj == nullObj) + FREE( (void *) ac->Cache.SecondaryColor.Ptr ); + if (ac->Cache.EdgeFlag.Ptr && ac->Cache.EdgeFlag.BufferObj == nullObj) + FREE( (void *) ac->Cache.EdgeFlag.Ptr ); + if (ac->Cache.Index.Ptr && ac->Cache.Index.BufferObj == nullObj) + FREE( (void *) ac->Cache.Index.Ptr ); + if (ac->Cache.FogCoord.Ptr && ac->Cache.FogCoord.BufferObj == nullObj) + FREE( (void *) ac->Cache.FogCoord.Ptr ); + + for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) { + if (ac->Cache.TexCoord[i].Ptr && ac->Cache.TexCoord[i].BufferObj == nullObj) + FREE( (void *) ac->Cache.TexCoord[i].Ptr ); + } + + for (i = 0; i < VERT_ATTRIB_MAX; i++) { + if (ac->Cache.Attrib[i].Ptr && ac->Cache.Attrib[i].BufferObj == nullObj) + FREE( (void *) ac->Cache.Attrib[i].Ptr ); + } + + if (ac->Elts) + FREE( ac->Elts ); + + /* Free the context structure itself */ + FREE(ac); + ctx->acache_context = NULL; +} + +void _ac_InvalidateState( GLcontext *ctx, GLuint new_state ) +{ + AC_CONTEXT(ctx)->NewState |= new_state; + AC_CONTEXT(ctx)->NewArrayState |= ctx->Array.NewState; +} diff --git a/nx-X11/extras/Mesa/src/mesa/array_cache/ac_context.h b/nx-X11/extras/Mesa/src/mesa/array_cache/ac_context.h new file mode 100644 index 000000000..36aded315 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/array_cache/ac_context.h @@ -0,0 +1,99 @@ + +/* + * Mesa 3-D graphics library + * Version: 5.1 + * + * Copyright (C) 1999-2002 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 + */ + +#ifndef _AC_CONTEXT_H +#define _AC_CONTEXT_H + +#include "glheader.h" +#include "mtypes.h" + +#include "array_cache/acache.h" + +/* These are used to make the ctx->Current values look like + * arrays (with zero StrideB). + */ +struct ac_arrays { + struct gl_client_array Vertex; + struct gl_client_array Normal; + struct gl_client_array Color; + struct gl_client_array SecondaryColor; + struct gl_client_array FogCoord; + struct gl_client_array Index; + struct gl_client_array TexCoord[MAX_TEXTURE_COORD_UNITS]; + struct gl_client_array EdgeFlag; + struct gl_client_array Attrib[VERT_ATTRIB_MAX]; /* GL_NV_vertex_program */ +}; + +struct ac_array_pointers { + struct gl_client_array *Vertex; + struct gl_client_array *Normal; + struct gl_client_array *Color; + struct gl_client_array *SecondaryColor; + struct gl_client_array *FogCoord; + struct gl_client_array *Index; + struct gl_client_array *TexCoord[MAX_TEXTURE_COORD_UNITS]; + struct gl_client_array *EdgeFlag; + struct gl_client_array *Attrib[VERT_ATTRIB_MAX]; /* GL_NV_vertex_program */ +}; + +struct ac_array_flags { + GLboolean Vertex; + GLboolean Normal; + GLboolean Color; + GLboolean SecondaryColor; + GLboolean FogCoord; + GLboolean Index; + GLboolean TexCoord[MAX_TEXTURE_COORD_UNITS]; + GLboolean EdgeFlag; + GLboolean Attrib[VERT_ATTRIB_MAX]; /* GL_NV_vertex_program */ +}; + + +typedef struct { + GLuint NewState; /* not needed? */ + GLuint NewArrayState; + + /* Facility for importing and caching array data: + */ + struct ac_arrays Fallback; + struct ac_arrays Cache; + struct ac_arrays Raw; + struct ac_array_flags IsCached; + GLuint start; + GLuint count; + + /* Facility for importing element lists: + */ + GLuint *Elts; + GLuint elt_size; + +} ACcontext; + +#define AC_CONTEXT(ctx) ((ACcontext *)ctx->acache_context) + +#endif diff --git a/nx-X11/extras/Mesa/src/mesa/array_cache/ac_import.c b/nx-X11/extras/Mesa/src/mesa/array_cache/ac_import.c new file mode 100644 index 000000000..416b2e793 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/array_cache/ac_import.c @@ -0,0 +1,902 @@ +/* + * 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 + */ + +#include "glheader.h" +#include "macros.h" +#include "imports.h" +#include "mtypes.h" + +#include "math/m_translate.h" +#include "array_cache/ac_context.h" +#include "math/m_translate.h" + +#define STRIDE_ARRAY( array, offset ) \ +do { \ + GLubyte *tmp = ADD_POINTERS( (array).BufferObj->Data, (array).Ptr ) \ + + (offset) * (array).StrideB; \ + (array).Ptr = tmp; \ +} while (0) + + +/* Set the array pointer back to its source when the cached data is + * invalidated: + */ +static void +reset_texcoord( GLcontext *ctx, GLuint unit ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + if (ctx->Array.TexCoord[unit].Enabled) { + ac->Raw.TexCoord[unit] = ctx->Array.TexCoord[unit]; + STRIDE_ARRAY(ac->Raw.TexCoord[unit], ac->start); + } + else { + ac->Raw.TexCoord[unit] = ac->Fallback.TexCoord[unit]; + + if (ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][3] != 1.0) + ac->Raw.TexCoord[unit].Size = 4; + else if (ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][2] != 0.0) + ac->Raw.TexCoord[unit].Size = 3; + else + ac->Raw.TexCoord[unit].Size = 2; + } + + ac->IsCached.TexCoord[unit] = GL_FALSE; + ac->NewArrayState &= ~_NEW_ARRAY_TEXCOORD(unit); +} + +static void +reset_vertex( GLcontext *ctx ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + ASSERT(ctx->Array.Vertex.Enabled + || (ctx->VertexProgram._Enabled && ctx->Array.VertexAttrib[0].Enabled)); + ac->Raw.Vertex = ctx->Array.Vertex; + STRIDE_ARRAY(ac->Raw.Vertex, ac->start); + ac->IsCached.Vertex = GL_FALSE; + ac->NewArrayState &= ~_NEW_ARRAY_VERTEX; +} + + +static void +reset_normal( GLcontext *ctx ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + if (ctx->Array.Normal.Enabled) { + ac->Raw.Normal = ctx->Array.Normal; + STRIDE_ARRAY(ac->Raw.Normal, ac->start); + } + else { + ac->Raw.Normal = ac->Fallback.Normal; + } + + ac->IsCached.Normal = GL_FALSE; + ac->NewArrayState &= ~_NEW_ARRAY_NORMAL; +} + + +static void +reset_color( GLcontext *ctx ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + if (ctx->Array.Color.Enabled) { + ac->Raw.Color = ctx->Array.Color; + STRIDE_ARRAY(ac->Raw.Color, ac->start); + } + else + ac->Raw.Color = ac->Fallback.Color; + + ac->IsCached.Color = GL_FALSE; + ac->NewArrayState &= ~_NEW_ARRAY_COLOR0; +} + + +static void +reset_secondarycolor( GLcontext *ctx ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + if (ctx->Array.SecondaryColor.Enabled) { + ac->Raw.SecondaryColor = ctx->Array.SecondaryColor; + STRIDE_ARRAY(ac->Raw.SecondaryColor, ac->start); + } + else + ac->Raw.SecondaryColor = ac->Fallback.SecondaryColor; + + ac->IsCached.SecondaryColor = GL_FALSE; + ac->NewArrayState &= ~_NEW_ARRAY_COLOR1; +} + + +static void +reset_index( GLcontext *ctx ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + if (ctx->Array.Index.Enabled) { + ac->Raw.Index = ctx->Array.Index; + STRIDE_ARRAY(ac->Raw.Index, ac->start); + } + else + ac->Raw.Index = ac->Fallback.Index; + + ac->IsCached.Index = GL_FALSE; + ac->NewArrayState &= ~_NEW_ARRAY_INDEX; +} + + +static void +reset_fogcoord( GLcontext *ctx ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + if (ctx->Array.FogCoord.Enabled) { + ac->Raw.FogCoord = ctx->Array.FogCoord; + STRIDE_ARRAY(ac->Raw.FogCoord, ac->start); + } + else + ac->Raw.FogCoord = ac->Fallback.FogCoord; + + ac->IsCached.FogCoord = GL_FALSE; + ac->NewArrayState &= ~_NEW_ARRAY_FOGCOORD; +} + + +static void +reset_edgeflag( GLcontext *ctx ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + if (ctx->Array.EdgeFlag.Enabled) { + ac->Raw.EdgeFlag = ctx->Array.EdgeFlag; + STRIDE_ARRAY(ac->Raw.EdgeFlag, ac->start); + } + else + ac->Raw.EdgeFlag = ac->Fallback.EdgeFlag; + + ac->IsCached.EdgeFlag = GL_FALSE; + ac->NewArrayState &= ~_NEW_ARRAY_EDGEFLAG; +} + + +static void +reset_attrib( GLcontext *ctx, GLuint index ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + if (ctx->Array.VertexAttrib[index].Enabled) { + ac->Raw.Attrib[index] = ctx->Array.VertexAttrib[index]; + STRIDE_ARRAY(ac->Raw.Attrib[index], ac->start); + } + else + ac->Raw.Attrib[index] = ac->Fallback.Attrib[index]; + + ac->IsCached.Attrib[index] = GL_FALSE; + ac->NewArrayState &= ~_NEW_ARRAY_ATTRIB(index); +} + + +/** + * Generic import function for color data + */ +static void +import( const GLcontext *ctx, + GLenum destType, + struct gl_client_array *to, + const struct gl_client_array *from ) +{ + const ACcontext *ac = AC_CONTEXT(ctx); + + if (destType == 0) + destType = from->Type; + + switch (destType) { + case GL_FLOAT: + _math_trans_4fc( (GLfloat (*)[4]) to->Ptr, + from->Ptr, + from->StrideB, + from->Type, + from->Size, + 0, + ac->count - ac->start); + + to->StrideB = 4 * sizeof(GLfloat); + to->Type = GL_FLOAT; + break; + + case GL_UNSIGNED_BYTE: + _math_trans_4ub( (GLubyte (*)[4]) to->Ptr, + from->Ptr, + from->StrideB, + from->Type, + from->Size, + 0, + ac->count - ac->start); + + to->StrideB = 4 * sizeof(GLubyte); + to->Type = GL_UNSIGNED_BYTE; + break; + + case GL_UNSIGNED_SHORT: + _math_trans_4us( (GLushort (*)[4]) to->Ptr, + from->Ptr, + from->StrideB, + from->Type, + from->Size, + 0, + ac->count - ac->start); + + to->StrideB = 4 * sizeof(GLushort); + to->Type = GL_UNSIGNED_SHORT; + break; + + default: + _mesa_problem(ctx, "Unexpected dest format in import()"); + break; + } +} + + + +/* + * Functions to import array ranges with specified types and strides. + * For example, if the vertex data is GLshort[2] and we want GLfloat[3] + * we'll use an import function to do the data conversion. + */ + +static void +import_texcoord( GLcontext *ctx, GLuint unit, GLenum type, GLuint stride ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + const struct gl_client_array *from = &ac->Raw.TexCoord[unit]; + struct gl_client_array *to = &ac->Cache.TexCoord[unit]; + (void) type; (void) stride; + + ASSERT(unit < ctx->Const.MaxTextureCoordUnits); + + /* Limited choices at this stage: + */ + ASSERT(type == GL_FLOAT); + ASSERT(stride == 4*sizeof(GLfloat) || stride == 0); + ASSERT(ac->count - ac->start < ctx->Const.MaxArrayLockSize); + + _math_trans_4f( (GLfloat (*)[4]) to->Ptr, + from->Ptr, + from->StrideB, + from->Type, + from->Size, + 0, + ac->count - ac->start); + + to->Size = from->Size; + to->StrideB = 4 * sizeof(GLfloat); + to->Type = GL_FLOAT; + ac->IsCached.TexCoord[unit] = GL_TRUE; +} + +static void +import_vertex( GLcontext *ctx, GLenum type, GLuint stride ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + const struct gl_client_array *from = &ac->Raw.Vertex; + struct gl_client_array *to = &ac->Cache.Vertex; + (void) type; (void) stride; + + /* Limited choices at this stage: + */ + ASSERT(type == GL_FLOAT); + ASSERT(stride == 4*sizeof(GLfloat) || stride == 0); + + _math_trans_4f( (GLfloat (*)[4]) to->Ptr, + from->Ptr, + from->StrideB, + from->Type, + from->Size, + 0, + ac->count - ac->start); + + to->Size = from->Size; + to->StrideB = 4 * sizeof(GLfloat); + to->Type = GL_FLOAT; + ac->IsCached.Vertex = GL_TRUE; +} + +static void +import_normal( GLcontext *ctx, GLenum type, GLuint stride ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + const struct gl_client_array *from = &ac->Raw.Normal; + struct gl_client_array *to = &ac->Cache.Normal; + (void) type; (void) stride; + + /* Limited choices at this stage: + */ + ASSERT(type == GL_FLOAT); + ASSERT(stride == 3*sizeof(GLfloat) || stride == 0); + + _math_trans_3f( (GLfloat (*)[3]) to->Ptr, + from->Ptr, + from->StrideB, + from->Type, + 0, + ac->count - ac->start); + + to->StrideB = 3 * sizeof(GLfloat); + to->Type = GL_FLOAT; + ac->IsCached.Normal = GL_TRUE; +} + +static void +import_color( GLcontext *ctx, GLenum type, GLuint stride ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + const struct gl_client_array *from = &ac->Raw.Color; + struct gl_client_array *to = &ac->Cache.Color; + (void) stride; + + import( ctx, type, to, from ); + + ac->IsCached.Color = GL_TRUE; +} + +static void +import_index( GLcontext *ctx, GLenum type, GLuint stride ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + const struct gl_client_array *from = &ac->Raw.Index; + struct gl_client_array *to = &ac->Cache.Index; + (void) type; (void) stride; + + /* Limited choices at this stage: + */ + ASSERT(type == GL_UNSIGNED_INT); + ASSERT(stride == sizeof(GLuint) || stride == 0); + + _math_trans_1ui( (GLuint *) to->Ptr, + from->Ptr, + from->StrideB, + from->Type, + 0, + ac->count - ac->start); + + to->StrideB = sizeof(GLuint); + to->Type = GL_UNSIGNED_INT; + ac->IsCached.Index = GL_TRUE; +} + +static void +import_secondarycolor( GLcontext *ctx, GLenum type, GLuint stride ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + const struct gl_client_array *from = &ac->Raw.SecondaryColor; + struct gl_client_array *to = &ac->Cache.SecondaryColor; + (void) stride; + + import( ctx, type, to, from ); + + ac->IsCached.SecondaryColor = GL_TRUE; +} + +static void +import_fogcoord( GLcontext *ctx, GLenum type, GLuint stride ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + const struct gl_client_array *from = &ac->Raw.FogCoord; + struct gl_client_array *to = &ac->Cache.FogCoord; + (void) type; (void) stride; + + /* Limited choices at this stage: + */ + ASSERT(type == GL_FLOAT); + ASSERT(stride == sizeof(GLfloat) || stride == 0); + + _math_trans_1f( (GLfloat *) to->Ptr, + from->Ptr, + from->StrideB, + from->Type, + 0, + ac->count - ac->start); + + to->StrideB = sizeof(GLfloat); + to->Type = GL_FLOAT; + ac->IsCached.FogCoord = GL_TRUE; +} + +static void +import_edgeflag( GLcontext *ctx, GLenum type, GLuint stride ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + const struct gl_client_array *from = &ac->Raw.EdgeFlag; + struct gl_client_array *to = &ac->Cache.EdgeFlag; + (void) type; (void) stride; + + /* Limited choices at this stage: + */ + ASSERT(type == GL_UNSIGNED_BYTE); + ASSERT(stride == sizeof(GLubyte) || stride == 0); + + _math_trans_1ub( (GLubyte *) to->Ptr, + from->Ptr, + from->StrideB, + from->Type, + 0, + ac->count - ac->start); + + to->StrideB = sizeof(GLubyte); + to->Type = GL_UNSIGNED_BYTE; + ac->IsCached.EdgeFlag = GL_TRUE; +} + +static void +import_attrib( GLcontext *ctx, GLuint index, GLenum type, GLuint stride ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + const struct gl_client_array *from = &ac->Raw.Attrib[index]; + struct gl_client_array *to = &ac->Cache.Attrib[index]; + (void) type; (void) stride; + + ASSERT(index < MAX_VERTEX_PROGRAM_ATTRIBS); + + /* Limited choices at this stage: + */ + ASSERT(type == GL_FLOAT); + ASSERT(stride == 4*sizeof(GLfloat) || stride == 0); + ASSERT(ac->count - ac->start < ctx->Const.MaxArrayLockSize); + + _math_trans_4f( (GLfloat (*)[4]) to->Ptr, + from->Ptr, + from->StrideB, + from->Type, + from->Size, + 0, + ac->count - ac->start); + + to->Size = from->Size; + to->StrideB = 4 * sizeof(GLfloat); + to->Type = GL_FLOAT; + ac->IsCached.Attrib[index] = GL_TRUE; +} + + + +/* + * Externals to request arrays with specific properties: + */ + + +struct gl_client_array * +_ac_import_texcoord( GLcontext *ctx, + GLuint unit, + GLenum type, + GLuint reqstride, + GLuint reqsize, + GLboolean reqwriteable, + GLboolean *writeable ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + ASSERT(unit < ctx->Const.MaxTextureCoordUnits); + + /* Can we keep the existing version? + */ + if (ac->NewArrayState & _NEW_ARRAY_TEXCOORD(unit)) + reset_texcoord( ctx, unit ); + + /* Is the request impossible? + */ + if (reqsize != 0 && ac->Raw.TexCoord[unit].Size > (GLint) reqsize) + return NULL; + + /* Do we need to pull in a copy of the client data: + */ + if (ac->Raw.TexCoord[unit].Type != type || + (reqstride != 0 && ac->Raw.TexCoord[unit].StrideB != (GLint)reqstride) || + reqwriteable) + { + if (!ac->IsCached.TexCoord[unit]) + import_texcoord(ctx, unit, type, reqstride ); + *writeable = GL_TRUE; + return &ac->Cache.TexCoord[unit]; + } + else { + *writeable = GL_FALSE; + return &ac->Raw.TexCoord[unit]; + } +} + +struct gl_client_array * +_ac_import_vertex( GLcontext *ctx, + GLenum type, + GLuint reqstride, + GLuint reqsize, + GLboolean reqwriteable, + GLboolean *writeable ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + /* Can we keep the existing version? + */ + if (ac->NewArrayState & _NEW_ARRAY_VERTEX) + reset_vertex( ctx ); + + /* Is the request impossible? + */ + if (reqsize != 0 && ac->Raw.Vertex.Size > (GLint) reqsize) + return NULL; + + /* Do we need to pull in a copy of the client data: + */ + if (ac->Raw.Vertex.Type != type || + (reqstride != 0 && ac->Raw.Vertex.StrideB != (GLint) reqstride) || + reqwriteable) + { + if (!ac->IsCached.Vertex) + import_vertex(ctx, type, reqstride ); + *writeable = GL_TRUE; + return &ac->Cache.Vertex; + } + else { + *writeable = GL_FALSE; + return &ac->Raw.Vertex; + } +} + +struct gl_client_array * +_ac_import_normal( GLcontext *ctx, + GLenum type, + GLuint reqstride, + GLboolean reqwriteable, + GLboolean *writeable ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + /* Can we keep the existing version? + */ + if (ac->NewArrayState & _NEW_ARRAY_NORMAL) + reset_normal( ctx ); + + /* Do we need to pull in a copy of the client data: + */ + if (ac->Raw.Normal.Type != type || + (reqstride != 0 && ac->Raw.Normal.StrideB != (GLint) reqstride) || + reqwriteable) + { + if (!ac->IsCached.Normal) + import_normal(ctx, type, reqstride ); + *writeable = GL_TRUE; + return &ac->Cache.Normal; + } + else { + *writeable = GL_FALSE; + return &ac->Raw.Normal; + } +} + +struct gl_client_array * +_ac_import_color( GLcontext *ctx, + GLenum type, + GLuint reqstride, + GLuint reqsize, + GLboolean reqwriteable, + GLboolean *writeable ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + /* Can we keep the existing version? + */ + if (ac->NewArrayState & _NEW_ARRAY_COLOR0) + reset_color( ctx ); + + /* Is the request impossible? + */ + if (reqsize != 0 && ac->Raw.Color.Size > (GLint) reqsize) { + return NULL; + } + + /* Do we need to pull in a copy of the client data: + */ + if ((type != 0 && ac->Raw.Color.Type != type) || + (reqstride != 0 && ac->Raw.Color.StrideB != (GLint) reqstride) || + reqwriteable) + { + if (!ac->IsCached.Color) { + import_color(ctx, type, reqstride ); + } + *writeable = GL_TRUE; + return &ac->Cache.Color; + } + else { + *writeable = GL_FALSE; + return &ac->Raw.Color; + } +} + +struct gl_client_array * +_ac_import_index( GLcontext *ctx, + GLenum type, + GLuint reqstride, + GLboolean reqwriteable, + GLboolean *writeable ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + /* Can we keep the existing version? + */ + if (ac->NewArrayState & _NEW_ARRAY_INDEX) + reset_index( ctx ); + + + /* Do we need to pull in a copy of the client data: + */ + if (ac->Raw.Index.Type != type || + (reqstride != 0 && ac->Raw.Index.StrideB != (GLint) reqstride) || + reqwriteable) + { + if (!ac->IsCached.Index) + import_index(ctx, type, reqstride ); + *writeable = GL_TRUE; + return &ac->Cache.Index; + } + else { + *writeable = GL_FALSE; + return &ac->Raw.Index; + } +} + +struct gl_client_array * +_ac_import_secondarycolor( GLcontext *ctx, + GLenum type, + GLuint reqstride, + GLuint reqsize, + GLboolean reqwriteable, + GLboolean *writeable ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + /* Can we keep the existing version? + */ + if (ac->NewArrayState & _NEW_ARRAY_COLOR1) + reset_secondarycolor( ctx ); + + /* Is the request impossible? + */ + if (reqsize != 0 && ac->Raw.SecondaryColor.Size > (GLint) reqsize) + return NULL; + + /* Do we need to pull in a copy of the client data: + */ + if ((type != 0 && ac->Raw.SecondaryColor.Type != type) || + (reqstride != 0 && ac->Raw.SecondaryColor.StrideB != (GLint)reqstride) || + reqwriteable) + { + if (!ac->IsCached.SecondaryColor) + import_secondarycolor(ctx, type, reqstride ); + *writeable = GL_TRUE; + return &ac->Cache.SecondaryColor; + } + else { + *writeable = GL_FALSE; + return &ac->Raw.SecondaryColor; + } +} + +struct gl_client_array * +_ac_import_fogcoord( GLcontext *ctx, + GLenum type, + GLuint reqstride, + GLboolean reqwriteable, + GLboolean *writeable ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + /* Can we keep the existing version? + */ + if (ac->NewArrayState & _NEW_ARRAY_FOGCOORD) + reset_fogcoord( ctx ); + + /* Do we need to pull in a copy of the client data: + */ + if (ac->Raw.FogCoord.Type != type || + (reqstride != 0 && ac->Raw.FogCoord.StrideB != (GLint) reqstride) || + reqwriteable) + { + if (!ac->IsCached.FogCoord) + import_fogcoord(ctx, type, reqstride ); + *writeable = GL_TRUE; + return &ac->Cache.FogCoord; + } + else { + *writeable = GL_FALSE; + return &ac->Raw.FogCoord; + } +} + +struct gl_client_array * +_ac_import_edgeflag( GLcontext *ctx, + GLenum type, + GLuint reqstride, + GLboolean reqwriteable, + GLboolean *writeable ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + /* Can we keep the existing version? + */ + if (ac->NewArrayState & _NEW_ARRAY_EDGEFLAG) + reset_edgeflag( ctx ); + + /* Do we need to pull in a copy of the client data: + */ + if (ac->Raw.EdgeFlag.Type != type || + (reqstride != 0 && ac->Raw.EdgeFlag.StrideB != (GLint) reqstride) || + reqwriteable) + { + if (!ac->IsCached.EdgeFlag) + import_edgeflag(ctx, type, reqstride ); + *writeable = GL_TRUE; + return &ac->Cache.EdgeFlag; + } + else { + *writeable = GL_FALSE; + return &ac->Raw.EdgeFlag; + } +} + +/* GL_NV_vertex_program */ +struct gl_client_array * +_ac_import_attrib( GLcontext *ctx, + GLuint index, + GLenum type, + GLuint reqstride, + GLuint reqsize, + GLboolean reqwriteable, + GLboolean *writeable ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + ASSERT(index < VERT_ATTRIB_MAX); + + /* Can we keep the existing version? + */ + if (ac->NewArrayState & _NEW_ARRAY_ATTRIB(index)) + reset_attrib( ctx, index ); + + /* Is the request impossible? + */ + if (reqsize != 0 && ac->Raw.Attrib[index].Size > (GLint) reqsize) + return NULL; + + /* Do we need to pull in a copy of the client data: + */ + if (ac->Raw.Attrib[index].Type != type || + (reqstride != 0 && ac->Raw.Attrib[index].StrideB != (GLint)reqstride) || + reqwriteable) + { + if (!ac->IsCached.Attrib[index]) + import_attrib(ctx, index, type, reqstride ); + *writeable = GL_TRUE; + return &ac->Cache.Attrib[index]; + } + else { + *writeable = GL_FALSE; + return &ac->Raw.Attrib[index]; + } +} + + +/* Clients must call this function to validate state and set bounds + * before importing any data: + */ +void +_ac_import_range( GLcontext *ctx, GLuint start, GLuint count ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + if (!ctx->Array.LockCount) { + /* Not locked, discard cached data. Changes to lock + * status are caught via. _ac_invalidate_state(). + */ + ac->NewArrayState = _NEW_ARRAY_ALL; + ac->start = start; + ac->count = count; + } + else { + /* Locked, discard data for any disabled arrays. Require that + * the whole locked range always be dealt with, otherwise hard to + * maintain cached data in the face of clipping. + */ + ac->NewArrayState |= ~ctx->Array._Enabled; + ac->start = ctx->Array.LockFirst; + ac->count = ctx->Array.LockCount; + ASSERT(ac->start == start); /* hmm? */ + ASSERT(ac->count == count); + } +} + + + +/* Additional convienence function for importing the element list + * for glDrawElements() and glDrawRangeElements(). + */ +CONST void * +_ac_import_elements( GLcontext *ctx, + GLenum new_type, + GLuint count, + GLenum old_type, + CONST void *indices ) +{ + ACcontext *ac = AC_CONTEXT(ctx); + + if (old_type == new_type) + return indices; + + if (ac->elt_size < count * sizeof(GLuint)) { + if (ac->Elts) FREE(ac->Elts); + while (ac->elt_size < count * sizeof(GLuint)) + ac->elt_size *= 2; + ac->Elts = (GLuint *) MALLOC(ac->elt_size); + } + + switch (new_type) { + case GL_UNSIGNED_BYTE: + ASSERT(0); + return NULL; + case GL_UNSIGNED_SHORT: + ASSERT(0); + return NULL; + case GL_UNSIGNED_INT: { + GLuint *out = (GLuint *)ac->Elts; + GLuint i; + + switch (old_type) { + case GL_UNSIGNED_BYTE: { + CONST GLubyte *in = (CONST GLubyte *)indices; + for (i = 0 ; i < count ; i++) + out[i] = in[i]; + break; + } + case GL_UNSIGNED_SHORT: { + CONST GLushort *in = (CONST GLushort *)indices; + for (i = 0 ; i < count ; i++) + out[i] = in[i]; + break; + } + default: + ASSERT(0); + } + + return (CONST void *)out; + } + default: + ASSERT(0); + break; + } + + return NULL; +} diff --git a/nx-X11/extras/Mesa/src/mesa/array_cache/acache.h b/nx-X11/extras/Mesa/src/mesa/array_cache/acache.h new file mode 100644 index 000000000..2bb64f365 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/array_cache/acache.h @@ -0,0 +1,132 @@ + +/* + * Mesa 3-D graphics library + * Version: 4.1 + * + * Copyright (C) 1999-2002 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 + */ + +#ifndef _ARRAYCACHE_H +#define _ARRAYCACHE_H + +#include "mtypes.h" + + +extern GLboolean +_ac_CreateContext( GLcontext *ctx ); + +extern void +_ac_DestroyContext( GLcontext *ctx ); + +extern void +_ac_InvalidateState( GLcontext *ctx, GLuint new_state ); + +extern struct gl_client_array * +_ac_import_vertex( GLcontext *ctx, + GLenum type, + GLuint reqstride, + GLuint reqsize, + GLboolean reqwritable, + GLboolean *writable ); + +extern struct gl_client_array * +_ac_import_normal( GLcontext *ctx, + GLenum type, + GLuint reqstride, + GLboolean reqwritable, + GLboolean *writable ); + +extern struct gl_client_array * +_ac_import_color( GLcontext *ctx, + GLenum type, + GLuint reqstride, + GLuint reqsize, + GLboolean reqwritable, + GLboolean *writable ); + +extern struct gl_client_array * +_ac_import_index( GLcontext *ctx, + GLenum type, + GLuint reqstride, + GLboolean reqwritable, + GLboolean *writable ); + +extern struct gl_client_array * +_ac_import_secondarycolor( GLcontext *ctx, + GLenum type, + GLuint reqstride, + GLuint reqsize, + GLboolean reqwritable, + GLboolean *writable ); + +extern struct gl_client_array * +_ac_import_fogcoord( GLcontext *ctx, + GLenum type, + GLuint reqstride, + GLboolean reqwritable, + GLboolean *writable ); + +extern struct gl_client_array * +_ac_import_edgeflag( GLcontext *ctx, + GLenum type, + GLuint reqstride, + GLboolean reqwritable, + GLboolean *writable ); + +extern struct gl_client_array * +_ac_import_texcoord( GLcontext *ctx, + GLuint unit, + GLenum type, + GLuint reqstride, + GLuint reqsize, + GLboolean reqwritable, + GLboolean *writable ); + +extern struct gl_client_array * +_ac_import_attrib( GLcontext *ctx, + GLuint index, + GLenum type, + GLuint reqstride, + GLuint reqsize, + GLboolean reqwritable, + GLboolean *writable ); + + +/* Clients must call this function to validate state and set bounds + * before importing any data: + */ +extern void +_ac_import_range( GLcontext *ctx, GLuint start, GLuint count ); + + +/* Additional convenience function: + */ +extern CONST void * +_ac_import_elements( GLcontext *ctx, + GLenum new_type, + GLuint count, + GLenum old_type, + CONST void *indices ); + + +#endif diff --git a/nx-X11/extras/Mesa/src/mesa/array_cache/descrip.mms b/nx-X11/extras/Mesa/src/mesa/array_cache/descrip.mms new file mode 100644 index 000000000..3555f83d8 --- /dev/null +++ b/nx-X11/extras/Mesa/src/mesa/array_cache/descrip.mms @@ -0,0 +1,37 @@ +# Makefile for core library for VMS +# contributed by Jouk Jansen joukj@hrem.stm.tudelft.nl +# Last revision : 16 June 2003 + +.first + define gl [---.include.gl] + define math [-.math] + define array_cache [-.array_cache] + +.include [---]mms-config. + +##### MACROS ##### + +VPATH = RCS + +INCDIR = [---.include],[-.main],[-.glapi] +LIBDIR = [---.lib] +CFLAGS = /include=($(INCDIR),[])/define=(PTHREADS=1)/name=(as_is,short) + +SOURCES = ac_context.c ac_import.c + +OBJECTS = ac_context.obj,ac_import.obj +##### RULES ##### + +VERSION=Mesa V3.4 + +##### TARGETS ##### +# Make the library +$(LIBDIR)$(GL_LIB) : $(OBJECTS) + @ library $(LIBDIR)$(GL_LIB) $(OBJECTS) + +clean : + purge + delete *.obj;* + +ac_context.obj : ac_context.c +ac_import.obj : ac_import.c -- cgit v1.2.3