2 * Mesa 3-D graphics library
4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
25 * Keith Whitwell <keith@tungstengraphics.com> Brian Paul
28 #include "main/imports.h"
29 #include "main/bufferobj.h"
30 #include "main/colormac.h"
31 #include "main/mtypes.h"
32 #include "main/samplerobj.h"
33 #include "main/teximage.h"
34 #include "program/prog_parameter.h"
35 #include "program/prog_statevars.h"
38 #include "s_context.h"
42 #include "s_texfetch.h"
43 #include "s_triangle.h"
44 #include "s_texfilter.h"
48 * Recompute the value of swrast->_RasterMask, etc. according to
49 * the current context. The _RasterMask field can be easily tested by
50 * drivers to determine certain basic GL state (does the primitive need
51 * stenciling, logic-op, fog, etc?).
54 _swrast_update_rasterflags( struct gl_context *ctx )
56 SWcontext *swrast = SWRAST_CONTEXT(ctx);
57 GLbitfield rasterMask = 0;
60 if (ctx->Color.AlphaEnabled) rasterMask |= ALPHATEST_BIT;
61 if (ctx->Color.BlendEnabled) rasterMask |= BLEND_BIT;
62 if (ctx->Depth.Test) rasterMask |= DEPTH_BIT;
63 if (swrast->_FogEnabled) rasterMask |= FOG_BIT;
64 if (ctx->Scissor.Enabled) rasterMask |= CLIP_BIT;
65 if (ctx->Stencil._Enabled) rasterMask |= STENCIL_BIT;
66 for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
67 if (!ctx->Color.ColorMask[i][0] ||
68 !ctx->Color.ColorMask[i][1] ||
69 !ctx->Color.ColorMask[i][2] ||
70 !ctx->Color.ColorMask[i][3]) {
71 rasterMask |= MASKING_BIT;
75 if (ctx->Color.ColorLogicOpEnabled) rasterMask |= LOGIC_OP_BIT;
76 if (ctx->Texture._EnabledUnits) rasterMask |= TEXTURE_BIT;
77 if ( ctx->Viewport.X < 0
78 || ctx->Viewport.X + ctx->Viewport.Width > (GLint) ctx->DrawBuffer->Width
79 || ctx->Viewport.Y < 0
80 || ctx->Viewport.Y + ctx->Viewport.Height > (GLint) ctx->DrawBuffer->Height) {
81 rasterMask |= CLIP_BIT;
84 if (ctx->Query.CurrentOcclusionObject)
85 rasterMask |= OCCLUSION_BIT;
88 /* If we're not drawing to exactly one color buffer set the
89 * MULTI_DRAW_BIT flag. Also set it if we're drawing to no
90 * buffers or the RGBA or CI mask disables all writes.
92 if (ctx->DrawBuffer->_NumColorDrawBuffers != 1) {
93 /* more than one color buffer designated for writing (or zero buffers) */
94 rasterMask |= MULTI_DRAW_BIT;
97 for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
98 if (ctx->Color.ColorMask[i][0] +
99 ctx->Color.ColorMask[i][1] +
100 ctx->Color.ColorMask[i][2] +
101 ctx->Color.ColorMask[i][3] == 0) {
102 rasterMask |= MULTI_DRAW_BIT; /* all RGBA channels disabled */
108 if (_swrast_use_fragment_program(ctx)) {
109 rasterMask |= FRAGPROG_BIT;
112 if (ctx->ATIFragmentShader._Enabled) {
113 rasterMask |= ATIFRAGSHADER_BIT;
116 #if CHAN_TYPE == GL_FLOAT
117 if (ctx->Color.ClampFragmentColor == GL_TRUE) {
118 rasterMask |= CLAMPING_BIT;
122 SWRAST_CONTEXT(ctx)->_RasterMask = rasterMask;
127 * Examine polygon cull state to compute the _BackfaceCullSign field.
128 * _BackfaceCullSign will be 0 if no culling, -1 if culling back-faces,
129 * and 1 if culling front-faces. The Polygon FrontFace state also
133 _swrast_update_polygon( struct gl_context *ctx )
135 GLfloat backface_sign;
137 if (ctx->Polygon.CullFlag) {
138 switch (ctx->Polygon.CullFaceMode) {
140 backface_sign = -1.0F;
143 backface_sign = 1.0F;
145 case GL_FRONT_AND_BACK:
148 backface_sign = 0.0F;
152 backface_sign = 0.0F;
155 SWRAST_CONTEXT(ctx)->_BackfaceCullSign = backface_sign;
157 /* This is for front/back-face determination, but not for culling */
158 SWRAST_CONTEXT(ctx)->_BackfaceSign
159 = (ctx->Polygon.FrontFace == GL_CW) ? -1.0F : 1.0F;
165 * Update the _PreferPixelFog field to indicate if we need to compute
166 * fog blend factors (from the fog coords) per-fragment.
169 _swrast_update_fog_hint( struct gl_context *ctx )
171 SWcontext *swrast = SWRAST_CONTEXT(ctx);
172 swrast->_PreferPixelFog = (!swrast->AllowVertexFog ||
173 _swrast_use_fragment_program(ctx) ||
174 (ctx->Hint.Fog == GL_NICEST &&
175 swrast->AllowPixelFog));
181 * Update the swrast->_TextureCombinePrimary flag.
184 _swrast_update_texture_env( struct gl_context *ctx )
186 SWcontext *swrast = SWRAST_CONTEXT(ctx);
189 swrast->_TextureCombinePrimary = GL_FALSE;
191 for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
192 const struct gl_tex_env_combine_state *combine =
193 ctx->Texture.Unit[i]._CurrentCombine;
195 for (term = 0; term < combine->_NumArgsRGB; term++) {
196 if (combine->SourceRGB[term] == GL_PRIMARY_COLOR) {
197 swrast->_TextureCombinePrimary = GL_TRUE;
200 if (combine->SourceA[term] == GL_PRIMARY_COLOR) {
201 swrast->_TextureCombinePrimary = GL_TRUE;
210 * Determine if we can defer texturing/shading until after Z/stencil
211 * testing. This potentially allows us to skip texturing/shading for
215 _swrast_update_deferred_texture(struct gl_context *ctx)
217 SWcontext *swrast = SWRAST_CONTEXT(ctx);
218 if (ctx->Color.AlphaEnabled) {
219 /* alpha test depends on post-texture/shader colors */
220 swrast->_DeferredTexture = GL_FALSE;
223 GLboolean use_fprog = _swrast_use_fragment_program(ctx);
224 const struct gl_fragment_program *fprog
225 = ctx->FragmentProgram._Current;
226 if (use_fprog && (fprog->Base.OutputsWritten & (1 << FRAG_RESULT_DEPTH))) {
227 /* Z comes from fragment program/shader */
228 swrast->_DeferredTexture = GL_FALSE;
230 else if (use_fprog && fprog->UsesKill) {
231 swrast->_DeferredTexture = GL_FALSE;
233 else if (ctx->Query.CurrentOcclusionObject) {
234 /* occlusion query depends on shader discard/kill results */
235 swrast->_DeferredTexture = GL_FALSE;
238 swrast->_DeferredTexture = GL_TRUE;
245 * Update swrast->_FogColor and swrast->_FogEnable values.
248 _swrast_update_fog_state( struct gl_context *ctx )
250 SWcontext *swrast = SWRAST_CONTEXT(ctx);
251 const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;
253 assert(fp == NULL || fp->Base.Target == GL_FRAGMENT_PROGRAM_ARB);
255 /* determine if fog is needed, and if so, which fog mode */
256 swrast->_FogEnabled = (!_swrast_use_fragment_program(ctx) &&
262 * Update state for running fragment programs. Basically, load the
263 * program parameters with current state values.
266 _swrast_update_fragment_program(struct gl_context *ctx, GLbitfield newState)
268 if (!_swrast_use_fragment_program(ctx))
271 _mesa_load_state_parameters(ctx,
272 ctx->FragmentProgram._Current->Base.Parameters);
277 * See if we can do early diffuse+specular (primary+secondary) color
278 * add per vertex instead of per-fragment.
281 _swrast_update_specular_vertex_add(struct gl_context *ctx)
283 SWcontext *swrast = SWRAST_CONTEXT(ctx);
284 GLboolean separateSpecular = ctx->Fog.ColorSumEnabled ||
285 (ctx->Light.Enabled &&
286 ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR);
288 swrast->SpecularVertexAdd = (separateSpecular
289 && ctx->Texture._EnabledUnits == 0x0
290 && !_swrast_use_fragment_program(ctx)
291 && !ctx->ATIFragmentShader._Enabled);
295 #define _SWRAST_NEW_DERIVED (_SWRAST_NEW_RASTERMASK | \
296 _NEW_PROGRAM_CONSTANTS | \
301 /* State referenced by _swrast_choose_triangle, _swrast_choose_line.
303 #define _SWRAST_NEW_TRIANGLE (_SWRAST_NEW_DERIVED | \
310 _SWRAST_NEW_RASTERMASK| \
313 _MESA_NEW_SEPARATE_SPECULAR)
315 #define _SWRAST_NEW_LINE (_SWRAST_NEW_DERIVED | \
322 _MESA_NEW_SEPARATE_SPECULAR)
324 #define _SWRAST_NEW_POINT (_SWRAST_NEW_DERIVED | \
330 _MESA_NEW_SEPARATE_SPECULAR)
332 #define _SWRAST_NEW_TEXTURE_SAMPLE_FUNC _NEW_TEXTURE
334 #define _SWRAST_NEW_TEXTURE_ENV_MODE _NEW_TEXTURE
336 #define _SWRAST_NEW_BLEND_FUNC _NEW_COLOR
341 * Stub for swrast->Triangle to select a true triangle function
342 * after a state change.
345 _swrast_validate_triangle( struct gl_context *ctx,
350 SWcontext *swrast = SWRAST_CONTEXT(ctx);
352 _swrast_validate_derived( ctx );
353 swrast->choose_triangle( ctx );
354 ASSERT(swrast->Triangle);
356 if (swrast->SpecularVertexAdd) {
357 /* separate specular color, but no texture */
358 swrast->SpecTriangle = swrast->Triangle;
359 swrast->Triangle = _swrast_add_spec_terms_triangle;
362 swrast->Triangle( ctx, v0, v1, v2 );
366 * Called via swrast->Line. Examine current GL state and choose a software
367 * line routine. Then call it.
370 _swrast_validate_line( struct gl_context *ctx, const SWvertex *v0, const SWvertex *v1 )
372 SWcontext *swrast = SWRAST_CONTEXT(ctx);
374 _swrast_validate_derived( ctx );
375 swrast->choose_line( ctx );
376 ASSERT(swrast->Line);
378 if (swrast->SpecularVertexAdd) {
379 swrast->SpecLine = swrast->Line;
380 swrast->Line = _swrast_add_spec_terms_line;
383 swrast->Line( ctx, v0, v1 );
387 * Called via swrast->Point. Examine current GL state and choose a software
388 * point routine. Then call it.
391 _swrast_validate_point( struct gl_context *ctx, const SWvertex *v0 )
393 SWcontext *swrast = SWRAST_CONTEXT(ctx);
395 _swrast_validate_derived( ctx );
396 swrast->choose_point( ctx );
398 if (swrast->SpecularVertexAdd) {
399 swrast->SpecPoint = swrast->Point;
400 swrast->Point = _swrast_add_spec_terms_point;
403 swrast->Point( ctx, v0 );
408 * Called via swrast->BlendFunc. Examine GL state to choose a blending
409 * function, then call it.
412 _swrast_validate_blend_func(struct gl_context *ctx, GLuint n, const GLubyte mask[],
413 GLvoid *src, const GLvoid *dst,
416 SWcontext *swrast = SWRAST_CONTEXT(ctx);
418 _swrast_validate_derived( ctx ); /* why is this needed? */
419 _swrast_choose_blend_func( ctx, chanType );
421 swrast->BlendFunc( ctx, n, mask, src, dst, chanType );
425 _swrast_sleep( struct gl_context *ctx, GLbitfield new_state )
427 (void) ctx; (void) new_state;
432 _swrast_invalidate_state( struct gl_context *ctx, GLbitfield new_state )
434 SWcontext *swrast = SWRAST_CONTEXT(ctx);
437 swrast->NewState |= new_state;
439 /* After 10 statechanges without any swrast functions being called,
440 * put the module to sleep.
442 if (++swrast->StateChanges > 10) {
443 swrast->InvalidateState = _swrast_sleep;
444 swrast->NewState = ~0;
448 if (new_state & swrast->InvalidateTriangleMask)
449 swrast->Triangle = _swrast_validate_triangle;
451 if (new_state & swrast->InvalidateLineMask)
452 swrast->Line = _swrast_validate_line;
454 if (new_state & swrast->InvalidatePointMask)
455 swrast->Point = _swrast_validate_point;
457 if (new_state & _SWRAST_NEW_BLEND_FUNC)
458 swrast->BlendFunc = _swrast_validate_blend_func;
460 if (new_state & _SWRAST_NEW_TEXTURE_SAMPLE_FUNC)
461 for (i = 0 ; i < ARRAY_SIZE(swrast->TextureSample); i++)
462 swrast->TextureSample[i] = NULL;
467 _swrast_update_texture_samplers(struct gl_context *ctx)
469 SWcontext *swrast = SWRAST_CONTEXT(ctx);
473 return; /* pipe hack */
475 for (u = 0; u < ARRAY_SIZE(swrast->TextureSample); u++) {
476 struct gl_texture_object *tObj = ctx->Texture.Unit[u]._Current;
477 /* Note: If tObj is NULL, the sample function will be a simple
478 * function that just returns opaque black (0,0,0,1).
480 _mesa_update_fetch_functions(ctx, u);
481 swrast->TextureSample[u] =
482 _swrast_choose_texture_sample_func(ctx, tObj,
483 _mesa_get_samplerobj(ctx, u));
489 * Update swrast->_ActiveAttribs, swrast->_NumActiveAttribs,
490 * swrast->_ActiveAtttribMask.
493 _swrast_update_active_attribs(struct gl_context *ctx)
495 SWcontext *swrast = SWRAST_CONTEXT(ctx);
496 GLbitfield64 attribsMask;
499 * Compute _ActiveAttribsMask = which fragment attributes are needed.
501 if (_swrast_use_fragment_program(ctx)) {
502 /* fragment program/shader */
503 attribsMask = ctx->FragmentProgram._Current->Base.InputsRead;
504 attribsMask &= ~VARYING_BIT_POS; /* WPOS is always handled specially */
506 else if (ctx->ATIFragmentShader._Enabled) {
507 attribsMask = ~0; /* XXX fix me */
513 #if CHAN_TYPE == GL_FLOAT
514 attribsMask |= VARYING_BIT_COL0;
517 if (ctx->Fog.ColorSumEnabled ||
518 (ctx->Light.Enabled &&
519 ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)) {
520 attribsMask |= VARYING_BIT_COL1;
523 if (swrast->_FogEnabled)
524 attribsMask |= VARYING_BIT_FOGC;
526 attribsMask |= (ctx->Texture._EnabledUnits << VARYING_SLOT_TEX0);
529 swrast->_ActiveAttribMask = attribsMask;
531 /* Update _ActiveAttribs[] list */
534 for (i = 0; i < VARYING_SLOT_MAX; i++) {
535 if (attribsMask & BITFIELD64_BIT(i)) {
536 swrast->_ActiveAttribs[num++] = i;
537 /* how should this attribute be interpolated? */
538 if (i == VARYING_SLOT_COL0 || i == VARYING_SLOT_COL1)
539 swrast->_InterpMode[i] = ctx->Light.ShadeModel;
541 swrast->_InterpMode[i] = GL_SMOOTH;
544 swrast->_NumActiveAttribs = num;
550 _swrast_validate_derived( struct gl_context *ctx )
552 SWcontext *swrast = SWRAST_CONTEXT(ctx);
554 if (swrast->NewState) {
555 if (swrast->NewState & _NEW_POLYGON)
556 _swrast_update_polygon( ctx );
558 if (swrast->NewState & (_NEW_HINT | _NEW_PROGRAM))
559 _swrast_update_fog_hint( ctx );
561 if (swrast->NewState & _SWRAST_NEW_TEXTURE_ENV_MODE)
562 _swrast_update_texture_env( ctx );
564 if (swrast->NewState & (_NEW_FOG | _NEW_PROGRAM))
565 _swrast_update_fog_state( ctx );
567 if (swrast->NewState & (_NEW_PROGRAM_CONSTANTS | _NEW_PROGRAM))
568 _swrast_update_fragment_program( ctx, swrast->NewState );
570 if (swrast->NewState & (_NEW_TEXTURE | _NEW_PROGRAM)) {
571 _swrast_update_texture_samplers( ctx );
574 if (swrast->NewState & (_NEW_COLOR | _NEW_PROGRAM))
575 _swrast_update_deferred_texture(ctx);
577 if (swrast->NewState & _SWRAST_NEW_RASTERMASK)
578 _swrast_update_rasterflags( ctx );
580 if (swrast->NewState & (_NEW_DEPTH |
585 _swrast_update_active_attribs(ctx);
587 if (swrast->NewState & (_NEW_FOG |
591 _swrast_update_specular_vertex_add(ctx);
593 swrast->NewState = 0;
594 swrast->StateChanges = 0;
595 swrast->InvalidateState = _swrast_invalidate_state;
599 #define SWRAST_DEBUG 0
601 /* Public entrypoints: See also s_bitmap.c, etc.
604 _swrast_Quad( struct gl_context *ctx,
605 const SWvertex *v0, const SWvertex *v1,
606 const SWvertex *v2, const SWvertex *v3 )
609 _mesa_debug(ctx, "_swrast_Quad\n");
610 _swrast_print_vertex( ctx, v0 );
611 _swrast_print_vertex( ctx, v1 );
612 _swrast_print_vertex( ctx, v2 );
613 _swrast_print_vertex( ctx, v3 );
615 SWRAST_CONTEXT(ctx)->Triangle( ctx, v0, v1, v3 );
616 SWRAST_CONTEXT(ctx)->Triangle( ctx, v1, v2, v3 );
620 _swrast_Triangle( struct gl_context *ctx, const SWvertex *v0,
621 const SWvertex *v1, const SWvertex *v2 )
624 _mesa_debug(ctx, "_swrast_Triangle\n");
625 _swrast_print_vertex( ctx, v0 );
626 _swrast_print_vertex( ctx, v1 );
627 _swrast_print_vertex( ctx, v2 );
629 SWRAST_CONTEXT(ctx)->Triangle( ctx, v0, v1, v2 );
633 _swrast_Line( struct gl_context *ctx, const SWvertex *v0, const SWvertex *v1 )
636 _mesa_debug(ctx, "_swrast_Line\n");
637 _swrast_print_vertex( ctx, v0 );
638 _swrast_print_vertex( ctx, v1 );
640 SWRAST_CONTEXT(ctx)->Line( ctx, v0, v1 );
644 _swrast_Point( struct gl_context *ctx, const SWvertex *v0 )
647 _mesa_debug(ctx, "_swrast_Point\n");
648 _swrast_print_vertex( ctx, v0 );
650 SWRAST_CONTEXT(ctx)->Point( ctx, v0 );
654 _swrast_InvalidateState( struct gl_context *ctx, GLbitfield new_state )
657 _mesa_debug(ctx, "_swrast_InvalidateState\n");
659 SWRAST_CONTEXT(ctx)->InvalidateState( ctx, new_state );
663 _swrast_ResetLineStipple( struct gl_context *ctx )
666 _mesa_debug(ctx, "_swrast_ResetLineStipple\n");
668 SWRAST_CONTEXT(ctx)->StippleCounter = 0;
672 _swrast_SetFacing(struct gl_context *ctx, GLuint facing)
674 SWRAST_CONTEXT(ctx)->PointLineFacing = facing;
678 _swrast_allow_vertex_fog( struct gl_context *ctx, GLboolean value )
681 _mesa_debug(ctx, "_swrast_allow_vertex_fog %d\n", value);
683 SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );
684 SWRAST_CONTEXT(ctx)->AllowVertexFog = value;
688 _swrast_allow_pixel_fog( struct gl_context *ctx, GLboolean value )
691 _mesa_debug(ctx, "_swrast_allow_pixel_fog %d\n", value);
693 SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );
694 SWRAST_CONTEXT(ctx)->AllowPixelFog = value;
699 * Initialize native program limits by copying the logical limits.
700 * See comments in init_program_limits() in context.c
703 init_program_native_limits(struct gl_program_constants *prog)
705 prog->MaxNativeInstructions = prog->MaxInstructions;
706 prog->MaxNativeAluInstructions = prog->MaxAluInstructions;
707 prog->MaxNativeTexInstructions = prog->MaxTexInstructions;
708 prog->MaxNativeTexIndirections = prog->MaxTexIndirections;
709 prog->MaxNativeAttribs = prog->MaxAttribs;
710 prog->MaxNativeTemps = prog->MaxTemps;
711 prog->MaxNativeAddressRegs = prog->MaxAddressRegs;
712 prog->MaxNativeParameters = prog->MaxParameters;
717 _swrast_CreateContext( struct gl_context *ctx )
720 SWcontext *swrast = calloc(1, sizeof(SWcontext));
722 const GLuint maxThreads = omp_get_max_threads();
724 const GLuint maxThreads = 1;
727 assert(ctx->Const.MaxViewportWidth <= SWRAST_MAX_WIDTH);
728 assert(ctx->Const.MaxViewportHeight <= SWRAST_MAX_WIDTH);
730 assert(ctx->Const.MaxRenderbufferSize <= SWRAST_MAX_WIDTH);
732 /* make sure largest texture image is <= SWRAST_MAX_WIDTH in size */
733 assert((1 << (ctx->Const.MaxTextureLevels - 1)) <= SWRAST_MAX_WIDTH);
734 assert((1 << (ctx->Const.MaxCubeTextureLevels - 1)) <= SWRAST_MAX_WIDTH);
735 assert((1 << (ctx->Const.Max3DTextureLevels - 1)) <= SWRAST_MAX_WIDTH);
737 assert(PROG_MAX_WIDTH == SWRAST_MAX_WIDTH);
740 _mesa_debug(ctx, "_swrast_CreateContext\n");
746 swrast->NewState = ~0;
748 swrast->choose_point = _swrast_choose_point;
749 swrast->choose_line = _swrast_choose_line;
750 swrast->choose_triangle = _swrast_choose_triangle;
752 swrast->InvalidatePointMask = _SWRAST_NEW_POINT;
753 swrast->InvalidateLineMask = _SWRAST_NEW_LINE;
754 swrast->InvalidateTriangleMask = _SWRAST_NEW_TRIANGLE;
756 swrast->Point = _swrast_validate_point;
757 swrast->Line = _swrast_validate_line;
758 swrast->Triangle = _swrast_validate_triangle;
759 swrast->InvalidateState = _swrast_sleep;
760 swrast->BlendFunc = _swrast_validate_blend_func;
762 swrast->AllowVertexFog = GL_TRUE;
763 swrast->AllowPixelFog = GL_TRUE;
765 swrast->Driver.SpanRenderStart = _swrast_span_render_start;
766 swrast->Driver.SpanRenderFinish = _swrast_span_render_finish;
768 for (i = 0; i < ARRAY_SIZE(swrast->TextureSample); i++)
769 swrast->TextureSample[i] = NULL;
771 /* SpanArrays is global and shared by all SWspan instances. However, when
772 * using multiple threads, it is necessary to have one SpanArrays instance
775 swrast->SpanArrays = malloc(maxThreads * sizeof(SWspanarrays));
776 if (!swrast->SpanArrays) {
780 for(i = 0; i < maxThreads; i++) {
781 swrast->SpanArrays[i].ChanType = CHAN_TYPE;
782 #if CHAN_TYPE == GL_UNSIGNED_BYTE
783 swrast->SpanArrays[i].rgba = swrast->SpanArrays[i].rgba8;
784 #elif CHAN_TYPE == GL_UNSIGNED_SHORT
785 swrast->SpanArrays[i].rgba = swrast->SpanArrays[i].rgba16;
787 swrast->SpanArrays[i].rgba = swrast->SpanArrays[i].attribs[VARYING_SLOT_COL0];
791 /* init point span buffer */
792 swrast->PointSpan.primitive = GL_POINT;
793 swrast->PointSpan.end = 0;
794 swrast->PointSpan.facing = 0;
795 swrast->PointSpan.array = swrast->SpanArrays;
797 init_program_native_limits(&ctx->Const.VertexProgram);
798 init_program_native_limits(&ctx->Const.GeometryProgram);
799 init_program_native_limits(&ctx->Const.FragmentProgram);
801 ctx->swrast_context = swrast;
803 swrast->stencil_temp.buf1 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
804 swrast->stencil_temp.buf2 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
805 swrast->stencil_temp.buf3 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
806 swrast->stencil_temp.buf4 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
808 if (!swrast->stencil_temp.buf1 ||
809 !swrast->stencil_temp.buf2 ||
810 !swrast->stencil_temp.buf3 ||
811 !swrast->stencil_temp.buf4) {
812 _swrast_DestroyContext(ctx);
820 _swrast_DestroyContext( struct gl_context *ctx )
822 SWcontext *swrast = SWRAST_CONTEXT(ctx);
825 _mesa_debug(ctx, "_swrast_DestroyContext\n");
828 free( swrast->SpanArrays );
829 free( swrast->ZoomedArrays );
830 free( swrast->TexelBuffer );
832 free(swrast->stencil_temp.buf1);
833 free(swrast->stencil_temp.buf2);
834 free(swrast->stencil_temp.buf3);
835 free(swrast->stencil_temp.buf4);
839 ctx->swrast_context = 0;
843 struct swrast_device_driver *
844 _swrast_GetDeviceDriverReference( struct gl_context *ctx )
846 SWcontext *swrast = SWRAST_CONTEXT(ctx);
847 return &swrast->Driver;
851 _swrast_flush( struct gl_context *ctx )
853 SWcontext *swrast = SWRAST_CONTEXT(ctx);
854 /* flush any pending fragments from rendering points */
855 if (swrast->PointSpan.end > 0) {
856 _swrast_write_rgba_span(ctx, &(swrast->PointSpan));
857 swrast->PointSpan.end = 0;
862 _swrast_render_primitive( struct gl_context *ctx, GLenum prim )
864 SWcontext *swrast = SWRAST_CONTEXT(ctx);
865 if (swrast->Primitive == GL_POINTS && prim != GL_POINTS) {
868 swrast->Primitive = prim;
872 /** called via swrast->Driver.SpanRenderStart() */
874 _swrast_span_render_start(struct gl_context *ctx)
876 _swrast_map_textures(ctx);
877 _swrast_map_renderbuffers(ctx);
881 /** called via swrast->Driver.SpanRenderFinish() */
883 _swrast_span_render_finish(struct gl_context *ctx)
885 _swrast_unmap_textures(ctx);
886 _swrast_unmap_renderbuffers(ctx);
891 _swrast_render_start( struct gl_context *ctx )
893 SWcontext *swrast = SWRAST_CONTEXT(ctx);
894 if (swrast->Driver.SpanRenderStart)
895 swrast->Driver.SpanRenderStart( ctx );
896 swrast->PointSpan.end = 0;
900 _swrast_render_finish( struct gl_context *ctx )
902 SWcontext *swrast = SWRAST_CONTEXT(ctx);
906 if (swrast->Driver.SpanRenderFinish)
907 swrast->Driver.SpanRenderFinish( ctx );
911 #define SWRAST_DEBUG_VERTICES 0
914 _swrast_print_vertex( struct gl_context *ctx, const SWvertex *v )
918 if (SWRAST_DEBUG_VERTICES) {
919 _mesa_debug(ctx, "win %f %f %f %f\n",
920 v->attrib[VARYING_SLOT_POS][0],
921 v->attrib[VARYING_SLOT_POS][1],
922 v->attrib[VARYING_SLOT_POS][2],
923 v->attrib[VARYING_SLOT_POS][3]);
925 for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++)
926 if (ctx->Texture.Unit[i]._ReallyEnabled)
927 _mesa_debug(ctx, "texcoord[%d] %f %f %f %f\n", i,
928 v->attrib[VARYING_SLOT_TEX0 + i][0],
929 v->attrib[VARYING_SLOT_TEX0 + i][1],
930 v->attrib[VARYING_SLOT_TEX0 + i][2],
931 v->attrib[VARYING_SLOT_TEX0 + i][3]);
933 #if CHAN_TYPE == GL_FLOAT
934 _mesa_debug(ctx, "color %f %f %f %f\n",
935 v->color[0], v->color[1], v->color[2], v->color[3]);
937 _mesa_debug(ctx, "color %d %d %d %d\n",
938 v->color[0], v->color[1], v->color[2], v->color[3]);
940 _mesa_debug(ctx, "spec %g %g %g %g\n",
941 v->attrib[VARYING_SLOT_COL1][0],
942 v->attrib[VARYING_SLOT_COL1][1],
943 v->attrib[VARYING_SLOT_COL1][2],
944 v->attrib[VARYING_SLOT_COL1][3]);
945 _mesa_debug(ctx, "fog %f\n", v->attrib[VARYING_SLOT_FOGC][0]);
946 _mesa_debug(ctx, "index %f\n", v->attrib[VARYING_SLOT_CI][0]);
947 _mesa_debug(ctx, "pointsize %f\n", v->pointSize);
948 _mesa_debug(ctx, "\n");