ffb_state.c

Mesa is an open-source implementation of the OpenGL specification - a system for rendering interacti

/* $XFree86: xc/lib/GL/mesa/src/drv/ffb/ffb_state.c,v 1.5 2002/10/30 12:51:27 alanh Exp $
 *
 * GLX Hardware Device Driver for Sun Creator/Creator3D
 * Copyright (C) 2000, 2001 David S. Miller
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * DAVID MILLER, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, 
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 
 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 *
 *    David S. Miller <[e-mail]>
 */

#include "mtypes.h"
#include "colormac.h"
#include "mm.h"
#include "ffb_dd.h"
#include "ffb_span.h"
#include "ffb_depth.h"
#include "ffb_context.h"
#include "ffb_vb.h"
#include "ffb_tris.h"
#include "ffb_state.h"
#include "ffb_lock.h"
#include "extensions.h"
#include "enums.h"

#include "swrast/swrast.h"
#include "vbo/vbo.h"
#include "tnl/tnl.h"
#include "swrast_setup/swrast_setup.h"

#include "tnl/t_pipeline.h"

#undef STATE_TRACE

static unsigned int ffbComputeAlphaFunc(GLcontext *ctx)
{
	unsigned int xclip;
	GLubyte alphaRef;

#ifdef STATE_TRACE
	fprintf(stderr, "ffbDDAlphaFunc: func(%s) ref(%02x)\n",
		_mesa_lookup_enum_by_nr(ctx->Color.AlphaFunc),
		ctx->Color.AlphaRef & 0xff);
#endif

	switch (ctx->Color.AlphaFunc) {
	case GL_NEVER: xclip = FFB_XCLIP_TEST_NEVER; break;
	case GL_LESS: xclip = FFB_XCLIP_TEST_LT; break;
	case GL_EQUAL: xclip = FFB_XCLIP_TEST_EQ; break;
	case GL_LEQUAL: xclip = FFB_XCLIP_TEST_LE; break;
	case GL_GREATER: xclip = FFB_XCLIP_TEST_GT; break;
	case GL_NOTEQUAL: xclip = FFB_XCLIP_TEST_NE; break;
	case GL_GEQUAL: xclip = FFB_XCLIP_TEST_GE; break;
	case GL_ALWAYS: xclip = FFB_XCLIP_TEST_ALWAYS; break;

	default:
		return FFB_XCLIP_TEST_ALWAYS | 0x00;
	}

	CLAMPED_FLOAT_TO_UBYTE(alphaRef, ctx->Color.AlphaRef);
	xclip |= (alphaRef & 0xff);

	return xclip;
}

static void ffbDDAlphaFunc(GLcontext *ctx, GLenum func, GLfloat ref)
{
	ffbContextPtr fmesa = FFB_CONTEXT(ctx);

	if (ctx->Color.AlphaEnabled) {
		unsigned int xclip = ffbComputeAlphaFunc(ctx);

		if (fmesa->xclip != xclip) {
			fmesa->xclip = xclip;
			FFB_MAKE_DIRTY(fmesa, FFB_STATE_XCLIP, 1);
		}
	}
}

static void ffbDDBlendEquationSeparate(GLcontext *ctx, 
				       GLenum modeRGB, GLenum modeA)
{

#ifdef STATE_TRACE
	fprintf(stderr, "ffbDDBlendEquation: mode(%s)\n", 
		_mesa_lookup_enum_by_nr(modeRGB));
#endif
	assert( modeRGB == modeA );
	FALLBACK( ctx, (modeRGB != GL_FUNC_ADD), FFB_BADATTR_BLENDEQN);
}

static void ffbDDBlendFuncSeparate(GLcontext *ctx, GLenum sfactorRGB,
				   GLenum dfactorRGB, GLenum sfactorA,
				   GLenum dfactorA)
{
	ffbContextPtr fmesa = FFB_CONTEXT(ctx);
	unsigned int blendc = 1 << 4;

#ifdef STATE_TRACE
	fprintf(stderr, "ffbDDBlendFuncSeparate: sRGB(%s) dRGB(%s) sA(%s) dA(%s)\n",
		_mesa_lookup_enum_by_nr(sfactorRGB),
		_mesa_lookup_enum_by_nr(dfactorRGB),
		_mesa_lookup_enum_by_nr(sfactorA),
		_mesa_lookup_enum_by_nr(dfactorA));
#endif
	switch (ctx->Color.BlendSrcRGB) {
	case GL_ZERO:
		blendc |= (0 << 0);
		break;

	case GL_ONE:
		blendc |= (1 << 0);
		break;

	case GL_ONE_MINUS_SRC_ALPHA:
		blendc |= (2 << 0);
		break;

	case GL_SRC_ALPHA:
		blendc |= (3 << 0);
		break;

	default:
		if (ctx->Color.BlendEnabled)
			FALLBACK( ctx, FFB_BADATTR_BLENDFUNC, GL_TRUE );
		return;
	};

	switch (ctx->Color.BlendDstRGB) {
	case GL_ZERO:
		blendc |= (0 << 2);
		break;

	case GL_ONE:
		blendc |= (1 << 2);
		break;

	case GL_ONE_MINUS_SRC_ALPHA:
		blendc |= (2 << 2);
		break;

	case GL_SRC_ALPHA:
		blendc |= (3 << 2);
		break;

	default:
		if (ctx->Color.BlendEnabled)
			FALLBACK( ctx, FFB_BADATTR_BLENDFUNC, GL_TRUE );
		return;
	};

	if (ctx->Color.BlendEnabled &&
	    ctx->Color.ColorLogicOpEnabled &&
	    ctx->Color.LogicOp != GL_COPY) {
		/* We could avoid this if sfactor is GL_ONE and
		 * dfactor is GL_ZERO.  I do not think that is even
		 * worthwhile to check because if someone is using
		 * blending they use more interesting settings and
		 * also it would add more state tracking to a lot
		 * of the code in this file.
		 */
		FALLBACK(ctx, FFB_BADATTR_BLENDROP, GL_TRUE);
		return;
	}

	FALLBACK( ctx, (FFB_BADATTR_BLENDFUNC|FFB_BADATTR_BLENDROP), GL_FALSE );

	if (blendc != fmesa->blendc) {
		fmesa->blendc = blendc;
		FFB_MAKE_DIRTY(fmesa, FFB_STATE_BLEND, 1);
	}
}

static void ffbDDDepthFunc(GLcontext *ctx, GLenum func)
{
	ffbContextPtr fmesa = FFB_CONTEXT(ctx);
	GLuint cmp;

#ifdef STATE_TRACE
	fprintf(stderr, "ffbDDDepthFunc: func(%s)\n",
		_mesa_lookup_enum_by_nr(func));
#endif

	switch (func) {
	case GL_NEVER:
		cmp = FFB_CMP_MAGN_NEVER;
		break;
	case GL_ALWAYS:
		cmp = FFB_CMP_MAGN_ALWAYS;
		break;
	case GL_LESS:
		cmp = FFB_CMP_MAGN_LT;
		break;
	case GL_LEQUAL:
		cmp = FFB_CMP_MAGN_LE;
		break;
	case GL_EQUAL:
		cmp = FFB_CMP_MAGN_EQ;
		break;
	case GL_GREATER:
		cmp = FFB_CMP_MAGN_GT;
		break;
	case GL_GEQUAL:
		cmp = FFB_CMP_MAGN_GE;
		break;
	case GL_NOTEQUAL:
		cmp = FFB_CMP_MAGN_NE;
		break;
	default:
		return;
	};

	if (! ctx->Depth.Test)
		cmp = FFB_CMP_MAGN_ALWAYS;

	cmp <<= 16;
	cmp = (fmesa->cmp & ~(0xff<<16)) | cmp;
	if (cmp != fmesa->cmp) {
		fmesa->cmp = cmp;
		FFB_MAKE_DIRTY(fmesa, FFB_STATE_CMP, 1);
	}
}

static void ffbDDDepthMask(GLcontext *ctx, GLboolean flag)
{
	ffbContextPtr fmesa = FFB_CONTEXT(ctx);
	GLuint fbc = fmesa->fbc;
	GLboolean enabled_now;

#ifdef STATE_TRACE
	fprintf(stderr, "ffbDDDepthMask: flag(%d)\n", flag);
#endif

	if ((fbc & FFB_FBC_ZE_MASK) == FFB_FBC_ZE_OFF)
		enabled_now = GL_FALSE;
	else
		enabled_now = GL_TRUE;

	if (flag != enabled_now) {
		fbc &= ~FFB_FBC_ZE_MASK;
		if (flag) {
			fbc |= FFB_FBC_WB_C | FFB_FBC_ZE_ON;
		} else {
			fbc |= FFB_FBC_ZE_OFF;
			fbc &= ~FFB_FBC_WB_C;
		}
		fmesa->fbc = fbc;
		FFB_MAKE_DIRTY(fmesa, FFB_STATE_FBC, 1);
	}
}

static void
ffbDDStencilFuncSeparate(GLcontext *ctx, GLenum face, GLenum func,
                         GLint ref, GLuint mask)
{
	ffbContextPtr fmesa = FFB_CONTEXT(ctx);
	unsigned int stencil, stencilctl, consty;

	/* We will properly update sw/hw state when stenciling is
	 * enabled.
	 */
	if (! ctx->Stencil.Enabled)
		return;

	stencilctl = fmesa->stencilctl;
	stencilctl &= ~(7 << 16);

	switch (func) {
	case GL_ALWAYS:		stencilctl |= (0 << 16); break;
	case GL_GREATER:	stencilctl |= (1 << 16); break;
	case GL_EQUAL:		stencilctl |= (2 << 16); break;
	case GL_GEQUAL:		stencilctl |= (3 << 16); break;
	case GL_NEVER:		stencilctl |= (4 << 16); break;
	case GL_LEQUAL:		stencilctl |= (5 << 16); break;
	case GL_NOTEQUAL:	stencilctl |= (6 << 16); break;
	case GL_LESS:		stencilctl |= (7 << 16); break;

	default:
		return;
	};

	consty = ref & 0xf;

	stencil = fmesa->stencil;
	stencil &= ~(0xf << 20);
	stencil |= (mask & 0xf) << 20;

	if (fmesa->stencil != stencil ||
	    fmesa->stencilctl != stencilctl ||
	    fmesa->consty != consty) {
		fmesa->stencil = stencil;
		fmesa->stencilctl = stencilctl;
		fmesa->consty = consty;
		FFB_MAKE_DIRTY(fmesa, FFB_STATE_STENCIL, 6);
	}
}

static void
ffbDDStencilMaskSeparate(GLcontext *ctx, GLenum face, GLuint mask)
{
	ffbContextPtr fmesa = FFB_CONTEXT(ctx);

	mask &= 0xf;
	if (fmesa->ypmask != mask) {
		fmesa->ypmask = mask;
		FFB_MAKE_DIRTY(fmesa, FFB_STATE_YPMASK, 1);
	}
}

static void
ffbDDStencilOpSeparate(GLcontext *ctx, GLenum face, GLenum fail,
                       GLenum zfail, GLenum zpass)
{
	ffbContextPtr fmesa = FFB_CONTEXT(ctx);
	unsigned int stencilctl;

	/* We will properly update sw/hw state when stenciling is
	 * enabled.
	 */
	if (! ctx->Stencil.Enabled)
		return;

	stencilctl = fmesa->stencilctl;
	stencilctl &= ~(0xfff00000);

	switch (fail) {
	case GL_ZERO:		stencilctl |= (0 << 28); break;
	case GL_KEEP:		stencilctl |= (1 << 28); break;
	case GL_INVERT:		stencilctl |= (2 << 28); break;
	case GL_REPLACE:	stencilctl |= (3 << 28); break;
	case GL_INCR:		stencilctl |= (4 << 28); break;
	case GL_DECR:		stencilctl |= (5 << 28); break;

	default:
		return;
	};

	switch (zfail) {
	case GL_ZERO:		stencilctl |= (0 << 24); break;
	case GL_KEEP:		stencilctl |= (1 << 24); break;
	case GL_INVERT:		stencilctl |= (2 << 24); break;
	case GL_REPLACE:	stencilctl |= (3 << 24); break;
	case GL_INCR:		stencilctl |= (4 << 24); break;
	case GL_DECR:		stencilctl |= (5 << 24); break;

	default:
		return;
	};

	switch (zpass) {
	case GL_ZERO:		stencilctl |= (0 << 20); break;
	case GL_KEEP:		stencilctl |= (1 << 20); break;
	case GL_INVERT:		stencilctl |= (2 << 20); break;
	case GL_REPLACE:	stencilctl |= (3 << 20); break;
	case GL_INCR:		stencilctl |= (4 << 20); break;
	case GL_DECR:		stencilctl |= (5 << 20); break;

	default:
		return;
	};

	if (fmesa->stencilctl != stencilctl) {
		fmesa->stencilctl = stencilctl;
		FFB_MAKE_DIRTY(fmesa, FFB_STATE_STENCIL, 6);
	}
}

static void ffbCalcViewportRegs(GLcontext *ctx)
{
	ffbContextPtr fmesa = FFB_CONTEXT(ctx);
	__DRIdrawablePrivate *dPriv = fmesa->driDrawable;
	GLuint xmin, xmax, ymin, ymax, zmin, zmax;
	unsigned int vcmin, vcmax;

	xmin = ctx->Viewport.X + dPriv->x;
	xmax = xmin + ctx->Viewport.Width;
	ymax = dPriv->y + dPriv->h - ctx->Viewport.Y;
	ymin = ymax - ctx->Viewport.Height;
	if (ctx->Scissor.Enabled) {
		GLuint sc_xmin, sc_xmax, sc_ymin, sc_ymax;

		sc_xmin = ctx->Viewport.X + dPriv->x;
		sc_xmax = sc_xmin + ctx->Viewport.Width;
		sc_ymax = dPriv->y + dPriv->h - ctx->Viewport.Y;
		sc_ymin = sc_ymax - ctx->Viewport.Height;
		if (sc_xmin > xmin)
			xmin = sc_xmin;
		if (sc_xmax < xmax)
			xmax = sc_xmax;
		if (sc_ymin > ymin)
			ymin = sc_ymin;
		if (sc_ymax < ymax)
			ymax = sc_ymax;
	}