mach64_state.c

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

	    x1 = ctx->Scissor.X;
	 }
	 if ( drawable->h - ctx->Scissor.Y - ctx->Scissor.Height > y1 ) {
	    y1 = drawable->h - ctx->Scissor.Y - ctx->Scissor.Height;
	 }
	 if ( ctx->Scissor.X + ctx->Scissor.Width - 1 < x2 ) {
	    x2 = ctx->Scissor.X + ctx->Scissor.Width - 1;
	 }
	 if ( drawable->h - ctx->Scissor.Y - 1 < y2 ) {
	    y2 = drawable->h - ctx->Scissor.Y - 1;
	 }
      }

      x1 += drawable->x;
      y1 += drawable->y;
      x2 += drawable->x;
      y2 += drawable->y;

      /* clamp to screen borders */
      if (x1 < 0) x1 = 0;
      if (y1 < 0) y1 = 0;
      if (x2 < 0) x2 = 0;
      if (y2 < 0) y2 = 0;
      if (x2 > mach64Screen->width-1) x2 = mach64Screen->width-1;
      if (y2 > mach64Screen->height-1) y2 = mach64Screen->height-1;

      if ( MACH64_DEBUG & DEBUG_VERBOSE_MSG ) {
	 fprintf( stderr, "%s: drawable %3d %3d %3d %3d\n",
		  __FUNCTION__,
		  drawable->x,
		  drawable->y,
		  drawable->w,
		  drawable->h );
	 fprintf( stderr, "%s:  scissor %3d %3d %3d %3d\n",
		  __FUNCTION__,
		  ctx->Scissor.X,
		  ctx->Scissor.Y,
		  ctx->Scissor.Width,
		  ctx->Scissor.Height );
	 fprintf( stderr, "%s:    final %3d %3d %3d %3d\n",
		  __FUNCTION__, x1, y1, x2, y2 );
	 fprintf( stderr, "\n" );
      }

      mmesa->setup.sc_top_bottom = ((y1 << 0) |
				    (y2 << 16));

      mmesa->setup.sc_left_right = ((x1 << 0) |
				    (x2 << 16));

       /* UPLOAD_MISC reduces the dirty state, we just need to
       * emit the scissor to the SAREA.  We need to dirty cliprects
       * since the scissor and cliprects are intersected to update the
       * single hardware scissor
       */
      mmesa->dirty |= MACH64_UPLOAD_MISC | MACH64_UPLOAD_CLIPRECTS;
   }
}

static void mach64DDScissor( GLcontext *ctx,
			     GLint x, GLint y, GLsizei w, GLsizei h )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);

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


/* =============================================================
 * Culling
 */

static void mach64UpdateCull( GLcontext *ctx )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
   GLfloat backface_sign = 1;

   if ( ctx->Polygon.CullFlag /*&& ctx->PB->primitive == GL_POLYGON*/ ) {
      backface_sign = 1;
      switch ( ctx->Polygon.CullFaceMode ) {
      case GL_BACK:
	 if ( ctx->Polygon.FrontFace == GL_CCW )
	    backface_sign = -1;
	 break;
      case GL_FRONT:
	 if ( ctx->Polygon.FrontFace != GL_CCW )
	    backface_sign = -1;
	 break;
      default:
      case GL_FRONT_AND_BACK:
	 backface_sign = 0;
	 break;
      }
   } else {
      backface_sign = 0;
   }

   mmesa->backface_sign = backface_sign;

}

static void mach64DDCullFace( GLcontext *ctx, GLenum mode )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);

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

static void mach64DDFrontFace( GLcontext *ctx, GLenum mode )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);

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


/* =============================================================
 * Masks
 */

static void mach64UpdateMasks( GLcontext *ctx )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
   GLuint mask = 0xffffffff;

   /* mach64 can't color mask with alpha blending enabled */
   if ( !ctx->Color.BlendEnabled ) {
      mask = mach64PackColor( mmesa->mach64Screen->cpp,
			      ctx->Color.ColorMask[RCOMP],
			      ctx->Color.ColorMask[GCOMP],
			      ctx->Color.ColorMask[BCOMP],
			      ctx->Color.ColorMask[ACOMP] );
   }

   if ( mmesa->setup.dp_write_mask != mask ) {
      mmesa->setup.dp_write_mask = mask;
      mmesa->dirty |= MACH64_UPLOAD_DP_WRITE_MASK;
   }
}

static void mach64DDColorMask( GLcontext *ctx,
			       GLboolean r, GLboolean g,
			       GLboolean b, GLboolean a )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);

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


/* =============================================================
 * Rendering attributes
 *
 * We really don't want to recalculate all this every time we bind a
 * texture.  These things shouldn't change all that often, so it makes
 * sense to break them out of the core texture state update routines.
 */

static void mach64UpdateSpecularLighting( GLcontext *ctx )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
   GLuint a = mmesa->setup.alpha_tst_cntl;

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

   if ( ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR  &&
        ctx->Light.Enabled ) {
      a |=  MACH64_SPECULAR_LIGHT_EN;
   } else {
      a &= ~MACH64_SPECULAR_LIGHT_EN;
   }

   if ( mmesa->setup.alpha_tst_cntl != a ) {
      mmesa->setup.alpha_tst_cntl = a;
      mmesa->dirty |= MACH64_UPLOAD_Z_ALPHA_CNTL;
      mmesa->new_state |= MACH64_NEW_CONTEXT;
   }
}

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

   if ( pname == GL_LIGHT_MODEL_COLOR_CONTROL ) {
      FLUSH_BATCH( mmesa );
      mach64UpdateSpecularLighting(ctx);
   }
}

static void mach64DDShadeModel( GLcontext *ctx, GLenum mode )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
   GLuint s = mmesa->setup.setup_cntl;

   s &= ~MACH64_FLAT_SHADE_MASK;

   switch ( mode ) {
   case GL_FLAT:
      s |= MACH64_FLAT_SHADE_VERTEX_3;
      break;
   case GL_SMOOTH:
      s |= MACH64_FLAT_SHADE_OFF;
      break;
   default:
      return;
   }

   if ( mmesa->setup.setup_cntl != s ) {
      FLUSH_BATCH( mmesa );
      mmesa->setup.setup_cntl = s;

      mmesa->dirty |= MACH64_UPLOAD_SETUP_CNTL;
   }
}


/* =============================================================
 * Viewport
 */


void mach64CalcViewport( GLcontext *ctx )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
   const GLfloat *v = ctx->Viewport._WindowMap.m;
   GLfloat *m = mmesa->hw_viewport;

   /* See also mach64_translate_vertex.
    */
   m[MAT_SX] =   v[MAT_SX];
   m[MAT_TX] =   v[MAT_TX] + (GLfloat)mmesa->drawX + SUBPIXEL_X;
   m[MAT_SY] = - v[MAT_SY];
   m[MAT_TY] = - v[MAT_TY] + mmesa->driDrawable->h + (GLfloat)mmesa->drawY + SUBPIXEL_Y;
   m[MAT_SZ] =   v[MAT_SZ] * mmesa->depth_scale;
   m[MAT_TZ] =   v[MAT_TZ] * mmesa->depth_scale;

   mmesa->SetupNewInputs = ~0;
}

static void mach64Viewport( GLcontext *ctx,
			  GLint x, GLint y,
			  GLsizei width, GLsizei height )
{
   mach64CalcViewport( ctx );
}

static void mach64DepthRange( GLcontext *ctx,
			    GLclampd nearval, GLclampd farval )
{
   mach64CalcViewport( ctx );
}


/* =============================================================
 * Miscellaneous
 */

static void mach64DDClearColor( GLcontext *ctx,
				const GLfloat color[4] )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
   GLubyte c[4];
   
   CLAMPED_FLOAT_TO_UBYTE(c[0], color[0]);
   CLAMPED_FLOAT_TO_UBYTE(c[1], color[1]);
   CLAMPED_FLOAT_TO_UBYTE(c[2], color[2]);
   CLAMPED_FLOAT_TO_UBYTE(c[3], color[3]);

   mmesa->ClearColor = mach64PackColor( mmesa->mach64Screen->cpp,
					c[0], c[1], c[2], c[3] );
}

static void mach64DDLogicOpCode( GLcontext *ctx, GLenum opcode )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
   
   if ( ctx->Color.ColorLogicOpEnabled ) {
      FLUSH_BATCH( mmesa );

      FALLBACK( mmesa, MACH64_FALLBACK_LOGICOP, opcode != GL_COPY);
   }
}

void mach64SetCliprects( GLcontext *ctx, GLenum mode )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
   __DRIdrawablePrivate *dPriv = mmesa->driDrawable;

   switch ( mode ) {
   case GL_FRONT_LEFT:
      mmesa->numClipRects = dPriv->numClipRects;
      mmesa->pClipRects = dPriv->pClipRects;
      mmesa->drawX = dPriv->x;
      mmesa->drawY = dPriv->y;
      break;
   case GL_BACK_LEFT:
      if ( dPriv->numBackClipRects == 0 ) {
	 mmesa->numClipRects = dPriv->numClipRects;
	 mmesa->pClipRects = dPriv->pClipRects;
	 mmesa->drawX = dPriv->x;
	 mmesa->drawY = dPriv->y;
      } else {
	 mmesa->numClipRects = dPriv->numBackClipRects;
	 mmesa->pClipRects = dPriv->pBackClipRects;
	 mmesa->drawX = dPriv->backX;
	 mmesa->drawY = dPriv->backY;
      }
      break;
   default:
      return;
   }

   mach64UpdateClipping( ctx );

   mmesa->dirty |= MACH64_UPLOAD_CLIPRECTS;
}

static void mach64DDDrawBuffer( GLcontext *ctx, GLenum mode )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);

   FLUSH_BATCH( mmesa );

   if (ctx->DrawBuffer->_NumColorDrawBuffers != 1) {
      /* GL_NONE or GL_FRONT_AND_BACK or stereo left&right, etc */
      FALLBACK( mmesa, MACH64_FALLBACK_DRAW_BUFFER, GL_TRUE );
      return;
   }

   switch ( ctx->DrawBuffer->_ColorDrawBufferIndexes[0] ) {
   case BUFFER_FRONT_LEFT:
      FALLBACK( mmesa, MACH64_FALLBACK_DRAW_BUFFER, GL_FALSE );
      mach64SetCliprects( ctx, GL_FRONT_LEFT );
      if (MACH64_DEBUG & DEBUG_VERBOSE_MSG)
	 fprintf(stderr,"%s: BUFFER_BIT_FRONT_LEFT\n", __FUNCTION__);
      break;
   case BUFFER_BACK_LEFT:
      FALLBACK( mmesa, MACH64_FALLBACK_DRAW_BUFFER, GL_FALSE );
      mach64SetCliprects( ctx, GL_BACK_LEFT );
      if (MACH64_DEBUG & DEBUG_VERBOSE_MSG)
	 fprintf(stderr,"%s: BUFFER_BIT_BACK_LEFT\n", __FUNCTION__);
      break;
   default:
      FALLBACK( mmesa, MACH64_FALLBACK_DRAW_BUFFER, GL_TRUE );
      if (MACH64_DEBUG & DEBUG_VERBOSE_MSG)
	 fprintf(stderr,"%s: fallback (mode=%d)\n", __FUNCTION__, mode);
      break;
   }

   mmesa->setup.dst_off_pitch = (((mmesa->drawPitch/8) << 22) |
				 (mmesa->drawOffset >> 3));

   mmesa->dirty |= MACH64_UPLOAD_DST_OFF_PITCH;
}

static void mach64DDReadBuffer( GLcontext *ctx, GLenum mode )
{
   /* nothing, until we implement h/w glRead/CopyPixels or CopyTexImage */
}

/* =============================================================
 * State enable/disable
 */

static void mach64DDEnable( GLcontext *ctx, GLenum cap, GLboolean state )
{
   mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);

   if ( MACH64_DEBUG & DEBUG_VERBOSE_API ) {
      fprintf( stderr, "%s( %s = %s )\n",
	       __FUNCTION__, _mesa_lookup_enum_by_nr( cap ),
	       state ? "GL_TRUE" : "GL_FALSE" );
   }

   switch ( cap ) {
   case GL_ALPHA_TEST:
      FLUSH_BATCH( mmesa );
      mmesa->new_state |= MACH64_NEW_ALPHA;
      break;

   case GL_BLEND:
      FLUSH_BATCH( mmesa );
      mmesa->new_state |= MACH64_NEW_ALPHA;

      /* enable(GL_BLEND) affects ColorLogicOpEnabled.
       */
      FALLBACK( mmesa, MACH64_FALLBACK_LOGICOP,
		(ctx->Color.ColorLogicOpEnabled &&
		 ctx->Color.LogicOp != GL_COPY));
      break;