X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fswrast%2Fs_context.c;h=fa91f15a8ff7f3e26f117b0eef2484236cbe5634;hb=a670c1280b78e6da3b298b61f623e4c733c6be94;hp=63771d9b0752072beb89b19532209a8490660116;hpb=cab974cf6c2dbfbf5dd5d291e1aae0f8eeb34290;p=mesa.git diff --git a/src/mesa/swrast/s_context.c b/src/mesa/swrast/s_context.c index 63771d9b075..fa91f15a8ff 100644 --- a/src/mesa/swrast/s_context.c +++ b/src/mesa/swrast/s_context.c @@ -1,10 +1,10 @@ -/* $Id: s_context.c,v 1.8 2000/12/26 05:09:32 keithw Exp $ */ +/* $Id: s_context.c,v 1.30 2002/04/19 00:38:27 brianp Exp $ */ /* * Mesa 3-D graphics library - * Version: 3.5 + * Version: 4.1 * - * Copyright (C) 1999 Brian Paul All Rights Reserved. + * 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"), @@ -31,11 +31,10 @@ #include "mtypes.h" #include "mem.h" -#include "s_pb.h" +#include "swrast.h" #include "s_points.h" #include "s_lines.h" #include "s_triangle.h" -#include "s_quads.h" #include "s_blend.h" #include "s_context.h" #include "s_texture.h" @@ -57,9 +56,9 @@ _swrast_update_rasterflags( GLcontext *ctx ) if (ctx->Color.BlendEnabled) RasterMask |= BLEND_BIT; if (ctx->Depth.Test) RasterMask |= DEPTH_BIT; if (ctx->Fog.Enabled) RasterMask |= FOG_BIT; - if (ctx->Scissor.Enabled) RasterMask |= SCISSOR_BIT; + if (ctx->Scissor.Enabled) RasterMask |= CLIP_BIT; if (ctx->Stencil.Enabled) RasterMask |= STENCIL_BIT; - if (ctx->Visual.RGBAflag) { + if (ctx->Visual.rgbMode) { const GLuint colorMask = *((GLuint *) &ctx->Color.ColorMask); if (colorMask != 0xffffffff) RasterMask |= MASKING_BIT; if (ctx->Color.ColorLogicOpEnabled) RasterMask |= LOGIC_OP_BIT; @@ -76,10 +75,10 @@ _swrast_update_rasterflags( GLcontext *ctx ) RasterMask |= ALPHABUF_BIT; if ( ctx->Viewport.X < 0 - || ctx->Viewport.X + ctx->Viewport.Width > ctx->DrawBuffer->Width + || ctx->Viewport.X + ctx->Viewport.Width > (GLint) ctx->DrawBuffer->Width || ctx->Viewport.Y < 0 - || ctx->Viewport.Y + ctx->Viewport.Height > ctx->DrawBuffer->Height) { - RasterMask |= WINCLIP_BIT; + || ctx->Viewport.Y + ctx->Viewport.Height > (GLint) ctx->DrawBuffer->Height) { + RasterMask |= CLIP_BIT; } if (ctx->Depth.OcclusionTest) @@ -96,20 +95,13 @@ _swrast_update_rasterflags( GLcontext *ctx ) else if (ctx->Color.DrawBuffer==GL_NONE) { RasterMask |= MULTI_DRAW_BIT; } - else if (ctx->Visual.RGBAflag && *((GLuint *) ctx->Color.ColorMask) == 0) { + else if (ctx->Visual.rgbMode && *((GLuint *) ctx->Color.ColorMask) == 0) { RasterMask |= MULTI_DRAW_BIT; /* all RGBA channels disabled */ } - else if (!ctx->Visual.RGBAflag && ctx->Color.IndexMask==0) { + else if (!ctx->Visual.rgbMode && ctx->Color.IndexMask==0) { RasterMask |= MULTI_DRAW_BIT; /* all color index bits disabled */ } - if ( ctx->Viewport.X<0 - || ctx->Viewport.X + ctx->Viewport.Width > ctx->DrawBuffer->Width - || ctx->Viewport.Y<0 - || ctx->Viewport.Y + ctx->Viewport.Height > ctx->DrawBuffer->Height) { - RasterMask |= WINCLIP_BIT; - } - SWRAST_CONTEXT(ctx)->_RasterMask = RasterMask; } @@ -153,31 +145,41 @@ _swrast_update_hint( GLcontext *ctx ) swrast->AllowPixelFog)); } -#define _SWRAST_NEW_TRIANGLE (_NEW_RENDERMODE| \ - _NEW_POLYGON| \ - _NEW_DEPTH| \ - _NEW_STENCIL| \ - _NEW_COLOR| \ - _NEW_TEXTURE| \ - _NEW_HINT| \ - _SWRAST_NEW_RASTERMASK| \ - _NEW_LIGHT| \ - _NEW_FOG) - -#define _SWRAST_NEW_LINE (_NEW_RENDERMODE| \ - _NEW_LINE| \ - _NEW_TEXTURE| \ - _NEW_LIGHT| \ - _NEW_FOG| \ - _NEW_DEPTH) - -#define _SWRAST_NEW_POINT (_NEW_RENDERMODE | \ - _NEW_POINT | \ - _NEW_TEXTURE | \ - _NEW_LIGHT | \ - _NEW_FOG) - -#define _SWRAST_NEW_QUAD 0 +#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 @@ -188,19 +190,6 @@ _swrast_update_hint( GLcontext *ctx ) /* Stub for swrast->Triangle to select a true triangle function * after a state change. */ -static void -_swrast_validate_quad( GLcontext *ctx, - const SWvertex *v0, const SWvertex *v1, - const SWvertex *v2, const SWvertex *v3 ) -{ - SWcontext *swrast = SWRAST_CONTEXT(ctx); - - _swrast_validate_derived( ctx ); - swrast->choose_quad( ctx ); - - swrast->Quad( ctx, v0, v1, v2, v3 ); -} - static void _swrast_validate_triangle( GLcontext *ctx, const SWvertex *v0, @@ -212,6 +201,12 @@ _swrast_validate_triangle( GLcontext *ctx, _swrast_validate_derived( ctx ); swrast->choose_triangle( ctx ); + if ((ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) && + !ctx->Texture._ReallyEnabled) { + swrast->SpecTriangle = swrast->Triangle; + swrast->Triangle = _swrast_add_spec_terms_triangle; + } + swrast->Triangle( ctx, v0, v1, v2 ); } @@ -223,6 +218,13 @@ _swrast_validate_line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 ) _swrast_validate_derived( ctx ); swrast->choose_line( ctx ); + if ((ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) && + !ctx->Texture._ReallyEnabled) { + swrast->SpecLine = swrast->Line; + swrast->Line = _swrast_add_spec_terms_line; + } + + swrast->Line( ctx, v0, v1 ); } @@ -234,6 +236,12 @@ _swrast_validate_point( GLcontext *ctx, const SWvertex *v0 ) _swrast_validate_derived( ctx ); swrast->choose_point( ctx ); + if ((ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) && + !ctx->Texture._ReallyEnabled) { + swrast->SpecPoint = swrast->Point; + swrast->Point = _swrast_add_spec_terms_point; + } + swrast->Point( ctx, v0 ); } @@ -255,17 +263,15 @@ _swrast_validate_blend_func( GLcontext *ctx, GLuint n, static void _swrast_validate_texture_sample( GLcontext *ctx, GLuint texUnit, const struct gl_texture_object *tObj, - GLuint n, - const GLfloat s[], const GLfloat t[], - const GLfloat u[], const GLfloat lambda[], - GLchan rgba[][4] ) + GLuint n, GLfloat texcoords[][4], + const GLfloat lambda[], GLchan rgba[][4] ) { SWcontext *swrast = SWRAST_CONTEXT(ctx); _swrast_validate_derived( ctx ); _swrast_choose_texture_sample_func( ctx, texUnit, tObj ); - swrast->TextureSample[texUnit]( ctx, texUnit, tObj, n, s, t, u, + swrast->TextureSample[texUnit]( ctx, texUnit, tObj, n, texcoords, lambda, rgba ); } @@ -302,15 +308,33 @@ _swrast_invalidate_state( GLcontext *ctx, GLuint new_state ) if (new_state & swrast->invalidate_point) swrast->Point = _swrast_validate_point; - if (new_state & swrast->invalidate_quad) - swrast->Quad = _swrast_validate_quad; - 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.MaxTextureUnits ; i++) swrast->TextureSample[i] = _swrast_validate_texture_sample; + + + if (ctx->Visual.rgbMode) { + ASSERT(swrast->Driver.WriteRGBASpan); + ASSERT(swrast->Driver.WriteRGBSpan); + ASSERT(swrast->Driver.WriteMonoRGBASpan); + ASSERT(swrast->Driver.WriteRGBAPixels); + ASSERT(swrast->Driver.WriteMonoRGBAPixels); + ASSERT(swrast->Driver.ReadRGBASpan); + ASSERT(swrast->Driver.ReadRGBAPixels); + } + else { + ASSERT(swrast->Driver.WriteCI32Span); + ASSERT(swrast->Driver.WriteCI8Span); + ASSERT(swrast->Driver.WriteMonoCISpan); + ASSERT(swrast->Driver.WriteCI32Pixels); + ASSERT(swrast->Driver.WriteMonoCIPixels); + ASSERT(swrast->Driver.ReadCI32Span); + ASSERT(swrast->Driver.ReadCI32Pixels); + } + } @@ -325,10 +349,6 @@ _swrast_validate_derived( GLcontext *ctx ) if (swrast->NewState & _SWRAST_NEW_RASTERMASK) _swrast_update_rasterflags( ctx ); - if (swrast->NewState & _NEW_TEXTURE) - swrast->_MultiTextureEnabled = (ctx->Texture._ReallyEnabled & - ~TEXTURE0_ANY); - if (swrast->NewState & _NEW_POLYGON) _swrast_update_polygon( ctx ); @@ -341,7 +361,7 @@ _swrast_validate_derived( GLcontext *ctx ) } } - +#define SWRAST_DEBUG 0 /* Public entrypoints: See also s_accum.c, s_bitmap.c, etc. */ @@ -350,54 +370,75 @@ _swrast_Quad( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1, const SWvertex *v2, const SWvertex *v3 ) { - SWRAST_CONTEXT(ctx)->Quad( ctx, v0, v1, v2, v3 ); + if (SWRAST_DEBUG) { + fprintf(stderr, "_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 ) { -/* fprintf(stderr, "%s\n", __FUNCTION__); */ -/* _swrast_print_vertex( ctx, v0 ); */ -/* _swrast_print_vertex( ctx, v1 ); */ -/* _swrast_print_vertex( ctx, v2 ); */ + if (SWRAST_DEBUG) { + fprintf(stderr, "_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) { + fprintf(stderr, "_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) { + fprintf(stderr, "_swrast_Point\n"); + _swrast_print_vertex( ctx, v0 ); + } SWRAST_CONTEXT(ctx)->Point( ctx, v0 ); } void _swrast_InvalidateState( GLcontext *ctx, GLuint new_state ) { + if (SWRAST_DEBUG) { + fprintf(stderr, "_swrast_InvalidateState\n"); + } SWRAST_CONTEXT(ctx)->InvalidateState( ctx, new_state ); } - -GLuint * -_swrast_get_stipple_counter_ref( GLcontext *ctx ) -{ - return &SWRAST_CONTEXT(ctx)->StippleCounter; -} - void _swrast_ResetLineStipple( GLcontext *ctx ) { + if (SWRAST_DEBUG) { + fprintf(stderr, "_swrast_ResetLineStipple\n"); + } SWRAST_CONTEXT(ctx)->StippleCounter = 0; } void _swrast_allow_vertex_fog( GLcontext *ctx, GLboolean value ) { + if (SWRAST_DEBUG) { + fprintf(stderr, "_swrast_allow_vertex_fog %d\n", value); + } SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT ); SWRAST_CONTEXT(ctx)->AllowVertexFog = value; } @@ -405,6 +446,9 @@ _swrast_allow_vertex_fog( GLcontext *ctx, GLboolean value ) void _swrast_allow_pixel_fog( GLcontext *ctx, GLboolean value ) { + if (SWRAST_DEBUG) { + fprintf(stderr, "_swrast_allow_pixel_fog %d\n", value); + } SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT ); SWRAST_CONTEXT(ctx)->AllowPixelFog = value; } @@ -415,31 +459,27 @@ _swrast_CreateContext( GLcontext *ctx ) { GLuint i; SWcontext *swrast = (SWcontext *)CALLOC(sizeof(SWcontext)); - if (!swrast) - return GL_FALSE; - swrast->PB = gl_alloc_pb(); - if (!swrast->PB) { - FREE(swrast); - return GL_FALSE; + if (SWRAST_DEBUG) { + fprintf(stderr, "_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->choose_quad = _swrast_choose_quad; swrast->invalidate_point = _SWRAST_NEW_POINT; swrast->invalidate_line = _SWRAST_NEW_LINE; swrast->invalidate_triangle = _SWRAST_NEW_TRIANGLE; - swrast->invalidate_quad = _SWRAST_NEW_QUAD; swrast->Point = _swrast_validate_point; swrast->Line = _swrast_validate_line; swrast->Triangle = _swrast_validate_triangle; - swrast->Quad = _swrast_validate_quad; swrast->InvalidateState = _swrast_sleep; swrast->BlendFunc = _swrast_validate_blend_func; @@ -463,32 +503,61 @@ _swrast_DestroyContext( GLcontext *ctx ) { SWcontext *swrast = SWRAST_CONTEXT(ctx); - FREE( swrast->PB ); + if (SWRAST_DEBUG) { + fprintf(stderr, "_swrast_DestroyContext\n"); + } + FREE( swrast ); ctx->swrast_context = 0; } +struct swrast_device_driver * +_swrast_GetDeviceDriverReference( GLcontext *ctx ) +{ + SWcontext *swrast = SWRAST_CONTEXT(ctx); + return &swrast->Driver; +} + +#define SWRAST_DEBUG_VERTICES 0 + void _swrast_print_vertex( GLcontext *ctx, const SWvertex *v ) { GLuint i; - fprintf(stderr, "\n"); - - fprintf(stderr, "win %f %f %f %f\n", - v->win[0], v->win[1], v->win[2], v->win[3]); - - for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) - fprintf(stderr, "texcoord[%d] %f %f %f %f\n", i, - v->texcoord[i][0], v->texcoord[i][1], - v->texcoord[i][2], v->texcoord[i][3]); - - fprintf(stderr, "color %d %d %d %d\n", - v->color[0], v->color[1], v->color[2], v->color[3]); - fprintf(stderr, "spec %d %d %d %d\n", - v->specular[0], v->specular[1], v->specular[2], v->specular[3]); - fprintf(stderr, "fog %f\n", v->fog); - fprintf(stderr, "index %d\n", v->index); - fprintf(stderr, "pointsize %f\n", v->pointSize); + + if (SWRAST_DEBUG_VERTICES) { + fprintf(stderr, "win %f %f %f %f\n", + v->win[0], v->win[1], v->win[2], v->win[3]); + + for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) + if (ctx->Texture.Unit[i]._ReallyEnabled) + fprintf(stderr, "texcoord[%d] %f %f %f %f\n", i, + v->texcoord[i][0], v->texcoord[i][1], + v->texcoord[i][2], v->texcoord[i][3]); + +#if CHAN_TYPE == GL_FLOAT + fprintf(stderr, "color %f %f %f %f\n", + v->color[0], v->color[1], v->color[2], v->color[3]); + fprintf(stderr, "spec %f %f %f %f\n", + v->specular[0], v->specular[1], v->specular[2], v->specular[3]); +#else + fprintf(stderr, "color %d %d %d %d\n", + v->color[0], v->color[1], v->color[2], v->color[3]); + fprintf(stderr, "spec %d %d %d %d\n", + v->specular[0], v->specular[1], v->specular[2], v->specular[3]); +#endif + fprintf(stderr, "fog %f\n", v->fog); + fprintf(stderr, "index %d\n", v->index); + fprintf(stderr, "pointsize %f\n", v->pointSize); + fprintf(stderr, "\n"); + } +} + + +void +_swrast_flush( GLcontext *ctx ) +{ + /* no-op */ }