validatetnl.c

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

/* ************************************************************************* *\
**
**    INTEL Corporation Proprietary Information
**
**    This listing is supplied under the terms of a license
**    agreement with INTEL Corporation and may not be copied
**    nor disclosed except in accordance with the terms of
**    that agreement.
**
**    Copyright (c) 2003 Intel Corporation.
**    All Rights Reserved.
**
** ************************************************************************* **
\* ************************************************************************* */

/**************************************************************************
 * Name         : validate.c
 * Author       : BCB
 * Created      : 08/05/2003
 *
 * Copyright    : 2003 by Imagination Technologies Limited. All rights reserved.
 *              : No part of this software, either material or conceptual
 *              : may be copied or distributed, transmitted, transcribed,
 *              : stored in a retrieval system or translated into any
 *              : human or computer language in any form by any means,
 *              : electronic, mechanical, manual or other-wise, or
 *              : disclosed to third parties without the express written
 *              : permission of Imagination Technologies Limited, Unit 8, HomePark
 *              : Industrial Estate, King's Langley, Hertfordshire,
 *              : WD4 8LZ, U.K.
 *
 * Platform     : ANSI
 **************************************************************************/
#define MODULE_ID MODID_VALIDATE

#include "context.h"
#include "slaveport.h"
#include "texblend.h"
#include "ws.h"
#include "CTL.h"

// Non-format-converting typecast
#define FasI(f)   *((CTLU32*)&(f))
#define IasF(i)   *((CTLF32*)&(i))



/* ************************************************************************* *\
	FUNCTION: ProcessViewport
	DESCRIPTION:

\* ************************************************************************* */
void ProcessViewport(GLESContext* gc)
{
   GLEStransformMachine* psTransform = &gc->sTransform;
   GLESviewport *psViewport = &gc->sState.sViewport;
   GLESDrawableParams *psDrawParams = &gc->sDrawableParams;
   CTL_VIEWPORT ctlViewport;
   CTLU32 dims[2];
	
	psViewport->bDirty = HFALSE;

   CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_SCREEN_ROTATION, 
         psDrawParams->eRotationAngle );

   dims[0] = psDrawParams->ui32Width;
   dims[1] = psDrawParams->ui32Height;
   CTL_SetStateVariableV( gc->sTransform.ctl, CTLSTATE_SCREEN_DIMS, dims );
         
   ctlViewport.i32X      = psViewport->i32X; 
   ctlViewport.i32Y      = psViewport->i32Y;
   ctlViewport.u32Width  = psViewport->ui32Width;
   ctlViewport.u32Height = psViewport->ui32Height;
   ctlViewport.Near      = F32toNATIVE( psViewport->MinZ );
   ctlViewport.Far       = F32toNATIVE( psViewport->MaxZ );

   CTL_SetViewport( gc->sTransform.ctl, &ctlViewport );

   if(gc->sTransform.ScreenRotation != gc->sDrawableParams.eRotationAngle)
   {
      psTransform->ScreenRotation = gc->sDrawableParams.eRotationAngle;
   }
}

/* ************************************************************************* *\
	FUNCTION: UpdateHXFFlags
	DESCRIPTION:
\* ************************************************************************* */
static void UpdateHXFFlags(GLESContext* gc)
   {
   // Determine LightEnable
   CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_LIGHT_ENABLE,
         ( gc->ui32TnLEnables & GLES_TL_LIGHTING_ENABLE ) ? CTLTRUE :
         CTLFALSE );

   if(gc->ui32TnLEnables & GLES_TL_LIGHTING_ENABLE)
      {
      // Determine Constant color
      if(gc->ui32TnLEnables & GLES_TL_COLORMAT_ENABLE)
         {	// if CM and no Vertex array
         if(!((gc->sVertexArray.ui32ArrayEnables & VARRAY_COLOR_ENABLE)
            && gc->sVertexArray.sCPState.pui8Pointer != NULL))
            {
            CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_COLOR_SOURCE,
                  CTLSOURCE_COLOR_MATERIAL );                  
            }
         }
      else
         {	// Always use material -
         CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_COLOR_SOURCE,
               CTLSOURCE_COLOR_MATERIAL );                  
         }

      }  // if

   CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_FOG_ENABLE, 
         ( gc->ui32RasterEnables & GLES_RS_FOG_ENABLE ) ? CTLTRUE : 
         CTLFALSE );

   }  /* UpdateHXFFlags */


/* ************************************************************************* *\
	FUNCTION:
	DESCRIPTION:
\* ************************************************************************* */
static void SetupInputDataPointers(GLESContext *gc)
   {
   GLESvertArrayPointerState* pDA = NULL;
   CTLBOOL bLightEnable = 0;
   CTL_COLOR_SOURCE ctlCS;

   // Set up vertex pointer.
   pDA = &(gc->sVertexArray.sVPState);
   CTL_SetPointer( gc->sTransform.ctl, pDA->pui8Pointer, CTLATYPE_VERTEX, 
         pDA->ctlFormat, pDA->ui32Size, pDA->ui32Stride );

   // Setup Normal pointer
   CTL_GetStateVariable( gc->sTransform.ctl, CTLSTATE_LIGHT_ENABLE,
         &bLightEnable );

   CTL_GetStateVariable( gc->sTransform.ctl, CTLSTATE_COLOR_SOURCE,
         (CTLU32*)&ctlCS );

   if( bLightEnable )
      {
      pDA = &gc->sVertexArray.sNPState;
      if(gc->sVertexArray.ui32ArrayEnables & VARRAY_NORMAL_ENABLE
         && pDA->pui8Pointer != NULL)
         {
         CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_NORMAL_NORMALIZE,
               ( gc->ui32TnLEnables & GLES_TL_NORMALIZE_ENABLE ) ? CTLTRUE :
               CTLFALSE );

         CTL_SetPointer( gc->sTransform.ctl, pDA->pui8Pointer, CTLATYPE_NORMAL,
               pDA->ctlFormat, pDA->ui32Size, pDA->ui32Stride );
         }  // if - normal array has been set
      else
         {  // no normal array, use object normal
         CTL_SetPointer( gc->sTransform.ctl, &gc->sState.sCurrent.Normal, 
               CTLATYPE_NORMAL, CTLAFORMAT_NATIVE, 3, 0 );
         }  // else - use object normal

      }  // if - lighting enabled
   else
      {  // no lighting
      CTL_SetPointer( gc->sTransform.ctl, 0, CTLATYPE_NORMAL, CTLAFORMAT_NONE, 0, 0 );
      }  // else - no lighting

   // Set up color pointers
   if( bLightEnable )
      {
      if( CTLSOURCE_COLOR_MATERIAL == ctlCS )
         {
         CTL_SetPointer( gc->sTransform.ctl, 0, CTLATYPE_COLOR, CTLAFORMAT_NONE, 0, 0 );
         }  // if
      else
         {
         //HXFASSERT(gc->sVertexArray.ui32ArrayEnables & VARRAY_COLOR_ENABLE);

         pDA = &gc->sVertexArray.sCPState;
         CTL_SetPointer( gc->sTransform.ctl, pDA->pui8Pointer, CTLATYPE_COLOR, 
               pDA->ctlFormat, pDA->ui32Size, pDA->ui32Stride );
         }  // else

      }
   else  // !HXF_LIGHT_ENABLE
      {
      if(gc->sVertexArray.ui32ArrayEnables & VARRAY_COLOR_ENABLE
         && gc->sVertexArray.sCPState.pui8Pointer != NULL )
         {
         pDA = &gc->sVertexArray.sCPState;
         CTL_SetPointer( gc->sTransform.ctl, pDA->pui8Pointer, CTLATYPE_COLOR,
               pDA->ctlFormat, pDA->ui32Size, pDA->ui32Stride );
         }
      else
         {
         CTL_SetPointer( gc->sTransform.ctl, &gc->sState.sCurrent.Color,
               CTLATYPE_COLOR, CTLAFORMAT_NATIVE, 4, 0 );
         }
      }

   if(gc->sTexture.abTexUnitValid[0] && gc->ui32RasterEnables & GLES_RS_TEXTURE0_ENABLE)
      {
      pDA = &(gc->sVertexArray.asTPState[0]);
      if(gc->sVertexArray.ui32ArrayEnables & VARRAY_TEXCOORD0_ENABLE
         && pDA->pui8Pointer != NULL)
         {
         CTL_SetPointer( gc->sTransform.ctl, pDA->pui8Pointer, CTLATYPE_TEXCOORD0,
               pDA->ctlFormat, pDA->ui32Size, pDA->ui32Stride );
         }
      else
         {
         CTLBOOL bTransformTex1;
         CTLU32 size = 2;
         
         CTL_GetStateVariable( gc->sTransform.ctl, CTLSTATE_TRANSFORM_TEX1, &bTransformTex1 );
         if( bTransformTex1 ) 
            {
            size = 4;
            }  // if
         
         CTL_SetPointer( gc->sTransform.ctl, &gc->sState.sCurrent.aTextureCoords[0],
               CTLATYPE_TEXCOORD0, CTLAFORMAT_NATIVE, size, 0 );
         }
      }
   else
      {
      CTL_SetPointer( gc->sTransform.ctl, 0, CTLATYPE_TEXCOORD0, CTLAFORMAT_NONE, 0, 0 );
      }

   if(gc->sTexture.abTexUnitValid[1] && gc->ui32RasterEnables & GLES_RS_TEXTURE1_ENABLE)
      {
      pDA = &(gc->sVertexArray.asTPState[1]);
      if(gc->sVertexArray.ui32ArrayEnables & VARRAY_TEXCOORD1_ENABLE
         && pDA->pui8Pointer != NULL)
         {
         CTL_SetPointer( gc->sTransform.ctl, pDA->pui8Pointer, CTLATYPE_TEXCOORD1,
               pDA->ctlFormat, pDA->ui32Size, pDA->ui32Stride );
         }
      else
         {
         CTLBOOL bTransformTex2;
         CTLU32 size = 2;

         CTL_GetStateVariable( gc->sTransform.ctl, CTLSTATE_TRANSFORM_TEX2, &bTransformTex2 );
         if( bTransformTex2 )
            {
            size = 4;
            }  // if

         CTL_SetPointer( gc->sTransform.ctl, &gc->sState.sCurrent.aTextureCoords[1],
               CTLATYPE_TEXCOORD1, CTLAFORMAT_NATIVE, size, 0 );
         }
      }
   else
      {
      CTL_SetPointer( gc->sTransform.ctl, 0, CTLATYPE_TEXCOORD1, CTLAFORMAT_NONE, 0, 0 );
      }

   }  /* SetupInputDataPointers */


/* ************************************************************************* *\
	FUNCTION:
	DESCRIPTION:
\* ************************************************************************* */
static void UpdateTransformMatrix(GLESContext *gc)
   {
   HUINT32 ScrRotation = 0;
   HBOOL bUpdateMVPD = HFALSE;
   GLESviewport* psViewport = NULL;
   GLEStransformMachine* psTransform = NULL;

   GLESMVTransform* pMVCur = NULL;
   GLESProjectionTransform* pProjCur = NULL;
   GLESTexTransform* pTexCur = NULL;

   psTransform = &(gc->sTransform);
   psViewport = &gc->sState.sViewport;

   pMVCur = &(psTransform->psModelViewStack[psTransform->ModelViewCurrent]);
   pProjCur = &(psTransform->psProjectionStack[psTransform->ProjectionCurrent]);

   if(psTransform->MVPSModelViewChangeCount != pMVCur->MatrixChangeCount)
      {
      bUpdateMVPD = HTRUE;
      }

   if(psTransform->PSChangeCount != pProjCur->MatrixChangeCount
      || psViewport->bDirty)
      {
      MATRIX4* pPSTransform   = 0;
      MATRIX4* pProjTransform = 0;
      MATRIX4* pSTransform    = 0;

      pSTransform = &(psTransform->ScreenMatrix);
      pProjTransform = ProjectionGetCurrentMatrix(gc, HFALSE);
      pPSTransform = &(psTransform->PSMatrix);

      if(psViewport->bDirty)
         {
         // Update Viewport Tranform Matrix
         ProcessViewport(gc);
         }

      psTransform->PSChangeCount = pProjCur->MatrixChangeCount;
      memcpy( pPSTransform, pProjTransform, sizeof( MATRIX4 ));
      bUpdateMVPD = HTRUE;
      }

   if(bUpdateMVPD)
      {
      MATRIX4* pMVTransform = 0;
      MATRIX4* pPSTransform = 0;

      pMVTransform = &(pMVCur->sMatrix);
      pPSTransform = &(psTransform->PSMatrix);

      psTransform->MVPSModelViewChangeCount = pMVCur->MatrixChangeCount;

      CTL_SetTransform( gc->sTransform.ctl, CTLTRANSFORM_VIEW, 
            (CTLMATRIX44*)pMVTransform );
      CTL_SetTransform( gc->sTransform.ctl, CTLTRANSFORM_PROJECTION, 
            (CTLMATRIX44*)pPSTransform );
      }

   // Only if we are texturing
   CTL_SetStateVariable( gc->sTransform.ctl, CTLSTATE_TRANSFORM_TEX1, CTLFALSE );
   if(gc->sTexture.abTexUnitValid[0])
      {
      const HUINT32 t = 0;
      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;
            }