i915_state.c

mesa-6.5-minigui源码

   I915_STATECHANGE(i915, I915_UPLOAD_CTX);

   if (mode == GL_SMOOTH) {
     i915->state.Ctx[I915_CTXREG_LIS4] &= ~(S4_FLATSHADE_ALPHA | 
					  S4_FLATSHADE_COLOR | 
					  S4_FLATSHADE_SPECULAR);
   } else {
     i915->state.Ctx[I915_CTXREG_LIS4] |= (S4_FLATSHADE_ALPHA | 
					 S4_FLATSHADE_COLOR | 
					 S4_FLATSHADE_SPECULAR);
   }
}

/* =============================================================
 * Fog
 */
void i915_update_fog( GLcontext *ctx )
{
   struct i915_context *i915 = I915_CONTEXT(ctx);
   GLenum mode;
   GLboolean enabled;
   GLboolean try_pixel_fog;
   
   if (ctx->FragmentProgram._Active) {
      /* Pull in static fog state from program */
      
      mode = ctx->FragmentProgram._Current->FogOption;
      enabled = (mode != GL_NONE);
      try_pixel_fog = 0;
   }
   else {
      enabled = ctx->Fog.Enabled;
      mode = ctx->Fog.Mode;

      try_pixel_fog = (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT &&
		       ctx->Hint.Fog == GL_NICEST && 
		       0);	/* XXX - DISABLE -- Need ortho fallback */
   }

   if (!enabled) {
      i915->vertex_fog = I915_FOG_NONE;
   }
   else if (try_pixel_fog) {

      I915_STATECHANGE(i915, I915_UPLOAD_FOG);
      i915->state.Fog[I915_FOGREG_MODE1] &= ~FMC1_FOGFUNC_MASK;
      i915->vertex_fog = I915_FOG_PIXEL;
	 
      switch (mode) {
      case GL_LINEAR:
	 if (ctx->Fog.End <= ctx->Fog.Start) {
	    /* XXX - this won't work with fragment programs.  Need to
	     * either fallback or append fog instructions to end of
	     * program in the case of linear fog.
	     */
	    i915->state.Fog[I915_FOGREG_MODE1] |= FMC1_FOGFUNC_VERTEX;
	    i915->vertex_fog = I915_FOG_VERTEX;
	 }
	 else {
	    GLfloat c1 = ctx->Fog.End/(ctx->Fog.End-ctx->Fog.Start);
	    GLfloat c2 = 1.0/(ctx->Fog.End-ctx->Fog.Start);

	    i915->state.Fog[I915_FOGREG_MODE1] &= ~FMC1_C1_MASK;
	    i915->state.Fog[I915_FOGREG_MODE1] |= FMC1_FOGFUNC_PIXEL_LINEAR;
	    i915->state.Fog[I915_FOGREG_MODE1] |= 
	       ((GLuint)(c1 * FMC1_C1_ONE)) & FMC1_C1_MASK;

	    if (i915->state.Fog[I915_FOGREG_MODE1] & FMC1_FOGINDEX_Z) {
	       i915->state.Fog[I915_FOGREG_MODE2] = (GLuint)(c2 * FMC2_C2_ONE);
	    }
	    else {
	       union { float f; int i; } fi;
	       fi.f = c2; 
	       i915->state.Fog[I915_FOGREG_MODE2] = fi.i; 
	    }
	 }
	 break;
      case GL_EXP:
	 i915->state.Fog[I915_FOGREG_MODE1] |= FMC1_FOGFUNC_PIXEL_EXP;
	 break;
      case GL_EXP2:
	 i915->state.Fog[I915_FOGREG_MODE1] |= FMC1_FOGFUNC_PIXEL_EXP2;
	 break;
      default:
	 break;
      }
   }
   else /* if (i915->vertex_fog != I915_FOG_VERTEX) */ {      
      I915_STATECHANGE(i915, I915_UPLOAD_FOG);
      i915->state.Fog[I915_FOGREG_MODE1] &= ~FMC1_FOGFUNC_MASK;
      i915->state.Fog[I915_FOGREG_MODE1] |= FMC1_FOGFUNC_VERTEX;
      i915->vertex_fog = I915_FOG_VERTEX;
   }

   {
      I915_STATECHANGE(i915, I915_UPLOAD_CTX);
      I915_ACTIVESTATE(i915, I915_UPLOAD_FOG, enabled);
      if (enabled)
	 i915->state.Ctx[I915_CTXREG_LIS5] |= S5_FOG_ENABLE;
      else
	 i915->state.Ctx[I915_CTXREG_LIS5] &= ~S5_FOG_ENABLE;
   }

   if (enabled) {
      _tnl_allow_vertex_fog( ctx, (i915->vertex_fog == I915_FOG_VERTEX) ); 
      _tnl_allow_pixel_fog( ctx, (i915->vertex_fog != I915_FOG_VERTEX) ); 
   }
}

static void i915Fogfv(GLcontext *ctx, GLenum pname, const GLfloat *param)
{
   struct i915_context *i915 = I915_CONTEXT(ctx);

   switch (pname) {
   case GL_FOG_COORDINATE_SOURCE_EXT: 
   case GL_FOG_MODE:
   case GL_FOG_START:
   case GL_FOG_END: 
      break;

   case GL_FOG_DENSITY:
      I915_STATECHANGE(i915, I915_UPLOAD_FOG);

      if (i915->state.Fog[I915_FOGREG_MODE1] & FMC1_FOGINDEX_Z) {
	 i915->state.Fog[I915_FOGREG_MODE3] = (GLuint)(ctx->Fog.Density *
						     FMC3_D_ONE);
      }
      else {
	 union { float f; int i; } fi;
	 fi.f = ctx->Fog.Density; 
	 i915->state.Fog[I915_FOGREG_MODE3] = fi.i; 
      }
      break;

   case GL_FOG_COLOR: 
      I915_STATECHANGE(i915, I915_UPLOAD_FOG);
      i915->state.Fog[I915_FOGREG_COLOR] = 
	 (_3DSTATE_FOG_COLOR_CMD | 
	  ((GLubyte)(ctx->Fog.Color[0]*255.0F) << 16) |
	  ((GLubyte)(ctx->Fog.Color[1]*255.0F) << 8) |
	  ((GLubyte)(ctx->Fog.Color[2]*255.0F) << 0));
      break;

   default:
      break;
   }
}

static void i915Hint(GLcontext *ctx, GLenum target, GLenum state)
{
   switch (target) {
   case GL_FOG_HINT:
      break;
   default:
      break;
   }
}

/* =============================================================
 */

static void i915Enable(GLcontext *ctx, GLenum cap, GLboolean state)
{
   struct i915_context *i915 = I915_CONTEXT(ctx);

   switch(cap) {
   case GL_TEXTURE_2D:
      break;

   case GL_LIGHTING:
   case GL_COLOR_SUM:
      update_specular( ctx );
      break;

   case GL_ALPHA_TEST:
      I915_STATECHANGE(i915, I915_UPLOAD_CTX);
      if (state)
	 i915->state.Ctx[I915_CTXREG_LIS6] |= S6_ALPHA_TEST_ENABLE;
      else
	 i915->state.Ctx[I915_CTXREG_LIS6] &= ~S6_ALPHA_TEST_ENABLE;
      break;

   case GL_BLEND:
      i915EvalLogicOpBlendState(ctx);
      break;

   case GL_COLOR_LOGIC_OP:
      i915EvalLogicOpBlendState(ctx);

      /* Logicop doesn't seem to work at 16bpp:
       */
      if (i915->intel.intelScreen->cpp == 2) /* XXX FBO fix */
	 FALLBACK( &i915->intel, I915_FALLBACK_LOGICOP, state );
      break;

   case GL_FRAGMENT_PROGRAM_ARB:
      break;

   case GL_DITHER:
      I915_STATECHANGE(i915, I915_UPLOAD_CTX);
      if (state)
	 i915->state.Ctx[I915_CTXREG_LIS5] |= S5_COLOR_DITHER_ENABLE;
      else
	 i915->state.Ctx[I915_CTXREG_LIS5] &= ~S5_COLOR_DITHER_ENABLE;
      break;

   case GL_DEPTH_TEST:
      I915_STATECHANGE(i915, I915_UPLOAD_CTX);
      if (state)
	 i915->state.Ctx[I915_CTXREG_LIS6] |= S6_DEPTH_TEST_ENABLE;
      else
	 i915->state.Ctx[I915_CTXREG_LIS6] &= ~S6_DEPTH_TEST_ENABLE;

      i915DepthMask( ctx, ctx->Depth.Mask );
      break;

   case GL_SCISSOR_TEST:
      I915_STATECHANGE(i915, I915_UPLOAD_BUFFERS);
      if (state)
	 i915->state.Buffer[I915_DESTREG_SENABLE] = (_3DSTATE_SCISSOR_ENABLE_CMD |
						   ENABLE_SCISSOR_RECT);
      else
	 i915->state.Buffer[I915_DESTREG_SENABLE] = (_3DSTATE_SCISSOR_ENABLE_CMD |
						   DISABLE_SCISSOR_RECT);
      break;

   case GL_LINE_SMOOTH:
      I915_STATECHANGE(i915, I915_UPLOAD_CTX);
      if (state)
	 i915->state.Ctx[I915_CTXREG_LIS4] |= S4_LINE_ANTIALIAS_ENABLE;
      else
	 i915->state.Ctx[I915_CTXREG_LIS4] &= ~S4_LINE_ANTIALIAS_ENABLE;
      break;

   case GL_FOG:
      break;

   case GL_CULL_FACE:
      i915CullFaceFrontFace(ctx, 0);
      break;

   case GL_STENCIL_TEST:
      {
         GLboolean hw_stencil = GL_FALSE;
         if (ctx->DrawBuffer) {
            struct intel_renderbuffer *irbStencil
               = intel_get_renderbuffer(ctx->DrawBuffer, BUFFER_STENCIL);
            hw_stencil = (irbStencil && irbStencil->region);
         }
         if (hw_stencil) {
            I915_STATECHANGE(i915, I915_UPLOAD_CTX);
            if (state)
               i915->state.Ctx[I915_CTXREG_LIS5] |= (S5_STENCIL_TEST_ENABLE |
                                                   S5_STENCIL_WRITE_ENABLE);
            else
               i915->state.Ctx[I915_CTXREG_LIS5] &= ~(S5_STENCIL_TEST_ENABLE | 
                                                    S5_STENCIL_WRITE_ENABLE);
         } else {
            FALLBACK( &i915->intel, I915_FALLBACK_STENCIL, state );
         }
      }
      break;

   case GL_POLYGON_STIPPLE:
      /* The stipple command worked on my 855GM box, but not my 845G.
       * I'll do more testing later to find out exactly which hardware
       * supports it.  Disabled for now.
       */
      if (i915->intel.hw_stipple && 
	  i915->intel.reduced_primitive == GL_TRIANGLES)
      {
	 I915_STATECHANGE(i915, I915_UPLOAD_STIPPLE);
	 if (state)
	    i915->state.Stipple[I915_STPREG_ST1] |= ST1_ENABLE;
	 else
	    i915->state.Stipple[I915_STPREG_ST1] &= ~ST1_ENABLE;
      }
      break;

   case GL_POLYGON_SMOOTH:
      FALLBACK( &i915->intel, I915_FALLBACK_POLYGON_SMOOTH, state );
      break;

   case GL_POINT_SMOOTH:
      FALLBACK( &i915->intel, I915_FALLBACK_POINT_SMOOTH, state );
      break;

   default:
      ;
   }
}


static void i915_init_packets( struct i915_context *i915 )
{
   intelScreenPrivate *screen = i915->intel.intelScreen;

   /* Zero all state */
   memset(&i915->state, 0, sizeof(i915->state));


   {
      I915_STATECHANGE(i915, I915_UPLOAD_CTX);
      /* Probably don't want to upload all this stuff every time one 
       * piece changes.
       */
      i915->state.Ctx[I915_CTXREG_LI] = (_3DSTATE_LOAD_STATE_IMMEDIATE_1 | 
				       I1_LOAD_S(2) |
				       I1_LOAD_S(4) |
				       I1_LOAD_S(5) |
				       I1_LOAD_S(6) | 
				       (4));
      i915->state.Ctx[I915_CTXREG_LIS2] = 0;
      i915->state.Ctx[I915_CTXREG_LIS4] = 0;
      i915->state.Ctx[I915_CTXREG_LIS5] = 0;

      if (screen->cpp == 2) /* XXX FBO fix */
	 i915->state.Ctx[I915_CTXREG_LIS5] |= S5_COLOR_DITHER_ENABLE;


      i915->state.Ctx[I915_CTXREG_LIS6] = (S6_COLOR_WRITE_ENABLE |
					 (2 << S6_TRISTRIP_PV_SHIFT));

      i915->state.Ctx[I915_CTXREG_STATE4] = (_3DSTATE_MODES_4_CMD |
					   ENABLE_LOGIC_OP_FUNC |
					   LOGIC_OP_FUNC(LOGICOP_COPY) |
					   ENABLE_STENCIL_TEST_MASK |
					   STENCIL_TEST_MASK(0xff) |
					   ENABLE_STENCIL_WRITE_MASK |
					   STENCIL_WRITE_MASK(0xff));

      i915->state.Ctx[I915_CTXREG_IAB] = (_3DSTATE_INDEPENDENT_ALPHA_BLEND_CMD |
					IAB_MODIFY_ENABLE |
					IAB_MODIFY_FUNC |
					IAB_MODIFY_SRC_FACTOR |
					IAB_MODIFY_DST_FACTOR);

      i915->state.Ctx[I915_CTXREG_BLENDCOLOR0] = _3DSTATE_CONST_BLEND_COLOR_CMD;
      i915->state.Ctx[I915_CTXREG_BLENDCOLOR1] = 0;

   }

   {
      I915_STATECHANGE(i915, I915_UPLOAD_STIPPLE);
      i915->state.Stipple[I915_STPREG_ST0] = _3DSTATE_STIPPLE;
   }


   {
      I915_STATECHANGE(i915, I915_UPLOAD_FOG);
      i915->state.Fog[I915_FOGREG_MODE0] = _3DSTATE_FOG_MODE_CMD;
      i915->state.Fog[I915_FOGREG_MODE1] = (FMC1_FOGFUNC_MODIFY_ENABLE |
					  FMC1_FOGFUNC_VERTEX |
					  FMC1_FOGINDEX_MODIFY_ENABLE |
					  FMC1_FOGINDEX_W |
					  FMC1_C1_C2_MODIFY_ENABLE |
					  FMC1_DENSITY_MODIFY_ENABLE);
      i915->state.Fog[I915_FOGREG_COLOR] = _3DSTATE_FOG_COLOR_CMD;
   }


   {
      I915_STATECHANGE(i915, I915_UPLOAD_BUFFERS);
      /* color buffer offset/stride */
      i915->state.Buffer[I915_DESTREG_CBUFADDR0] = _3DSTATE_BUF_INFO_CMD;
      /* XXX FBO: remove this?  Also get set in i915_set_draw_region() */
      i915->state.Buffer[I915_DESTREG_CBUFADDR1] = 
	 (BUF_3D_ID_COLOR_BACK | 
<<<<<<< i915_state.c
	  BUF_3D_PITCH(screen->front.pitch) |  /* pitch in bytes */
=======
	  BUF_3D_PITCH(screen->front.pitch * screen->cpp) | /* XXX FBO fix */
>>>>>>> 1.7.2.9
	  BUF_3D_USE_FENCE);
      /*i915->state.Buffer[I915_DESTREG_CBUFADDR2] is the offset */

<<<<<<< i915_state.c

      /* depth/Z buffer offset/stride */
=======
>>>>>>> 1.7.2.9
      i915->state.Buffer[I915_DESTREG_DBUFADDR0] = _3DSTATE_BUF_INFO_CMD;
      /* XXX FBO: remove this?  Also get set in i915_set_draw_region() */
      i915->state.Buffer[I915_DESTREG_DBUFADDR1] = 
	 (BUF_3D_ID_DEPTH |
<<<<<<< i915_state.c
	  BUF_3D_PITCH(screen->depth.pitch) |  /* pitch in bytes */
=======
	  BUF_3D_PITCH(screen->depth.pitch * screen->cpp) | /* XXX FBO fix */
>>>>>>> 1.7.2.9
	  BUF_3D_USE_FENCE);

      i915->state.Buffer[I915_DESTREG_DV0] = _3DSTATE_DST_BUF_VARS_CMD;

<<<<<<< i915_state.c
      /* color/depth pixel format */
=======
      /* XXX FBO: remove this?  Also get set in i915_set_draw_region() */
#if 0 /* seems we don't need this */
>>>>>>> 1.7.2.9
      switch (screen->fbFormat) {
      case DV_PF_565:
	 i915->state.Buffer[I915_DESTREG_DV1] = (DSTORG_HORT_BIAS(0x8) | /* .5 */
					       DSTORG_VERT_BIAS(0x8) | /* .5 */
					       LOD_PRECLAMP_OGL |
					       TEX_DEFAULT_COLOR_OGL |
					       DITHER_FULL_ALWAYS |
					       screen->fbFormat |
					       DEPTH_FRMT_16_FIXED);
	 break;
      case DV_PF_8888:
	 i915->state.Buffer[I915_DESTREG_DV1] = (DSTORG_HORT_BIAS(0x8) | /* .5 */
					       DSTORG_VERT_BIAS(0x8) | /* .5 */
					       LOD_PRECLAMP_OGL |
					       TEX_DEFAULT_COLOR_OGL |
					       screen->fbFormat |
					       DEPTH_FRMT_24_FIXED_8_OTHER);
	 break;
      }
<<<<<<< i915_state.c

      /* scissor */
=======
#endif

>>>>>>> 1.7.2.9
      i915->state.Buffer[I915_DESTREG_SENABLE] = (_3DSTATE_SCISSOR_ENABLE_CMD |
						DISABLE_SCISSOR_RECT);
      i915->state.Buffer[I915_DESTREG_SR0] = _3DSTATE_SCISSOR_RECT_0_CMD;
      i915->state.Buffer[I915_DESTREG_SR1] = 0;
      i915->state.Buffer[I915_DESTREG_SR2] = 0;
   }


#if 0
   {
      I915_STATECHANGE(i915, I915_UPLOAD_DEFAULTS);
      i915->state.Default[I915_DEFREG_C0] = _3DSTATE_DEFAULT_DIFFUSE;
      i915->state.Default[I915_DEFREG_C1] = 0;
      i915->state.Default[I915_DEFREG_S0] = _3DSTATE_DEFAULT_SPECULAR;
      i915->state.Default[I915_DEFREG_S1] = 0;
      i915->state.Default[I915_DEFREG_Z0] = _3DSTATE_DEFAULT_Z;
      i915->state.Default[I915_DEFREG_Z1] = 0;
   }
#endif


   /* These will be emitted every at the head of every buffer, unless
    * we get hardware contexts working.
    */
   i915->state.active = (I915_UPLOAD_PROGRAM | 
			 I915_UPLOAD_STIPPLE | 
			 I915_UPLOAD_CTX | 
			 I915_UPLOAD_BUFFERS |
			 I915_UPLOAD_INVARIENT);
}

void i915InitStateFunctions( struct dd_function_table *functions )
{
   functions->AlphaFunc = i915AlphaFunc;
   functions->BlendColor = i915BlendColor;
   functions->BlendEquationSeparate = i915BlendEquationSeparate;
   functions->BlendFuncSeparate = i915BlendFuncSeparate;
   functions->ColorMask = i915ColorMask;
   functions->CullFace = i915CullFaceFrontFace;
   functions->DepthFunc = i915DepthFunc;
   functions->DepthMask = i915DepthMask;
   functions->Enable = i915Enable;
   functions->Fogfv = i915Fogfv;
   functions->FrontFace = i915CullFaceFrontFace;
   functions->Hint = i915Hint;
   functions->LightModelfv = i915LightModelfv;
   functions->LineWidth = i915LineWidth;
   functions->LogicOpcode = i915LogicOp;
   functions->PointSize = i915PointSize;
   functions->PolygonStipple = i915PolygonStipple;
   functions->Scissor = i915Scissor;
   functions->ShadeModel = i915ShadeModel;
   functions->StencilFuncSeparate = i915StencilFuncSeparate;
   functions->StencilMaskSeparate = i915StencilMaskSeparate;
   functions->StencilOpSeparate = i915StencilOpSeparate;
}


void i915InitState( struct i915_context *i915 )
{
   GLcontext *ctx = &i915->intel.ctx;

   i915_init_packets( i915 );

   intelInitState( ctx );

   memcpy( &i915->initial, &i915->state, sizeof(i915->state) );
   i915->current = &i915->state;
}