gamma_state.c

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

/* $XFree86: xc/lib/GL/mesa/src/drv/gamma/gamma_state.c,v 1.5 2002/11/05 17:46:07 tsi Exp $ */
/*
 * Copyright 2001 by Alan Hourihane.
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Alan Hourihane not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Alan Hourihane makes no representations
 * about the suitability of this software for any purpose.  It is provided
 * "as is" without express or implied warranty.
 *
 * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL ALAN HOURIHANE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 *
 * Authors:  Alan Hourihane, <[e-mail]>
 *
 * 3DLabs Gamma driver
 */

#include "gamma_context.h"
#include "gamma_macros.h"
#include "buffers.h"
#include "macros.h"
#include "glint_dri.h"
#include "colormac.h"
#include "swrast/swrast.h"
#include "swrast_setup/swrast_setup.h"
#include "vbo/vbo.h"
#include "tnl/tnl.h"

#define ENABLELIGHTING 0

/* =============================================================
 * Alpha blending
 */

static void gammaUpdateAlphaMode( GLcontext *ctx )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
   u_int32_t a = gmesa->AlphaTestMode;
   u_int32_t b = gmesa->AlphaBlendMode;
   u_int32_t f = gmesa->AB_FBReadMode_Save = 0;
   GLubyte refByte = (GLint) (ctx->Color.AlphaRef * 255.0);

   a &= ~(AT_CompareMask | AT_RefValueMask);
   b &= ~(AB_SrcBlendMask | AB_DstBlendMask);

   a |= refByte << 4;

   switch ( ctx->Color.AlphaFunc ) {
      case GL_NEVER:
	 a |= AT_Never;
	 break;
      case GL_LESS:
	 a |= AT_Less;
         break;
      case GL_EQUAL:
	 a |= AT_Equal;
	 break;
      case GL_LEQUAL:
	 a |= AT_LessEqual;
	 break;
      case GL_GEQUAL:
	 a |= AT_GreaterEqual;
	 break;
      case GL_GREATER:
	 a |= AT_Greater;
	 break;
      case GL_NOTEQUAL:
	 a |= AT_NotEqual;
	 break;
      case GL_ALWAYS:
	 a |= AT_Always;
	 break;
   }

   if ( ctx->Color.AlphaEnabled ) {
      f |= FBReadDstEnable;
      a |= AlphaTestModeEnable;
   } else {
      a &= ~AlphaTestModeEnable;
   }

   switch ( ctx->Color.BlendSrcRGB ) {
      case GL_ZERO:
	 b |= AB_Src_Zero; 
	 break;
      case GL_ONE:
	 b |= AB_Src_One;
	 break;
      case GL_DST_COLOR:
	 b |= AB_Src_DstColor;
	 break;
      case GL_ONE_MINUS_DST_COLOR:
	 b |= AB_Src_OneMinusDstColor;
	 break;
      case GL_SRC_ALPHA:
	 b |= AB_Src_SrcAlpha;
	 break;
      case GL_ONE_MINUS_SRC_ALPHA:
	 b |= AB_Src_OneMinusSrcAlpha;
	 break;
      case GL_DST_ALPHA:
	 b |= AB_Src_DstAlpha;
         f |= FBReadSrcEnable;
	 break;
      case GL_ONE_MINUS_DST_ALPHA:
	 b |= AB_Src_OneMinusDstAlpha;
         f |= FBReadSrcEnable;
	 break;
      case GL_SRC_ALPHA_SATURATE:
	 b |= AB_Src_SrcAlphaSaturate;
	 break;
   }

   switch ( ctx->Color.BlendDstRGB ) {
      case GL_ZERO:
	 b |= AB_Dst_Zero;
	 break;
      case GL_ONE:
	 b |= AB_Dst_One;
	 break;
      case GL_SRC_COLOR:
	 b |= AB_Dst_SrcColor;
	 break;
      case GL_ONE_MINUS_SRC_COLOR:
	 b |= AB_Dst_OneMinusSrcColor;
	 break;
      case GL_SRC_ALPHA:
	 b |= AB_Dst_SrcAlpha;
	 break;
      case GL_ONE_MINUS_SRC_ALPHA:
	 b |= AB_Dst_OneMinusSrcAlpha;
	 break;
      case GL_DST_ALPHA:
	 b |= AB_Dst_DstAlpha;
         f |= FBReadSrcEnable;
	 break;
      case GL_ONE_MINUS_DST_ALPHA:
	 b |= AB_Dst_OneMinusDstAlpha;
         f |= FBReadSrcEnable;
	 break;
   }

   if ( ctx->Color.BlendEnabled ) {
      f |= FBReadDstEnable;
      b |= AlphaBlendModeEnable;
   } else {
      b &= ~AlphaBlendModeEnable;
   }

   if ( gmesa->AlphaTestMode != a ) {
      gmesa->AlphaTestMode = a;
      gmesa->dirty |= GAMMA_UPLOAD_ALPHA;
   }
   if ( gmesa->AlphaBlendMode != b) {
      gmesa->AlphaBlendMode = b;
      gmesa->dirty |= GAMMA_UPLOAD_BLEND;
   }
   gmesa->AB_FBReadMode_Save = f;
}

static void gammaDDAlphaFunc( GLcontext *ctx, GLenum func, GLfloat ref )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
   (void) ref;

   FLUSH_BATCH( gmesa );

   gmesa->new_state |= GAMMA_NEW_ALPHA;
}

static void gammaDDBlendEquationSeparate( GLcontext *ctx, 
					  GLenum modeRGB, GLenum modeA )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   assert( modeRGB == modeA );
   FLUSH_BATCH( gmesa );

   gmesa->new_state |= GAMMA_NEW_ALPHA;
}

static void gammaDDBlendFuncSeparate( GLcontext *ctx,
				     GLenum sfactorRGB, GLenum dfactorRGB,
				     GLenum sfactorA, GLenum dfactorA )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   FLUSH_BATCH( gmesa );

   gmesa->new_state |= GAMMA_NEW_ALPHA;
}


/* ================================================================
 * Buffer clear
 */

static void gammaDDClear( GLcontext *ctx, GLbitfield mask )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
   GLINTDRIPtr gDRIPriv = (GLINTDRIPtr)gmesa->driScreen->pDevPriv;
   GLuint temp = 0;

   FLUSH_BATCH( gmesa );

   /* Update and emit any new state.  We need to do this here to catch
    * changes to the masks.
    * FIXME: Just update the masks?
    */
   if ( gmesa->new_state )
      gammaDDUpdateHWState( ctx );

#ifdef DO_VALIDATE
    /* Flush any partially filled buffers */
    FLUSH_DMA_BUFFER(gmesa);

    DRM_SPINLOCK(&gmesa->driScreen->pSAREA->drawable_lock,
		 gmesa->driScreen->drawLockID);
    VALIDATE_DRAWABLE_INFO_NO_LOCK(gmesa);
#endif

    if (mask & BUFFER_BIT_DEPTH) {
	 /* Turn off writes the FB */
	 CHECK_DMA_BUFFER(gmesa, 1);
	 WRITE(gmesa->buf, FBWriteMode, FBWriteModeDisable);

	 mask &= ~BUFFER_BIT_DEPTH;

	 /*
	  * Turn Rectangle2DControl off when the window is not clipped
	  * (i.e., the GID tests are not necessary).  This dramatically
	  * increases the performance of the depth clears.
	  */
	 if (!gmesa->NotClipped) {
	    CHECK_DMA_BUFFER(gmesa, 1);
	    WRITE(gmesa->buf, Rectangle2DControl, 1);
	 }

	 temp = (gmesa->LBReadMode & LBPartialProdMask) | LBWindowOriginBot;
	 if (gDRIPriv->numMultiDevices == 2) temp |= LBScanLineInt2;
	 
	 CHECK_DMA_BUFFER(gmesa, 5);
	 WRITE(gmesa->buf, LBReadMode, temp);
	 WRITE(gmesa->buf, DeltaMode, DM_DepthEnable);
	 WRITE(gmesa->buf, DepthMode, (DepthModeEnable |
					DM_Always |
					DM_SourceDepthRegister |
					DM_WriteMask));
	 WRITE(gmesa->buf, GLINTDepth, gmesa->ClearDepth);

	 /* Increment the frame count */
	 gmesa->FrameCount++;
#ifdef FAST_CLEAR_4
	 gmesa->FrameCount &= 0x0f;
#else
	 gmesa->FrameCount &= 0xff;
#endif

	 /* Force FCP to be written */
	 WRITE(gmesa->buf, GLINTWindow, (WindowEnable |
					  W_PassIfEqual |
					  (gmesa->Window & W_GIDMask) |
					  W_DepthFCP |
					  W_LBUpdateFromRegisters |
					  W_OverrideWriteFiltering |
					  (gmesa->FrameCount << 9)));

	/* Clear part of the depth and FCP buffers */
	{
	    int y = gmesa->driScreen->fbHeight - gmesa->driDrawable->y - gmesa->driDrawable->h;
	    int x = gmesa->driDrawable->x;
	    int w = gmesa->driDrawable->w;
	    int h = gmesa->driDrawable->h;
#ifndef TURN_OFF_FCP
	    float hsub = h;

	    if (gmesa->WindowChanged) {
		gmesa->WindowChanged = GL_FALSE;
	    } else {
#ifdef FAST_CLEAR_4
		hsub /= 16;
#else
		hsub /= 256;
#endif

		/* Handle the case where the height < # of FCPs */
		if (hsub < 1.0) {
		    if (gmesa->FrameCount > h)
			gmesa->FrameCount = 0;
		    h = 1;
		    y += gmesa->FrameCount;
		} else {
		    h = (gmesa->FrameCount+1)*hsub;
		    h -= (int)(gmesa->FrameCount*hsub);
		    y += gmesa->FrameCount*hsub;
		}
	    }
#endif
	    if (h && w) {
#if 0
		CHECK_DMA_BUFFER(gmesa, 2);
		WRITE(gmesa->buf, Rectangle2DMode, ((h & 0xfff)<<12) |
						   (w & 0xfff) );
		WRITE(gmesa->buf, DrawRectangle2D, ((y & 0xffff)<<16) |
						   (x & 0xffff) );
#else
		CHECK_DMA_BUFFER(gmesa, 8);
		WRITE(gmesa->buf, StartXDom,   x<<16);
		WRITE(gmesa->buf, StartY,      y<<16);
		WRITE(gmesa->buf, StartXSub,   (x+w)<<16);
		WRITE(gmesa->buf, GLINTCount,  h);
		WRITE(gmesa->buf, dY,          1<<16);
		WRITE(gmesa->buf, dXDom,       0<<16);
		WRITE(gmesa->buf, dXSub,       0<<16);
		WRITE(gmesa->buf, Render,      0x00000040); /* NOT_DONE */
#endif
	    }
	}

	CHECK_DMA_BUFFER(gmesa, 6);
	WRITE(gmesa->buf, DepthMode, gmesa->DepthMode);
	WRITE(gmesa->buf, DeltaMode, gmesa->DeltaMode);
	WRITE(gmesa->buf, LBReadMode, gmesa->LBReadMode);
	WRITE(gmesa->buf, GLINTWindow, gmesa->Window);
	WRITE(gmesa->buf, FastClearDepth, gmesa->ClearDepth);
	WRITE(gmesa->buf, FBWriteMode, FBWriteModeEnable);

	/* Turn on Depth FCP */
	if (gmesa->Window & W_DepthFCP) {
	    CHECK_DMA_BUFFER(gmesa, 1);
	    WRITE(gmesa->buf, WindowOr, (gmesa->FrameCount << 9));
	}

	/* Turn off GID clipping if window is not clipped */
	if (gmesa->NotClipped) {
	    CHECK_DMA_BUFFER(gmesa, 1);
	    WRITE(gmesa->buf, Rectangle2DControl, 0);
	}
    }

    if (mask & (BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT)) {
	int y = gmesa->driScreen->fbHeight - gmesa->driDrawable->y - gmesa->driDrawable->h;
	int x = gmesa->driDrawable->x;
	int w = gmesa->driDrawable->w;
	int h = gmesa->driDrawable->h;

	mask &= ~(BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT);

	if (x < 0) { w -= -x; x = 0; }

	/* Turn on GID clipping if window is clipped */
	if (!gmesa->NotClipped) {
	    CHECK_DMA_BUFFER(gmesa, 1);
	    WRITE(gmesa->buf, Rectangle2DControl, 1);
	}

        CHECK_DMA_BUFFER(gmesa, 18);
        WRITE(gmesa->buf, FBBlockColor, gmesa->ClearColor);
        WRITE(gmesa->buf, ColorDDAMode, ColorDDADisable);
	WRITE(gmesa->buf, FBWriteMode, FBWriteModeEnable);
	WRITE(gmesa->buf, DepthMode, 0);
	WRITE(gmesa->buf, DeltaMode, 0);
	WRITE(gmesa->buf, AlphaBlendMode, 0);
#if 1
	WRITE(gmesa->buf, dY,          1<<16);
	WRITE(gmesa->buf, dXDom,       0<<16);
	WRITE(gmesa->buf, dXSub,       0<<16);
	WRITE(gmesa->buf, StartXSub,   (x+w)<<16);
	WRITE(gmesa->buf, GLINTCount,  h);
	WRITE(gmesa->buf, StartXDom,   x<<16);
	WRITE(gmesa->buf, StartY,      y<<16);
	WRITE(gmesa->buf, Render,      0x00000048); /* NOT_DONE */
#else
	WRITE(gmesa->buf, Rectangle2DMode, (((h & 0xfff)<<12) |
					      (w & 0xfff)));
	WRITE(gmesa->buf, DrawRectangle2D, (((y & 0xffff)<<16) |
					      (x & 0xffff)));
#endif
	WRITE(gmesa->buf, DepthMode, gmesa->DepthMode);
	WRITE(gmesa->buf, DeltaMode, gmesa->DeltaMode);
	WRITE(gmesa->buf, AlphaBlendMode, gmesa->AlphaBlendMode);
	WRITE(gmesa->buf, ColorDDAMode, gmesa->ColorDDAMode);

	/* Turn off GID clipping if window is clipped */
	if (gmesa->NotClipped) {
	    CHECK_DMA_BUFFER(gmesa, 1);
	    WRITE(gmesa->buf, Rectangle2DControl, 0);
	}
    }

#ifdef DO_VALIDATE
    PROCESS_DMA_BUFFER_TOP_HALF(gmesa);

    DRM_SPINUNLOCK(&gmesa->driScreen->pSAREA->drawable_lock,
		   gmesa->driScreen->drawLockID);
    VALIDATE_DRAWABLE_INFO_NO_LOCK_POST(gmesa);

    PROCESS_DMA_BUFFER_BOTTOM_HALF(gmesa);
#endif

   if ( mask )
      _swrast_Clear( ctx, mask );
}

/* =============================================================
 * Depth testing
 */

static void gammaUpdateZMode( GLcontext *ctx )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
   u_int32_t z = gmesa->DepthMode;
   u_int32_t delta = gmesa->DeltaMode;
   u_int32_t window = gmesa->Window;
   u_int32_t lbread = gmesa->LBReadMode;

   z &= ~DM_CompareMask;

   switch ( ctx->Depth.Func ) {
      case GL_NEVER:
	 z |= DM_Never;