-/* $XFree86: xc/lib/GL/mesa/src/drv/i810/i810state.c,v 1.9 2002/10/30 12:51:33 alanh Exp $ */
#include <stdio.h>
-#include "glheader.h"
-#include "context.h"
-#include "macros.h"
-#include "enums.h"
-#include "dd.h"
-#include "colormac.h"
+#include "main/glheader.h"
+#include "main/context.h"
+#include "main/macros.h"
+#include "main/dd.h"
+#include "main/colormac.h"
+#include "swrast/swrast.h"
+#include "tnl/tnl.h"
+#include "tnl/t_pipeline.h"
+#include "vbo/vbo.h"
+#include "swrast_setup/swrast_setup.h"
#include "texmem.h"
#include "i810context.h"
#include "i810state.h"
#include "i810tex.h"
-#include "i810vb.h"
-#include "i810tris.h"
#include "i810ioctl.h"
-#include "swrast/swrast.h"
-#include "array_cache/acache.h"
-#include "tnl/tnl.h"
-#include "swrast_setup/swrast_setup.h"
-
-#include "tnl/t_pipeline.h"
-static __inline__ GLuint i810PackColor(GLuint format,
+static INLINE GLuint i810PackColor(GLuint format,
GLubyte r, GLubyte g,
GLubyte b, GLubyte a)
{
}
-static void i810AlphaFunc(GLcontext *ctx, GLenum func, GLfloat ref)
+static void i810AlphaFunc(struct gl_context *ctx, GLenum func, GLfloat ref)
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
GLuint a = (ZA_UPDATE_ALPHAFUNC|ZA_UPDATE_ALPHAREF);
imesa->Setup[I810_CTXREG_ZA] |= a;
}
-static void i810BlendEquationSeparate(GLcontext *ctx,
+static void i810BlendEquationSeparate(struct gl_context *ctx,
GLenum modeRGB, GLenum modeA)
{
assert( modeRGB == modeA );
ctx->Color.LogicOp != GL_COPY));
}
-static void i810BlendFuncSeparate( GLcontext *ctx, GLenum sfactorRGB,
+static void i810BlendFuncSeparate( struct gl_context *ctx, GLenum sfactorRGB,
GLenum dfactorRGB, GLenum sfactorA,
GLenum dfactorA )
{
GLuint a = SDM_UPDATE_SRC_BLEND | SDM_UPDATE_DST_BLEND;
GLboolean fallback = GL_FALSE;
- switch (ctx->Color.BlendSrcRGB) {
+ switch (ctx->Color.Blend[0].SrcRGB) {
case GL_ZERO: a |= SDM_SRC_ZERO; break;
- case GL_SRC_ALPHA: a |= SDM_SRC_SRC_ALPHA; break;
case GL_ONE: a |= SDM_SRC_ONE; break;
- case GL_DST_COLOR: a |= SDM_SRC_DST_COLOR; break;
- case GL_ONE_MINUS_DST_COLOR: a |= SDM_SRC_INV_DST_COLOR; break;
+ case GL_SRC_COLOR: a |= SDM_SRC_SRC_COLOR; break;
+ case GL_ONE_MINUS_SRC_COLOR: a |= SDM_SRC_INV_SRC_COLOR; break;
+ case GL_SRC_ALPHA: a |= SDM_SRC_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: a |= SDM_SRC_INV_SRC_ALPHA; break;
case GL_DST_ALPHA: a |= SDM_SRC_ONE; break;
case GL_ONE_MINUS_DST_ALPHA: a |= SDM_SRC_ZERO; break;
- case GL_SRC_ALPHA_SATURATE: /*a |= SDM_SRC_SRC_ALPHA; break;*/
+ case GL_DST_COLOR: a |= SDM_SRC_DST_COLOR; break;
+ case GL_ONE_MINUS_DST_COLOR: a |= SDM_SRC_INV_DST_COLOR; break;
+
+ /* (f, f, f, 1), f = min(As, 1 - Ad) = min(As, 1 - 1) = 0
+ * So (f, f, f, 1) = (0, 0, 0, 1). Since there is no destination alpha and
+ * the only supported alpha operation is GL_FUNC_ADD, the result modulating
+ * the source alpha with the alpha factor is largely irrelevant.
+ */
+ case GL_SRC_ALPHA_SATURATE: a |= SDM_SRC_ZERO; break;
+
case GL_CONSTANT_COLOR:
case GL_ONE_MINUS_CONSTANT_COLOR:
case GL_CONSTANT_ALPHA:
return;
}
- switch (ctx->Color.BlendDstRGB) {
- case GL_SRC_ALPHA: a |= SDM_DST_SRC_ALPHA; break;
- case GL_ONE_MINUS_SRC_ALPHA: a |= SDM_DST_INV_SRC_ALPHA; break;
+ switch (ctx->Color.Blend[0].DstRGB) {
case GL_ZERO: a |= SDM_DST_ZERO; break;
case GL_ONE: a |= SDM_DST_ONE; break;
case GL_SRC_COLOR: a |= SDM_DST_SRC_COLOR; break;
case GL_ONE_MINUS_SRC_COLOR: a |= SDM_DST_INV_SRC_COLOR; break;
+ case GL_SRC_ALPHA: a |= SDM_DST_SRC_ALPHA; break;
+ case GL_ONE_MINUS_SRC_ALPHA: a |= SDM_DST_INV_SRC_ALPHA; break;
case GL_DST_ALPHA: a |= SDM_DST_ONE; break;
case GL_ONE_MINUS_DST_ALPHA: a |= SDM_DST_ZERO; break;
+ case GL_DST_COLOR: a |= SDM_DST_DST_COLOR; break;
+ case GL_ONE_MINUS_DST_COLOR: a |= SDM_DST_INV_DST_COLOR; break;
+
case GL_CONSTANT_COLOR:
case GL_ONE_MINUS_CONSTANT_COLOR:
case GL_CONSTANT_ALPHA:
-static void i810DepthFunc(GLcontext *ctx, GLenum func)
+static void i810DepthFunc(struct gl_context *ctx, GLenum func)
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
int zmode;
imesa->Setup[I810_CTXREG_LCS] |= zmode;
}
-static void i810DepthMask(GLcontext *ctx, GLboolean flag)
+static void i810DepthMask(struct gl_context *ctx, GLboolean flag)
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
I810_STATECHANGE(imesa, I810_UPLOAD_CTX);
* The i810 supports a 4x4 stipple natively, GL wants 32x32.
* Fortunately stipple is usually a repeating pattern.
*/
-static void i810PolygonStipple( GLcontext *ctx, const GLubyte *mask )
+static void i810PolygonStipple( struct gl_context *ctx, const GLubyte *mask )
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
const GLubyte *m = mask;
*/
-static void i810Scissor( GLcontext *ctx, GLint x, GLint y,
+static void i810Scissor( struct gl_context *ctx, GLint x, GLint y,
GLsizei w, GLsizei h )
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
}
-static void i810LogicOp( GLcontext *ctx, GLenum opcode )
+static void i810LogicOp( struct gl_context *ctx, GLenum opcode )
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
FALLBACK( imesa, I810_FALLBACK_LOGICOP,
/* Fallback to swrast for select and feedback.
*/
-static void i810RenderMode( GLcontext *ctx, GLenum mode )
+static void i810RenderMode( struct gl_context *ctx, GLenum mode )
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
FALLBACK( imesa, I810_FALLBACK_RENDERMODE, (mode != GL_RENDER) );
}
-void i810DrawBuffer(GLcontext *ctx, GLenum mode )
+void i810DrawBuffer(struct gl_context *ctx, GLenum mode )
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
int front = 0;
- /*
- * _DrawDestMask is easier to cope with than <mode>.
- */
- switch ( ctx->Color._DrawDestMask ) {
- case DD_FRONT_LEFT_BIT:
+ if (ctx->DrawBuffer->_NumColorDrawBuffers != 1) {
+ /* GL_NONE or GL_FRONT_AND_BACK or stereo left&right, etc */
+ FALLBACK( imesa, I810_FALLBACK_DRAW_BUFFER, GL_TRUE );
+ return;
+ }
+
+ switch ( ctx->DrawBuffer->_ColorDrawBufferIndexes[0]) {
+ case BUFFER_FRONT_LEFT:
front = 1;
break;
- case DD_BACK_LEFT_BIT:
+ case BUFFER_BACK_LEFT:
front = 0;
break;
default:
- /* GL_NONE or GL_FRONT_AND_BACK or stereo left&right, etc */
FALLBACK( imesa, I810_FALLBACK_DRAW_BUFFER, GL_TRUE );
return;
}
imesa->i810Screen->backPitchBits);
i810XMesaSetBackClipRects( imesa );
}
-
- /* We want to update the s/w rast state too so that r200SetBuffer()
- * gets called.
- */
- _swrast_DrawBuffer(ctx, mode);
}
-static void i810ReadBuffer(GLcontext *ctx, GLenum mode )
+static void i810ReadBuffer(struct gl_context *ctx, GLenum mode )
{
/* XXX anything? */
}
-static void i810ClearColor(GLcontext *ctx, const GLfloat color[4] )
+static void i810ClearColor(struct gl_context *ctx, const GLfloat color[4] )
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
GLubyte c[4];
* Culling - the i810 isn't quite as clean here as the rest of
* its interfaces, but it's not bad.
*/
-static void i810CullFaceFrontFace(GLcontext *ctx, GLenum unused)
+static void i810CullFaceFrontFace(struct gl_context *ctx, GLenum unused)
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
GLuint mode = LCS_CULL_BOTH;
}
-static void i810LineWidth( GLcontext *ctx, GLfloat widthf )
+static void i810LineWidth( struct gl_context *ctx, GLfloat widthf )
{
i810ContextPtr imesa = I810_CONTEXT( ctx );
- int width = (int)ctx->Line._Width;
+ /* AA, non-AA limits are same */
+ const int width = (int) CLAMP(ctx->Line.Width,
+ ctx->Const.MinLineWidth,
+ ctx->Const.MaxLineWidth);
imesa->LcsLineWidth = 0;
if (width & 1) imesa->LcsLineWidth |= LCS_LINEWIDTH_1_0;
}
}
-static void i810PointSize( GLcontext *ctx, GLfloat sz )
+static void i810PointSize( struct gl_context *ctx, GLfloat sz )
{
i810ContextPtr imesa = I810_CONTEXT( ctx );
- int size = (int)ctx->Point._Size;
+ /* AA, non-AA limits are same */
+ const int size = (int) CLAMP(ctx->Point.Size,
+ ctx->Const.MinPointSize,
+ ctx->Const.MaxPointSize);
imesa->LcsPointSize = 0;
if (size & 1) imesa->LcsPointSize |= LCS_LINEWIDTH_1_0;
* Color masks
*/
-static void i810ColorMask(GLcontext *ctx,
+static void i810ColorMask(struct gl_context *ctx,
GLboolean r, GLboolean g,
GLboolean b, GLboolean a )
{
/* Seperate specular not fully implemented on the i810.
*/
-static void i810LightModelfv(GLcontext *ctx, GLenum pname,
+static void i810LightModelfv(struct gl_context *ctx, GLenum pname,
const GLfloat *param)
{
if (pname == GL_LIGHT_MODEL_COLOR_CONTROL)
/* But the 815 has it...
*/
-static void i810LightModelfv_i815(GLcontext *ctx, GLenum pname,
+static void i810LightModelfv_i815(struct gl_context *ctx, GLenum pname,
const GLfloat *param)
{
if (pname == GL_LIGHT_MODEL_COLOR_CONTROL)
/* In Mesa 3.5 we can reliably do native flatshading.
*/
-static void i810ShadeModel(GLcontext *ctx, GLenum mode)
+static void i810ShadeModel(struct gl_context *ctx, GLenum mode)
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
I810_STATECHANGE(imesa, I810_UPLOAD_CTX);
/* =============================================================
* Fog
*/
-static void i810Fogfv(GLcontext *ctx, GLenum pname, const GLfloat *param)
+static void i810Fogfv(struct gl_context *ctx, GLenum pname, const GLfloat *param)
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
/* =============================================================
*/
-static void i810Enable(GLcontext *ctx, GLenum cap, GLboolean state)
+static void i810Enable(struct gl_context *ctx, GLenum cap, GLboolean state)
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
imesa->Setup[I810_CTXREG_LCS] |= LCS_CULL_DISABLE;
break;
case GL_TEXTURE_2D:
+ case GL_TEXTURE_RECTANGLE_NV:
I810_STATECHANGE(imesa, I810_UPLOAD_CTX);
if (ctx->Texture.CurrentUnit == 0) {
imesa->Setup[I810_CTXREG_MT] &= ~MT_TEXEL0_ENABLE;
void i810EmitDrawingRectangle( i810ContextPtr imesa )
{
- __DRIdrawablePrivate *dPriv = imesa->driDrawable;
+ __DRIdrawable *dPriv = imesa->driDrawable;
i810ScreenPrivate *i810Screen = imesa->i810Screen;
int x0 = imesa->drawX;
int y0 = imesa->drawY;
-static void i810CalcViewport( GLcontext *ctx )
+static void i810CalcViewport( struct gl_context *ctx )
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
const GLfloat *v = ctx->Viewport._WindowMap.m;
m[MAT_TZ] = v[MAT_TZ] * (1.0 / 0xffff);
}
-static void i810Viewport( GLcontext *ctx,
+static void i810Viewport( struct gl_context *ctx,
GLint x, GLint y,
GLsizei width, GLsizei height )
{
i810CalcViewport( ctx );
}
-static void i810DepthRange( GLcontext *ctx,
+static void i810DepthRange( struct gl_context *ctx,
GLclampd nearval, GLclampd farval )
{
i810CalcViewport( ctx );
-void i810InitState( GLcontext *ctx )
+void i810InitState( struct gl_context *ctx )
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
i810ScreenPrivate *i810Screen = imesa->i810Screen;
MC_UPDATE_DEST |
MC_DEST_CURRENT |
MC_UPDATE_ARG1 |
- MC_ARG1_ITERATED_COLOR |
- MC_ARG1_DONT_REPLICATE_ALPHA |
- MC_ARG1_DONT_INVERT |
+ ((MC_ARG_ITERATED_COLOR |
+ MC_ARG_DONT_REPLICATE_ALPHA |
+ MC_ARG_DONT_INVERT) << MC_ARG1_SHIFT) |
MC_UPDATE_ARG2 |
- MC_ARG2_ONE |
- MC_ARG2_DONT_REPLICATE_ALPHA |
- MC_ARG2_DONT_INVERT |
+ ((MC_ARG_ONE |
+ MC_ARG_DONT_REPLICATE_ALPHA |
+ MC_ARG_DONT_INVERT) << MC_ARG2_SHIFT) |
MC_UPDATE_OP |
MC_OP_ARG1 );
MC_UPDATE_DEST |
MC_DEST_CURRENT |
MC_UPDATE_ARG1 |
- MC_ARG1_ONE |
- MC_ARG1_DONT_REPLICATE_ALPHA |
- MC_ARG1_DONT_INVERT |
+ ((MC_ARG_ONE |
+ MC_ARG_DONT_REPLICATE_ALPHA |
+ MC_ARG_DONT_INVERT) << MC_ARG1_SHIFT) |
MC_UPDATE_ARG2 |
- MC_ARG2_ONE |
- MC_ARG2_DONT_REPLICATE_ALPHA |
- MC_ARG2_DONT_INVERT |
+ ((MC_ARG_ONE |
+ MC_ARG_DONT_REPLICATE_ALPHA |
+ MC_ARG_DONT_INVERT) << MC_ARG2_SHIFT) |
MC_UPDATE_OP |
MC_OP_DISABLE );
MC_UPDATE_DEST |
MC_DEST_CURRENT |
MC_UPDATE_ARG1 |
- MC_ARG1_CURRENT_COLOR |
- MC_ARG1_REPLICATE_ALPHA |
- MC_ARG1_DONT_INVERT |
+ ((MC_ARG_CURRENT_COLOR |
+ MC_ARG_REPLICATE_ALPHA |
+ MC_ARG_DONT_INVERT) << MC_ARG1_SHIFT) |
MC_UPDATE_ARG2 |
- MC_ARG2_ONE |
- MC_ARG2_DONT_REPLICATE_ALPHA |
- MC_ARG2_DONT_INVERT |
+ ((MC_ARG_ONE |
+ MC_ARG_DONT_REPLICATE_ALPHA |
+ MC_ARG_DONT_INVERT) << MC_ARG2_SHIFT) |
MC_UPDATE_OP |
MC_OP_DISABLE );
imesa->Setup[I810_CTXREG_MA0] = ( GFX_OP_MAP_ALPHA_STAGES |
MA_STAGE_0 |
MA_UPDATE_ARG1 |
- MA_ARG1_ITERATED_ALPHA |
- MA_ARG1_DONT_INVERT |
+ ((MA_ARG_ITERATED_ALPHA |
+ MA_ARG_DONT_INVERT) << MA_ARG1_SHIFT) |
MA_UPDATE_ARG2 |
- MA_ARG2_CURRENT_ALPHA |
- MA_ARG2_DONT_INVERT |
+ ((MA_ARG_CURRENT_ALPHA |
+ MA_ARG_DONT_INVERT) << MA_ARG2_SHIFT) |
MA_UPDATE_OP |
MA_OP_ARG1 );
imesa->Setup[I810_CTXREG_MA1] = ( GFX_OP_MAP_ALPHA_STAGES |
MA_STAGE_1 |
MA_UPDATE_ARG1 |
- MA_ARG1_CURRENT_ALPHA |
- MA_ARG1_DONT_INVERT |
+ ((MA_ARG_CURRENT_ALPHA |
+ MA_ARG_DONT_INVERT) << MA_ARG1_SHIFT) |
MA_UPDATE_ARG2 |
- MA_ARG2_CURRENT_ALPHA |
- MA_ARG2_DONT_INVERT |
+ ((MA_ARG_CURRENT_ALPHA |
+ MA_ARG_DONT_INVERT) << MA_ARG2_SHIFT) |
MA_UPDATE_OP |
MA_OP_ARG1 );
imesa->Setup[I810_CTXREG_MA2] = ( GFX_OP_MAP_ALPHA_STAGES |
MA_STAGE_2 |
MA_UPDATE_ARG1 |
- MA_ARG1_CURRENT_ALPHA |
- MA_ARG1_DONT_INVERT |
+ ((MA_ARG_CURRENT_ALPHA |
+ MA_ARG_DONT_INVERT) << MA_ARG1_SHIFT) |
MA_UPDATE_ARG2 |
- MA_ARG2_CURRENT_ALPHA |
- MA_ARG2_DONT_INVERT |
+ ((MA_ARG_CURRENT_ALPHA |
+ MA_ARG_DONT_INVERT) << MA_ARG2_SHIFT) |
MA_UPDATE_OP |
MA_OP_ARG1 );
if (imesa->glCtx->Visual.doubleBufferMode && imesa->sarea->pf_current_page == 0) {
/* use back buffer by default */
- imesa->drawMap = i810Screen->back.map;
- imesa->readMap = i810Screen->back.map;
imesa->BufferSetup[I810_DESTREG_DI1] = (i810Screen->backOffset |
i810Screen->backPitchBits);
} else {
/* use front buffer by default */
- imesa->drawMap = (char *)imesa->driScreen->pFB;
- imesa->readMap = (char *)imesa->driScreen->pFB;
imesa->BufferSetup[I810_DESTREG_DI1] = (i810Screen->fbOffset |
i810Screen->backPitchBits);
}
}
-static void i810InvalidateState( GLcontext *ctx, GLuint new_state )
+static void i810InvalidateState( struct gl_context *ctx, GLuint new_state )
{
_swrast_InvalidateState( ctx, new_state );
_swsetup_InvalidateState( ctx, new_state );
- _ac_InvalidateState( ctx, new_state );
+ _vbo_InvalidateState( ctx, new_state );
_tnl_InvalidateState( ctx, new_state );
I810_CONTEXT(ctx)->new_state |= new_state;
}
-void i810InitStateFuncs(GLcontext *ctx)
+void i810InitStateFuncs(struct gl_context *ctx)
{
/* Callbacks for internal Mesa events.
*/
} else {
ctx->Driver.LightModelfv = i810LightModelfv;
}
-
- /* Pixel path fallbacks.
- */
- ctx->Driver.Accum = _swrast_Accum;
- ctx->Driver.Bitmap = _swrast_Bitmap;
- ctx->Driver.CopyPixels = _swrast_CopyPixels;
- ctx->Driver.DrawPixels = _swrast_DrawPixels;
- ctx->Driver.ReadPixels = _swrast_ReadPixels;
-
- /* Swrast hooks for imaging extensions:
- */
- ctx->Driver.CopyColorTable = _swrast_CopyColorTable;
- ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable;
- ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D;
- ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D;
}
projects / mesa.git / blobdiff