X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fswrast%2Fs_context.c;h=a63179c05f302b775474556780f28a77ef1c309e;hb=17f1c49b9ad05af4f6482f6fa950e5dcc1a779d1;hp=a4acac233360eb03bb61fd1d494d9a2a5792336d;hpb=c5943d6c1cc4eedbea088bc1f611abc153e90524;p=mesa.git diff --git a/src/mesa/swrast/s_context.c b/src/mesa/swrast/s_context.c index a4acac23336..a63179c05f3 100644 --- a/src/mesa/swrast/s_context.c +++ b/src/mesa/swrast/s_context.c @@ -1,6 +1,5 @@ /* * Mesa 3-D graphics library - * Version: 7.1 * * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. * @@ -17,19 +16,19 @@ * 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. + * THE AUTHORS OR COPYRIGHT HOLDERS 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 - * Brian Paul + * Keith Whitwell Brian Paul */ #include "main/imports.h" #include "main/bufferobj.h" -#include "main/colormac.h" #include "main/mtypes.h" +#include "main/samplerobj.h" #include "main/teximage.h" #include "program/prog_parameter.h" #include "program/prog_statevars.h" @@ -61,7 +60,7 @@ _swrast_update_rasterflags( struct gl_context *ctx ) 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->Scissor.EnableFlags) rasterMask |= CLIP_BIT; if (ctx->Stencil._Enabled) rasterMask |= STENCIL_BIT; for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) { if (!ctx->Color.ColorMask[i][0] || @@ -73,11 +72,11 @@ _swrast_update_rasterflags( struct gl_context *ctx ) } } if (ctx->Color.ColorLogicOpEnabled) rasterMask |= LOGIC_OP_BIT; - if (ctx->Texture._EnabledUnits) rasterMask |= TEXTURE_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) { + if (ctx->Texture._MaxEnabledTexImageUnit >= 0) rasterMask |= TEXTURE_BIT; + if ( ctx->ViewportArray[0].X < 0 + || ctx->ViewportArray[0].X + ctx->ViewportArray[0].Width > (GLfloat) ctx->DrawBuffer->Width + || ctx->ViewportArray[0].Y < 0 + || ctx->ViewportArray[0].Y + ctx->ViewportArray[0].Height > (GLfloat) ctx->DrawBuffer->Height) { rasterMask |= CLIP_BIT; } @@ -105,7 +104,7 @@ _swrast_update_rasterflags( struct gl_context *ctx ) } - if (ctx->FragmentProgram._Current) { + if (_swrast_use_fragment_program(ctx)) { rasterMask |= FRAGPROG_BIT; } @@ -170,7 +169,7 @@ _swrast_update_fog_hint( struct gl_context *ctx ) { SWcontext *swrast = SWRAST_CONTEXT(ctx); swrast->_PreferPixelFog = (!swrast->AllowVertexFog || - ctx->FragmentProgram._Current || + _swrast_use_fragment_program(ctx) || (ctx->Hint.Fog == GL_NICEST && swrast->AllowPixelFog)); } @@ -220,13 +219,14 @@ _swrast_update_deferred_texture(struct gl_context *ctx) swrast->_DeferredTexture = GL_FALSE; } else { + GLboolean use_fprog = _swrast_use_fragment_program(ctx); const struct gl_fragment_program *fprog = ctx->FragmentProgram._Current; - if (fprog && (fprog->Base.OutputsWritten & (1 << FRAG_RESULT_DEPTH))) { + if (use_fprog && (fprog->Base.OutputsWritten & (1 << FRAG_RESULT_DEPTH))) { /* Z comes from fragment program/shader */ swrast->_DeferredTexture = GL_FALSE; } - else if (fprog && fprog->UsesKill) { + else if (use_fprog && fprog->UsesKill) { swrast->_DeferredTexture = GL_FALSE; } else if (ctx->Query.CurrentOcclusionObject) { @@ -249,10 +249,12 @@ _swrast_update_fog_state( struct gl_context *ctx ) SWcontext *swrast = SWRAST_CONTEXT(ctx); const struct gl_fragment_program *fp = ctx->FragmentProgram._Current; - assert((fp == NULL) || (fp->Base.Target == GL_FRAGMENT_PROGRAM_ARB)); + assert(fp == NULL || fp->Base.Target == GL_FRAGMENT_PROGRAM_ARB); + (void) fp; /* silence unused var warning */ /* determine if fog is needed, and if so, which fog mode */ - swrast->_FogEnabled = (fp == NULL && ctx->Fog.Enabled); + swrast->_FogEnabled = (!_swrast_use_fragment_program(ctx) && + ctx->Fog.Enabled); } @@ -263,10 +265,11 @@ _swrast_update_fog_state( struct gl_context *ctx ) static void _swrast_update_fragment_program(struct gl_context *ctx, GLbitfield newState) { - const struct gl_fragment_program *fp = ctx->FragmentProgram._Current; - if (fp) { - _mesa_load_state_parameters(ctx, fp->Base.Parameters); - } + if (!_swrast_use_fragment_program(ctx)) + return; + + _mesa_load_state_parameters(ctx, + ctx->FragmentProgram._Current->Base.Parameters); } @@ -283,8 +286,8 @@ _swrast_update_specular_vertex_add(struct gl_context *ctx) ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR); swrast->SpecularVertexAdd = (separateSpecular - && ctx->Texture._EnabledUnits == 0x0 - && !ctx->FragmentProgram._Current + && ctx->Texture._MaxEnabledTexImageUnit == -1 + && !_swrast_use_fragment_program(ctx) && !ctx->ATIFragmentShader._Enabled); } @@ -307,7 +310,7 @@ _swrast_update_specular_vertex_add(struct gl_context *ctx) _SWRAST_NEW_RASTERMASK| \ _NEW_LIGHT| \ _NEW_FOG | \ - _DD_NEW_SEPARATE_SPECULAR) + _MESA_NEW_SEPARATE_SPECULAR) #define _SWRAST_NEW_LINE (_SWRAST_NEW_DERIVED | \ _NEW_RENDERMODE| \ @@ -316,7 +319,7 @@ _swrast_update_specular_vertex_add(struct gl_context *ctx) _NEW_LIGHT| \ _NEW_FOG| \ _NEW_DEPTH | \ - _DD_NEW_SEPARATE_SPECULAR) + _MESA_NEW_SEPARATE_SPECULAR) #define _SWRAST_NEW_POINT (_SWRAST_NEW_DERIVED | \ _NEW_RENDERMODE | \ @@ -324,7 +327,7 @@ _swrast_update_specular_vertex_add(struct gl_context *ctx) _NEW_TEXTURE | \ _NEW_LIGHT | \ _NEW_FOG | \ - _DD_NEW_SEPARATE_SPECULAR) + _MESA_NEW_SEPARATE_SPECULAR) #define _SWRAST_NEW_TEXTURE_SAMPLE_FUNC _NEW_TEXTURE @@ -348,7 +351,7 @@ _swrast_validate_triangle( struct gl_context *ctx, _swrast_validate_derived( ctx ); swrast->choose_triangle( ctx ); - ASSERT(swrast->Triangle); + assert(swrast->Triangle); if (swrast->SpecularVertexAdd) { /* separate specular color, but no texture */ @@ -370,7 +373,7 @@ _swrast_validate_line( struct gl_context *ctx, const SWvertex *v0, const SWverte _swrast_validate_derived( ctx ); swrast->choose_line( ctx ); - ASSERT(swrast->Line); + assert(swrast->Line); if (swrast->SpecularVertexAdd) { swrast->SpecLine = swrast->Line; @@ -405,7 +408,7 @@ _swrast_validate_point( struct gl_context *ctx, const SWvertex *v0 ) * Called via swrast->BlendFunc. Examine GL state to choose a blending * function, then call it. */ -static void _ASMAPI +static void _swrast_validate_blend_func(struct gl_context *ctx, GLuint n, const GLubyte mask[], GLvoid *src, const GLvoid *dst, GLenum chanType ) @@ -455,7 +458,7 @@ _swrast_invalidate_state( struct gl_context *ctx, GLbitfield new_state ) swrast->BlendFunc = _swrast_validate_blend_func; if (new_state & _SWRAST_NEW_TEXTURE_SAMPLE_FUNC) - for (i = 0 ; i < ctx->Const.MaxTextureImageUnits ; i++) + for (i = 0 ; i < ARRAY_SIZE(swrast->TextureSample); i++) swrast->TextureSample[i] = NULL; } @@ -469,15 +472,15 @@ _swrast_update_texture_samplers(struct gl_context *ctx) if (!swrast) return; /* pipe hack */ - for (u = 0; u < ctx->Const.MaxTextureImageUnits; u++) { + for (u = 0; u < ARRAY_SIZE(swrast->TextureSample); u++) { 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). */ - if (tObj) { - _mesa_update_fetch_functions(tObj); - } - swrast->TextureSample[u] = _swrast_choose_texture_sample_func(ctx, tObj); + _mesa_update_fetch_functions(ctx, u); + swrast->TextureSample[u] = + _swrast_choose_texture_sample_func(ctx, tObj, + _mesa_get_samplerobj(ctx, u)); } } @@ -490,37 +493,38 @@ static void _swrast_update_active_attribs(struct gl_context *ctx) { SWcontext *swrast = SWRAST_CONTEXT(ctx); - GLuint attribsMask; + GLbitfield64 attribsMask; /* * Compute _ActiveAttribsMask = which fragment attributes are needed. */ - if (ctx->FragmentProgram._Current) { + if (_swrast_use_fragment_program(ctx)) { /* fragment program/shader */ attribsMask = ctx->FragmentProgram._Current->Base.InputsRead; - attribsMask &= ~FRAG_BIT_WPOS; /* WPOS is always handled specially */ + attribsMask &= ~VARYING_BIT_POS; /* WPOS is always handled specially */ } else if (ctx->ATIFragmentShader._Enabled) { - attribsMask = ~0; /* XXX fix me */ + attribsMask = VARYING_BIT_COL0 | VARYING_BIT_COL1 | + VARYING_BIT_FOGC | VARYING_BITS_TEX_ANY; } else { /* fixed function */ attribsMask = 0x0; #if CHAN_TYPE == GL_FLOAT - attribsMask |= FRAG_BIT_COL0; + attribsMask |= VARYING_BIT_COL0; #endif if (ctx->Fog.ColorSumEnabled || (ctx->Light.Enabled && ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)) { - attribsMask |= FRAG_BIT_COL1; + attribsMask |= VARYING_BIT_COL1; } if (swrast->_FogEnabled) - attribsMask |= FRAG_BIT_FOGC; + attribsMask |= VARYING_BIT_FOGC; - attribsMask |= (ctx->Texture._EnabledUnits << FRAG_ATTRIB_TEX0); + attribsMask |= (ctx->Texture._EnabledCoordUnits << VARYING_SLOT_TEX0); } swrast->_ActiveAttribMask = attribsMask; @@ -528,11 +532,11 @@ _swrast_update_active_attribs(struct gl_context *ctx) /* Update _ActiveAttribs[] list */ { GLuint i, num = 0; - for (i = 0; i < FRAG_ATTRIB_MAX; i++) { - if (attribsMask & (1 << i)) { + for (i = 0; i < VARYING_SLOT_MAX; i++) { + if (attribsMask & BITFIELD64_BIT(i)) { swrast->_ActiveAttribs[num++] = i; /* how should this attribute be interpolated? */ - if (i == FRAG_ATTRIB_COL0 || i == FRAG_ATTRIB_COL1) + if (i == VARYING_SLOT_COL0 || i == VARYING_SLOT_COL1) swrast->_InterpMode[i] = ctx->Light.ShadeModel; else swrast->_InterpMode[i] = GL_SMOOTH; @@ -595,7 +599,7 @@ _swrast_validate_derived( struct gl_context *ctx ) #define SWRAST_DEBUG 0 -/* Public entrypoints: See also s_accum.c, s_bitmap.c, etc. +/* Public entrypoints: See also s_bitmap.c, etc. */ void _swrast_Quad( struct gl_context *ctx, @@ -714,13 +718,25 @@ GLboolean _swrast_CreateContext( struct gl_context *ctx ) { GLuint i; - SWcontext *swrast = (SWcontext *)CALLOC(sizeof(SWcontext)); + SWcontext *swrast = calloc(1, sizeof(SWcontext)); #ifdef _OPENMP - const GLint maxThreads = omp_get_max_threads(); + const GLuint maxThreads = omp_get_max_threads(); #else - const GLint maxThreads = 1; + const GLuint maxThreads = 1; #endif + assert(ctx->Const.MaxViewportWidth <= SWRAST_MAX_WIDTH); + assert(ctx->Const.MaxViewportHeight <= SWRAST_MAX_WIDTH); + + assert(ctx->Const.MaxRenderbufferSize <= SWRAST_MAX_WIDTH); + + /* make sure largest texture image is <= SWRAST_MAX_WIDTH in size */ + assert((1 << (ctx->Const.MaxTextureLevels - 1)) <= SWRAST_MAX_WIDTH); + assert((1 << (ctx->Const.MaxCubeTextureLevels - 1)) <= SWRAST_MAX_WIDTH); + assert((1 << (ctx->Const.Max3DTextureLevels - 1)) <= SWRAST_MAX_WIDTH); + + assert(PROG_MAX_WIDTH == SWRAST_MAX_WIDTH); + if (SWRAST_DEBUG) { _mesa_debug(ctx, "_swrast_CreateContext\n"); } @@ -747,20 +763,19 @@ _swrast_CreateContext( struct gl_context *ctx ) swrast->AllowVertexFog = GL_TRUE; swrast->AllowPixelFog = GL_TRUE; - /* Optimized Accum buffer */ - swrast->_IntegerAccumMode = GL_FALSE; - swrast->_IntegerAccumScaler = 0.0; + swrast->Driver.SpanRenderStart = _swrast_span_render_start; + swrast->Driver.SpanRenderFinish = _swrast_span_render_finish; - for (i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++) + for (i = 0; i < ARRAY_SIZE(swrast->TextureSample); i++) swrast->TextureSample[i] = NULL; /* SpanArrays is global and shared by all SWspan instances. However, when * using multiple threads, it is necessary to have one SpanArrays instance * per thread. */ - swrast->SpanArrays = (SWspanarrays *) MALLOC(maxThreads * sizeof(SWspanarrays)); + swrast->SpanArrays = malloc(maxThreads * sizeof(SWspanarrays)); if (!swrast->SpanArrays) { - FREE(swrast); + free(swrast); return GL_FALSE; } for(i = 0; i < maxThreads; i++) { @@ -770,7 +785,7 @@ _swrast_CreateContext( struct gl_context *ctx ) #elif CHAN_TYPE == GL_UNSIGNED_SHORT swrast->SpanArrays[i].rgba = swrast->SpanArrays[i].rgba16; #else - swrast->SpanArrays[i].rgba = swrast->SpanArrays[i].attribs[FRAG_ATTRIB_COL0]; + swrast->SpanArrays[i].rgba = swrast->SpanArrays[i].attribs[VARYING_SLOT_COL0]; #endif } @@ -780,23 +795,25 @@ _swrast_CreateContext( struct gl_context *ctx ) swrast->PointSpan.facing = 0; swrast->PointSpan.array = swrast->SpanArrays; - /* TexelBuffer is also global and normally shared by all SWspan instances; - * when running with multiple threads, create one per thread. - */ - swrast->TexelBuffer = (GLfloat *) MALLOC(ctx->Const.MaxTextureImageUnits * maxThreads * - MAX_WIDTH * 4 * sizeof(GLfloat)); - if (!swrast->TexelBuffer) { - FREE(swrast->SpanArrays); - FREE(swrast); - return GL_FALSE; - } - - init_program_native_limits(&ctx->Const.VertexProgram); - init_program_native_limits(&ctx->Const.GeometryProgram); - init_program_native_limits(&ctx->Const.FragmentProgram); + init_program_native_limits(&ctx->Const.Program[MESA_SHADER_VERTEX]); + init_program_native_limits(&ctx->Const.Program[MESA_SHADER_GEOMETRY]); + init_program_native_limits(&ctx->Const.Program[MESA_SHADER_FRAGMENT]); ctx->swrast_context = swrast; + swrast->stencil_temp.buf1 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte)); + swrast->stencil_temp.buf2 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte)); + swrast->stencil_temp.buf3 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte)); + swrast->stencil_temp.buf4 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte)); + + if (!swrast->stencil_temp.buf1 || + !swrast->stencil_temp.buf2 || + !swrast->stencil_temp.buf3 || + !swrast->stencil_temp.buf4) { + _swrast_DestroyContext(ctx); + return GL_FALSE; + } + return GL_TRUE; } @@ -809,11 +826,16 @@ _swrast_DestroyContext( struct gl_context *ctx ) _mesa_debug(ctx, "_swrast_DestroyContext\n"); } - FREE( swrast->SpanArrays ); - if (swrast->ZoomedArrays) - FREE( swrast->ZoomedArrays ); - FREE( swrast->TexelBuffer ); - FREE( swrast ); + free( swrast->SpanArrays ); + free( swrast->ZoomedArrays ); + free( swrast->TexelBuffer ); + + free(swrast->stencil_temp.buf1); + free(swrast->stencil_temp.buf2); + free(swrast->stencil_temp.buf3); + free(swrast->stencil_temp.buf4); + + free( swrast ); ctx->swrast_context = 0; } @@ -848,6 +870,24 @@ _swrast_render_primitive( struct gl_context *ctx, GLenum prim ) } +/** called via swrast->Driver.SpanRenderStart() */ +void +_swrast_span_render_start(struct gl_context *ctx) +{ + _swrast_map_textures(ctx); + _swrast_map_renderbuffers(ctx); +} + + +/** called via swrast->Driver.SpanRenderFinish() */ +void +_swrast_span_render_finish(struct gl_context *ctx) +{ + _swrast_unmap_textures(ctx); + _swrast_unmap_renderbuffers(ctx); +} + + void _swrast_render_start( struct gl_context *ctx ) { @@ -861,10 +901,16 @@ void _swrast_render_finish( struct gl_context *ctx ) { SWcontext *swrast = SWRAST_CONTEXT(ctx); + struct gl_query_object *query = ctx->Query.CurrentOcclusionObject; + + _swrast_flush(ctx); + if (swrast->Driver.SpanRenderFinish) swrast->Driver.SpanRenderFinish( ctx ); - _swrast_flush(ctx); + if (query && (query->Target == GL_ANY_SAMPLES_PASSED || + query->Target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE)) + query->Result = !!query->Result; } @@ -877,18 +923,18 @@ _swrast_print_vertex( struct gl_context *ctx, const SWvertex *v ) if (SWRAST_DEBUG_VERTICES) { _mesa_debug(ctx, "win %f %f %f %f\n", - v->attrib[FRAG_ATTRIB_WPOS][0], - v->attrib[FRAG_ATTRIB_WPOS][1], - v->attrib[FRAG_ATTRIB_WPOS][2], - v->attrib[FRAG_ATTRIB_WPOS][3]); + v->attrib[VARYING_SLOT_POS][0], + v->attrib[VARYING_SLOT_POS][1], + v->attrib[VARYING_SLOT_POS][2], + v->attrib[VARYING_SLOT_POS][3]); for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) - if (ctx->Texture.Unit[i]._ReallyEnabled) + if (ctx->Texture.Unit[i]._Current) _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]); + v->attrib[VARYING_SLOT_TEX0 + i][0], + v->attrib[VARYING_SLOT_TEX0 + i][1], + v->attrib[VARYING_SLOT_TEX0 + i][2], + v->attrib[VARYING_SLOT_TEX0 + i][3]); #if CHAN_TYPE == GL_FLOAT _mesa_debug(ctx, "color %f %f %f %f\n", @@ -898,12 +944,12 @@ _swrast_print_vertex( struct gl_context *ctx, const SWvertex *v ) v->color[0], v->color[1], v->color[2], v->color[3]); #endif _mesa_debug(ctx, "spec %g %g %g %g\n", - v->attrib[FRAG_ATTRIB_COL1][0], - v->attrib[FRAG_ATTRIB_COL1][1], - v->attrib[FRAG_ATTRIB_COL1][2], - v->attrib[FRAG_ATTRIB_COL1][3]); - _mesa_debug(ctx, "fog %f\n", v->attrib[FRAG_ATTRIB_FOGC][0]); - _mesa_debug(ctx, "index %f\n", v->attrib[FRAG_ATTRIB_CI][0]); + v->attrib[VARYING_SLOT_COL1][0], + v->attrib[VARYING_SLOT_COL1][1], + v->attrib[VARYING_SLOT_COL1][2], + v->attrib[VARYING_SLOT_COL1][3]); + _mesa_debug(ctx, "fog %f\n", v->attrib[VARYING_SLOT_FOGC][0]); + _mesa_debug(ctx, "index %f\n", v->attrib[VARYING_SLOT_CI][0]); _mesa_debug(ctx, "pointsize %f\n", v->pointSize); _mesa_debug(ctx, "\n"); }