ctl.c

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

   if( pState->BaseIndex > 0 )
      {
      if( pState->pInPosition && pState->InPositionStride )
         {
         pState->pInPosition = pState->pInPosition + 
               ( pState->InPositionStride * pState->BaseIndex );
         }  // if

      if( pState->pInNormal && pState->InNormalStride )
         {
         pState->pInNormal = pState->pInNormal + 
               ( pState->InNormalStride * pState->BaseIndex );
         }  // if

      if( pState->pInDiffuse && pState->InDiffuseStride )
         {
         pState->pInDiffuse = pState->pInDiffuse + 
               ( pState->InDiffuseStride * pState->BaseIndex );
         }  // if

      if( pState->pInSpecular && pState->InSpecularStride )
         {
         pState->pInSpecular = pState->pInSpecular + 
               ( pState->InSpecularStride * pState->BaseIndex );
         }  // if

      if( pState->pInTextureCoordinate1 && pState->InTextureCoordinate1Stride )
         {
         pState->pInTextureCoordinate1 = pState->pInTextureCoordinate1 + 
               ( pState->InTextureCoordinate1Stride * pState->BaseIndex );
         }  // if

      if( pState->pInTextureCoordinate2 && pState->InTextureCoordinate2Stride )
         {
         pState->pInTextureCoordinate2 = pState->pInTextureCoordinate2 + 
               ( pState->InTextureCoordinate2Stride * pState->BaseIndex );
         }  // if

      }  // if

   }  /* SetupPointers */


CTLBOOL CTL_DrawPrimitives( CTLHANDLE h, CTL_PRIMITIVE_TYPE eType, CTLU32 u32BaseVertexIndex, 
      CTLU32 u32NumVertices, CTLU32 u32PrimitiveCount )
   {
   HXFState* pState = __CTL_GET_STATE( h );

   HXFASSERT( 0 != pState );

   if( HXF_LIGHT_ENABLE & pState->Flags )
      {
      if( HXF_SEPERATE_SPECULAR & pState->Flags )
         {
         pState->Flags |= HXF_OUTPUT_SPECULAR;
         }  // if
      }  // if

   if( !SetupLighting( pState ))
      {
      return CTLFALSE;
      }  // if

   SetupPrimitiveType( pState, eType );

   pState->NumPrimitives = u32PrimitiveCount;
	pState->NumVertices   = u32NumVertices;
	pState->BaseIndex     = u32BaseVertexIndex;
	HXF_PROFILER_UPDATECOUNTERS( pState->NumPrimitives, pState->NumVertices );

   SetupPointers( pState );

   if( !HXFDrawPrimitives( pState ))
		{
      return CTLFALSE;
		}  // if

   return CTLTRUE;

   }  /* CTL_DrawPrimitives */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_EnableLight( CTLHANDLE h, CTLU32 u32Index, CTLBOOL bEnable )
   {
   HXFState* pState  = __CTL_GET_STATE( h );
   CTLU32    u32Mask = 1L << u32Index;

   HXFASSERT( 0 != pState );

   pState->ctl.bfLightEnable &= ~u32Mask;
   if( bEnable )
      {
      pState->ctl.bfLightEnable |= u32Mask;
      }  // if

   return CTLTRUE;

   }  /* CTL_EnableLight */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_GetLight( CTLHANDLE h, CTLU32 u32Index, CTL_LIGHT* psLight )
   {
   HXFState* pState = __CTL_GET_STATE( h );

   HXFASSERT( 0 != psLight );
   HXFASSERT( 0 != pState );

   memcpy( psLight, &pState->ctl.asLights[u32Index], sizeof( *psLight ));

   return CTLTRUE;

   }  /* CTL_GetLight */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_GetMaterial( CTLHANDLE h, CTL_MATERIAL* psMaterial )
   {
   HXFState* pState = __CTL_GET_STATE( h );

   HXFASSERT( 0 != psMaterial );
   HXFASSERT( 0 != pState );

   memcpy( psMaterial, &pState->ctl.sMaterial, sizeof( *psMaterial ));   

   return CTLTRUE;
   
   }  /* CTL_GetMaterial */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_GetRasterVariable( CTLHANDLE h, CTL_RASTERVAR eWhich, CTLU32* pu32Param )
   {
   HXFState* pState = __CTL_GET_STATE( h );

   HXFASSERT( 0 != pu32Param );
   HXFASSERT( 0 != pState );

   switch( eWhich )
      {
      case CTLRASTER_HANDLE:
         *pu32Param = (CTLU32)pState->ctl.pvRasterHandle;
         break;  // CTLRASTER_HANDLE
      
      default:
         HXFASSERT( CTLFALSE );
         return CTLFALSE;

      } // switch

   return CTLTRUE;

   }  /* CTL_GetRasterVariableV */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_GetStateVariable( CTLHANDLE h, CTL_STATEVAR eWhich, CTLU32* pu32Param )
   {
   HXFState* pState = __CTL_GET_STATE( h );

   HXFASSERT( 0 != pu32Param );
   HXFASSERT( 0 != pState );

   switch( eWhich )
      {
      case CTLSTATE_COLOR_SOURCE:
         *pu32Param = (( HXF_LM_COLOR_CONSTANT & pState->Flags ) ?
               CTLSOURCE_COLOR_MATERIAL : CTLSOURCE_COLOR_CONSTANT );
         break;  // CTLSTATE_COLOR_SOURCE

      case CTLSTATE_CULL_MODE:
         *pu32Param = (( HXF_CULL_CW & pState->Flags ) ? CTLCULL_CW :
               (( HXF_CULL_CCW & pState->Flags ) ? CTLCULL_CCW :
               CTLCULL_NONE ));
         break;  // CTLSTATE_CULL_MODE

      case CTLSTATE_FOG_DENSITY:
         *pu32Param = pState->FogDensity;
         break;  // CTLSTATE_FOG_DENSITY

      case CTLSTATE_FOG_ENABLE:
         *pu32Param = ( HXF_FOG_ENABLE & pState->Flags ) ? CTLTRUE : CTLFALSE;
         break;  // CTLSTATE_FOG_ENABLE

      case CTLSTATE_FOG_END:
         *pu32Param = pState->FogEnd;
         break;  // CTLSTATE_FOG_END

      case CTLSTATE_FOG_MODE:
         if( HXFFogLinearProc == pState->pfFogProc )
            *pu32Param = CTLFOG_LINEAR;
         else if( HXFFogExpProc == pState->pfFogProc )
            *pu32Param = CTLFOG_EXP;
         else if( HXFFogExp2Proc == pState->pfFogProc )
            *pu32Param = CTLFOG_EXP2;
         else
            HXFASSERT( CTLFALSE );
         break;  // CTLSTATE_FOG_MODE

      case CTLSTATE_FOG_START:
         *pu32Param = pState->ctl.FogStart;
         break;  // CTLSTATE_FOG_START

      case CTLSTATE_LIGHT_ENABLE:
         *pu32Param = ( HXF_LIGHT_ENABLE & pState->Flags ) ? CTLTRUE : CTLFALSE;
         break;  // CTLSTATE_LIGHT_ENABLE

      case CTLSTATE_LIGHT_TWOSIDED:
         *pu32Param = ( HXF_LIGHTING_TWO_SIDED & pState->Flags ) ? CTLTRUE : CTLFALSE;
         break;  // CTLSTATE_LIGHT_TWOSIDED

      case CTLSTATE_LINEWIDTH:
         *pu32Param = *((CTLU32*)&pState->ctl.fLineWidth);
         break;  // CTLSTATE_LINEWIDTH

      case CTLSTATE_NORMAL_NORMALIZE:
         *pu32Param = ( HXF_NORMAL_NORMALIZE & pState->Flags ) ? CTLTRUE : CTLFALSE;
         break;  // CTLSTATE_NORMAL_NORMALIZE

      case CTLSTATE_POINTSIZE:
         *pu32Param = *((CTLU32*)&pState->ctl.fPointSize);
         break;  // CTLSTATE_POINTSIZE

      case CTLSTATE_SCREEN_ROTATION:
         *pu32Param = pState->ctl.eRotation;
         break;  // CTLSTATE_SCREEN_ROTATION

      case CTLSTATE_TRANSFORM_TEX1:
         *pu32Param = ( HXF_TEXTURE1_TRANSFORM_ENABLE & pState->Flags ) ? CTLTRUE : CTLFALSE;
         break;  // CTLSTATE_TRANSFORM_TEX1

      case CTLSTATE_TRANSFORM_TEX2:
         *pu32Param = ( HXF_TEXTURE2_TRANSFORM_ENABLE & pState->Flags ) ? CTLTRUE : CTLFALSE;
         break;  // CTLSTATE_TRANSFORM_TEX2

      default:
         HXFASSERT( CTLFALSE );
         return CTLFALSE;

      }  // switch

   return CTLTRUE;

   }  /* CTL_GetStateVariable */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_GetStateVariableV( CTLHANDLE h, CTL_STATEVAR eWhich, void* pvParams )
   {
   HXFState* pState = __CTL_GET_STATE( h );

   HXFASSERT( 0 != pvParams );
   HXFASSERT( 0 != pState );

   switch( eWhich )
      {
      case CTLSTATE_COLOR_CURRENT:
         memcpy( pvParams, &pState->ctl.sColorCurrent, sizeof( pState->ctl.sColorCurrent ));
         break;  // CTLSTATE_COLOR_CURRENT

      case CTLSTATE_LIGHT_AMBIENT:
         HXFASSERT( CTLFALSE );
         break;  // CTLSTATE_LIGHT_AMBIENT

      case CTLSTATE_NORMAL_CURRENT:
         HXFASSERT( CTLFALSE );
         break;  // CTLSTATE_NORMAL_CURRENT

      case CTLSTATE_SCREEN_DIMS:
         *((CTLU32*)pvParams + 0 ) = pState->ctl.u32ScreenWidth;
         *((CTLU32*)pvParams + 1 ) = pState->ctl.u32ScreenHeight;
         break;  // CTLSTATE_SCREEN_DIMS

      default:
         HXFASSERT( CTLFALSE );
         break;  // default

      }  // switch

   return CTLTRUE;

   }  /* CTL_GetStateVariableV */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_GetTransform( CTLHANDLE h, CTL_TRANSFORM_TYPE eType, CTLMATRIX44* psMatrix )
   {
   HXFState* pState = __CTL_GET_STATE( h );

   HXFASSERT( 0 != psMatrix );
   HXFASSERT( 0 != pState );

   switch( eType )
      {
      case CTLTRANSFORM_PROJECTION:
         memcpy( psMatrix, &pState->ctl.mProj, sizeof( pState->ctl.mProj ));
         break;  // CTLTRANSFORM_PROJECTION

      case CTLTRANSFORM_TEX1:
         memcpy( psMatrix, &pState->pTransformMatrix[1], sizeof( pState->pTransformMatrix[1] ));
         break;  // CTLTRANSFORM_TEX1

      case CTLTRANSFORM_TEX2:
         memcpy( psMatrix, &pState->pTransformMatrix[2], sizeof( pState->pTransformMatrix[2] ));
         break;  // CTLTRANSFORM_TEX2

      case CTLTRANSFORM_VIEW:
         memcpy( psMatrix, &pState->ctl.mView, sizeof( pState->ctl.mView ));
         break;  // CTLTRANSFORM_VIEW
         
      default:
         HXFASSERT( CTLFALSE );
         break;  // default

      }  // switch

   return CTLTRUE;

   }  /* CTL_GetTransform */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLU32 CTL_GetVertexSize( CTLHANDLE h )
   {
   HXFState* pState = __CTL_GET_STATE( h );
	CTLU32 OutVtxSize = HXF_VTX_BASE_SIZE;

   HXFASSERT( 0 != pState );

   // Calculate the output vertex size
	if(pState->Flags & HXF_LIGHT_ENABLE)
	{
		OutVtxSize += HXF_VTX_DIFFUSE_SIZE;

		if(pState->Flags & HXF_SEPERATE_SPECULAR
			|| pState->Flags & HXF_FOG_ENABLE)
		{
			OutVtxSize += HXF_VTX_SPECULAR_SIZE;
		}
	}
	else
	{
		if(pState->pInDiffuse)
		{
			OutVtxSize += HXF_VTX_DIFFUSE_SIZE;
		}

		if(pState->pInSpecular
			|| pState->Flags & HXF_FOG_ENABLE)
		{
			OutVtxSize += HXF_VTX_SPECULAR_SIZE;
		}
	}

	if(pState->pInTextureCoordinate1)
	{
		OutVtxSize += HXF_VTX_TEX1_SIZE;
	}

	if(pState->pInTextureCoordinate2)
	{
		OutVtxSize += HXF_VTX_TEX2_SIZE;
	}

	// Store the size of the data that we will
	// transmit to marathon
   return OutVtxSize;

   }  /* CTL_GetVertexSize */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_GetViewport( CTLHANDLE h, CTL_VIEWPORT* psViewport )
   {
   HXFState* pState = __CTL_GET_STATE( h );

   HXFASSERT( 0 != psViewport );
   HXFASSERT( 0 != pState );

   *psViewport = pState->ctl.sViewport;

   return CTLTRUE;
   
   }  /* CTL_GetViewport */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_SetIndices( CTLHANDLE h, CTLU16* pu16Indices )
   {
   HXFState* pState = __CTL_GET_STATE( h );

   // OK for indices to be null if drawing non-indexed primitives
   //HXFASSERT( 0 != pu16Indices );
   HXFASSERT( 0 != pState );

   pState->pIndices = (HBYTE*)pu16Indices;

   return CTLTRUE;

   }  /* CTL_SetIndices */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_SetLight( CTLHANDLE h, CTLU32 u32Index, CTL_LIGHT* psLight )
   {
   HXFState* pState    = __CTL_GET_STATE( h );
   HXFLight* pHXFLight = 0;
   
   HXFASSERT( 0 != psLight );
   HXFASSERT( 0 != pState );

   memcpy( &pState->ctl.asLights[u32Index], psLight, sizeof( CTL_LIGHT ));
      
   // Pack the colors into their aligned counterparts.
   // TODO: verify this is needed, since the engine seems to use the unaligned
   //  versions in the same struct to do the lighting.
   pHXFLight = &pState->ctl.pLights[u32Index];
   HXFASSERT( 0 != pHXFLight );

   Color4s_Pack4x( (U16*)pHXFLight->sAmbient.pClr,  (X32*)&psLight->sAmbient );
   Color4s_Pack4x( (U16*)pHXFLight->sDiffuse.pClr,  (X32*)&psLight->sDiffuse );
   Color4s_Pack4x( (U16*)pHXFLight->sSpecular.pClr, (X32*)&psLight->sSpecular );

   // Spot exponent is a straight copy.
   pHXFLight->SpotExponent = psLight->SpotExponent;

   // Precompute the cosine of the spot cutoff.
   if( psLight->SpotCutoff != IasX( 180 ))
      {
      float rad = XtoF( psLight->SpotCutoff ) * 3.14159265358979323846f / 180.0f;
      pHXFLight->CosSpotCutoff = FtoX( (float)cos( rad ));
      }  // if
   else
      {
      pHXFLight->CosSpotCutoff = HXF_MAX_FIXED;
      }  // else

   return CTLTRUE;

   }  /* CTL_SetLight */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_SetMaterial( CTLHANDLE h, CTL_MATERIAL* psMaterial )
   {
   HXFState* pState = __CTL_GET_STATE( h );