src/mesa/swrast/s_context.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.3
   4  *
   5  * Copyright (C) 1999-2004  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Keith Whitwell <keith@tungstengraphics.com>
  26  *    Brian Paul
  27  */
  28
  29 #include "imports.h"
  30 #include "bufferobj.h"
  31 #include "context.h"
  32 #include "colormac.h"
  33 #include "mtypes.h"
  34 #include "program.h"
  35 #include "texobj.h"
  36 #include "nvfragprog.h"
  37
  38 #include "swrast.h"
  39 #include "s_blend.h"
  40 #include "s_context.h"
  41 #include "s_lines.h"
  42 #include "s_points.h"
  43 #include "s_span.h"
  44 #include "s_triangle.h"
  45 #include "s_texture.h"
  46
  47
  48 /**
  49  * Recompute the value of swrast->_RasterMask, etc. according to
  50  * the current context.  The _RasterMask field can be easily tested by
  51  * drivers to determine certain basic GL state (does the primitive need
  52  * stenciling, logic-op, fog, etc?).
  53  */
  54 static void
  55 _swrast_update_rasterflags( GLcontext *ctx )
  56 {
  57    GLuint rasterMask = 0;
  58
  59    if (ctx->Color.AlphaEnabled)           rasterMask |= ALPHATEST_BIT;
  60    if (ctx->Color.BlendEnabled)           rasterMask |= BLEND_BIT;
  61    if (ctx->Depth.Test)                   rasterMask |= DEPTH_BIT;
  62    if (ctx->Fog.Enabled)                  rasterMask |= FOG_BIT;
  63    if (ctx->Scissor.Enabled)              rasterMask |= CLIP_BIT;
  64    if (ctx->Stencil.Enabled)              rasterMask |= STENCIL_BIT;
  65    if (ctx->Visual.rgbMode) {
  66       const GLuint colorMask = *((GLuint *) &ctx->Color.ColorMask);
  67       if (colorMask != 0xffffffff)        rasterMask |= MASKING_BIT;
  68       if (ctx->Color._LogicOpEnabled)     rasterMask |= LOGIC_OP_BIT;
  69       if (ctx->Texture._EnabledUnits)     rasterMask |= TEXTURE_BIT;
  70    }
  71    else {
  72       if (ctx->Color.IndexMask != 0xffffffff) rasterMask |= MASKING_BIT;
  73       if (ctx->Color.IndexLogicOpEnabled)     rasterMask |= LOGIC_OP_BIT;
  74    }
  75
  76    if (ctx->DrawBuffer->UseSoftwareAlphaBuffers
  77        && ctx->Color.ColorMask[ACOMP]
  78        && ctx->Color.DrawBuffer != GL_NONE)
  79       rasterMask |= ALPHABUF_BIT;
  80
  81    if (   ctx->Viewport.X < 0
  82        || ctx->Viewport.X + ctx->Viewport.Width > (GLint) ctx->DrawBuffer->Width
  83        || ctx->Viewport.Y < 0
  84        || ctx->Viewport.Y + ctx->Viewport.Height > (GLint) ctx->DrawBuffer->Height) {
  85       rasterMask |= CLIP_BIT;
  86    }
  87
  88    if (ctx->Depth.OcclusionTest || ctx->Occlusion.Active)
  89       rasterMask |= OCCLUSION_BIT;
  90
  91
  92    /* If we're not drawing to exactly one color buffer set the
  93     * MULTI_DRAW_BIT flag.  Also set it if we're drawing to no
  94     * buffers or the RGBA or CI mask disables all writes.
  95     */
  96    if (_mesa_bitcount(ctx->Color._DrawDestMask[0]) != 1) {
  97       /* more than one color buffer designated for writing (or zero buffers) */
  98       rasterMask |= MULTI_DRAW_BIT;
  99    }
 100    else if (ctx->Visual.rgbMode && *((GLuint *) ctx->Color.ColorMask) == 0) {
 101       rasterMask |= MULTI_DRAW_BIT; /* all RGBA channels disabled */
 102    }
 103    else if (!ctx->Visual.rgbMode && ctx->Color.IndexMask==0) {
 104       rasterMask |= MULTI_DRAW_BIT; /* all color index bits disabled */
 105    }
 106
 107    if (ctx->FragmentProgram._Enabled) {
 108       rasterMask |= FRAGPROG_BIT;
 109    }
 110
 111    SWRAST_CONTEXT(ctx)->_RasterMask = rasterMask;
 112 }
 113
 114
 115 /**
 116  * Examine polycon culls tate to compute the _BackfaceSign field.
 117  * _BackfaceSign will be 0 if no culling, -1 if culling back-faces,
 118  * and 1 if culling front-faces.  The Polygon FrontFace state also
 119  * factors in.
 120  */
 121 static void
 122 _swrast_update_polygon( GLcontext *ctx )
 123 {
 124    GLfloat backface_sign = 1;
 125
 126    if (ctx->Polygon.CullFlag) {
 127       backface_sign = 1;
 128       switch(ctx->Polygon.CullFaceMode) {
 129       case GL_BACK:
 130          if(ctx->Polygon.FrontFace==GL_CCW)
 131             backface_sign = -1;
 132          break;
 133       case GL_FRONT:
 134          if(ctx->Polygon.FrontFace!=GL_CCW)
 135             backface_sign = -1;
 136          break;
 137       default:
 138       case GL_FRONT_AND_BACK:
 139          backface_sign = 0;
 140          break;
 141       }
 142    }
 143    else {
 144       backface_sign = 0;
 145    }
 146
 147    SWRAST_CONTEXT(ctx)->_BackfaceSign = backface_sign;
 148 }
 149
 150
 151 /**
 152  * Update the _PreferPixelFog field to indicate if we need to compute
 153  * fog factors per-fragment.
 154  */
 155 static void
 156 _swrast_update_fog_hint( GLcontext *ctx )
 157 {
 158    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 159    swrast->_PreferPixelFog = (!swrast->AllowVertexFog ||
 160                               ctx->FragmentProgram._Enabled ||
 161                               (ctx->Hint.Fog == GL_NICEST &&
 162                                swrast->AllowPixelFog));
 163 }
 164
 165
 166
 167 /**
 168  * Update the swrast->_AnyTextureCombine flag.
 169  */
 170 static void
 171 _swrast_update_texture_env( GLcontext *ctx )
 172 {
 173    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 174    GLuint i;
 175    swrast->_AnyTextureCombine = GL_FALSE;
 176    for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
 177       if (ctx->Texture.Unit[i].EnvMode == GL_COMBINE_EXT ||
 178           ctx->Texture.Unit[i].EnvMode == GL_COMBINE4_NV) {
 179          swrast->_AnyTextureCombine = GL_TRUE;
 180          return;
 181       }
 182    }
 183 }
 184
 185
 186 /**
 187  * Update swrast->_FogColor and swrast->_FogEnable values.
 188  */
 189 static void
 190 _swrast_update_fog_state( GLcontext *ctx )
 191 {
 192    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 193
 194    /* convert fog color to GLchan values */
 195    CLAMPED_FLOAT_TO_CHAN(swrast->_FogColor[RCOMP], ctx->Fog.Color[RCOMP]);
 196    CLAMPED_FLOAT_TO_CHAN(swrast->_FogColor[GCOMP], ctx->Fog.Color[GCOMP]);
 197    CLAMPED_FLOAT_TO_CHAN(swrast->_FogColor[BCOMP], ctx->Fog.Color[BCOMP]);
 198
 199    /* determine if fog is needed, and if so, which fog mode */
 200    swrast->_FogEnabled = GL_FALSE;
 201    if (ctx->FragmentProgram._Enabled) {
 202       if (ctx->FragmentProgram.Current->Base.Target==GL_FRAGMENT_PROGRAM_ARB) {
 203          const struct fragment_program *p
 204             = (struct fragment_program *) ctx->FragmentProgram.Current;
 205          if (p->FogOption != GL_NONE) {
 206             swrast->_FogEnabled = GL_TRUE;
 207             swrast->_FogMode = p->FogOption;
 208          }
 209       }
 210    }
 211    else if (ctx->Fog.Enabled) {
 212       swrast->_FogEnabled = GL_TRUE;
 213       swrast->_FogMode = ctx->Fog.Mode;
 214    }
 215 }
 216
 217
 218 /**
 219  * Update state for running fragment programs.  Basically, load the
 220  * program parameters with current state values.
 221  */
 222 static void
 223 _swrast_update_fragment_program( GLcontext *ctx )
 224 {
 225    if (ctx->FragmentProgram._Enabled) {
 226       struct fragment_program *program = ctx->FragmentProgram.Current;
 227       _mesa_load_state_parameters(ctx, program->Parameters);
 228    }
 229 }
 230
 231
 232
 233 #define _SWRAST_NEW_DERIVED (_SWRAST_NEW_RASTERMASK |   \
 234                              _NEW_TEXTURE |             \
 235                              _NEW_HINT |                \
 236                              _NEW_POLYGON )
 237
 238 /* State referenced by _swrast_choose_triangle, _swrast_choose_line.
 239  */
 240 #define _SWRAST_NEW_TRIANGLE (_SWRAST_NEW_DERIVED |             \
 241                               _NEW_RENDERMODE|                  \
 242                               _NEW_POLYGON|                     \
 243                               _NEW_DEPTH|                       \
 244                               _NEW_STENCIL|                     \
 245                               _NEW_COLOR|                       \
 246                               _NEW_TEXTURE|                     \
 247                               _SWRAST_NEW_RASTERMASK|           \
 248                               _NEW_LIGHT|                       \
 249                               _NEW_FOG |                        \
 250                               _DD_NEW_SEPARATE_SPECULAR)
 251
 252 #define _SWRAST_NEW_LINE (_SWRAST_NEW_DERIVED |         \
 253                           _NEW_RENDERMODE|              \
 254                           _NEW_LINE|                    \
 255                           _NEW_TEXTURE|                 \
 256                           _NEW_LIGHT|                   \
 257                           _NEW_FOG|                     \
 258                           _NEW_DEPTH |                  \
 259                           _DD_NEW_SEPARATE_SPECULAR)
 260
 261 #define _SWRAST_NEW_POINT (_SWRAST_NEW_DERIVED |        \
 262                            _NEW_RENDERMODE |            \
 263                            _NEW_POINT |                 \
 264                            _NEW_TEXTURE |               \
 265                            _NEW_LIGHT |                 \
 266                            _NEW_FOG |                   \
 267                            _DD_NEW_SEPARATE_SPECULAR)
 268
 269 #define _SWRAST_NEW_TEXTURE_SAMPLE_FUNC _NEW_TEXTURE
 270
 271 #define _SWRAST_NEW_TEXTURE_ENV_MODE _NEW_TEXTURE
 272
 273 #define _SWRAST_NEW_BLEND_FUNC _NEW_COLOR
 274
 275
 276
 277 /**
 278  * Stub for swrast->Triangle to select a true triangle function
 279  * after a state change.
 280  */
 281 static void
 282 _swrast_validate_triangle( GLcontext *ctx,
 283                            const SWvertex *v0,
 284                            const SWvertex *v1,
 285                            const SWvertex *v2 )
 286 {
 287    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 288
 289    _swrast_validate_derived( ctx );
 290    swrast->choose_triangle( ctx );
 291
 292    if (ctx->Texture._EnabledUnits == 0
 293        && NEED_SECONDARY_COLOR(ctx)
 294        && !ctx->FragmentProgram._Enabled) {
 295       /* separate specular color, but no texture */
 296       swrast->SpecTriangle = swrast->Triangle;
 297       swrast->Triangle = _swrast_add_spec_terms_triangle;
 298    }
 299
 300    swrast->Triangle( ctx, v0, v1, v2 );
 301 }
 302
 303 /**
 304  * Called via swrast->Line.  Examine current GL state and choose a software
 305  * line routine.  Then call it.
 306  */
 307 static void
 308 _swrast_validate_line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 )
 309 {
 310    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 311
 312    _swrast_validate_derived( ctx );
 313    swrast->choose_line( ctx );
 314
 315    if (ctx->Texture._EnabledUnits == 0
 316        && NEED_SECONDARY_COLOR(ctx)
 317        && !ctx->FragmentProgram._Enabled) {
 318       swrast->SpecLine = swrast->Line;
 319       swrast->Line = _swrast_add_spec_terms_line;
 320    }
 321
 322
 323    swrast->Line( ctx, v0, v1 );
 324 }
 325
 326 /**
 327  * Called via swrast->Point.  Examine current GL state and choose a software
 328  * point routine.  Then call it.
 329  */
 330 static void
 331 _swrast_validate_point( GLcontext *ctx, const SWvertex *v0 )
 332 {
 333    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 334
 335    _swrast_validate_derived( ctx );
 336    swrast->choose_point( ctx );
 337
 338    if (ctx->Texture._EnabledUnits == 0
 339        && NEED_SECONDARY_COLOR(ctx)
 340        && !ctx->FragmentProgram._Enabled) {
 341       swrast->SpecPoint = swrast->Point;
 342       swrast->Point = _swrast_add_spec_terms_point;
 343    }
 344
 345    swrast->Point( ctx, v0 );
 346 }
 347
 348
 349 /**
 350  * Called via swrast->BlendFunc.  Examine GL state to choose a blending
 351  * function, then call it.
 352  */
 353 static void _ASMAPI
 354 _swrast_validate_blend_func( GLcontext *ctx, GLuint n,
 355                              const GLubyte mask[],
 356                              GLchan src[][4],
 357                              CONST GLchan dst[][4] )
 358 {
 359    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 360
 361    _swrast_validate_derived( ctx );
 362    _swrast_choose_blend_func( ctx );
 363
 364    swrast->BlendFunc( ctx, n, mask, src, dst );
 365 }
 366
 367
 368 /**
 369  * Called via the swrast->TextureSample[i] function pointer.
 370  * Basically, given a texture object, an array of texture coords
 371  * and an array of level-of-detail values, return an array of colors.
 372  * In this case, determine the correct texture sampling routine
 373  * (depending on filter mode, texture dimensions, etc) then call the
 374  * sampler routine.
 375  */
 376 static void
 377 _swrast_validate_texture_sample( GLcontext *ctx, GLuint texUnit,
 378                                  const struct gl_texture_object *tObj,
 379                                  GLuint n, const GLfloat texcoords[][4],
 380                                  const GLfloat lambda[], GLchan rgba[][4] )
 381 {
 382    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 383
 384    _swrast_validate_derived( ctx );
 385
 386    /* Compute min/mag filter threshold */
 387    if (tObj && tObj->MinFilter != tObj->MagFilter) {
 388       if (tObj->MagFilter == GL_LINEAR
 389           && (tObj->MinFilter == GL_NEAREST_MIPMAP_NEAREST ||
 390               tObj->MinFilter == GL_NEAREST_MIPMAP_LINEAR)) {
 391          swrast->_MinMagThresh[texUnit] = 0.5F;
 392       }
 393       else {
 394          swrast->_MinMagThresh[texUnit] = 0.0F;
 395       }
 396    }
 397
 398    swrast->TextureSample[texUnit] =
 399       _swrast_choose_texture_sample_func( ctx, tObj );
 400
 401    swrast->TextureSample[texUnit]( ctx, texUnit, tObj, n, texcoords,
 402                                    lambda, rgba );
 403 }
 404
 405
 406 static void
 407 _swrast_sleep( GLcontext *ctx, GLuint new_state )
 408 {
 409    (void) ctx; (void) new_state;
 410 }
 411
 412
 413 static void
 414 _swrast_invalidate_state( GLcontext *ctx, GLuint new_state )
 415 {
 416    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 417    GLuint i;
 418
 419    swrast->NewState |= new_state;
 420
 421    /* After 10 statechanges without any swrast functions being called,
 422     * put the module to sleep.
 423     */
 424    if (++swrast->StateChanges > 10) {
 425       swrast->InvalidateState = _swrast_sleep;
 426       swrast->NewState = ~0;
 427       new_state = ~0;
 428    }
 429
 430    if (new_state & swrast->invalidate_triangle)
 431       swrast->Triangle = _swrast_validate_triangle;
 432
 433    if (new_state & swrast->invalidate_line)
 434       swrast->Line = _swrast_validate_line;
 435
 436    if (new_state & swrast->invalidate_point)
 437       swrast->Point = _swrast_validate_point;
 438
 439    if (new_state & _SWRAST_NEW_BLEND_FUNC)
 440       swrast->BlendFunc = _swrast_validate_blend_func;
 441
 442    if (new_state & _SWRAST_NEW_TEXTURE_SAMPLE_FUNC)
 443       for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
 444          swrast->TextureSample[i] = _swrast_validate_texture_sample;
 445
 446    /* Debug checks */
 447    if (ctx->Visual.rgbMode) {
 448       ASSERT(swrast->Driver.WriteRGBASpan);
 449       ASSERT(swrast->Driver.WriteRGBSpan);
 450       ASSERT(swrast->Driver.WriteMonoRGBASpan);
 451       ASSERT(swrast->Driver.WriteRGBAPixels);
 452       ASSERT(swrast->Driver.WriteMonoRGBAPixels);
 453       ASSERT(swrast->Driver.ReadRGBASpan);
 454       ASSERT(swrast->Driver.ReadRGBAPixels);
 455    }
 456    else {
 457       ASSERT(swrast->Driver.WriteCI32Span);
 458       ASSERT(swrast->Driver.WriteCI8Span);
 459       ASSERT(swrast->Driver.WriteMonoCISpan);
 460       ASSERT(swrast->Driver.WriteCI32Pixels);
 461       ASSERT(swrast->Driver.WriteMonoCIPixels);
 462       ASSERT(swrast->Driver.ReadCI32Span);
 463       ASSERT(swrast->Driver.ReadCI32Pixels);
 464    }
 465 }
 466
 467
 468 void
 469 _swrast_validate_derived( GLcontext *ctx )
 470 {
 471    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 472
 473    if (swrast->NewState) {
 474       if (swrast->NewState & _SWRAST_NEW_RASTERMASK)
 475          _swrast_update_rasterflags( ctx );
 476
 477       if (swrast->NewState & _NEW_POLYGON)
 478          _swrast_update_polygon( ctx );
 479
 480       if (swrast->NewState & (_NEW_HINT | _NEW_PROGRAM))
 481          _swrast_update_fog_hint( ctx );
 482
 483       if (swrast->NewState & _SWRAST_NEW_TEXTURE_ENV_MODE)
 484          _swrast_update_texture_env( ctx );
 485
 486       if (swrast->NewState & (_NEW_FOG | _NEW_PROGRAM))
 487          _swrast_update_fog_state( ctx );
 488
 489       if (swrast->NewState & _NEW_PROGRAM)
 490          _swrast_update_fragment_program( ctx );
 491
 492       swrast->NewState = 0;
 493       swrast->StateChanges = 0;
 494       swrast->InvalidateState = _swrast_invalidate_state;
 495    }
 496 }
 497
 498 #define SWRAST_DEBUG 0
 499
 500 /* Public entrypoints:  See also s_accum.c, s_bitmap.c, etc.
 501  */
 502 void
 503 _swrast_Quad( GLcontext *ctx,
 504               const SWvertex *v0, const SWvertex *v1,
 505               const SWvertex *v2, const SWvertex *v3 )
 506 {
 507    if (SWRAST_DEBUG) {
 508       _mesa_debug(ctx, "_swrast_Quad\n");
 509       _swrast_print_vertex( ctx, v0 );
 510       _swrast_print_vertex( ctx, v1 );
 511       _swrast_print_vertex( ctx, v2 );
 512       _swrast_print_vertex( ctx, v3 );
 513    }
 514    SWRAST_CONTEXT(ctx)->Triangle( ctx, v0, v1, v3 );
 515    SWRAST_CONTEXT(ctx)->Triangle( ctx, v1, v2, v3 );
 516 }
 517
 518 void
 519 _swrast_Triangle( GLcontext *ctx, const SWvertex *v0,
 520                   const SWvertex *v1, const SWvertex *v2 )
 521 {
 522    if (SWRAST_DEBUG) {
 523       _mesa_debug(ctx, "_swrast_Triangle\n");
 524       _swrast_print_vertex( ctx, v0 );
 525       _swrast_print_vertex( ctx, v1 );
 526       _swrast_print_vertex( ctx, v2 );
 527    }
 528    SWRAST_CONTEXT(ctx)->Triangle( ctx, v0, v1, v2 );
 529 }
 530
 531 void
 532 _swrast_Line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 )
 533 {
 534    if (SWRAST_DEBUG) {
 535       _mesa_debug(ctx, "_swrast_Line\n");
 536       _swrast_print_vertex( ctx, v0 );
 537       _swrast_print_vertex( ctx, v1 );
 538    }
 539    SWRAST_CONTEXT(ctx)->Line( ctx, v0, v1 );
 540 }
 541
 542 void
 543 _swrast_Point( GLcontext *ctx, const SWvertex *v0 )
 544 {
 545    if (SWRAST_DEBUG) {
 546       _mesa_debug(ctx, "_swrast_Point\n");
 547       _swrast_print_vertex( ctx, v0 );
 548    }
 549    SWRAST_CONTEXT(ctx)->Point( ctx, v0 );
 550 }
 551
 552 void
 553 _swrast_InvalidateState( GLcontext *ctx, GLuint new_state )
 554 {
 555    if (SWRAST_DEBUG) {
 556       _mesa_debug(ctx, "_swrast_InvalidateState\n");
 557    }
 558    SWRAST_CONTEXT(ctx)->InvalidateState( ctx, new_state );
 559 }
 560
 561 void
 562 _swrast_ResetLineStipple( GLcontext *ctx )
 563 {
 564    if (SWRAST_DEBUG) {
 565       _mesa_debug(ctx, "_swrast_ResetLineStipple\n");
 566    }
 567    SWRAST_CONTEXT(ctx)->StippleCounter = 0;
 568 }
 569
 570 void
 571 _swrast_allow_vertex_fog( GLcontext *ctx, GLboolean value )
 572 {
 573    if (SWRAST_DEBUG) {
 574       _mesa_debug(ctx, "_swrast_allow_vertex_fog %d\n", value);
 575    }
 576    SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );
 577    SWRAST_CONTEXT(ctx)->AllowVertexFog = value;
 578 }
 579
 580 void
 581 _swrast_allow_pixel_fog( GLcontext *ctx, GLboolean value )
 582 {
 583    if (SWRAST_DEBUG) {
 584       _mesa_debug(ctx, "_swrast_allow_pixel_fog %d\n", value);
 585    }
 586    SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );
 587    SWRAST_CONTEXT(ctx)->AllowPixelFog = value;
 588 }
 589
 590
 591 GLboolean
 592 _swrast_CreateContext( GLcontext *ctx )
 593 {
 594    GLuint i;
 595    SWcontext *swrast = (SWcontext *)CALLOC(sizeof(SWcontext));
 596
 597    if (SWRAST_DEBUG) {
 598       _mesa_debug(ctx, "_swrast_CreateContext\n");
 599    }
 600
 601    if (!swrast)
 602       return GL_FALSE;
 603
 604    swrast->NewState = ~0;
 605
 606    swrast->choose_point = _swrast_choose_point;
 607    swrast->choose_line = _swrast_choose_line;
 608    swrast->choose_triangle = _swrast_choose_triangle;
 609
 610    swrast->invalidate_point = _SWRAST_NEW_POINT;
 611    swrast->invalidate_line = _SWRAST_NEW_LINE;
 612    swrast->invalidate_triangle = _SWRAST_NEW_TRIANGLE;
 613
 614    swrast->Point = _swrast_validate_point;
 615    swrast->Line = _swrast_validate_line;
 616    swrast->Triangle = _swrast_validate_triangle;
 617    swrast->InvalidateState = _swrast_sleep;
 618    swrast->BlendFunc = _swrast_validate_blend_func;
 619
 620    swrast->AllowVertexFog = GL_TRUE;
 621    swrast->AllowPixelFog = GL_TRUE;
 622
 623    if (ctx->Visual.doubleBufferMode)
 624       swrast->CurrentBufferBit = DD_BACK_LEFT_BIT;
 625    else
 626       swrast->CurrentBufferBit = DD_FRONT_LEFT_BIT;
 627
 628    /* Optimized Accum buffer */
 629    swrast->_IntegerAccumMode = GL_TRUE;
 630    swrast->_IntegerAccumScaler = 0.0;
 631
 632    for (i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++)
 633       swrast->TextureSample[i] = _swrast_validate_texture_sample;
 634
 635    swrast->SpanArrays = MALLOC_STRUCT(span_arrays);
 636    if (!swrast->SpanArrays) {
 637       FREE(swrast);
 638       return GL_FALSE;
 639    }
 640
 641    /* init point span buffer */
 642    swrast->PointSpan.primitive = GL_POINT;
 643    swrast->PointSpan.start = 0;
 644    swrast->PointSpan.end = 0;
 645    swrast->PointSpan.facing = 0;
 646    swrast->PointSpan.array = swrast->SpanArrays;
 647
 648    assert(ctx->Const.MaxTextureUnits > 0);
 649    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_UNITS);
 650
 651    swrast->TexelBuffer = (GLchan *) MALLOC(ctx->Const.MaxTextureUnits *
 652                                            MAX_WIDTH * 4 * sizeof(GLchan));
 653    if (!swrast->TexelBuffer) {
 654       FREE(swrast->SpanArrays);
 655       FREE(swrast);
 656       return GL_FALSE;
 657    }
 658
 659    ctx->swrast_context = swrast;
 660
 661    return GL_TRUE;
 662 }
 663
 664 void
 665 _swrast_DestroyContext( GLcontext *ctx )
 666 {
 667    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 668
 669    if (SWRAST_DEBUG) {
 670       _mesa_debug(ctx, "_swrast_DestroyContext\n");
 671    }
 672
 673    FREE( swrast->SpanArrays );
 674    FREE( swrast->TexelBuffer );
 675    FREE( swrast );
 676
 677    ctx->swrast_context = 0;
 678 }
 679
 680
 681 struct swrast_device_driver *
 682 _swrast_GetDeviceDriverReference( GLcontext *ctx )
 683 {
 684    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 685    return &swrast->Driver;
 686 }
 687
 688 void
 689 _swrast_flush( GLcontext *ctx )
 690 {
 691    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 692    /* flush any pending fragments from rendering points */
 693    if (swrast->PointSpan.end > 0) {
 694       if (ctx->Visual.rgbMode) {
 695          if (ctx->Texture._EnabledCoordUnits)
 696             _swrast_write_texture_span(ctx, &(swrast->PointSpan));
 697          else
 698             _swrast_write_rgba_span(ctx, &(swrast->PointSpan));
 699       }
 700       else {
 701          _swrast_write_index_span(ctx, &(swrast->PointSpan));
 702       }
 703       swrast->PointSpan.end = 0;
 704    }
 705 }
 706
 707 void
 708 _swrast_render_primitive( GLcontext *ctx, GLenum prim )
 709 {
 710    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 711    if (swrast->Primitive == GL_POINTS && prim != GL_POINTS) {
 712       _swrast_flush(ctx);
 713    }
 714    swrast->Primitive = prim;
 715 }
 716
 717
 718 void
 719 _swrast_render_start( GLcontext *ctx )
 720 {
 721    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 722    if (swrast->Driver.SpanRenderStart)
 723       swrast->Driver.SpanRenderStart( ctx );
 724    swrast->PointSpan.end = 0;
 725 }
 726
 727 void
 728 _swrast_render_finish( GLcontext *ctx )
 729 {
 730    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 731    if (swrast->Driver.SpanRenderFinish)
 732       swrast->Driver.SpanRenderFinish( ctx );
 733
 734    _swrast_flush(ctx);
 735 }
 736
 737
 738 #define SWRAST_DEBUG_VERTICES 0
 739
 740 void
 741 _swrast_print_vertex( GLcontext *ctx, const SWvertex *v )
 742 {
 743    GLuint i;
 744
 745    if (SWRAST_DEBUG_VERTICES) {
 746       _mesa_debug(ctx, "win %f %f %f %f\n",
 747                   v->win[0], v->win[1], v->win[2], v->win[3]);
 748
 749       for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
 750          if (ctx->Texture.Unit[i]._ReallyEnabled)
 751             _mesa_debug(ctx, "texcoord[%d] %f %f %f %f\n", i,
 752                         v->texcoord[i][0], v->texcoord[i][1],
 753                         v->texcoord[i][2], v->texcoord[i][3]);
 754
 755 #if CHAN_TYPE == GL_FLOAT
 756       _mesa_debug(ctx, "color %f %f %f %f\n",
 757                   v->color[0], v->color[1], v->color[2], v->color[3]);
 758       _mesa_debug(ctx, "spec %f %f %f %f\n",
 759                   v->specular[0], v->specular[1],
 760                   v->specular[2], v->specular[3]);
 761 #else
 762       _mesa_debug(ctx, "color %d %d %d %d\n",
 763                   v->color[0], v->color[1], v->color[2], v->color[3]);
 764       _mesa_debug(ctx, "spec %d %d %d %d\n",
 765                   v->specular[0], v->specular[1],
 766                   v->specular[2], v->specular[3]);
 767 #endif
 768       _mesa_debug(ctx, "fog %f\n", v->fog);
 769       _mesa_debug(ctx, "index %d\n", v->index);
 770       _mesa_debug(ctx, "pointsize %f\n", v->pointSize);
 771       _mesa_debug(ctx, "\n");
 772    }
 773 }