validatetnl.c

Lido PXA270平台开发板的最新BSP,包括源代码

         if(!pTexCur->bIsIdentity) // check if it is Identity
            {
            CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_TRANSFORM_TEX1, CTLTRUE );
            CTL_SetTransform( gc->sTransform.ctl, CTLTRANSFORM_TEX1, 
                  (CTLMATRIX44*)&pTexCur->sMatrix );
            }

         psTransform->CurrentTexMatrixChangeCount[t] = pTexCur->MatrixChangeCount;
         }
      }  // if - tex stage 1 is valid

   CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_TRANSFORM_TEX2, CTLFALSE );
   if(gc->sTexture.abTexUnitValid[1])
      {
      const HUINT32 t = 1;
      HUINT32 cur = psTransform->TextureCurrent[t];
      pTexCur = &(psTransform->apsTextureStack[t][cur]);

      if(pTexCur->MatrixChangeCount != psTransform->CurrentTexMatrixChangeCount[t])
         {
         if(pTexCur->IdentityCheckChangeCount != pTexCur->MatrixChangeCount)
            {
            pTexCur->bIsIdentity = MATRIX4_ISIDENT( (NATIVE*)&pTexCur->sMatrix );
            pTexCur->IdentityCheckChangeCount = pTexCur->MatrixChangeCount;
            }

         if(!pTexCur->bIsIdentity) // check if it is Identity
            {
            CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_TRANSFORM_TEX2, CTLTRUE );
            CTL_SetTransform( gc->sTransform.ctl, CTLTRANSFORM_TEX2, 
                  (CTLMATRIX44*)&pTexCur->sMatrix );
            }

         psTransform->CurrentTexMatrixChangeCount[t] = pTexCur->MatrixChangeCount;
         }
      }  // if - tex stage 2 is valid

   }  /* UpdateTRansformMatrix */


/***********************************************************************************
 Function Name      : SetupFaceOrder
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : Sets up useful flags for SW back face culling.
************************************************************************************/
static void SetupFaceOrder(GLESContext *gc)
   {
   CTLBOOL bLight2Sided = CTLFALSE;

   gc->sHWContext.ui32PrimitiveHeader &= MBX1_TAPRIM_CULLMODECLRMASK;

   CTL_GetStateVariable( gc->sTransform.ctl, CTLSTATE_LIGHT_TWOSIDED, &bLight2Sided );
   if (gc->ui32TnLEnables & GLES_TL_CULLFACE_ENABLE)
      {
      if(gc->sState.sPolygon.eFrontFaceDirection == GL_CW)
         {
         switch (gc->sState.sPolygon.eCullMode)
            {
            case GL_FRONT:
               {
               if( bLight2Sided )
                  {
                  CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_NORMAL_INVERT, CTLTRUE );
                  }
               CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_CULL_MODE, CTLCULL_CW );
               gc->sHWContext.ui32PrimitiveHeader |= MBX1_TAPRIM_CULLMODECW;
               break;
               }
            case GL_FRONT_AND_BACK:
               {
               break;
               }
            case GL_BACK:
               {
               CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_CULL_MODE, CTLCULL_CCW );
               gc->sHWContext.ui32PrimitiveHeader |= MBX1_TAPRIM_CULLMODECCW;
               break;
               }
            }
         }  // front face is defined CW
      else
         {  // front face is defined CCW
         switch (gc->sState.sPolygon.eCullMode)
            {
            case GL_FRONT:
               {
               if( bLight2Sided )
                  {
                  CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_NORMAL_INVERT, CTLTRUE );
                  }
               CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_CULL_MODE, CTLCULL_CCW );
               gc->sHWContext.ui32PrimitiveHeader |= MBX1_TAPRIM_CULLMODECCW;
               break;
               }
            case GL_FRONT_AND_BACK:
               {
               break;
               }
            case GL_BACK:
               {
               CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_CULL_MODE, CTLCULL_CW );
               gc->sHWContext.ui32PrimitiveHeader |= MBX1_TAPRIM_CULLMODECW;
               break;
               }
            }
         }  // front face is defined CCW
      }  // culling enabled
   else
      {  // culling disabled
      if( bLight2Sided )
         {
         //pState->Flags |= HXF_CULL_FLIP_2SIDED;
         // Check for Front Face to determine what side to selectively cull
         // during 2 sided lighting

         if(gc->sState.sPolygon.eFrontFaceDirection == GL_CW)
            {
            CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_CULL_MODE, CTLCULL_CCW );
            gc->sHWContext.ui32PrimitiveHeader |= MBX1_TAPRIM_CULLMODECCW;
            }
         else
            {
            CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_CULL_MODE, CTLCULL_CW );
            gc->sHWContext.ui32PrimitiveHeader |= MBX1_TAPRIM_CULLMODECW;
            }
         }  // two-sided lighting enabled
      else
         {
         CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_CULL_MODE, CTLCULL_NONE );
         gc->sHWContext.ui32PrimitiveHeader |= MBX1_TAPRIM_CULLMODENONE;
         }
      }  // culling disabled

   }  /* SetupFaceOrder */


/***********************************************************************************
 Function Name      : ComputeFogState
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        :
************************************************************************************/
static IMG_VOID ComputeFogState( GLESContext *gc )
   {
   GLESfogState* pFog = &gc->sState.sFog;

   if(( pFog->eMode == GL_LINEAR ) && pFog->bLinearDirty )
      {
      CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_FOG_END, FasI( pFog->End ));
      pFog->bLinearDirty = IMG_FALSE;
      }  // if

   }  /* ComputeFogState */


/***********************************************************************************
 Function Name      : ComputeLightState
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        :
************************************************************************************/
static IMG_VOID ComputeLightState(GLESContext *gc)
   {
   IMG_UINT32 i = 0;

   CTL_SetMaterial( gc->sTransform.ctl, &gc->sState.sLight.sMaterial.ctlMaterial );

   CTL_SetStateVariableV( gc->sTransform.ctl, CTLSTATE_LIGHT_AMBIENT,
         &gc->sState.sLight.sModel.Ambient );

   for(i = 0; i < GLES_MAX_LIGHTS; ++i)
      {
      CTL_EnableLight( gc->sTransform.ctl, i, 
            (( GLES_TL_LIGHT0_ENABLE << i ) & gc->ui32TnLEnables )
            ? CTLTRUE : CTLFALSE );

      if(gc->ui32TnLEnables & (GLES_TL_LIGHT0_ENABLE << (i)))
         {
         CTL_SetLight( gc->sTransform.ctl, i, &gc->sState.sLight.sLights[i].ctlLight );
         }  // if - light is enabled

      }  // for - each light

   }  /* ComputeLightState */


/***********************************************************************************
 Function Name      : ValidateVertexFormat
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : Sets up control words defining vertex format depending on
					  current state. Also sets up outputvertex function pointer.
************************************************************************************/

static IMG_VOID ValidateVertexFormat(GLESContext *gc)
{

	if(gc->ui32RasterEnables & GLES_RS_FOG_ENABLE)
	{
		gc->sHWContext.ui32ISPTSPWord |= MBX1_ISPTSPCTL_OFFSET;
	}
	else
	{
		gc->sHWContext.ui32ISPTSPWord &= ~MBX1_ISPTSPCTL_OFFSET;
	}

	switch(gc->sHWContext.ui32NumTextureLayers)
	{
		case 0:
			gc->sHWContext.ui32ISPTSPWord &= MBX1_ISPTSPCTL_UVCOUNTCLRMASK;
			break;
		case 1:
			gc->sHWContext.ui32ISPTSPWord &= MBX1_ISPTSPCTL_UVCOUNTCLRMASK;

			break;
		case 2:
			gc->sHWContext.ui32ISPTSPWord |= MBX1_ISPTSPCTL_UVCOUNT;
			break;
		default:
			break;
	}

	gc->sHWContext.ui32ISPTSPWord &= MBX1_ISPTSPCTL_NUMPASSESCLRMASK;
	gc->sHWContext.ui32ISPTSPWord |= (gc->sHWContext.ui32PassCount << MBX1_ISPTSPCTL_NUMPASSESSHIFT);
}

/***********************************************************************************
 Function Name      : ValidateState
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : Main Validation function. Sets up and emits state prior to
					  drawing.
************************************************************************************/
void ValidateState(GLESContext *gc)
{
	IMG_BOOL bTextureUnitsChanged = IMG_FALSE;

	GLES_TIME_START(GLES_TIMER_VALIDATE_TIME);

	if(gc->ui32DirtyMask & GLES_DIRTY_SW_TEXTURE_UNIT)
	{
		bTextureUnitsChanged = ValidateTextureUnits(gc);
	}

	if((gc->ui32DirtyMask & GLES_DIRTY_SW_FOG) || bTextureUnitsChanged)
	{
		gc->ui32DirtyMask |= GLES_DIRTY_SW_VERTEXFORMAT;
	}

	if(gc->ui32DirtyMask & GLES_DIRTY_SW_POLYOFFSET)
	{
		ValidatePolygonOffset(gc);
	}

	if(gc->ui32DirtyMask & GLES_DIRTY_SW_CULL)
	{
		SetupFaceOrder(gc);
	}

	if(gc->ui32DirtyMask & GLES_DIRTY_SW_LINEPOINTSIZE)
	{
		ValidatePointLineSize(gc);
	}

	if(bTextureUnitsChanged || (gc->ui32DirtyMask & GLES_DIRTY_SW_TEXTURE_STATE))
	{
		ValidateTextureState(gc);
	}

	if(gc->ui32DirtyMask & GLES_DIRTY_SW_VERTEXFORMAT)
	{
		ValidateVertexFormat(gc);
	}

	if(gc->ui32DirtyMask & (GLES_DIRTY_SW_VERTEXFORMAT|GLES_DIRTY_HW_ISPTSP|GLES_DIRTY_HW_TSPOBJECT))
	{
		SetupControlWords(gc);
	}

	UpdateHXFFlags(gc);
	UpdateTransformMatrix(gc); // Ensure that the transform is current;

	ComputeLightState(gc);
	ComputeFogState(gc);

	SetupInputDataPointers(gc);

	gc->ui32DirtyMask = 0;
	gc->ui32DirtyConstantMask = 0;

	GLES_TIME_STOP(GLES_TIMER_VALIDATE_TIME);
}



/***********************************************************************************
 Function Name      : InitCurrentState
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : Setup the current TnL State for inputs.
************************************************************************************/
void InitCurrentState( GLESContext* gc )
   {
   HUINT32 i = 0;
   NATIVE DefaultWhite[4]  = {  nONE,  nONE, nONE, nONE };
   NATIVE DefaultNormal[3] = { nZERO, nZERO, nONE };

   /* Init current color and sync with CTL */
   gc->sState.sCurrent.Color = *((CTLCOLOR4*)DefaultWhite);
   CTL_SetStateVariableV( gc->sTransform.ctl, CTLSTATE_COLOR_CURRENT,  DefaultWhite );
   
   /* Init current normal and sync with CTL */
   gc->sState.sCurrent.Normal = *((CTLVECTOR3*)DefaultNormal);
   CTL_SetStateVariableV( gc->sTransform.ctl, CTLSTATE_NORMAL_CURRENT, DefaultNormal );

   for( i = 0; i < GLES_MAX_TEXTURE_UNITS; i++ )
      {
      gc->sState.sCurrent.aTextureCoords[i].x = nZERO;   // s
      gc->sState.sCurrent.aTextureCoords[i].y = nZERO;   // t
      gc->sState.sCurrent.aTextureCoords[i].z = nZERO;   // r
      gc->sState.sCurrent.aTextureCoords[i].w = nONE;    // q
      }  // for

   }  /* InitCurrentState */


/* ************************************************************************* *\
** ************************************************************************* **
** EOF
** ************************************************************************* **
\* ************************************************************************* */