matrix.c

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

GLAPI void APIENTRY glTranslatex( GLfixed x, GLfixed y, GLfixed z )
   {
   glTranslatef( XtoF( x ), XtoF( y ), XtoF( z ));
   }  /* glTranslatex */

#elif defined( PROFILE_COMMON_LITE )

GLAPI void APIENTRY glTranslatex( GLfixed x, GLfixed y, GLfixed z )
   {
   Matrix4x* pMat = 0;
   Matrix4x tmp;

   __GL_GET_CONTEXT();
   HXF_PROFILER_START( HXFPROFILE_STATE_MATRIX );

   pMat = gc->sProcs.pfnGetCurrentMatrix( gc, TRUE );
   Matrix4x_SetIdentity( (X32*)&tmp );

   tmp._41 = x;
   tmp._42 = y;
   tmp._43 = z;

   Matrix4x_Multiply( (X32*)pMat, (X32*)&tmp, (X32*)pMat );

   HXF_PROFILER_STOP( HXFPROFILE_STATE_MATRIX );

   }  /* glTranslatex */

#else
#error "Profile not defined for glTranslate"
#endif  /* PROFILE */


/***********************************************************************************
 Function Name      : glPopMatrix
 Inputs             : -
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Pops the current matrix stack
************************************************************************************/

GLAPI void APIENTRY glPopMatrix(void)
{
	__GL_GET_CONTEXT();
	HXF_PROFILER_START(HXFPROFILE_STATE_MATRIX);

   (*gc->sProcs.pfnPopMatrix)(gc);

	HXF_PROFILER_STOP(HXFPROFILE_STATE_MATRIX);
}

/***********************************************************************************
 Function Name      : glPushMatrix
 Inputs             : -
 Outputs            : -
 Returns            : -
 Description        : ENTRYPOINT: Pushes the current matrix onto its stack.
************************************************************************************/

GLAPI void APIENTRY glPushMatrix(void)
{
	__GL_GET_CONTEXT();
	HXF_PROFILER_START(HXFPROFILE_STATE_MATRIX);

   (*gc->sProcs.pfnPushMatrix)(gc);

  	HXF_PROFILER_STOP(HXFPROFILE_STATE_MATRIX);
}

/* ************************************************************************* *\
	FUNCTION: glLoadIdentity
	DESCRIPTION:
\* ************************************************************************* */
void APIENTRY glLoadIdentity (void)
   {
   MATRIX4* pMat = 0;

   __GL_GET_CONTEXT();
   HXF_PROFILER_START( HXFPROFILE_STATE_MATRIX );

   pMat = gc->sProcs.pfnGetCurrentMatrix( gc, TRUE );
   MATRIX4_IDENTITY( (NATIVE*)pMat );

   HXF_PROFILER_STOP( HXFPROFILE_STATE_MATRIX );

   }  /* glLoadIdentity */


/* ************************************************************************* *\
	FUNCTION:
	DESCRIPTION:
\* ************************************************************************* */
void ModelViewPushMatrix(GLESContext *gc)
{
	HUINT32 i;

	i = gc->sTransform.ModelViewCurrent;

	gc->sTransform.ModelViewCurrent++;

	if(GLES_MAX_MODELVIEW_STACK_DEPTH == gc->sTransform.ModelViewCurrent)
	{
		gc->sTransform.ModelViewCurrent--;
		SetError(gc, GL_STACK_OVERFLOW);
		return;
	}

	// Copy data up
	memcpy(&(gc->sTransform.psModelViewStack[gc->sTransform.ModelViewCurrent]),
				&(gc->sTransform.psModelViewStack[i]),
				sizeof(gc->sTransform.psModelViewStack[0]));
}

/* ************************************************************************* *\
	FUNCTION:
	DESCRIPTION:
\* ************************************************************************* */
void ModelViewPopMatrix(GLESContext *gc)
{
	if(0 == gc->sTransform.ModelViewCurrent)
	{
		SetError(gc, GL_STACK_UNDERFLOW);
		return;
	}

	gc->sTransform.ModelViewCurrent--;
}

/* ************************************************************************* *\
	FUNCTION:
	DESCRIPTION:
\* ************************************************************************* */
MATRIX4* ModelViewGetCurrentMatrix( GLESContext *gc, U32 bMakeDirty )
   {
	U32 i;
	GLESMVTransform* pMVElement = NULL;
	i = gc->sTransform.ModelViewCurrent;
	pMVElement = &(gc->sTransform.psModelViewStack[i]);

	if( bMakeDirty )
	   {
		pMVElement->MatrixChangeCount = UpdateMatrixChangeCount( gc );
	   }  // if

	return &pMVElement->sMatrix;
   
   }  /* ModelViewGetCurrentMatrix */


/* ************************************************************************* *\
	FUNCTION:
	DESCRIPTION:
\* ************************************************************************* */
void ProjectionPushMatrix(GLESContext *gc)
{
	U32 i;
	i = gc->sTransform.ProjectionCurrent;
   gc->sTransform.ProjectionCurrent++;

	if(GLES_MAX_PROJECTION_STACK_DEPTH == gc->sTransform.ProjectionCurrent)
	{
		gc->sTransform.ProjectionCurrent--;
		SetError(gc, GL_STACK_OVERFLOW);
		return;
	}

	// Copy data up
	memcpy(&(gc->sTransform.psProjectionStack[gc->sTransform.ProjectionCurrent]),
				&(gc->sTransform.psProjectionStack[i]),
				sizeof(gc->sTransform.psProjectionStack[0]));
}

/* ************************************************************************* *\
	FUNCTION:
	DESCRIPTION:
\* ************************************************************************* */
void ProjectionPopMatrix(GLESContext *gc)
{
	if(0 == gc->sTransform.ProjectionCurrent)
	{
		SetError(gc, GL_STACK_UNDERFLOW);
		return;
	}

	gc->sTransform.ProjectionCurrent--;
}

/* ************************************************************************* *\
	FUNCTION:
	DESCRIPTION:
\* ************************************************************************* */
MATRIX4* ProjectionGetCurrentMatrix( GLESContext *gc, U32 bMakeDirty )
   {
	U32 i;
	GLESProjectionTransform* pPMatrix = NULL;

	i = gc->sTransform.ProjectionCurrent;
	pPMatrix = &(gc->sTransform.psProjectionStack[i]);

	if(bMakeDirty)
	   {
		pPMatrix->MatrixChangeCount = UpdateMatrixChangeCount(gc);
	   }  // if

	return &(pPMatrix->sMatrix);
   
   }  /* ProjectionGetCurrentMatrix */

/* ************************************************************************* *\
	FUNCTION:
	DESCRIPTION:
\* ************************************************************************* */
void TexturePushMatrix(GLESContext *gc)
{
	HUINT32 i, t;

	t = gc->sState.sTexture.ui32ActiveTexture;
	i = gc->sTransform.TextureCurrent[t];

	gc->sTransform.TextureCurrent[t]++;
	if(GLES_MAX_TEXTURE_STACK_DEPTH == gc->sTransform.TextureCurrent[t])
	{
		gc->sTransform.TextureCurrent[t]--;
		SetError(gc, GL_STACK_OVERFLOW);
		return;
	}

	// Copy data up
	memcpy(&(gc->sTransform.apsTextureStack[t][gc->sTransform.TextureCurrent[t]]),
				&(gc->sTransform.apsTextureStack[t][i]),
				sizeof(gc->sTransform.apsTextureStack[0][0]));
}

/* ************************************************************************* *\
	FUNCTION:
	DESCRIPTION:
\* ************************************************************************* */
void TexturePopMatrix(GLESContext *gc)
{
	HUINT32 t;

	t = gc->sState.sTexture.ui32ActiveTexture;

	if(0 == gc->sTransform.TextureCurrent[t])
	{
		SetError(gc, GL_STACK_UNDERFLOW);
		return;
	}

	gc->sTransform.TextureCurrent[t]--;
}

/* ************************************************************************* *\
	FUNCTION: TextureGetCurrent
	DESCRIPTION:
\* ************************************************************************* */
MATRIX4* TextureGetCurrentMatrix( GLESContext *gc, U32 bMakeDirty )
   {
	U32 i;
	U32 t;

	GLESTexTransform* pTMatrix = NULL;

	t = gc->sState.sTexture.ui32ActiveTexture;
	i = gc->sTransform.TextureCurrent[t];

	pTMatrix = &(gc->sTransform.apsTextureStack[t][i]);

	if(bMakeDirty)
   	{
		pTMatrix->MatrixChangeCount = UpdateMatrixChangeCount(gc);
	   }  // if
	
   return &pTMatrix->sMatrix;

   }  /* TextureGetCurrentMatrix */


/* ************************************************************************* *\
	FUNCTION: TextureGetCurrent
	DESCRIPTION:
\* ************************************************************************* */
MATRIX4* TextureGetCurrentMatrixIdx(GLESContext *gc, U32 Idx)
{
	HUINT32 i;
	i = gc->sTransform.TextureCurrent[Idx];
	return &(gc->sTransform.apsTextureStack[Idx][i].sMatrix);
}


/***********************************************************************************
 Function Name      : SetupTransformLightingProcs
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : Sets up Matrix function pointers.
************************************************************************************/

void SetupTransformLightingProcs(GLESContext *gc)
{
	gc->sProcs.pfnGetCurrentMatrix = ModelViewGetCurrentMatrix;
	gc->sProcs.pfnPushMatrix = ModelViewPushMatrix;
	gc->sProcs.pfnPopMatrix = ModelViewPopMatrix;
}

//extern BOOL VirtualSetAttributes( HUINT32 lpvAddress, HUINT32 cbSize,
//						HUINT32 dwNewFlags, HUINT32 dwMask, HUINT32* lpdwOldFlags);

/***********************************************************************************
 Function Name      : InitTransformState
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : Initialises transform machine and state
************************************************************************************/

IMG_BOOL InitTransformState(GLESContext *gc)
   {
   BOOL bRet = IMG_TRUE;
   IMG_UINT32 i;
   GLEStransformMachine* psTransform = NULL;
   GLESlightSourceState* psLightState = NULL;

   psTransform = &gc->sTransform;
   psLightState = &(gc->sState.sLight.sLights[0]);

   /* Allocate memory for matrix stacks */
   psTransform->psModelViewStack = (GLESMVTransform*)GLESCalloc(gc, GLES_MAX_MODELVIEW_STACK_DEPTH * sizeof(GLESMVTransform));
   psTransform->psProjectionStack = (GLESProjectionTransform*)GLESCalloc(gc, GLES_MAX_PROJECTION_STACK_DEPTH * sizeof(GLESProjectionTransform));
   if(!psTransform->psModelViewStack || !psTransform->psProjectionStack)
      {
      bRet = IMG_FALSE;
      }

   for (i=0; i<GLES_MAX_TEXTURE_UNITS; i++)
      {
      psTransform->apsTextureStack[i] =
         (GLESTexTransform*) GLESCalloc(gc, GLES_MAX_TEXTURE_STACK_DEPTH * sizeof(GLESTexTransform));
      if(!psTransform->apsTextureStack[i])
         {
         bRet = IMG_FALSE;
         }
      }

   if(bRet)
      {
      // Initialize Matrix State
      gc->sState.eMatrixMode = GL_MODELVIEW;

      psTransform->ModelViewCurrent = 0;
      MATRIX4_IDENTITY( (NATIVE*)&psTransform->psModelViewStack[0].sMatrix );
      psTransform->psModelViewStack[0].MatrixChangeCount = UpdateMatrixChangeCount(gc);

      psTransform->ProjectionCurrent = 0;
      MATRIX4_IDENTITY( (NATIVE*)&psTransform->psProjectionStack[0].sMatrix );
      psTransform->psProjectionStack[0].MatrixChangeCount = UpdateMatrixChangeCount(gc);

      for (i=0; i<GLES_MAX_TEXTURE_UNITS; ++i)
         {
         psTransform->TextureCurrent[i] = 0;
         MATRIX4_IDENTITY( (NATIVE*)&psTransform->apsTextureStack[i][0].sMatrix );
         psTransform->apsTextureStack[i][0].MatrixChangeCount = UpdateMatrixChangeCount(gc);
         }

      psTransform->ScreenRotation = -1;
      MATRIX4_IDENTITY( (NATIVE*)&psTransform->PSMatrix );
      MATRIX4_IDENTITY( (NATIVE*)&psTransform->ScreenMatrix );
      }

   if(bRet)
      {
      if( CTLHANDLE_NULL == ( psTransform->ctl = CTL_Init() ))
         {
         bRet = IMG_FALSE;
         }

#if defined( PROFILE_COMMON_LITE )      
      psTransform->pMRLState = (MRLState*)psTransform->ctl;
#elif defined( PROFILE_COMMON )
      psTransform->pMRLState = (MRLState*)malloc( sizeof( MRLState ));
#else
#error "Profile not defined for MRL creation"
#endif
      }

   if( bRet )
      {
      psTransform->pMRLState->pHWState   = &gc->sHWContext;
      psTransform->pMRLState->SPAddr     = (HUINT32)psTransform->pMRLState->pHWState->psHWInfo->sDeviceSpecific.sMBX.sTASlavePort.pvData;
      psTransform->pMRLState->SPBaseAddr = (HUINT32)psTransform->pMRLState->pHWState->psHWInfo->sDeviceSpecific.sMBX.sTASlavePort.pvData;
      psTransform->pMRLState->SPTermAddr = (HUINT32)psTransform->pMRLState->pHWState->psHWInfo->sDeviceSpecific.sMBX.sTAControlSlavePort.pvData;

      CTL_SetRasterVariable( gc->sTransform.ctl, CTLRASTER_HANDLE, 
            (CTLU32)psTransform->pMRLState );
      }

   if(bRet)
      {
      ApplyDepthRange(gc, GLES_Zero, GLES_One);

#ifdef HXF_PROFILE
      HXFProfilerInitialize();
#endif // HXF_PROFILE
      }

   if(!bRet)
      {
      FreeTransformState(gc);
      }

   return bRet;

   }  /* InitTransformState */

/***********************************************************************************
 Function Name      : FreeTransformState
 Inputs             : gc
 Outputs            : -
 Returns            : -
 Description        : Cleanup transform machine and state
************************************************************************************/
void FreeTransformState(GLESContext *gc)
   {
   IMG_UINT32 i;

   if(gc->sTransform.psModelViewStack)
      {
      GLESFree(gc, gc->sTransform.psModelViewStack);
      gc->sTransform.psModelViewStack = NULL;
      }

   if(gc->sTransform.psProjectionStack)
      {
      GLESFree(gc, gc->sTransform.psProjectionStack);
      gc->sTransform.psProjectionStack = NULL;
      }

   for (i=0; i<GLES_MAX_TEXTURE_UNITS; i++)
      {
      if(gc, gc->sTransform.apsTextureStack[i])
         {
         GLESFree(gc, gc->sTransform.apsTextureStack[i]);
         gc->sTransform.apsTextureStack[i]= NULL;
         }
      }

   // free the xform engine state state
   if( CTLHANDLE_NULL != gc->sTransform.ctl )
      {
      CTL_Done( gc->sTransform.ctl  );
      gc->sTransform.ctl = CTLHANDLE_NULL;
#if defined( PROFILE_COMMON )
      free( gc->sTransform.pMRLState );
#endif
      gc->sTransform.pMRLState = 0;
      }

#ifdef HXF_PROFILE
   HXFProfilerShutdown();
#endif // HXF_PROFILE

   }  /* FreeTransformState */


/***********************************************************************************
 Function Name      : HXFCCWCullDirection
 Inputs             : pState
 Outputs            : -
 Returns            : -
 Description        : Change the culling direction for 2 sided lighting.
************************************************************************************/
void HXFFlipCullDirection(MRLState * pState)
{
   CTL_CULL_MODE ctlCull;

   CTL_GetStateVariable( pState, CTLSTATE_CULL_MODE, (CTLU32*)&ctlCull );
	if( CTLCULL_CW == ctlCull )
	{
      CTL_SetStateVariable( pState, CTLSTATE_CULL_MODE, CTLCULL_CCW );
		pState->PrimitiveHeader &= MBX1_TAPRIM_CULLMODECLRMASK;
		pState->PrimitiveHeader |= MBX1_TAPRIM_CULLMODECCW;
	}
	else
	{
      CTL_SetStateVariable( pState, CTLSTATE_CULL_MODE, CTLCULL_CW );
		pState->PrimitiveHeader &= MBX1_TAPRIM_CULLMODECLRMASK;
		pState->PrimitiveHeader |= MBX1_TAPRIM_CULLMODECW;
	}
}


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