mach64_state.c

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

/* $XFree86$ */ /* -*- mode: c; c-basic-offset: 3 -*- */
/*
 * Copyright 2000 Gareth Hughes
 * 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"),
 * 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 (including the next
 * paragraph) 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
 * GARETH HUGHES 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.
 */

/*
 * Authors:
 *	Gareth Hughes <[e-mail]>
 *	Leif Delgass <[e-mail]>
 *	Jos�Fonseca <[e-mail]>
 */

#include "mach64_context.h"
#include "mach64_state.h"
#include "mach64_ioctl.h"
#include "mach64_tris.h"
#include "mach64_vb.h"
#include "mach64_tex.h"

#include "context.h"
#include "enums.h"
#include "colormac.h"
#include "swrast/swrast.h"
#include "vbo/vbo.h"
#include "tnl/tnl.h"
#include "swrast_setup/swrast_setup.h"

#include "tnl/t_pipeline.h"


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

static void mach64UpdateAlphaMode( GLcontext *ctx )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
   GLuint a = mmesa->setup.alpha_tst_cntl;
   GLuint s = mmesa->setup.scale_3d_cntl;
   GLuint m = mmesa->setup.dp_write_mask;

   if ( ctx->Color.AlphaEnabled ) {
      GLubyte ref;

      CLAMPED_FLOAT_TO_UBYTE(ref, ctx->Color.AlphaRef);

      a &= ~(MACH64_ALPHA_TEST_MASK | MACH64_REF_ALPHA_MASK);

      switch ( ctx->Color.AlphaFunc ) {
      case GL_NEVER:
	 a |= MACH64_ALPHA_TEST_NEVER;
	 break;
      case GL_LESS:
	 a |= MACH64_ALPHA_TEST_LESS;
         break;
      case GL_LEQUAL:
	 a |= MACH64_ALPHA_TEST_LEQUAL;
	 break;
      case GL_EQUAL:
	 a |= MACH64_ALPHA_TEST_EQUAL;
	 break;
      case GL_GEQUAL:
	 a |= MACH64_ALPHA_TEST_GEQUAL;
	 break;
      case GL_GREATER:
	 a |= MACH64_ALPHA_TEST_GREATER;
	 break;
      case GL_NOTEQUAL:
	 a |= MACH64_ALPHA_TEST_NOTEQUAL;
	 break;
      case GL_ALWAYS:
	 a |= MACH64_ALPHA_TEST_ALWAYS;
	 break;
      }

      a |= (ref << MACH64_REF_ALPHA_SHIFT);
      a |=  MACH64_ALPHA_TEST_EN;
   } else {
      a &= ~MACH64_ALPHA_TEST_EN;
   }

   FALLBACK( mmesa, MACH64_FALLBACK_BLEND_FUNC, GL_FALSE );

   if ( ctx->Color.BlendEnabled ) {
      s &= ~(MACH64_ALPHA_BLEND_SRC_MASK |
	     MACH64_ALPHA_BLEND_DST_MASK |
	     MACH64_ALPHA_BLEND_SAT);

      switch ( ctx->Color.BlendSrcRGB ) {
      case GL_ZERO:
	 s |= MACH64_ALPHA_BLEND_SRC_ZERO;
	 break;
      case GL_ONE:
	 s |= MACH64_ALPHA_BLEND_SRC_ONE;
	 break;
      case GL_DST_COLOR:
	 s |= MACH64_ALPHA_BLEND_SRC_DSTCOLOR;
	 break;
      case GL_ONE_MINUS_DST_COLOR:
	 s |= MACH64_ALPHA_BLEND_SRC_INVDSTCOLOR;
	 break;
      case GL_SRC_ALPHA:
	 s |= MACH64_ALPHA_BLEND_SRC_SRCALPHA;
	 break;
      case GL_ONE_MINUS_SRC_ALPHA:
	 s |= MACH64_ALPHA_BLEND_SRC_INVSRCALPHA;
	 break;
      case GL_DST_ALPHA:
	 s |= MACH64_ALPHA_BLEND_SRC_DSTALPHA;
	 break;
      case GL_ONE_MINUS_DST_ALPHA:
	 s |= MACH64_ALPHA_BLEND_SRC_INVDSTALPHA;
	 break;
      case GL_SRC_ALPHA_SATURATE:
	 s |= (MACH64_ALPHA_BLEND_SRC_SRCALPHA |
	       MACH64_ALPHA_BLEND_SAT);
	 break;
      default:
         FALLBACK( mmesa, MACH64_FALLBACK_BLEND_FUNC, GL_TRUE );
      }

      switch ( ctx->Color.BlendDstRGB ) {
      case GL_ZERO:
	 s |= MACH64_ALPHA_BLEND_DST_ZERO;
	 break;
      case GL_ONE:
	 s |= MACH64_ALPHA_BLEND_DST_ONE;
	 break;
      case GL_SRC_COLOR:
	 s |= MACH64_ALPHA_BLEND_DST_SRCCOLOR;
	 break;
      case GL_ONE_MINUS_SRC_COLOR:
	 s |= MACH64_ALPHA_BLEND_DST_INVSRCCOLOR;
	 break;
      case GL_SRC_ALPHA:
	 s |= MACH64_ALPHA_BLEND_DST_SRCALPHA;
	 break;
      case GL_ONE_MINUS_SRC_ALPHA:
	 s |= MACH64_ALPHA_BLEND_DST_INVSRCALPHA;
	 break;
      case GL_DST_ALPHA:
	 s |= MACH64_ALPHA_BLEND_DST_DSTALPHA;
	 break;
      case GL_ONE_MINUS_DST_ALPHA:
	 s |= MACH64_ALPHA_BLEND_DST_INVDSTALPHA;
	 break;
      default:
         FALLBACK( mmesa, MACH64_FALLBACK_BLEND_FUNC, GL_TRUE );
      }

      m = 0xffffffff; /* Can't color mask and blend at the same time */
      s &= ~MACH64_ALPHA_FOG_EN_FOG; /* Can't fog and blend at the same time */
      s |=  MACH64_ALPHA_FOG_EN_ALPHA;
   } else {
      s &= ~MACH64_ALPHA_FOG_EN_ALPHA;
   }

   if ( mmesa->setup.alpha_tst_cntl != a ) {
      mmesa->setup.alpha_tst_cntl = a;
      mmesa->dirty |= MACH64_UPLOAD_Z_ALPHA_CNTL;
   }
   if ( mmesa->setup.scale_3d_cntl != s ) {
      mmesa->setup.scale_3d_cntl = s;
      mmesa->dirty |= MACH64_UPLOAD_SCALE_3D_CNTL;
   }
   if ( mmesa->setup.dp_write_mask != m ) {
      mmesa->setup.dp_write_mask = m;
      mmesa->dirty |= MACH64_UPLOAD_DP_WRITE_MASK;
   }
}

static void mach64DDAlphaFunc( GLcontext *ctx, GLenum func, GLfloat ref )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);

   FLUSH_BATCH( mmesa );
   mmesa->new_state |= MACH64_NEW_ALPHA;
}

static void mach64DDBlendEquationSeparate( GLcontext *ctx, 
					   GLenum modeRGB, GLenum modeA )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);

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

   /* BlendEquation affects ColorLogicOpEnabled
    */
   FALLBACK( MACH64_CONTEXT(ctx), MACH64_FALLBACK_LOGICOP,
	     (ctx->Color.ColorLogicOpEnabled &&
	      ctx->Color.LogicOp != GL_COPY));

   /* Can only do blend addition, not min, max, subtract, etc. */
   FALLBACK( MACH64_CONTEXT(ctx), MACH64_FALLBACK_BLEND_EQ,
	     modeRGB != GL_FUNC_ADD);

   mmesa->new_state |= MACH64_NEW_ALPHA;
}

static void mach64DDBlendFuncSeparate( GLcontext *ctx,
				       GLenum sfactorRGB, GLenum dfactorRGB,
				       GLenum sfactorA, GLenum dfactorA )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);

   FLUSH_BATCH( mmesa );
   mmesa->new_state |= MACH64_NEW_ALPHA;
}


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

static void mach64UpdateZMode( GLcontext *ctx )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
   GLuint z = mmesa->setup.z_cntl;

   if ( MACH64_DEBUG & DEBUG_VERBOSE_MSG ) {
      fprintf( stderr, "%s:\n", __FUNCTION__ );
   }

   if ( ctx->Depth.Test ) {
      z &= ~MACH64_Z_TEST_MASK;

      switch ( ctx->Depth.Func ) {
      case GL_NEVER:
	 z |= MACH64_Z_TEST_NEVER;
	 break;
      case GL_ALWAYS:
	 z |= MACH64_Z_TEST_ALWAYS;
	 break;
      case GL_LESS:
	 z |= MACH64_Z_TEST_LESS;
	 break;
      case GL_LEQUAL:
	 z |= MACH64_Z_TEST_LEQUAL;
	 break;
      case GL_EQUAL:
	 z |= MACH64_Z_TEST_EQUAL;
	 break;
      case GL_GEQUAL:
	 z |= MACH64_Z_TEST_GEQUAL;
	 break;
      case GL_GREATER:
	 z |= MACH64_Z_TEST_GREATER;
	 break;
      case GL_NOTEQUAL:
	 z |= MACH64_Z_TEST_NOTEQUAL;
	 break;
      }

      z |=  MACH64_Z_EN;
   } else {
      z &= ~MACH64_Z_EN;
   }

   if ( ctx->Depth.Mask ) {
      z |=  MACH64_Z_MASK_EN;
   } else {
      z &= ~MACH64_Z_MASK_EN;
   }

   if ( mmesa->setup.z_cntl != z ) {
      mmesa->setup.z_cntl = z;
      mmesa->dirty |= MACH64_UPLOAD_Z_ALPHA_CNTL;
   }
}

static void mach64DDDepthFunc( GLcontext *ctx, GLenum func )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);

   FLUSH_BATCH( mmesa );
   mmesa->new_state |= MACH64_NEW_DEPTH;
}

static void mach64DDDepthMask( GLcontext *ctx, GLboolean flag )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);

   FLUSH_BATCH( mmesa );
   mmesa->new_state |= MACH64_NEW_DEPTH;
}

static void mach64DDClearDepth( GLcontext *ctx, GLclampd d )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);

   /* Always have a 16-bit depth buffer.
    */
   mmesa->ClearDepth = d * 0xffff;
}


/* =============================================================
 * Fog
 */

static void mach64UpdateFogAttrib( GLcontext *ctx )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);

   CARD32 s = mmesa->setup.scale_3d_cntl;
   GLubyte c[4];
   CARD32 col;

   /* Can't fog if blending is on */
   if ( ctx->Color.BlendEnabled )
      return;

   if ( ctx->Fog.Enabled ) {
      s |= MACH64_ALPHA_FOG_EN_FOG;
      s &= ~(MACH64_ALPHA_BLEND_SRC_MASK |
	     MACH64_ALPHA_BLEND_DST_MASK |
	     MACH64_ALPHA_BLEND_SAT);
      /* From Utah-glx: "fog color is now dest and fog factor is alpha, so
       * use GL_SRC_ALPHA GL_ONE_MINUS_SRC_ALPHA"
       */
      s |= (MACH64_ALPHA_BLEND_SRC_SRCALPHA | 
	    MACH64_ALPHA_BLEND_DST_INVSRCALPHA);
      /* From Utah-glx: "can't use texture alpha when fogging" */
      s &= ~MACH64_TEX_MAP_AEN;
   } else {
      s &= ~(MACH64_ALPHA_BLEND_SRC_MASK |
	     MACH64_ALPHA_BLEND_DST_MASK |
	     MACH64_ALPHA_BLEND_SAT);
      s |= (MACH64_ALPHA_BLEND_SRC_ONE | 
	    MACH64_ALPHA_BLEND_DST_ZERO);
      s &= ~MACH64_ALPHA_FOG_EN_FOG;
   }

   c[0] = FLOAT_TO_UBYTE( ctx->Fog.Color[0] );
   c[1] = FLOAT_TO_UBYTE( ctx->Fog.Color[1] );
   c[2] = FLOAT_TO_UBYTE( ctx->Fog.Color[2] );
   c[3] = FLOAT_TO_UBYTE( ctx->Fog.Color[3] );

   col = mach64PackColor( 4, c[0], c[1], c[2], c[3] );

   if ( mmesa->setup.dp_fog_clr != col ) {
      mmesa->setup.dp_fog_clr = col;
      mmesa->dirty |= MACH64_UPLOAD_DP_FOG_CLR;
   }
   if ( mmesa->setup.scale_3d_cntl != s ) {
      mmesa->setup.scale_3d_cntl = s;
      mmesa->dirty |= MACH64_UPLOAD_SCALE_3D_CNTL;
   }

}

static void mach64DDFogfv( GLcontext *ctx, GLenum pname, const GLfloat *param )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);

   FLUSH_BATCH( mmesa );
   mmesa->new_state |= MACH64_NEW_FOG;
}


/* =============================================================
 * Clipping
 */

static void mach64UpdateClipping( GLcontext *ctx )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
   mach64ScreenPtr mach64Screen = mmesa->mach64Screen;

   if ( mmesa->driDrawable ) {
      __DRIdrawablePrivate *drawable = mmesa->driDrawable;
      int x1 = 0;
      int y1 = 0;
      int x2 = drawable->w - 1;
      int y2 = drawable->h - 1;

      if ( ctx->Scissor.Enabled ) {
	 if ( ctx->Scissor.X > x1 ) {