ctl.c

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

   HXFALIGNEDCOLOR4S colorSpecular;

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

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

   HXFAlignedColor4S_Initialize( &colorSpecular );
   Color4s_Pack4x( (U16*)colorSpecular.pClr, (X32*)&psMaterial->sSpecular );

   pState->Flags &= ~HXF_SPECULAR_ENABLE;
   if( !Color4s_IsZero( (U16*)colorSpecular.pClr ))
      {
      pState->Flags |= HXF_SPECULAR_ENABLE;
      }  // if

   Color4s_Pack4x( (U16*)&pState->MaterialEmissive, (X32*)&psMaterial->sEmissive );

   pState->MaterialPower = psMaterial->Power;

   return CTLTRUE;
   
   }  /* CTL_SetMaterial */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_SetPointer( CTLHANDLE h, void* pvArray, CTL_ARRAY_TYPE eType, 
      CTL_ARRAY_FORMAT eFmt, CTLU32 u32Size, CTLU32 u32Stride )
   {
   HXFState* pState = __CTL_GET_STATE( h );

   HXFASSERT( 0 != pState );

   switch( eType )
      {
      case CTLATYPE_COLOR:
         pState->pInDiffuse        = pvArray;
         pState->InDiffuseStride   = u32Stride;
         pState->pfLoadDiffuseProc = g_pfCopyColorProcs[eFmt];
         if( HXF_LIGHT_ENABLE & pState->Flags )
            {
            pState->pfLoadDiffuseProc = g_pfLoadColorProcs[eFmt];
            }  // if         
         break;  // CTLATYPE_COLOR

      case CTLATYPE_NORMAL:
         pState->pInNormal        = pvArray;
         pState->InNormalStride   = u32Stride;
         pState->pfLoadNormalProc = g_pfLoadNormalProcs[eFmt];
         if( HXF_NORMAL_NORMALIZE & pState->Flags )
            {
            g_pfLoadNormalizeNormalProcs[eFmt];
            }  // if         
         break;  // CTLATYPE_NORMAL

      case CTLATYPE_TEXCOORD0:
         pState->pInTextureCoordinate1      = pvArray;
         pState->InTextureCoordinate1Stride = u32Stride;
         pState->pfLoadTex1Proc             = 0; 
         if( u32Size > 0 )
            {
            pState->pfLoadTex1Proc = g_pfLoadTexCoordsProcs[eFmt][u32Size - 2];
            if( HXF_TEXTURE1_TRANSFORM_ENABLE & pState->Flags )
               {
               pState->pfLoadTex1Proc = g_pfTransformTexCoordsProcs[eFmt][u32Size - 2];
               }  // if
            }  // if

         pState->Flags &= ~HXF_OUTPUT_TEX1;
         if( 0 != pvArray )
            {
            pState->Flags |= HXF_OUTPUT_TEX1;
            }  // if
         break;  // CTLATYPE_TEXCOORD0

      case CTLATYPE_TEXCOORD1:
         pState->pInTextureCoordinate2      = pvArray;
         pState->InTextureCoordinate2Stride = u32Stride;
         pState->pfLoadTex2Proc             = 0;
         if( u32Size > 0 )
            {
            pState->pfLoadTex2Proc = g_pfLoadTexCoordsProcs[eFmt][u32Size - 2];
            if( HXF_TEXTURE2_TRANSFORM_ENABLE & pState->Flags )
               {
               pState->pfLoadTex2Proc = g_pfTransformTexCoordsProcs[eFmt][u32Size - 2];
               }  // if
            } // if

         pState->Flags &= ~HXF_OUTPUT_TEX2;
         if( 0 != pvArray )
            {
            pState->Flags |= HXF_OUTPUT_TEX2;
            }  // if
         break;  // CTLATYPE_TEXCOORD1

      case CTLATYPE_VERTEX:
         pState->pInPosition        = pvArray;
         pState->InPositionStride   = u32Stride;
         pState->pfLoadPositionProc = 0;
         if( u32Size > 0 )
            {
            pState->pfLoadPositionProc = g_pfLoadPositionProcs[eFmt][u32Size - 2];
            }  // if
         break;  // CTLATYPE_VERTEX

      default:
         HXFASSERT( CTLFALSE );
         break;  // default
      }  // switch
   
   return CTLTRUE;

   }  /* CTL_SetPointer */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_SetRasterCallbacks( CTLHANDLE h, CTL_RASTER_CALLBACKS* psCallbacks )
   {
   HXFState* pState = __CTL_GET_STATE( h );

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

   pState->ctl.sRasterCallbacks = *psCallbacks;

   return CTLTRUE;

   }  /* CTL_SetRasterCallbacks */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_SetRasterVariable( CTLHANDLE h, CTL_RASTERVAR eWhich, CTLU32 u32Param )
   {
   return CTL_SetRasterVariableV( h, eWhich, &u32Param );
	
   }  /* CTL_SetRasterVariable */


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

   HXFASSERT( 0 != pState );

   switch( eWhich )
      {
      case CTLRASTER_HANDLE:
         pState->ctl.pvRasterHandle = (void*)(*(CTLU32*)pvParams);
         break;  // CTLRASTER_HANDLE

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

      }  // switch

   return CTLTRUE;

   }  /* CTL_SetRasterVariableV */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_SetStateVariable( CTLHANDLE h, CTL_STATEVAR eWhich, CTLU32 u32Param )
   {
   HXFState* pState = __CTL_GET_STATE( h );
   
   HXFASSERT( 0 != pState );

   switch( eWhich )
      {
      case CTLSTATE_COLOR_SOURCE:
         pState->Flags &= ~HXF_LM_COLOR_CONSTANT;
         if( CTLSOURCE_COLOR_MATERIAL == u32Param )
            {
            pState->Flags |= HXF_LM_COLOR_CONSTANT;
            }  // if
         break;  // CTLSTATE_COLOR_SOURCE

      case CTLSTATE_CULL_MODE:
         pState->Flags &= ~HXF_CULL_MASK;
         switch( u32Param )
            {
            case CTLCULL_CW:   pState->Flags |= HXF_CULL_CW;  break; // CTLCULL_CW
            case CTLCULL_CCW:  pState->Flags |= HXF_CULL_CCW; break; // CTLCULL_CCW
            case CTLCULL_NONE: break; // CTLCULL_NONE
            default: HXFASSERT( CTLFALSE ); break; // default
            }  // switch
         break;  // CTLSTATE_CULL_MODE

      case CTLSTATE_FOG_DENSITY:
         pState->FogDensity = u32Param;
         break;  // CTLSTATE_FOG_DENSITY

      case CTLSTATE_FOG_ENABLE:
         pState->Flags &= ~HXF_FOG_ENABLE;
         if( CTLFALSE != u32Param )
            {
            pState->Flags |= HXF_FOG_ENABLE;
            }  // if
         break;  // CTLSTATE_FOG_ENABLE

      case CTLSTATE_FOG_END:
         pState->FogEnd = u32Param;
         Process_Fog( pState );
         break;  // CTLSTATE_FOG_END

      case CTLSTATE_FOG_MODE:
         switch( u32Param )
            {
            case CTLFOG_LINEAR: pState->pfFogProc = HXFFogLinearProc; break; // CTLFOG_LINEAR
            case CTLFOG_EXP:    pState->pfFogProc = HXFFogExpProc;    break; // CTLFOG_EXP
            case CTLFOG_EXP2:   pState->pfFogProc = HXFFogExp2Proc;   break; // CTLFOG_EXP2
            default: HXFASSERT( CTLFALSE ); break;  // default
            }  // switch
         break;  // CTLSTATE_FOG_MODE

      case CTLSTATE_FOG_START:
         pState->ctl.FogStart = u32Param;
         Process_Fog( pState );
         break;  // CTLSTATE_FOG_START

      case CTLSTATE_LIGHT_ENABLE:
         pState->Flags &= ~HXF_LIGHT_ENABLE;
         if( CTLFALSE != u32Param )
            {
            pState->Flags |= HXF_LIGHT_ENABLE;
            }  // if
         break;  // CTLSTATE_LIGHT_ENABLE

      case CTLSTATE_LIGHT_TWOSIDED:
         pState->Flags &= ~HXF_LIGHTING_TWO_SIDED;
         if( CTLFALSE != u32Param )
            {
            pState->Flags |= HXF_LIGHTING_TWO_SIDED;
            }  // if
         break;  // CTLSTATE_LIGHT_TWOSIDED

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

      case CTLSTATE_NORMAL_INVERT:
         pState->Flags &= ~HXF_INVERT_NORMALS;
         if( CTLFALSE != u32Param )
            {
            pState->Flags |= HXF_INVERT_NORMALS;
            }  // if
         break;  // CTLSTATE_NORMAL_INVERT

      case CTLSTATE_NORMAL_NORMALIZE:
         pState->Flags &= ~HXF_NORMAL_NORMALIZE;
         if( CTLFALSE != u32Param )
            {
            pState->Flags |= HXF_NORMAL_NORMALIZE;
            }  // if
         break;  // CTLSTATE_NORMAL_NORMALIZE

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

      case CTLSTATE_SCREEN_ROTATION:
         pState->ctl.eRotation = u32Param;
         Process_Viewport( pState );
         break;  // CTLSTATE_SCREEN_ROTATION

      case CTLSTATE_TRANSFORM_TEX1:
         pState->Flags &= ~HXF_TEXTURE1_TRANSFORM_ENABLE;
         if( CTLFALSE != u32Param )
            {
            pState->Flags |= HXF_TEXTURE1_TRANSFORM_ENABLE;
            }  // if
         break;  // CTLSTATE_TRANSFORM_TEX1

      case CTLSTATE_TRANSFORM_TEX2:
         pState->Flags &= ~HXF_TEXTURE2_TRANSFORM_ENABLE;
         if( CTLFALSE != u32Param )
            {
            pState->Flags |= HXF_TEXTURE2_TRANSFORM_ENABLE;
            }  // if
         break;  // CTLSTATE_TRANSFORM_TEX2

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

      }  // switch

   return CTLTRUE;
   
   }  /* CTL_SetStateVariable */


/* ************************************************************************* *\
\* ************************************************************************* */
CTLBOOL CTL_SetStateVariableV( 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( &pState->ctl.sColorCurrent, pvParams, sizeof( pState->ctl.sColorCurrent ));
         break;  // CTLSTATE_COLOR_CURRENT

      case CTLSTATE_LIGHT_AMBIENT:
         Color4s_Pack4x( (U16*)pState->ctl.sAmbient.pClr, (X32*)pvParams );
         break;  // CTLSTATE_LIGHT_AMBIENT

      case CTLSTATE_NORMAL_CURRENT:
         break;  // CTLSTATE_NORMAL_CURRENT

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

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

      }  // switch

   return CTLTRUE;

   }  /* CTL_SetStateVariableV */


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

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

   HXFASSERT( 0 != pState->pTransformMatrix );

   switch( eType )
      {
      case CTLTRANSFORM_PROJECTION:
         Matrix4x_Multiply( (X32*)&pState->pTransformMatrix[0],
               (X32*)psMatrix,
               (X32*)&pState->ctl.mScreen );
         
         memcpy( &pState->ctl.mProj, &pState->pTransformMatrix[0], sizeof( pState->ctl.mProj ));
//         memcpy( &pState->ctl.mProj, psMatrix, sizeof( pState->ctl.mProj ));

         Matrix4x_Multiply( (X32*)&pState->pTransformMatrix[0], 
               (X32*)&pState->ctl.mView, 
               (X32*)&pState->ctl.mProj );
         break;  // CTLTRANSFORM_PROJECTION

      case CTLTRANSFORM_TEX1:
         memcpy( &pState->pTransformMatrix[1], psMatrix, sizeof( pState->pTransformMatrix[1] ));
         // OPTIMIZATION: disable tex transforms for an identity matrix
         if( Matrix4x_IsIdentity( (X32*)psMatrix ))
            {
            pState->Flags &= ~HXF_TEXTURE1_TRANSFORM_ENABLE;
            }  // if
         break;  // CTLTRANSFORM_TEX1

      case CTLTRANSFORM_TEX2:
         memcpy( &pState->pTransformMatrix[2], psMatrix, sizeof( pState->pTransformMatrix[2] ));
         // OPTIMIZATION: disable tex transforms for an identity matrix
         if( Matrix4x_IsIdentity( (X32*)psMatrix ))
            {
         	pState->Flags &= ~HXF_TEXTURE2_TRANSFORM_ENABLE;
            }  // if
         break;  // CTLTRANSFORM_TEX2

      case CTLTRANSFORM_VIEW:
         Matrix4x_Multiply( (X32*)&pState->pTransformMatrix[0], 
               (X32*)psMatrix, 
               (X32*)&pState->ctl.mProj );

         memcpy( &pState->ctl.mView, psMatrix, sizeof( pState->ctl.mView ));

         pState->FogXForm[0] = psMatrix->m13;
         pState->FogXForm[1] = psMatrix->m23;
         pState->FogXForm[2] = psMatrix->m33;
         pState->FogXForm[3] = psMatrix->m43;
         break;  // CTLTRANSFORM_VIEW
         
      default:
         HXFASSERT( CTLFALSE );
         break;  // default

      }  // switch

   return CTLTRUE;

   }  /* CTL_SetTransform */


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

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

   pState->ctl.sViewport = *psViewport;
   Process_Viewport( pState );

   return CTLTRUE;

   }  /* CTL_SetViewport */


/* ************************************************************************* *\
\* ************************************************************************* */

HXFState* ctlBeginPrimitiveList( HXFState* pState, void* pv1, void* pv2, CTLU32 u32 )
   {
   return pState->ctl.sRasterCallbacks.BeginPrimitiveList(
         pState->ctl.pvRasterHandle, pv1, pv2, u32 );
   }  /* ctlBeginPrimitiveList */


HXFState* ctlEndPrimitiveList( HXFState* pState )
   {
   return pState->ctl.sRasterCallbacks.EndPrimitiveList(
         pState->ctl.pvRasterHandle );
   }  /* ctlEndPrimitiveList */


HXFState* ctlBeginClipList( HXFState* pState )
   {
   return pState->ctl.sRasterCallbacks.BeginClipList(
         pState->ctl.pvRasterHandle );
   }  /* ctlBeginClipList */


HXFState* ctlVertex( HXFState* pState, void* pv1, void* pv2, void* pv3 )
   {
   return pState->ctl.sRasterCallbacks.Vertex(
         pState->ctl.pvRasterHandle, pv1, pv2, pv3 );
   }  /* ctlVertex */


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