-/* $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"),
#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"
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;
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)
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;
}
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
/* 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,
_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 );
}
_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 );
}
_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 );
}
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 );
}
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);
+ }
+
}
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 );
}
}
-
+#define SWRAST_DEBUG 0
/* Public entrypoints: See also s_accum.c, s_bitmap.c, etc.
*/
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;
}
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;
}
{
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;
{
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 */
}
projects / mesa.git / blobdiff