-/*\r
- * Mesa 3-D graphics library\r
- * Version: 6.5\r
- *\r
- * Copyright (C) 1999-2005 Brian Paul All Rights Reserved.\r
- *\r
- * Permission is hereby granted, free of charge, to any person obtaining a\r
- * copy of this software and associated documentation files (the "Software"),\r
- * to deal in the Software without restriction, including without limitation\r
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
- * and/or sell copies of the Software, and to permit persons to whom the\r
- * Software is furnished to do so, subject to the following conditions:\r
- *\r
- * The above copyright notice and this permission notice shall be included\r
- * in all copies or substantial portions of the Software.\r
- *\r
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS\r
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\r
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN\r
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
- *\r
- * Authors:\r
- * Keith Whitwell <keith@tungstengraphics.com>\r
- * Brian Paul\r
- */\r
-\r
-#include "imports.h"\r
-#include "bufferobj.h"\r
-#include "context.h"\r
-#include "colormac.h"\r
-#include "mtypes.h"\r
-#include "program.h"\r
-#include "swrast.h"\r
-#include "s_blend.h"\r
-#include "s_context.h"\r
-#include "s_lines.h"\r
-#include "s_points.h"\r
-#include "s_span.h"\r
-#include "s_triangle.h"\r
-#include "s_texfilter.h"\r
-\r
-\r
-/**\r
- * Recompute the value of swrast->_RasterMask, etc. according to\r
- * the current context. The _RasterMask field can be easily tested by\r
- * drivers to determine certain basic GL state (does the primitive need\r
- * stenciling, logic-op, fog, etc?).\r
- */\r
-static void\r
-_swrast_update_rasterflags( GLcontext *ctx )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
- GLbitfield rasterMask = 0;\r
-\r
- if (ctx->Color.AlphaEnabled) rasterMask |= ALPHATEST_BIT;\r
- if (ctx->Color.BlendEnabled) rasterMask |= BLEND_BIT;\r
- if (ctx->Depth.Test) rasterMask |= DEPTH_BIT;\r
- if (swrast->_FogEnabled) rasterMask |= FOG_BIT;\r
- if (ctx->Scissor.Enabled) rasterMask |= CLIP_BIT;\r
- if (ctx->Stencil.Enabled) rasterMask |= STENCIL_BIT;\r
- if (ctx->Visual.rgbMode) {\r
- const GLuint colorMask = *((GLuint *) &ctx->Color.ColorMask);\r
- if (colorMask != 0xffffffff) rasterMask |= MASKING_BIT;\r
- if (ctx->Color._LogicOpEnabled) rasterMask |= LOGIC_OP_BIT;\r
- if (ctx->Texture._EnabledUnits) rasterMask |= TEXTURE_BIT;\r
- }\r
- else {\r
- if (ctx->Color.IndexMask != 0xffffffff) rasterMask |= MASKING_BIT;\r
- if (ctx->Color.IndexLogicOpEnabled) rasterMask |= LOGIC_OP_BIT;\r
- }\r
-\r
- if ( ctx->Viewport.X < 0\r
- || ctx->Viewport.X + ctx->Viewport.Width > (GLint) ctx->DrawBuffer->Width\r
- || ctx->Viewport.Y < 0\r
- || ctx->Viewport.Y + ctx->Viewport.Height > (GLint) ctx->DrawBuffer->Height) {\r
- rasterMask |= CLIP_BIT;\r
- }\r
-\r
- if (ctx->Query.CurrentOcclusionObject)\r
- rasterMask |= OCCLUSION_BIT;\r
-\r
-\r
- /* If we're not drawing to exactly one color buffer set the\r
- * MULTI_DRAW_BIT flag. Also set it if we're drawing to no\r
- * buffers or the RGBA or CI mask disables all writes.\r
- */\r
- if (ctx->DrawBuffer->_NumColorDrawBuffers[0] != 1) {\r
- /* more than one color buffer designated for writing (or zero buffers) */\r
- rasterMask |= MULTI_DRAW_BIT;\r
- }\r
- else if (ctx->Visual.rgbMode && *((GLuint *) ctx->Color.ColorMask) == 0) {\r
- rasterMask |= MULTI_DRAW_BIT; /* all RGBA channels disabled */\r
- }\r
- else if (!ctx->Visual.rgbMode && ctx->Color.IndexMask==0) {\r
- rasterMask |= MULTI_DRAW_BIT; /* all color index bits disabled */\r
- }\r
-\r
- if (ctx->FragmentProgram._Active) {\r
- rasterMask |= FRAGPROG_BIT;\r
- }\r
-\r
- if (ctx->ShaderObjects._FragmentShaderPresent) {\r
- rasterMask |= FRAGPROG_BIT;\r
- }\r
-\r
- if (ctx->ATIFragmentShader._Enabled) {\r
- rasterMask |= ATIFRAGSHADER_BIT;\r
- }\r
-\r
-#if CHAN_TYPE == GL_FLOAT\r
- if (ctx->Color.ClampFragmentColor == GL_TRUE) {\r
- rasterMask |= CLAMPING_BIT;\r
- }\r
-#endif\r
-\r
- SWRAST_CONTEXT(ctx)->_RasterMask = rasterMask;\r
-}\r
-\r
-\r
-/**\r
- * Examine polycon culls tate to compute the _BackfaceSign field.\r
- * _BackfaceSign will be 0 if no culling, -1 if culling back-faces,\r
- * and 1 if culling front-faces. The Polygon FrontFace state also\r
- * factors in.\r
- */\r
-static void\r
-_swrast_update_polygon( GLcontext *ctx )\r
-{\r
- GLfloat backface_sign = 1;\r
-\r
- if (ctx->Polygon.CullFlag) {\r
- backface_sign = 1;\r
- switch(ctx->Polygon.CullFaceMode) {\r
- case GL_BACK:\r
- if(ctx->Polygon.FrontFace==GL_CCW)\r
- backface_sign = -1;\r
- break;\r
- case GL_FRONT:\r
- if(ctx->Polygon.FrontFace!=GL_CCW)\r
- backface_sign = -1;\r
- break;\r
- default:\r
- case GL_FRONT_AND_BACK:\r
- backface_sign = 0;\r
- break;\r
- }\r
- }\r
- else {\r
- backface_sign = 0;\r
- }\r
-\r
- SWRAST_CONTEXT(ctx)->_BackfaceSign = backface_sign;\r
-}\r
-\r
-\r
-/**\r
- * Update the _PreferPixelFog field to indicate if we need to compute\r
- * fog factors per-fragment.\r
- */\r
-static void\r
-_swrast_update_fog_hint( GLcontext *ctx )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
- swrast->_PreferPixelFog = (!swrast->AllowVertexFog ||\r
- ctx->FragmentProgram._Enabled || /* not _Active! */\r
- (ctx->Hint.Fog == GL_NICEST &&\r
- swrast->AllowPixelFog));\r
-}\r
-\r
-\r
-\r
-/**\r
- * Update the swrast->_AnyTextureCombine flag.\r
- */\r
-static void\r
-_swrast_update_texture_env( GLcontext *ctx )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
- GLuint i;\r
- swrast->_AnyTextureCombine = GL_FALSE;\r
- for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {\r
- if (ctx->Texture.Unit[i].EnvMode == GL_COMBINE_EXT ||\r
- ctx->Texture.Unit[i].EnvMode == GL_COMBINE4_NV) {\r
- swrast->_AnyTextureCombine = GL_TRUE;\r
- return;\r
- }\r
- }\r
-}\r
-\r
-\r
-/**\r
- * Update swrast->_FogColor and swrast->_FogEnable values.\r
- */\r
-static void\r
-_swrast_update_fog_state( GLcontext *ctx )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
-\r
- /* convert fog color to GLchan values */\r
- CLAMPED_FLOAT_TO_CHAN(swrast->_FogColor[RCOMP], ctx->Fog.Color[RCOMP]);\r
- CLAMPED_FLOAT_TO_CHAN(swrast->_FogColor[GCOMP], ctx->Fog.Color[GCOMP]);\r
- CLAMPED_FLOAT_TO_CHAN(swrast->_FogColor[BCOMP], ctx->Fog.Color[BCOMP]);\r
-\r
- /* determine if fog is needed, and if so, which fog mode */\r
- swrast->_FogEnabled = GL_FALSE;\r
- if (ctx->FragmentProgram._Active) {\r
- if (ctx->FragmentProgram._Current->Base.Target==GL_FRAGMENT_PROGRAM_ARB) {\r
- const struct fragment_program *p\r
- = (struct fragment_program *) ctx->FragmentProgram._Current;\r
- if (p->FogOption != GL_NONE) {\r
- swrast->_FogEnabled = GL_TRUE;\r
- swrast->_FogMode = p->FogOption;\r
- }\r
- }\r
- }\r
- else if (ctx->Fog.Enabled) {\r
- swrast->_FogEnabled = GL_TRUE;\r
- swrast->_FogMode = ctx->Fog.Mode;\r
- }\r
-}\r
-\r
-\r
-/**\r
- * Update state for running fragment programs. Basically, load the\r
- * program parameters with current state values.\r
- */\r
-static void\r
-_swrast_update_fragment_program( GLcontext *ctx )\r
-{\r
- if (ctx->FragmentProgram._Active) {\r
- struct fragment_program *program = ctx->FragmentProgram._Current;\r
- _mesa_load_state_parameters(ctx, program->Base.Parameters);\r
- }\r
-}\r
-\r
-\r
-\r
-#define _SWRAST_NEW_DERIVED (_SWRAST_NEW_RASTERMASK | \\r
- _NEW_TEXTURE | \\r
- _NEW_HINT | \\r
- _NEW_POLYGON )\r
-\r
-/* State referenced by _swrast_choose_triangle, _swrast_choose_line.\r
- */\r
-#define _SWRAST_NEW_TRIANGLE (_SWRAST_NEW_DERIVED | \\r
- _NEW_RENDERMODE| \\r
- _NEW_POLYGON| \\r
- _NEW_DEPTH| \\r
- _NEW_STENCIL| \\r
- _NEW_COLOR| \\r
- _NEW_TEXTURE| \\r
- _SWRAST_NEW_RASTERMASK| \\r
- _NEW_LIGHT| \\r
- _NEW_FOG | \\r
- _DD_NEW_SEPARATE_SPECULAR)\r
-\r
-#define _SWRAST_NEW_LINE (_SWRAST_NEW_DERIVED | \\r
- _NEW_RENDERMODE| \\r
- _NEW_LINE| \\r
- _NEW_TEXTURE| \\r
- _NEW_LIGHT| \\r
- _NEW_FOG| \\r
- _NEW_DEPTH | \\r
- _DD_NEW_SEPARATE_SPECULAR)\r
-\r
-#define _SWRAST_NEW_POINT (_SWRAST_NEW_DERIVED | \\r
- _NEW_RENDERMODE | \\r
- _NEW_POINT | \\r
- _NEW_TEXTURE | \\r
- _NEW_LIGHT | \\r
- _NEW_FOG | \\r
- _DD_NEW_SEPARATE_SPECULAR)\r
-\r
-#define _SWRAST_NEW_TEXTURE_SAMPLE_FUNC _NEW_TEXTURE\r
-\r
-#define _SWRAST_NEW_TEXTURE_ENV_MODE _NEW_TEXTURE\r
-\r
-#define _SWRAST_NEW_BLEND_FUNC _NEW_COLOR\r
-\r
-\r
-\r
-/**\r
- * Stub for swrast->Triangle to select a true triangle function\r
- * after a state change.\r
- */\r
-static void\r
-_swrast_validate_triangle( GLcontext *ctx,\r
- const SWvertex *v0,\r
- const SWvertex *v1,\r
- const SWvertex *v2 )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
-\r
- _swrast_validate_derived( ctx );\r
- swrast->choose_triangle( ctx );\r
-\r
- if (ctx->Texture._EnabledUnits == 0\r
- && NEED_SECONDARY_COLOR(ctx)\r
- && !ctx->FragmentProgram._Active) {\r
- /* separate specular color, but no texture */\r
- swrast->SpecTriangle = swrast->Triangle;\r
- swrast->Triangle = _swrast_add_spec_terms_triangle;\r
- }\r
-\r
- swrast->Triangle( ctx, v0, v1, v2 );\r
-}\r
-\r
-/**\r
- * Called via swrast->Line. Examine current GL state and choose a software\r
- * line routine. Then call it.\r
- */\r
-static void\r
-_swrast_validate_line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
-\r
- _swrast_validate_derived( ctx );\r
- swrast->choose_line( ctx );\r
-\r
- if (ctx->Texture._EnabledUnits == 0\r
- && NEED_SECONDARY_COLOR(ctx)\r
- && !ctx->FragmentProgram._Active) {\r
- swrast->SpecLine = swrast->Line;\r
- swrast->Line = _swrast_add_spec_terms_line;\r
- }\r
-\r
-\r
- swrast->Line( ctx, v0, v1 );\r
-}\r
-\r
-/**\r
- * Called via swrast->Point. Examine current GL state and choose a software\r
- * point routine. Then call it.\r
- */\r
-static void\r
-_swrast_validate_point( GLcontext *ctx, const SWvertex *v0 )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
-\r
- _swrast_validate_derived( ctx );\r
- swrast->choose_point( ctx );\r
-\r
- if (ctx->Texture._EnabledUnits == 0\r
- && NEED_SECONDARY_COLOR(ctx)\r
- && !ctx->FragmentProgram._Active) {\r
- swrast->SpecPoint = swrast->Point;\r
- swrast->Point = _swrast_add_spec_terms_point;\r
- }\r
-\r
- swrast->Point( ctx, v0 );\r
-}\r
-\r
-\r
-/**\r
- * Called via swrast->BlendFunc. Examine GL state to choose a blending\r
- * function, then call it.\r
- */\r
-static void _ASMAPI\r
-_swrast_validate_blend_func( GLcontext *ctx, GLuint n,\r
- const GLubyte mask[],\r
- GLchan src[][4],\r
- CONST GLchan dst[][4] )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
-\r
- _swrast_validate_derived( ctx );\r
- _swrast_choose_blend_func( ctx );\r
-\r
- swrast->BlendFunc( ctx, n, mask, src, dst );\r
-}\r
-\r
-\r
-static void\r
-_swrast_sleep( GLcontext *ctx, GLbitfield new_state )\r
-{\r
- (void) ctx; (void) new_state;\r
-}\r
-\r
-\r
-static void\r
-_swrast_invalidate_state( GLcontext *ctx, GLbitfield new_state )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
- GLuint i;\r
-\r
- swrast->NewState |= new_state;\r
-\r
- /* After 10 statechanges without any swrast functions being called,\r
- * put the module to sleep.\r
- */\r
- if (++swrast->StateChanges > 10) {\r
- swrast->InvalidateState = _swrast_sleep;\r
- swrast->NewState = ~0;\r
- new_state = ~0;\r
- }\r
-\r
- if (new_state & swrast->InvalidateTriangleMask)\r
- swrast->Triangle = _swrast_validate_triangle;\r
-\r
- if (new_state & swrast->InvalidateLineMask)\r
- swrast->Line = _swrast_validate_line;\r
-\r
- if (new_state & swrast->InvalidatePointMask)\r
- swrast->Point = _swrast_validate_point;\r
-\r
- if (new_state & _SWRAST_NEW_BLEND_FUNC)\r
- swrast->BlendFunc = _swrast_validate_blend_func;\r
-\r
- if (new_state & _SWRAST_NEW_TEXTURE_SAMPLE_FUNC)\r
- for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)\r
- swrast->TextureSample[i] = NULL;\r
-}\r
-\r
-\r
-static void\r
-_swrast_update_texture_samplers(GLcontext *ctx)\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
- GLuint u;\r
-\r
- for (u = 0; u < ctx->Const.MaxTextureImageUnits; u++) {\r
- const struct gl_texture_object *tObj = ctx->Texture.Unit[u]._Current;\r
- if (tObj)\r
- swrast->TextureSample[u] =\r
- _swrast_choose_texture_sample_func(ctx, tObj);\r
- }\r
-}\r
-\r
-\r
-void\r
-_swrast_validate_derived( GLcontext *ctx )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
-\r
- if (swrast->NewState) {\r
- if (swrast->NewState & _SWRAST_NEW_RASTERMASK)\r
- _swrast_update_rasterflags( ctx );\r
-\r
- if (swrast->NewState & _NEW_POLYGON)\r
- _swrast_update_polygon( ctx );\r
-\r
- if (swrast->NewState & (_NEW_HINT | _NEW_PROGRAM))\r
- _swrast_update_fog_hint( ctx );\r
-\r
- if (swrast->NewState & _SWRAST_NEW_TEXTURE_ENV_MODE)\r
- _swrast_update_texture_env( ctx );\r
-\r
- if (swrast->NewState & (_NEW_FOG | _NEW_PROGRAM))\r
- _swrast_update_fog_state( ctx );\r
-\r
- if (swrast->NewState & _NEW_PROGRAM)\r
- _swrast_update_fragment_program( ctx );\r
-\r
- if (swrast->NewState & _NEW_TEXTURE)\r
- _swrast_update_texture_samplers( ctx );\r
-\r
- swrast->NewState = 0;\r
- swrast->StateChanges = 0;\r
- swrast->InvalidateState = _swrast_invalidate_state;\r
- }\r
-}\r
-\r
-#define SWRAST_DEBUG 0\r
-\r
-/* Public entrypoints: See also s_accum.c, s_bitmap.c, etc.\r
- */\r
-void\r
-_swrast_Quad( GLcontext *ctx,\r
- const SWvertex *v0, const SWvertex *v1,\r
- const SWvertex *v2, const SWvertex *v3 )\r
-{\r
- if (SWRAST_DEBUG) {\r
- _mesa_debug(ctx, "_swrast_Quad\n");\r
- _swrast_print_vertex( ctx, v0 );\r
- _swrast_print_vertex( ctx, v1 );\r
- _swrast_print_vertex( ctx, v2 );\r
- _swrast_print_vertex( ctx, v3 );\r
- }\r
- SWRAST_CONTEXT(ctx)->Triangle( ctx, v0, v1, v3 );\r
- SWRAST_CONTEXT(ctx)->Triangle( ctx, v1, v2, v3 );\r
-}\r
-\r
-void\r
-_swrast_Triangle( GLcontext *ctx, const SWvertex *v0,\r
- const SWvertex *v1, const SWvertex *v2 )\r
-{\r
- if (SWRAST_DEBUG) {\r
- _mesa_debug(ctx, "_swrast_Triangle\n");\r
- _swrast_print_vertex( ctx, v0 );\r
- _swrast_print_vertex( ctx, v1 );\r
- _swrast_print_vertex( ctx, v2 );\r
- }\r
- SWRAST_CONTEXT(ctx)->Triangle( ctx, v0, v1, v2 );\r
-}\r
-\r
-void\r
-_swrast_Line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 )\r
-{\r
- if (SWRAST_DEBUG) {\r
- _mesa_debug(ctx, "_swrast_Line\n");\r
- _swrast_print_vertex( ctx, v0 );\r
- _swrast_print_vertex( ctx, v1 );\r
- }\r
- SWRAST_CONTEXT(ctx)->Line( ctx, v0, v1 );\r
-}\r
-\r
-void\r
-_swrast_Point( GLcontext *ctx, const SWvertex *v0 )\r
-{\r
- if (SWRAST_DEBUG) {\r
- _mesa_debug(ctx, "_swrast_Point\n");\r
- _swrast_print_vertex( ctx, v0 );\r
- }\r
- SWRAST_CONTEXT(ctx)->Point( ctx, v0 );\r
-}\r
-\r
-void\r
-_swrast_InvalidateState( GLcontext *ctx, GLbitfield new_state )\r
-{\r
- if (SWRAST_DEBUG) {\r
- _mesa_debug(ctx, "_swrast_InvalidateState\n");\r
- }\r
- SWRAST_CONTEXT(ctx)->InvalidateState( ctx, new_state );\r
-}\r
-\r
-void\r
-_swrast_ResetLineStipple( GLcontext *ctx )\r
-{\r
- if (SWRAST_DEBUG) {\r
- _mesa_debug(ctx, "_swrast_ResetLineStipple\n");\r
- }\r
- SWRAST_CONTEXT(ctx)->StippleCounter = 0;\r
-}\r
-\r
-void\r
-_swrast_allow_vertex_fog( GLcontext *ctx, GLboolean value )\r
-{\r
- if (SWRAST_DEBUG) {\r
- _mesa_debug(ctx, "_swrast_allow_vertex_fog %d\n", value);\r
- }\r
- SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );\r
- SWRAST_CONTEXT(ctx)->AllowVertexFog = value;\r
-}\r
-\r
-void\r
-_swrast_allow_pixel_fog( GLcontext *ctx, GLboolean value )\r
-{\r
- if (SWRAST_DEBUG) {\r
- _mesa_debug(ctx, "_swrast_allow_pixel_fog %d\n", value);\r
- }\r
- SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );\r
- SWRAST_CONTEXT(ctx)->AllowPixelFog = value;\r
-}\r
-\r
-\r
-GLboolean\r
-_swrast_CreateContext( GLcontext *ctx )\r
-{\r
- GLuint i;\r
- SWcontext *swrast = (SWcontext *)CALLOC(sizeof(SWcontext));\r
-\r
- if (SWRAST_DEBUG) {\r
- _mesa_debug(ctx, "_swrast_CreateContext\n");\r
- }\r
-\r
- if (!swrast)\r
- return GL_FALSE;\r
-\r
- swrast->NewState = ~0;\r
-\r
- swrast->choose_point = _swrast_choose_point;\r
- swrast->choose_line = _swrast_choose_line;\r
- swrast->choose_triangle = _swrast_choose_triangle;\r
-\r
- swrast->InvalidatePointMask = _SWRAST_NEW_POINT;\r
- swrast->InvalidateLineMask = _SWRAST_NEW_LINE;\r
- swrast->InvalidateTriangleMask = _SWRAST_NEW_TRIANGLE;\r
-\r
- swrast->Point = _swrast_validate_point;\r
- swrast->Line = _swrast_validate_line;\r
- swrast->Triangle = _swrast_validate_triangle;\r
- swrast->InvalidateState = _swrast_sleep;\r
- swrast->BlendFunc = _swrast_validate_blend_func;\r
-\r
- swrast->AllowVertexFog = GL_TRUE;\r
- swrast->AllowPixelFog = GL_TRUE;\r
-\r
- /* Optimized Accum buffer */\r
- swrast->_IntegerAccumMode = GL_FALSE;\r
- swrast->_IntegerAccumScaler = 0.0;\r
-\r
- for (i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++)\r
- swrast->TextureSample[i] = NULL;\r
-\r
- swrast->SpanArrays = MALLOC_STRUCT(span_arrays);\r
- if (!swrast->SpanArrays) {\r
- FREE(swrast);\r
- return GL_FALSE;\r
- }\r
-\r
- /* init point span buffer */\r
- swrast->PointSpan.primitive = GL_POINT;\r
- swrast->PointSpan.start = 0;\r
- swrast->PointSpan.end = 0;\r
- swrast->PointSpan.facing = 0;\r
- swrast->PointSpan.array = swrast->SpanArrays;\r
-\r
- assert(ctx->Const.MaxTextureUnits > 0);\r
- assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_UNITS);\r
-\r
- swrast->TexelBuffer = (GLchan *) MALLOC(ctx->Const.MaxTextureUnits *\r
- MAX_WIDTH * 4 * sizeof(GLchan));\r
- if (!swrast->TexelBuffer) {\r
- FREE(swrast->SpanArrays);\r
- FREE(swrast);\r
- return GL_FALSE;\r
- }\r
-\r
- ctx->swrast_context = swrast;\r
-\r
- return GL_TRUE;\r
-}\r
-\r
-void\r
-_swrast_DestroyContext( GLcontext *ctx )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
-\r
- if (SWRAST_DEBUG) {\r
- _mesa_debug(ctx, "_swrast_DestroyContext\n");\r
- }\r
-\r
- FREE( swrast->SpanArrays );\r
- FREE( swrast->TexelBuffer );\r
- FREE( swrast );\r
-\r
- ctx->swrast_context = 0;\r
-}\r
-\r
-\r
-struct swrast_device_driver *\r
-_swrast_GetDeviceDriverReference( GLcontext *ctx )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
- return &swrast->Driver;\r
-}\r
-\r
-void\r
-_swrast_flush( GLcontext *ctx )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
- /* flush any pending fragments from rendering points */\r
- if (swrast->PointSpan.end > 0) {\r
- if (ctx->Visual.rgbMode) {\r
- _swrast_write_rgba_span(ctx, &(swrast->PointSpan));\r
- }\r
- else {\r
- _swrast_write_index_span(ctx, &(swrast->PointSpan));\r
- }\r
- swrast->PointSpan.end = 0;\r
- }\r
-}\r
-\r
-void\r
-_swrast_render_primitive( GLcontext *ctx, GLenum prim )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
- if (swrast->Primitive == GL_POINTS && prim != GL_POINTS) {\r
- _swrast_flush(ctx);\r
- }\r
- swrast->Primitive = prim;\r
-}\r
-\r
-\r
-void\r
-_swrast_render_start( GLcontext *ctx )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
- if (swrast->Driver.SpanRenderStart)\r
- swrast->Driver.SpanRenderStart( ctx );\r
- swrast->PointSpan.end = 0;\r
-}\r
- \r
-void\r
-_swrast_render_finish( GLcontext *ctx )\r
-{\r
- SWcontext *swrast = SWRAST_CONTEXT(ctx);\r
- if (swrast->Driver.SpanRenderFinish)\r
- swrast->Driver.SpanRenderFinish( ctx );\r
-\r
- _swrast_flush(ctx);\r
-}\r
-\r
-\r
-#define SWRAST_DEBUG_VERTICES 0\r
-\r
-void\r
-_swrast_print_vertex( GLcontext *ctx, const SWvertex *v )\r
-{\r
- GLuint i;\r
-\r
- if (SWRAST_DEBUG_VERTICES) {\r
- _mesa_debug(ctx, "win %f %f %f %f\n",\r
- v->win[0], v->win[1], v->win[2], v->win[3]);\r
-\r
- for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)\r
- if (ctx->Texture.Unit[i]._ReallyEnabled)\r
- _mesa_debug(ctx, "texcoord[%d] %f %f %f %f\n", i,\r
- v->texcoord[i][0], v->texcoord[i][1],\r
- v->texcoord[i][2], v->texcoord[i][3]);\r
-\r
-#if CHAN_TYPE == GL_FLOAT\r
- _mesa_debug(ctx, "color %f %f %f %f\n",\r
- v->color[0], v->color[1], v->color[2], v->color[3]);\r
- _mesa_debug(ctx, "spec %f %f %f %f\n",\r
- v->specular[0], v->specular[1],\r
- v->specular[2], v->specular[3]);\r
-#else\r
- _mesa_debug(ctx, "color %d %d %d %d\n",\r
- v->color[0], v->color[1], v->color[2], v->color[3]);\r
- _mesa_debug(ctx, "spec %d %d %d %d\n",\r
- v->specular[0], v->specular[1],\r
- v->specular[2], v->specular[3]);\r
-#endif\r
- _mesa_debug(ctx, "fog %f\n", v->fog);\r
- _mesa_debug(ctx, "index %d\n", v->index);\r
- _mesa_debug(ctx, "pointsize %f\n", v->pointSize);\r
- _mesa_debug(ctx, "\n");\r
- }\r
-}\r
+/*
+ * Mesa 3-D graphics library
+ * Version: 6.5.3
+ *
+ * Copyright (C) 1999-2007 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>
+ * Brian Paul
+ */
+
+#include "imports.h"
+#include "bufferobj.h"
+#include "context.h"
+#include "colormac.h"
+#include "mtypes.h"
+#include "prog_statevars.h"
+#include "teximage.h"
+#include "swrast.h"
+#include "s_blend.h"
+#include "s_context.h"
+#include "s_lines.h"
+#include "s_points.h"
+#include "s_span.h"
+#include "s_triangle.h"
+#include "s_texfilter.h"
+
+
+/**
+ * Recompute the value of swrast->_RasterMask, etc. according to
+ * the current context. The _RasterMask field can be easily tested by
+ * drivers to determine certain basic GL state (does the primitive need
+ * stenciling, logic-op, fog, etc?).
+ */
+static void
+_swrast_update_rasterflags( GLcontext *ctx )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ GLbitfield rasterMask = 0;
+
+ if (ctx->Color.AlphaEnabled) rasterMask |= ALPHATEST_BIT;
+ if (ctx->Color.BlendEnabled) rasterMask |= BLEND_BIT;
+ if (ctx->Depth.Test) rasterMask |= DEPTH_BIT;
+ if (swrast->_FogEnabled) rasterMask |= FOG_BIT;
+ if (ctx->Scissor.Enabled) rasterMask |= CLIP_BIT;
+ if (ctx->Stencil.Enabled) rasterMask |= STENCIL_BIT;
+ if (ctx->Visual.rgbMode) {
+ const GLuint colorMask = *((GLuint *) &ctx->Color.ColorMask);
+ if (colorMask != 0xffffffff) rasterMask |= MASKING_BIT;
+ if (ctx->Color._LogicOpEnabled) rasterMask |= LOGIC_OP_BIT;
+ if (ctx->Texture._EnabledUnits) rasterMask |= TEXTURE_BIT;
+ }
+ else {
+ if (ctx->Color.IndexMask != 0xffffffff) rasterMask |= MASKING_BIT;
+ if (ctx->Color.IndexLogicOpEnabled) rasterMask |= LOGIC_OP_BIT;
+ }
+
+ if ( ctx->Viewport.X < 0
+ || ctx->Viewport.X + ctx->Viewport.Width > (GLint) ctx->DrawBuffer->Width
+ || ctx->Viewport.Y < 0
+ || ctx->Viewport.Y + ctx->Viewport.Height > (GLint) ctx->DrawBuffer->Height) {
+ rasterMask |= CLIP_BIT;
+ }
+
+ if (ctx->Query.CurrentOcclusionObject)
+ rasterMask |= OCCLUSION_BIT;
+
+
+ /* If we're not drawing to exactly one color buffer set the
+ * MULTI_DRAW_BIT flag. Also set it if we're drawing to no
+ * buffers or the RGBA or CI mask disables all writes.
+ */
+ if (ctx->DrawBuffer->_NumColorDrawBuffers[0] != 1) {
+ /* more than one color buffer designated for writing (or zero buffers) */
+ rasterMask |= MULTI_DRAW_BIT;
+ }
+ else if (ctx->Visual.rgbMode && *((GLuint *) ctx->Color.ColorMask) == 0) {
+ rasterMask |= MULTI_DRAW_BIT; /* all RGBA channels disabled */
+ }
+ else if (!ctx->Visual.rgbMode && ctx->Color.IndexMask==0) {
+ rasterMask |= MULTI_DRAW_BIT; /* all color index bits disabled */
+ }
+
+ if (ctx->FragmentProgram._Current) {
+ rasterMask |= FRAGPROG_BIT;
+ }
+
+ if (ctx->ATIFragmentShader._Enabled) {
+ rasterMask |= ATIFRAGSHADER_BIT;
+ }
+
+#if CHAN_TYPE == GL_FLOAT
+ if (ctx->Color.ClampFragmentColor == GL_TRUE) {
+ rasterMask |= CLAMPING_BIT;
+ }
+#endif
+
+ SWRAST_CONTEXT(ctx)->_RasterMask = rasterMask;
+}
+
+
+/**
+ * Examine polycon culls tate to compute the _BackfaceSign field.
+ * _BackfaceSign will be 0 if no culling, -1 if culling back-faces,
+ * and 1 if culling front-faces. The Polygon FrontFace state also
+ * factors in.
+ */
+static void
+_swrast_update_polygon( GLcontext *ctx )
+{
+ GLfloat backface_sign;
+
+ if (ctx->Polygon.CullFlag) {
+ backface_sign = 1.0;
+ switch (ctx->Polygon.CullFaceMode) {
+ case GL_BACK:
+ if (ctx->Polygon.FrontFace == GL_CCW)
+ backface_sign = -1.0;
+ break;
+ case GL_FRONT:
+ if (ctx->Polygon.FrontFace != GL_CCW)
+ backface_sign = -1.0;
+ break;
+ case GL_FRONT_AND_BACK:
+ /* fallthrough */
+ default:
+ backface_sign = 0.0;
+ break;
+ }
+ }
+ else {
+ backface_sign = 0.0;
+ }
+
+ SWRAST_CONTEXT(ctx)->_BackfaceSign = backface_sign;
+}
+
+
+/**
+ * Update the _PreferPixelFog field to indicate if we need to compute
+ * fog blend factors (from the fog coords) per-fragment.
+ */
+static void
+_swrast_update_fog_hint( GLcontext *ctx )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ swrast->_PreferPixelFog = (!swrast->AllowVertexFog ||
+ ctx->FragmentProgram._Current ||
+ (ctx->Hint.Fog == GL_NICEST &&
+ swrast->AllowPixelFog));
+}
+
+
+
+/**
+ * Update the swrast->_AnyTextureCombine flag.
+ */
+static void
+_swrast_update_texture_env( GLcontext *ctx )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ GLuint i;
+ swrast->_AnyTextureCombine = GL_FALSE;
+ for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
+ if (ctx->Texture.Unit[i].EnvMode == GL_COMBINE_EXT ||
+ ctx->Texture.Unit[i].EnvMode == GL_COMBINE4_NV) {
+ swrast->_AnyTextureCombine = GL_TRUE;
+ return;
+ }
+ }
+}
+
+
+/**
+ * Update swrast->_FogColor and swrast->_FogEnable values.
+ */
+static void
+_swrast_update_fog_state( GLcontext *ctx )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;
+
+ /* determine if fog is needed, and if so, which fog mode */
+ swrast->_FogEnabled = GL_FALSE;
+ if (fp && fp->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
+ if (fp->FogOption != GL_NONE) {
+ swrast->_FogEnabled = GL_TRUE;
+ swrast->_FogMode = fp->FogOption;
+ }
+ }
+ else if (ctx->Fog.Enabled) {
+ swrast->_FogEnabled = GL_TRUE;
+ swrast->_FogMode = ctx->Fog.Mode;
+ }
+}
+
+
+/**
+ * Update state for running fragment programs. Basically, load the
+ * program parameters with current state values.
+ */
+static void
+_swrast_update_fragment_program(GLcontext *ctx, GLbitfield newState)
+{
+ const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;
+ if (fp) {
+#if 0
+ /* XXX Need a way to trigger the initial loading of parameters
+ * even when there's no recent state changes.
+ */
+ if (fp->Base.Parameters->StateFlags & newState)
+#endif
+ _mesa_load_state_parameters(ctx, fp->Base.Parameters);
+ }
+}
+
+
+
+#define _SWRAST_NEW_DERIVED (_SWRAST_NEW_RASTERMASK | \
+ _NEW_TEXTURE | \
+ _NEW_HINT | \
+ _NEW_POLYGON )
+
+/* State referenced by _swrast_choose_triangle, _swrast_choose_line.
+ */
+#define _SWRAST_NEW_TRIANGLE (_SWRAST_NEW_DERIVED | \
+ _NEW_RENDERMODE| \
+ _NEW_POLYGON| \
+ _NEW_DEPTH| \
+ _NEW_STENCIL| \
+ _NEW_COLOR| \
+ _NEW_TEXTURE| \
+ _SWRAST_NEW_RASTERMASK| \
+ _NEW_LIGHT| \
+ _NEW_FOG | \
+ _DD_NEW_SEPARATE_SPECULAR)
+
+#define _SWRAST_NEW_LINE (_SWRAST_NEW_DERIVED | \
+ _NEW_RENDERMODE| \
+ _NEW_LINE| \
+ _NEW_TEXTURE| \
+ _NEW_LIGHT| \
+ _NEW_FOG| \
+ _NEW_DEPTH | \
+ _DD_NEW_SEPARATE_SPECULAR)
+
+#define _SWRAST_NEW_POINT (_SWRAST_NEW_DERIVED | \
+ _NEW_RENDERMODE | \
+ _NEW_POINT | \
+ _NEW_TEXTURE | \
+ _NEW_LIGHT | \
+ _NEW_FOG | \
+ _DD_NEW_SEPARATE_SPECULAR)
+
+#define _SWRAST_NEW_TEXTURE_SAMPLE_FUNC _NEW_TEXTURE
+
+#define _SWRAST_NEW_TEXTURE_ENV_MODE _NEW_TEXTURE
+
+#define _SWRAST_NEW_BLEND_FUNC _NEW_COLOR
+
+
+
+/**
+ * Stub for swrast->Triangle to select a true triangle function
+ * after a state change.
+ */
+static void
+_swrast_validate_triangle( GLcontext *ctx,
+ const SWvertex *v0,
+ const SWvertex *v1,
+ const SWvertex *v2 )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+ _swrast_validate_derived( ctx );
+ swrast->choose_triangle( ctx );
+ ASSERT(swrast->Triangle);
+
+ if (ctx->Texture._EnabledUnits == 0
+ && NEED_SECONDARY_COLOR(ctx)
+ && !ctx->FragmentProgram._Current) {
+ /* separate specular color, but no texture */
+ swrast->SpecTriangle = swrast->Triangle;
+ swrast->Triangle = _swrast_add_spec_terms_triangle;
+ }
+
+ swrast->Triangle( ctx, v0, v1, v2 );
+}
+
+/**
+ * Called via swrast->Line. Examine current GL state and choose a software
+ * line routine. Then call it.
+ */
+static void
+_swrast_validate_line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+ _swrast_validate_derived( ctx );
+ swrast->choose_line( ctx );
+ ASSERT(swrast->Line);
+
+ if (ctx->Texture._EnabledUnits == 0
+ && NEED_SECONDARY_COLOR(ctx)
+ && !ctx->FragmentProgram._Current) {
+ swrast->SpecLine = swrast->Line;
+ swrast->Line = _swrast_add_spec_terms_line;
+ }
+
+
+ swrast->Line( ctx, v0, v1 );
+}
+
+/**
+ * Called via swrast->Point. Examine current GL state and choose a software
+ * point routine. Then call it.
+ */
+static void
+_swrast_validate_point( GLcontext *ctx, const SWvertex *v0 )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+ _swrast_validate_derived( ctx );
+ swrast->choose_point( ctx );
+
+ if (ctx->Texture._EnabledUnits == 0
+ && NEED_SECONDARY_COLOR(ctx)
+ && !ctx->FragmentProgram._Current) {
+ swrast->SpecPoint = swrast->Point;
+ swrast->Point = _swrast_add_spec_terms_point;
+ }
+
+ swrast->Point( ctx, v0 );
+}
+
+
+/**
+ * Called via swrast->BlendFunc. Examine GL state to choose a blending
+ * function, then call it.
+ */
+static void _ASMAPI
+_swrast_validate_blend_func(GLcontext *ctx, GLuint n, const GLubyte mask[],
+ GLvoid *src, const GLvoid *dst,
+ GLenum chanType )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+ _swrast_validate_derived( ctx ); /* why is this needed? */
+ _swrast_choose_blend_func( ctx, chanType );
+
+ swrast->BlendFunc( ctx, n, mask, src, dst, chanType );
+}
+
+
+/**
+ * Make sure we have texture image data for all the textures we may need
+ * for subsequent rendering.
+ */
+static void
+_swrast_validate_texture_images(GLcontext *ctx)
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ GLuint u;
+
+ if (!swrast->ValidateTextureImage || !ctx->Texture._EnabledUnits) {
+ /* no textures enabled, or no way to validate images! */
+ return;
+ }
+
+ for (u = 0; u < ctx->Const.MaxTextureImageUnits; u++) {
+ if (ctx->Texture.Unit[u]._ReallyEnabled) {
+ struct gl_texture_object *texObj = ctx->Texture.Unit[u]._Current;
+ ASSERT(texObj);
+ if (texObj) {
+ GLuint numFaces = (texObj->Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
+ GLuint face;
+ for (face = 0; face < numFaces; face++) {
+ GLint lvl;
+ for (lvl = texObj->BaseLevel; lvl <= texObj->_MaxLevel; lvl++) {
+ struct gl_texture_image *texImg = texObj->Image[face][lvl];
+ if (texImg && !texImg->Data) {
+ swrast->ValidateTextureImage(ctx, texObj, face, lvl);
+ ASSERT(texObj->Image[face][lvl]->Data);
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+
+/**
+ * Free the texture image data attached to all currently enabled
+ * textures. Meant to be called by device drivers when transitioning
+ * from software to hardware rendering.
+ */
+void
+_swrast_eject_texture_images(GLcontext *ctx)
+{
+ GLuint u;
+
+ if (!ctx->Texture._EnabledUnits) {
+ /* no textures enabled */
+ return;
+ }
+
+ for (u = 0; u < ctx->Const.MaxTextureImageUnits; u++) {
+ if (ctx->Texture.Unit[u]._ReallyEnabled) {
+ struct gl_texture_object *texObj = ctx->Texture.Unit[u]._Current;
+ ASSERT(texObj);
+ if (texObj) {
+ GLuint numFaces = (texObj->Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
+ GLuint face;
+ for (face = 0; face < numFaces; face++) {
+ GLint lvl;
+ for (lvl = texObj->BaseLevel; lvl <= texObj->_MaxLevel; lvl++) {
+ struct gl_texture_image *texImg = texObj->Image[face][lvl];
+ if (texImg && texImg->Data) {
+ _mesa_free_texmemory(texImg->Data);
+ texImg->Data = NULL;
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+
+
+static void
+_swrast_sleep( GLcontext *ctx, GLbitfield new_state )
+{
+ (void) ctx; (void) new_state;
+}
+
+
+static void
+_swrast_invalidate_state( GLcontext *ctx, GLbitfield new_state )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ GLuint i;
+
+ swrast->NewState |= new_state;
+
+ /* After 10 statechanges without any swrast functions being called,
+ * put the module to sleep.
+ */
+ if (++swrast->StateChanges > 10) {
+ swrast->InvalidateState = _swrast_sleep;
+ swrast->NewState = ~0;
+ new_state = ~0;
+ }
+
+ if (new_state & swrast->InvalidateTriangleMask)
+ swrast->Triangle = _swrast_validate_triangle;
+
+ if (new_state & swrast->InvalidateLineMask)
+ swrast->Line = _swrast_validate_line;
+
+ if (new_state & swrast->InvalidatePointMask)
+ swrast->Point = _swrast_validate_point;
+
+ if (new_state & _SWRAST_NEW_BLEND_FUNC)
+ swrast->BlendFunc = _swrast_validate_blend_func;
+
+ if (new_state & _SWRAST_NEW_TEXTURE_SAMPLE_FUNC)
+ for (i = 0 ; i < ctx->Const.MaxTextureImageUnits ; i++)
+ swrast->TextureSample[i] = NULL;
+}
+
+
+void
+_swrast_update_texture_samplers(GLcontext *ctx)
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ GLuint u;
+
+ for (u = 0; u < ctx->Const.MaxTextureImageUnits; u++) {
+ const struct gl_texture_object *tObj = ctx->Texture.Unit[u]._Current;
+ /* Note: If tObj is NULL, the sample function will be a simple
+ * function that just returns opaque black (0,0,0,1).
+ */
+ swrast->TextureSample[u] = _swrast_choose_texture_sample_func(ctx, tObj);
+ }
+}
+
+
+/**
+ * Update swrast->_ActiveAttribs and swrast->_NumActiveAttribs
+ */
+static void
+_swrast_update_fragment_attribs(GLcontext *ctx)
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ GLuint attribsMask;
+
+ if (ctx->FragmentProgram._Current) {
+ attribsMask = ctx->FragmentProgram._Current->Base.InputsRead;
+ }
+ else {
+ GLuint u;
+ attribsMask = 0x0;
+
+#if 0 /* not yet */
+ if (ctx->Depth.Test)
+ attribsMask |= FRAG_BIT_WPOS;
+ if (NEED_SECONDARY_COLOR(ctx))
+ attribsMask |= FRAG_BIT_COL1;
+#endif
+ if (swrast->_FogEnabled)
+ attribsMask |= FRAG_BIT_FOGC;
+
+ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+ if (ctx->Texture.Unit[u]._ReallyEnabled) {
+ attribsMask |= FRAG_BIT_TEX(u);
+ }
+ }
+ }
+
+ /* don't want to interpolate these generic attribs just yet */
+ /* XXX temporary */
+ attribsMask &= ~(FRAG_BIT_WPOS |
+ FRAG_BIT_COL0 |
+ FRAG_BIT_COL1 |
+ FRAG_BIT_FOGC);
+
+ /* Update _ActiveAttribs[] list */
+ {
+ GLuint i, num = 0;
+ for (i = 0; i < FRAG_ATTRIB_MAX; i++) {
+ if (attribsMask & (1 << i))
+ swrast->_ActiveAttribs[num++] = i;
+ }
+ swrast->_NumActiveAttribs = num;
+ }
+}
+
+
+/**
+ * Update the swrast->_ColorOutputsMask which indicates which color
+ * renderbuffers (aka rendertargets) are being written to by the current
+ * fragment program.
+ * We also take glDrawBuffers() into account to skip outputs that are
+ * set to GL_NONE.
+ */
+static void
+_swrast_update_color_outputs(GLcontext *ctx)
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ const struct gl_framebuffer *fb = ctx->DrawBuffer;
+
+ swrast->_ColorOutputsMask = 0;
+ swrast->_NumColorOutputs = 0;
+
+ if (ctx->FragmentProgram._Current) {
+ const GLbitfield outputsWritten
+ = ctx->FragmentProgram._Current->Base.OutputsWritten;
+ GLuint output;
+ for (output = 0; output < ctx->Const.MaxDrawBuffers; output++) {
+ if ((outputsWritten & (1 << (FRAG_RESULT_DATA0 + output)))
+ && (fb->_NumColorDrawBuffers[output] > 0)) {
+ swrast->_ColorOutputsMask |= (1 << output);
+ swrast->_NumColorOutputs = output + 1;
+ }
+ }
+ }
+ if (swrast->_ColorOutputsMask == 0x0) {
+ /* no fragment program, or frag prog didn't write to gl_FragData[] */
+ if (fb->_NumColorDrawBuffers[0] > 0) {
+ swrast->_ColorOutputsMask = 0x1;
+ swrast->_NumColorOutputs = 1;
+ }
+ }
+}
+
+
+void
+_swrast_validate_derived( GLcontext *ctx )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+ if (swrast->NewState) {
+ if (swrast->NewState & _NEW_POLYGON)
+ _swrast_update_polygon( ctx );
+
+ if (swrast->NewState & (_NEW_HINT | _NEW_PROGRAM))
+ _swrast_update_fog_hint( ctx );
+
+ if (swrast->NewState & _SWRAST_NEW_TEXTURE_ENV_MODE)
+ _swrast_update_texture_env( ctx );
+
+ if (swrast->NewState & (_NEW_FOG | _NEW_PROGRAM))
+ _swrast_update_fog_state( ctx );
+
+ if (swrast->NewState & (_NEW_MODELVIEW |
+ _NEW_PROJECTION |
+ _NEW_TEXTURE_MATRIX |
+ _NEW_FOG |
+ _NEW_LIGHT |
+ _NEW_LINE |
+ _NEW_TEXTURE |
+ _NEW_TRANSFORM |
+ _NEW_POINT |
+ _NEW_VIEWPORT |
+ _NEW_PROGRAM))
+ _swrast_update_fragment_program( ctx, swrast->NewState );
+
+ if (swrast->NewState & (_NEW_TEXTURE | _NEW_PROGRAM))
+ _swrast_update_texture_samplers( ctx );
+
+ if (swrast->NewState & (_NEW_TEXTURE | _NEW_PROGRAM))
+ _swrast_validate_texture_images( ctx );
+
+ if (swrast->NewState & _SWRAST_NEW_RASTERMASK)
+ _swrast_update_rasterflags( ctx );
+
+ if (swrast->NewState & (_NEW_DEPTH |
+ _NEW_FOG |
+ _NEW_PROGRAM |
+ _NEW_TEXTURE))
+ _swrast_update_fragment_attribs(ctx);
+
+ if (swrast->NewState & (_NEW_PROGRAM | _NEW_BUFFERS))
+ _swrast_update_color_outputs(ctx);
+
+ swrast->NewState = 0;
+ swrast->StateChanges = 0;
+ swrast->InvalidateState = _swrast_invalidate_state;
+ }
+}
+
+#define SWRAST_DEBUG 0
+
+/* Public entrypoints: See also s_accum.c, s_bitmap.c, etc.
+ */
+void
+_swrast_Quad( GLcontext *ctx,
+ const SWvertex *v0, const SWvertex *v1,
+ const SWvertex *v2, const SWvertex *v3 )
+{
+ if (SWRAST_DEBUG) {
+ _mesa_debug(ctx, "_swrast_Quad\n");
+ _swrast_print_vertex( ctx, v0 );
+ _swrast_print_vertex( ctx, v1 );
+ _swrast_print_vertex( ctx, v2 );
+ _swrast_print_vertex( ctx, v3 );
+ }
+ SWRAST_CONTEXT(ctx)->Triangle( ctx, v0, v1, v3 );
+ SWRAST_CONTEXT(ctx)->Triangle( ctx, v1, v2, v3 );
+}
+
+void
+_swrast_Triangle( GLcontext *ctx, const SWvertex *v0,
+ const SWvertex *v1, const SWvertex *v2 )
+{
+ if (SWRAST_DEBUG) {
+ _mesa_debug(ctx, "_swrast_Triangle\n");
+ _swrast_print_vertex( ctx, v0 );
+ _swrast_print_vertex( ctx, v1 );
+ _swrast_print_vertex( ctx, v2 );
+ }
+ SWRAST_CONTEXT(ctx)->Triangle( ctx, v0, v1, v2 );
+}
+
+void
+_swrast_Line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 )
+{
+ if (SWRAST_DEBUG) {
+ _mesa_debug(ctx, "_swrast_Line\n");
+ _swrast_print_vertex( ctx, v0 );
+ _swrast_print_vertex( ctx, v1 );
+ }
+ SWRAST_CONTEXT(ctx)->Line( ctx, v0, v1 );
+}
+
+void
+_swrast_Point( GLcontext *ctx, const SWvertex *v0 )
+{
+ if (SWRAST_DEBUG) {
+ _mesa_debug(ctx, "_swrast_Point\n");
+ _swrast_print_vertex( ctx, v0 );
+ }
+ SWRAST_CONTEXT(ctx)->Point( ctx, v0 );
+}
+
+void
+_swrast_InvalidateState( GLcontext *ctx, GLbitfield new_state )
+{
+ if (SWRAST_DEBUG) {
+ _mesa_debug(ctx, "_swrast_InvalidateState\n");
+ }
+ SWRAST_CONTEXT(ctx)->InvalidateState( ctx, new_state );
+}
+
+void
+_swrast_ResetLineStipple( GLcontext *ctx )
+{
+ if (SWRAST_DEBUG) {
+ _mesa_debug(ctx, "_swrast_ResetLineStipple\n");
+ }
+ SWRAST_CONTEXT(ctx)->StippleCounter = 0;
+}
+
+void
+_swrast_allow_vertex_fog( GLcontext *ctx, GLboolean value )
+{
+ if (SWRAST_DEBUG) {
+ _mesa_debug(ctx, "_swrast_allow_vertex_fog %d\n", value);
+ }
+ SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );
+ SWRAST_CONTEXT(ctx)->AllowVertexFog = value;
+}
+
+void
+_swrast_allow_pixel_fog( GLcontext *ctx, GLboolean value )
+{
+ if (SWRAST_DEBUG) {
+ _mesa_debug(ctx, "_swrast_allow_pixel_fog %d\n", value);
+ }
+ SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );
+ SWRAST_CONTEXT(ctx)->AllowPixelFog = value;
+}
+
+
+GLboolean
+_swrast_CreateContext( GLcontext *ctx )
+{
+ GLuint i;
+ SWcontext *swrast = (SWcontext *)CALLOC(sizeof(SWcontext));
+
+ if (SWRAST_DEBUG) {
+ _mesa_debug(ctx, "_swrast_CreateContext\n");
+ }
+
+ if (!swrast)
+ return GL_FALSE;
+
+ swrast->NewState = ~0;
+
+ swrast->choose_point = _swrast_choose_point;
+ swrast->choose_line = _swrast_choose_line;
+ swrast->choose_triangle = _swrast_choose_triangle;
+
+ swrast->InvalidatePointMask = _SWRAST_NEW_POINT;
+ swrast->InvalidateLineMask = _SWRAST_NEW_LINE;
+ swrast->InvalidateTriangleMask = _SWRAST_NEW_TRIANGLE;
+
+ swrast->Point = _swrast_validate_point;
+ swrast->Line = _swrast_validate_line;
+ swrast->Triangle = _swrast_validate_triangle;
+ swrast->InvalidateState = _swrast_sleep;
+ swrast->BlendFunc = _swrast_validate_blend_func;
+
+ swrast->AllowVertexFog = GL_TRUE;
+ swrast->AllowPixelFog = GL_TRUE;
+
+ /* Optimized Accum buffer */
+ swrast->_IntegerAccumMode = GL_FALSE;
+ swrast->_IntegerAccumScaler = 0.0;
+
+ for (i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++)
+ swrast->TextureSample[i] = NULL;
+
+ swrast->SpanArrays = MALLOC_STRUCT(sw_span_arrays);
+ if (!swrast->SpanArrays) {
+ FREE(swrast);
+ return GL_FALSE;
+ }
+ swrast->SpanArrays->ChanType = CHAN_TYPE;
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+ swrast->SpanArrays->rgba = swrast->SpanArrays->color.sz1.rgba;
+ swrast->SpanArrays->spec = swrast->SpanArrays->color.sz1.spec;
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+ swrast->SpanArrays->rgba = swrast->SpanArrays->color.sz2.rgba;
+ swrast->SpanArrays->spec = swrast->SpanArrays->color.sz2.spec;
+#else
+ swrast->SpanArrays->rgba = swrast->SpanArrays->attribs[FRAG_ATTRIB_COL0];
+ swrast->SpanArrays->spec = swrast->SpanArrays->attribs[FRAG_ATTRIB_COL1];
+#endif
+
+ /* init point span buffer */
+ swrast->PointSpan.primitive = GL_POINT;
+ swrast->PointSpan.end = 0;
+ swrast->PointSpan.facing = 0;
+ swrast->PointSpan.array = swrast->SpanArrays;
+
+ swrast->TexelBuffer = (GLchan *) MALLOC(ctx->Const.MaxTextureImageUnits *
+ MAX_WIDTH * 4 * sizeof(GLchan));
+ if (!swrast->TexelBuffer) {
+ FREE(swrast->SpanArrays);
+ FREE(swrast);
+ return GL_FALSE;
+ }
+
+ ctx->swrast_context = swrast;
+
+ return GL_TRUE;
+}
+
+void
+_swrast_DestroyContext( GLcontext *ctx )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+ if (SWRAST_DEBUG) {
+ _mesa_debug(ctx, "_swrast_DestroyContext\n");
+ }
+
+ FREE( swrast->SpanArrays );
+ FREE( swrast->TexelBuffer );
+ FREE( swrast );
+
+ ctx->swrast_context = 0;
+}
+
+
+struct swrast_device_driver *
+_swrast_GetDeviceDriverReference( GLcontext *ctx )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ return &swrast->Driver;
+}
+
+void
+_swrast_flush( GLcontext *ctx )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ /* flush any pending fragments from rendering points */
+ if (swrast->PointSpan.end > 0) {
+ if (ctx->Visual.rgbMode) {
+ _swrast_write_rgba_span(ctx, &(swrast->PointSpan));
+ }
+ else {
+ _swrast_write_index_span(ctx, &(swrast->PointSpan));
+ }
+ swrast->PointSpan.end = 0;
+ }
+}
+
+void
+_swrast_render_primitive( GLcontext *ctx, GLenum prim )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ if (swrast->Primitive == GL_POINTS && prim != GL_POINTS) {
+ _swrast_flush(ctx);
+ }
+ swrast->Primitive = prim;
+}
+
+
+void
+_swrast_render_start( GLcontext *ctx )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ if (swrast->Driver.SpanRenderStart)
+ swrast->Driver.SpanRenderStart( ctx );
+ swrast->PointSpan.end = 0;
+}
+
+void
+_swrast_render_finish( GLcontext *ctx )
+{
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ if (swrast->Driver.SpanRenderFinish)
+ swrast->Driver.SpanRenderFinish( ctx );
+
+ _swrast_flush(ctx);
+}
+
+
+#define SWRAST_DEBUG_VERTICES 0
+
+void
+_swrast_print_vertex( GLcontext *ctx, const SWvertex *v )
+{
+ GLuint i;
+
+ if (SWRAST_DEBUG_VERTICES) {
+ _mesa_debug(ctx, "win %f %f %f %f\n",
+ v->win[0], v->win[1], v->win[2], v->win[3]);
+
+ for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++)
+ if (ctx->Texture.Unit[i]._ReallyEnabled)
+ _mesa_debug(ctx, "texcoord[%d] %f %f %f %f\n", i,
+ v->attrib[FRAG_ATTRIB_TEX0 + i][0],
+ v->attrib[FRAG_ATTRIB_TEX0 + i][1],
+ v->attrib[FRAG_ATTRIB_TEX0 + i][2],
+ v->attrib[FRAG_ATTRIB_TEX0 + i][3]);
+
+#if CHAN_TYPE == GL_FLOAT
+ _mesa_debug(ctx, "color %f %f %f %f\n",
+ v->color[0], v->color[1], v->color[2], v->color[3]);
+ _mesa_debug(ctx, "spec %f %f %f %f\n",
+ v->specular[0], v->specular[1],
+ v->specular[2], v->specular[3]);
+#else
+ _mesa_debug(ctx, "color %d %d %d %d\n",
+ v->color[0], v->color[1], v->color[2], v->color[3]);
+ _mesa_debug(ctx, "spec %d %d %d %d\n",
+ v->specular[0], v->specular[1],
+ v->specular[2], v->specular[3]);
+#endif
+ _mesa_debug(ctx, "fog %f\n", v->attrib[FRAG_ATTRIB_FOGC][0]);
+ _mesa_debug(ctx, "index %d\n", v->index);
+ _mesa_debug(ctx, "pointsize %f\n", v->pointSize);
+ _mesa_debug(ctx, "\n");
+ }
+}