gamma_state.c

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

	 break;
      case GL_ALWAYS:
	 z |= DM_Always;
	 break;
      case GL_LESS:
	 z |= DM_Less;
	 break;
      case GL_LEQUAL:
	 z |= DM_LessEqual;
	 break;
      case GL_EQUAL:
	 z |= DM_Equal;
	 break;
      case GL_GEQUAL:
	 z |= DM_GreaterEqual;
	 break;
      case GL_GREATER:
	 z |= DM_Greater;
	 break;
      case GL_NOTEQUAL:
	 z |= DM_NotEqual;
	 break;
   }

   if ( ctx->Depth.Test ) {
      z      |= DepthModeEnable;
      delta  |= DM_DepthEnable;
      window |= W_DepthFCP;
      lbread |= LBReadDstEnable;
   } else {
      z      &= ~DepthModeEnable;
      delta  &= ~DM_DepthEnable;
      window &= ~W_DepthFCP;
      lbread &= ~LBReadDstEnable;
   }

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

#if 0
   if ( gmesa->DepthMode != z ){
#endif
      gmesa->DepthMode = z;
      gmesa->DeltaMode = delta;
      gmesa->Window = window;
      gmesa->LBReadMode = lbread;
      gmesa->dirty |= GAMMA_UPLOAD_DEPTH;
#if 0
   }
#endif
}

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

   FLUSH_BATCH( gmesa );
   gmesa->new_state |= GAMMA_NEW_DEPTH;
}

static void gammaDDDepthMask( GLcontext *ctx, GLboolean flag )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   FLUSH_BATCH( gmesa );
   gmesa->new_state |= GAMMA_NEW_DEPTH;
}

static void gammaDDClearDepth( GLcontext *ctx, GLclampd d )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   switch ( gmesa->DepthSize ) {
   case 16:
      gmesa->ClearDepth = d * 0x0000ffff;
      break;
   case 24:
      gmesa->ClearDepth = d * 0x00ffffff;
      break;
   case 32:
      gmesa->ClearDepth = d * 0xffffffff;
      break;
   }
}

static void gammaDDFinish( GLcontext *ctx )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   FLUSH_DMA_BUFFER(gmesa);
}

static void gammaDDFlush( GLcontext *ctx )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   FLUSH_DMA_BUFFER(gmesa);
}

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

static void gammaUpdateFogAttrib( GLcontext *ctx )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
   u_int32_t f = gmesa->FogMode;
   u_int32_t g = gmesa->GeometryMode;
   u_int32_t d = gmesa->DeltaMode;

   if (ctx->Fog.Enabled) {
      f |= FogModeEnable;
      g |= GM_FogEnable;
      d |= DM_FogEnable;
   } else {
      f &= ~FogModeEnable;
      g &= ~GM_FogEnable;
      d &= ~DM_FogEnable;
   }

   g &= ~GM_FogMask;

   switch (ctx->Fog.Mode) {
      case GL_LINEAR:
         g |= GM_FogLinear;
         break;
      case GL_EXP:
         g |= GM_FogExp;
         break;
      case GL_EXP2:
         g |= GM_FogExpSquared;
         break;
   }

   if ( gmesa->FogMode != f ) {
      gmesa->FogMode = f;
      gmesa->dirty |= GAMMA_UPLOAD_FOG;
   }
 
   if ( gmesa->GeometryMode != g ) {
      gmesa->GeometryMode = g;
      gmesa->dirty |= GAMMA_UPLOAD_GEOMETRY;
   }

   if ( gmesa->DeltaMode != d ) {
      gmesa->DeltaMode = d;
      gmesa->dirty |= GAMMA_UPLOAD_DEPTH;
   }
}

#if 0
static void gammaDDFogfv( GLcontext *ctx, GLenum pname, const GLfloat *param )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   FLUSH_BATCH( gmesa );
   gmesa->new_state |= GAMMA_NEW_FOG;
}
#endif

/* =============================================================
 * Lines
 */
static void gammaDDLineWidth( GLcontext *ctx, GLfloat width )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   CHECK_DMA_BUFFER(gmesa, 3);
   WRITE(gmesa->buf, LineWidth, (GLuint)width);
   WRITEF(gmesa->buf, AAlineWidth, width);
   WRITE(gmesa->buf, LineWidthOffset, (GLuint)(width-1)/2);
}

static void gammaDDLineStipple( GLcontext *ctx, GLint factor, GLushort pattern )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   gmesa->LineMode &= ~(LM_StippleMask | LM_RepeatFactorMask);
   gmesa->LineMode |= ((GLuint)(factor - 1) << 1) | ((GLuint)pattern << 10); 

   gmesa->dirty |= GAMMA_UPLOAD_LINEMODE;
}



/* =============================================================
 * Points
 */
static void gammaDDPointSize( GLcontext *ctx, GLfloat size )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   CHECK_DMA_BUFFER(gmesa, 2);
   WRITE(gmesa->buf, PointSize, (GLuint)size);
   WRITEF(gmesa->buf, AApointSize, size);
}

/* =============================================================
 * Polygon 
 */

static void gammaUpdatePolygon( GLcontext *ctx )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
   u_int32_t g = gmesa->GeometryMode;

   g &= ~(GM_PolyOffsetFillEnable | GM_PolyOffsetPointEnable |
          GM_PolyOffsetLineEnable);

   if (ctx->Polygon.OffsetFill) g |= GM_PolyOffsetFillEnable;
   if (ctx->Polygon.OffsetPoint) g |= GM_PolyOffsetPointEnable;
   if (ctx->Polygon.OffsetLine) g |= GM_PolyOffsetLineEnable;

   g &= ~GM_FB_PolyMask;

   switch (ctx->Polygon.FrontMode) {
      case GL_FILL:
         g |= GM_FrontPolyFill;
         break;
      case GL_LINE:
         g |= GM_FrontPolyLine;
         break;
      case GL_POINT:
         g |= GM_FrontPolyPoint;
         break;
   }

   switch (ctx->Polygon.BackMode) {
      case GL_FILL:
         g |= GM_BackPolyFill;
         break;
      case GL_LINE:
         g |= GM_BackPolyLine;
         break;
      case GL_POINT:
         g |= GM_BackPolyPoint;
         break;
   }

   if ( gmesa->GeometryMode != g ) {
      gmesa->GeometryMode = g;
      gmesa->dirty |= GAMMA_UPLOAD_GEOMETRY;
   }

   gmesa->dirty |= GAMMA_UPLOAD_POLYGON;
}

static void gammaDDPolygonMode( GLcontext *ctx, GLenum face, GLenum mode)
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   FLUSH_BATCH( gmesa );

   gmesa->new_state |= GAMMA_NEW_POLYGON;
}

static void gammaUpdateStipple( GLcontext *ctx )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   FLUSH_BATCH( gmesa );

   if (ctx->Polygon.StippleFlag) {
      gmesa->AreaStippleMode |= AreaStippleModeEnable/* | ASM_X32 | ASM_Y32*/;
   } else {
      gmesa->AreaStippleMode &= ~AreaStippleModeEnable;
   }

   gmesa->dirty |= GAMMA_UPLOAD_STIPPLE;
}

static void gammaDDPolygonStipple( GLcontext *ctx, const GLubyte *mask)
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
   FLUSH_BATCH( gmesa );
   gmesa->new_state |= GAMMA_NEW_STIPPLE;
}

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

static void gammaUpdateClipping( GLcontext *ctx )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
   GLint x1, y1, x2, y2;

   if ( gmesa->driDrawable ) {
      x1 = gmesa->driDrawable->x + ctx->Scissor.X;
      y1 = gmesa->driScreen->fbHeight -
	(gmesa->driDrawable->y +
	 gmesa->driDrawable->h) + ctx->Scissor.Y;
      x2 = x1 + ctx->Scissor.Width;
      y2 = y1 + ctx->Scissor.Height;

      gmesa->ScissorMinXY = x1 | (y1 << 16);
      gmesa->ScissorMaxXY = x2 | (y2 << 16);
      if (ctx->Scissor.Enabled) 
         gmesa->ScissorMode |= UserScissorEnable;
      else
         gmesa->ScissorMode &= ~UserScissorEnable;

      gmesa->dirty |= GAMMA_UPLOAD_CLIP;
   }
}

static void gammaDDScissor( GLcontext *ctx,
			   GLint x, GLint y, GLsizei w, GLsizei h )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   FLUSH_BATCH( gmesa );
   gmesa->new_state |= GAMMA_NEW_CLIP;
}

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

static void gammaUpdateCull( GLcontext *ctx )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
   u_int32_t g = gmesa->GeometryMode;

   g &= ~(GM_PolyCullMask | GM_FFMask);

   if (ctx->Polygon.FrontFace == GL_CCW) {
      g |= GM_FrontFaceCCW;
   } else {
      g |= GM_FrontFaceCW;
   }

   switch ( ctx->Polygon.CullFaceMode ) {
      case GL_FRONT:
	 g |= GM_PolyCullFront;
	 break;
      case GL_BACK:
	 g |= GM_PolyCullBack;
	 break;
      case GL_FRONT_AND_BACK:
	 g |= GM_PolyCullBoth;
	 break;
   }

   if ( ctx->Polygon.CullFlag ) {
      g |= GM_PolyCullEnable;
   } else {
      g &= ~GM_PolyCullEnable;
   }

   if ( gmesa->GeometryMode != g ) {
      gmesa->GeometryMode = g;
      gmesa->dirty |= GAMMA_UPLOAD_GEOMETRY;
   }
}

static void gammaDDCullFace( GLcontext *ctx, GLenum mode )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   FLUSH_BATCH( gmesa );
   gmesa->new_state |= GAMMA_NEW_CULL;
}

static void gammaDDFrontFace( GLcontext *ctx, GLenum mode )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   FLUSH_BATCH( gmesa );
   gmesa->new_state |= GAMMA_NEW_CULL;
}

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

static void gammaUpdateMasks( GLcontext *ctx )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);


   GLuint mask = gammaPackColor( gmesa->gammaScreen->cpp,
				ctx->Color.ColorMask[RCOMP],
				ctx->Color.ColorMask[GCOMP],
				ctx->Color.ColorMask[BCOMP],
				ctx->Color.ColorMask[ACOMP] );

   if (gmesa->gammaScreen->cpp == 2) mask |= mask << 16;

   if ( gmesa->FBHardwareWriteMask != mask ) {
      gmesa->FBHardwareWriteMask = mask;
      gmesa->dirty |= GAMMA_UPLOAD_MASKS;
   }
}

static void gammaDDColorMask( GLcontext *ctx, GLboolean r, GLboolean g,
			      GLboolean b, GLboolean a)
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   FLUSH_BATCH( gmesa );
   gmesa->new_state |= GAMMA_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.
 */

#if ENABLELIGHTING
static void gammaDDLightfv(GLcontext *ctx, GLenum light, GLenum pname, 
				const GLfloat *params, GLint nParams)
{
    gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
    GLfloat l,x,y,z,w;

    switch(light) {
    case GL_LIGHT0:
	switch (pname) {
	case GL_AMBIENT:
	    CHECK_DMA_BUFFER(gmesa, 3);
	    /* We don't do alpha */
	    WRITEF(gmesa->buf, Light0AmbientIntensityBlue, params[2]);
	    WRITEF(gmesa->buf, Light0AmbientIntensityGreen, params[1]);
	    WRITEF(gmesa->buf, Light0AmbientIntensityRed, params[0]);