rstate.c

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

				In: dwData - Value of state modification
</function>
------------------------------------------------------------------------------*/
void D3DM_RS_ZBias(LPD3DM_CONTEXT psContext,DWORD dwData)
{
	D3DM_DPF((DPF_ENTRY, "->D3DM_RS_ZBias"));

	/* Record the new ZBIAS value */
	psContext->sTState.D3DZBias = FL2NTV(LONG_TO_FLOAT(dwData));

	if(psContext->sTState.D3DZBias == D3DM_Zero && psContext->sTState.D3DSSDBias == D3DM_Zero)
	{
#if defined (SUPPORT_VGP) || defined (SUPPORT_VGP_LITE)
		if(psContext->sTState.dwRSFlags & TSTATE_RSFLAGS_DEPTHBIAS)
		{
			/* We need to update position section */
			psContext->sTState.sSWTNLState.dwSectionModFlags |= (1 << VGPTNL_SECTIONORD_POSITION);
		}
#endif
		psContext->sTState.dwRSFlags &= ~TSTATE_RSFLAGS_DEPTHBIAS;
	}
	else
	{
#if defined (SUPPORT_VGP) || defined (SUPPORT_VGP_LITE)
		if(!(psContext->sTState.dwRSFlags & TSTATE_RSFLAGS_DEPTHBIAS))
		{
			/* We need to update position section */
			psContext->sTState.sSWTNLState.dwSectionModFlags |= (1 << VGPTNL_SECTIONORD_POSITION);
		}
#endif
		psContext->sTState.dwRSFlags |= TSTATE_RSFLAGS_DEPTHBIAS;
	}

	psContext->sTState.D3DZBias = Mul(psContext->sTState.D3DZBias , LONG_AS_NTV(psContext->sRegData.dwZBiasScale));

	psContext->sTState.sSWTNLState.dwTNLFlags |= PVRD3DTNL_FLAGS_ZBIAS_PARAMS_CHANGED;

	D3DM_DPF((DPF_STATE, "D3DM_RS_ZBias   : Data = %d", dwData));
	D3DM_DPF((DPF_EXIT, "<-D3DM_RS_ZBias"));
}
/*----------------------------------------------------------------------------
<function>
	FUNCTION:   D3DM_RS_SlopeScaledDepthBias

	PURPOSE:    

	PARAMETERS:	In: psContext - Context who's state is to be modified
				In: dwData - Value of state modification
</function>
------------------------------------------------------------------------------*/
void D3DM_RS_SlopeScaledDepthBias(LPD3DM_CONTEXT psContext,DWORD dwData)
{
	D3DM_DPF((DPF_ENTRY, "->D3DM_RS_SlopeScaledDepthBias"));

#if !defined(SUPPORT_VGP) && !defined (SUPPORT_VGP_LITE)
	/* Record the new SSDBIAS value */
	psContext->sTState.D3DSSDBias = FL2NTV(LONG_TO_FLOAT(dwData));
#else
	psContext->sTState.D3DSSDBias = D3DM_Zero;
#endif

	if(psContext->sTState.D3DZBias == D3DM_Zero && psContext->sTState.D3DSSDBias == D3DM_Zero)
	{
#if defined (SUPPORT_VGP) || defined (SUPPORT_VGP_LITE)
		if(psContext->sTState.dwRSFlags & TSTATE_RSFLAGS_DEPTHBIAS)
		{
			/* We need to update position section */
			psContext->sTState.sSWTNLState.dwSectionModFlags |= (1 << VGPTNL_SECTIONORD_POSITION);
		}
#endif
		psContext->sTState.dwRSFlags &= ~TSTATE_RSFLAGS_DEPTHBIAS;
	}
	else
	{
#if defined (SUPPORT_VGP) || defined (SUPPORT_VGP_LITE)
		if(!(psContext->sTState.dwRSFlags & TSTATE_RSFLAGS_DEPTHBIAS))
		{
			/* We need to update position section */
			psContext->sTState.sSWTNLState.dwSectionModFlags |= (1 << VGPTNL_SECTIONORD_POSITION);
		}
#endif
		psContext->sTState.dwRSFlags |= TSTATE_RSFLAGS_DEPTHBIAS;
	}

	D3DM_DPF((DPF_STATE, "D3DM_RS_SlopeScaledDepthBias   : Data = %d", dwData));
	D3DM_DPF((DPF_EXIT, "<-D3DM_RS_SlopeScaledDepthBias"));
}
/*----------------------------------------------------------------------------
<function>
	FUNCTION:   D3DM_RS_TextureFactor

	PURPOSE:    

	PARAMETERS:	In: psContext - Context who's state is to be modified
				In: dwData - Value of state modification
</function>
------------------------------------------------------------------------------*/
void D3DM_RS_TextureFactor(LPD3DM_CONTEXT psContext,DWORD dwData)
{
	DWORD	dwTSPObjCtl;

	D3DM_DPF((DPF_ENTRY, "->D3DM_RS_TextureFactor"));

	/* Write the new factor-colour into the TSP per-pbject control word */
	dwTSPObjCtl = psContext->sHWState.sTACtl3DState.dwTSPObjCtl;

	dwTSPObjCtl &= MBX1_TSPOBJ_FACTORCLRMASK;
	dwTSPObjCtl |= ((dwData >> 26) << MBX1_TSPOBJ_FACTORASHIFT) & (~MBX1_TSPOBJ_FACTORAMASK);
	dwTSPObjCtl |= ((dwData >> 19) << MBX1_TSPOBJ_FACTORRSHIFT) & (~MBX1_TSPOBJ_FACTORRMASK);
	dwTSPObjCtl |= ((dwData >> 11) << MBX1_TSPOBJ_FACTORGSHIFT) & (~MBX1_TSPOBJ_FACTORGMASK);
	dwTSPObjCtl |= ((dwData >>  3) << MBX1_TSPOBJ_FACTORBSHIFT) & (~MBX1_TSPOBJ_FACTORBMASK);

	psContext->sHWState.sTACtl3DState.dwTSPObjCtl = dwTSPObjCtl;

	/* Flag that the TSP per-object control word has been modified */
	psContext->sHWStateCtl.dwTACtl3DStateChanged |= MBX1_TASTATEPRES_TSPCTL;

	D3DM_DPF((DPF_STATE, "D3DM_RS_TextureFactor: Colour = 0x%08X", dwData));
	D3DM_DPF((DPF_EXIT, "<-D3DM_RS_TextureFactor"));
}

/*----------------------------------------------------------------------------
<function>
	FUNCTION:   D3DM_RS_Wrap

	PURPOSE:    

	PARAMETERS:	In: psContext - Context who's state is to be modified
				In: dwData - Value of state modification
</function>
------------------------------------------------------------------------------*/
void D3DM_RS_Wrap(LPD3DM_CONTEXT psContext,DWORD dwData)
{
	PTRANSIENT_STATE	psTState;
	DWORD				dwCoordSet;
	DWORD				dwWrapFlags;
	DWORD				dwWrapFlagsShift;
	DWORD				i;
	DWORD				dwType;

	D3DM_DPF((DPF_ENTRY, "->D3DM_RS_Wrap"));

	dwType = D3DM_MAKE_RSVALUE(psContext->eLastRenderStateChange);
																										 
	D3DM_DPF((DPF_STATE,"D3DM_RS_Wrap: CoordSet = %d, Data = %d", dwType - D3DMRS_WRAP0, dwData));

	psTState = &psContext->sTState;

	/* Determine which coord set we are changing the wrap-state of	*/
	dwCoordSet = dwType - D3DMRS_WRAP0;

	/* Update the coordinate-set wrapping flags	*/
	dwWrapFlags = 0;
	if	(dwData & D3DMWRAPCOORD_0)
	{
		dwWrapFlags |= TSTATE_WRAPFLAGS_WRAPCOORD0;
	}
	if	(dwData & D3DMWRAPCOORD_1)
	{
		dwWrapFlags |= TSTATE_WRAPFLAGS_WRAPCOORD1;
	}

	dwWrapFlagsShift = TSTATE_WRAPFLAGS_COORDSET0SHIFT + 
					   (dwCoordSet * TSTATE_WRAPFLAGS_PERCOORDSET_LSHIFT);

	psTState->dwWrapFlags &= ~(TSTATE_WRAPFLAGS_WRAPMASK << dwWrapFlagsShift);
	psTState->dwWrapFlags |= dwWrapFlags << dwWrapFlagsShift;

	/* Look at each layer to see if it uses the texture coord */
	for (i = 0; i < MBX1_MAXTEXTURE_LAYERS; i++)
	{
		PLAYER_TSTATE	psLState;

		psLState = &psTState->sLState[i];

		/*
			Update the HW texture-addressing mode for this layer if it is
			using this coordinate-set
		*/
		if	(psLState->dwCoordSetNum == dwCoordSet)
		{
			PMBX1_TSPLAYER_STATE	psHWLState;

			/* Update addressing mode for both U and V */
			UpdateHWTexAddrMode(psContext, psLState, 0);
			UpdateHWTexAddrMode(psContext, psLState, 1);

			/*
				Copy the nex HW addresing mode from the per-layer data into the
				overall new HW-state
			*/
			psHWLState = &psContext->sHWState.sTACtl3DState.sTSPLState[i];
			psHWLState->dwLCtl1 &= MBX1_TSPPL1_TUADDRMODECLRMASK & 
								   MBX1_TSPPL1_TVADDRMODECLRMASK;
			psHWLState->dwLCtl1 |= psLState->sTSPLState.dwLCtl1 & 
								   (~(MBX1_TSPPL1_TUADDRMODECLRMASK & 
								      MBX1_TSPPL1_TVADDRMODECLRMASK));
			
			/* Flag that the TSP state for this layer has been modified */
			psContext->sHWStateCtl.dwTACtl3DStateChanged |= MBX1_TASTATEPRES_LAYER0CTL << i;
		}
	}
	D3DM_DPF((DPF_EXIT, "<-D3DM_RS_Wrap"));
}

/*----------------------------------------------------------------------------
<function>
	FUNCTION:   D3DM_RS_Lighting

	PURPOSE:    

	PARAMETERS:	In: psContext - Context who's state is to be modified
				In: dwData - Value of state modification
</function>
------------------------------------------------------------------------------*/
void D3DM_RS_Lighting(LPD3DM_CONTEXT psContext,DWORD dwData)
{
	PTRANSIENT_STATE	psTState;
	DBGLPSTR			pszLightingDesc;

	D3DM_DPF((DPF_ENTRY, "->D3DM_RS_Lighting"));

	psTState = &psContext->sTState;
	/* Record the new render-state state */
	if(dwData)
	{
		/* If lighting is being enabled, update the lighting colour-sources	*/
		if	(!(psTState->dwRSFlags & TSTATE_RSFLAGS_LIGHTING))
		{
			ProcessLightingColourSources(psContext);
		}

		psTState->dwRSFlags |= TSTATE_RSFLAGS_LIGHTING;
		DBGSETSTR(pszLightingDesc, "Enable");
	}
	else
	{
		/* If lighting is being disabled, update the lighting colour-sources	*/
		if(psTState->dwRSFlags & TSTATE_RSFLAGS_LIGHTING)
		{
			ProcessLightingColourSources(psContext);
		}

		psTState->dwRSFlags &= ~TSTATE_RSFLAGS_LIGHTING;
		DBGSETSTR(pszLightingDesc, "Disable");
	}

	D3DM_DPF((DPF_STATE,"D3DM_RS_Lighting: Data = %d (%hs)", dwData, pszLightingDesc));
	D3DM_DPF((DPF_EXIT, "<-D3DM_RS_Lighting"));
}

/*----------------------------------------------------------------------------
<function>
	FUNCTION:   D3DM_RS_Ambient

	PURPOSE:    

	PARAMETERS:	In: psContext - Context who's state is to be modified
				In: dwData - Value of state modification
</function>
------------------------------------------------------------------------------*/
void D3DM_RS_Ambient(LPD3DM_CONTEXT psContext, DWORD dwData)
{
	PSWTNLSTATE		psSWTNLState;

	D3DM_DPF((DPF_ENTRY, "->D3DM_RS_Ambient"));

	/* Record the new ambient colour in float-format */
	psSWTNLState = &psContext->sTState.sSWTNLState;

	psSWTNLState->sAmbientColour.a = Div(LONG_AS_NTV((dwData & 0xff000000) >> 24),	LONG_AS_NTV(255));
	psSWTNLState->sAmbientColour.r = Div(LONG_AS_NTV((dwData & 0x00ff0000) >> 16),	LONG_AS_NTV(255));
	psSWTNLState->sAmbientColour.g = Div(LONG_AS_NTV((dwData & 0x0000ff00) >>  8),	LONG_AS_NTV(255));
	psSWTNLState->sAmbientColour.b = Div(LONG_AS_NTV((dwData & 0x000000ff)),		LONG_AS_NTV(255));

	/* Flag that the lighting colour sources have changed */
	psSWTNLState->dwTNLFlags |= PVRD3DTNL_FLAGS_COLOURVTX_CHANGED;

	D3DM_DPF((DPF_EXIT, "<-D3DM_RS_Ambient"));
}

/*----------------------------------------------------------------------------
<function>
	FUNCTION:   D3DM_RS_Ambient

	PURPOSE:    

	PARAMETERS:	In: psContext - Context who's state is to be modified
				In: dwData - Value of state modification
</function>
------------------------------------------------------------------------------*/
void D3DM_RS_FogVertexMode(LPD3DM_CONTEXT psContext,DWORD dwData)
{
	D3DM_DPF((DPF_ENTRY, "->D3DM_RS_FogVertexMode"));

	/* Just record the new vertex-fog mode */
	psContext->sTState.dwD3DVertexFogMode = dwData;

	D3DM_DPF((DPF_EXIT, "<-D3DM_RS_FogVertexMode"));
}

/*----------------------------------------------------------------------------
<function>
	FUNCTION:   D3DM_RS_ColorVertex

	PURPOSE:    

	PARAMETERS:	In: psContext - Context who's state is to be modified
				In: dwData - Value of state modification
</function>
------------------------------------------------------------------------------*/
void D3DM_RS_ColorVertex(LPD3DM_CONTEXT psContext,DWORD dwData)
{
	PTRANSIENT_STATE	psTState;
	DBGLPSTR			pszColourVertexDesc;

	D3DM_DPF((DPF_ENTRY, "->D3DM_RS_ColorVertex"));

	/* Record the new render-state state */
	psTState = &psContext->sTState;
	if(dwData)
	{
		psTState->dwRSFlags |= TSTATE_RSFLAGS_COLORVERTEX;
		DBGSETSTR(pszColourVertexDesc, "Enable");
	}
	else
	{
		psTState->dwRSFlags &= ~TSTATE_RSFLAGS_COLORVERTEX;
		DBGSETSTR(pszColourVertexDesc, "Disable");
	}

	/* Update the lighting colour sources */
	ProcessLightingColourSources(psContext);

	D3DM_DPF((DPF_STATE,"D3DM_RS_ColorVertex: Data = %d (%hs)", dwData, pszColourVertexDesc));
	D3DM_DPF((DPF_EXIT, "<-D3DM_RS_ColorVertex"));
}

/*----------------------------------------------------------------------------
<function>
	FUNCTION:   D3DM_RS_LocalViewer

	PURPOSE:    

	PARAMETERS:	In: psContext - Context who's state is to be modified
				In: dwData - Value of state modification
</function>
------------------------------------------------------------------------------*/
void D3DM_RS_LocalViewer(LPD3DM_CONTEXT psContext,DWORD dwData)
{
	PTRANSIENT_STATE	psTState;
	DBGLPSTR			pszLocalViewerDesc;

	D3DM_DPF((DPF_ENTRY, "->D3DM_RS_LocalViewer"));

	/* Record the new render-state state */
	psTState = &psContext->sTState;
	if	(dwData)
	{
		psTState->dwRSFlags |= TSTATE_RSFLAGS_LOCALVIEWER;
		DBGSETSTR(pszLocalViewerDesc, "Enable");
	}
	else
	{
		psTState->dwRSFlags &= ~TSTATE_RSFLAGS_LOCALVIEWER;
		DBGSETSTR(pszLocalViewerDesc, "Disable");
	}

	D3DM_DPF((DPF_STATE,"D3DM_RS_LocalViewer: Data = %d (%hs)", dwData, pszLocalViewerDesc));
	D3DM_DPF((DPF_EXIT, "<-D3DM_RS_LocalViewer"));
}

/*----------------------------------------------------------------------------
<function>
	FUNCTION:   D3DM_RS_NormalizeNormals

	PURPOSE:    

	PARAMETERS:	In: psContext - Context who's state is to be modified
				In: dwData - Value of state modification
</function>
------------------------------------------------------------------------------*/
void D3DM_RS_NormalizeNormals(LPD3DM_CONTEXT psContext,DWORD dwData)
{
	PTRANSIENT_STATE	psTState;
	DBGLPSTR			pszNormalizeDesc;

	D3DM_DPF((DPF_ENTRY, "->D3DM_RS_NormalizeNormals"));

	/* Record the new render-state state */
	psTState = &psContext->sTState;
	if(dwData)
	{
		psTState->dwRSFlags |= TSTATE_RSFLAGS_NORMALIZENORMALS;
		DBGSETSTR(pszNormalizeDesc, "Enable");
	}
	else
	{
		psTState->dwRSFlags &= ~TSTATE_RSFLAGS_NORMALIZENORMALS;
		DBGSETSTR(pszNormalizeDesc, "Disable");
	}

	D3DM_DPF((DPF_STATE,"D3DM_RS_NormalizeNormals: Data = %d (%hs)", dwData, pszNormalizeDesc));
	D3DM_DPF((DPF_EXIT, "<-D3DM_RS_NormalizeNormals"));
}
/*----------------------------------------------------------------------------
<function>
	FUNCTION:   D3DM_RS_SetMaterialSource

	PURPOSE:    

	PARAMETERS:	In: psContext - Context who's state is to be modified
				In: dwData - Value of state modification
</function>
------------------------------------------------------------------------------*/
void D3DM_RS_SetMaterialSource(LPD3DM_CONTEXT psContext, DWORD dwData)
{
	TNLCOLSRCTYPE		eColourSourceType;
	PSWTNLSTATE			psSWTNLState;
	DWORD				dwType;

	D3DM_DPF((DPF_ENTRY, "->D3DM_RS_SetMaterialSource"));

	psSWTNLState = &psContext->sTState.sSWTNLState;
	dwType		 = D3DM_MAKE_RSVALUE(psContext->eLastRenderStateChange);

	/* Determine which colour-source we are changing */
	switch(psContext->eLastRenderStateChange)
	{
		case D3DMRS_DIFFUSEMATERIALSOURCE:
		{
			eColourSourceType = TNLCOLSRCTYPE_DIFFUSE;
			break;
		}

		case D3DMRS_SPECULARMATERIALSOURCE:
		{
			eColourSourceType = TNLCOLSRCTYPE_SPECULAR;
			break;
		}

		case D3DMRS_AMBIENTMATERIALSOURCE:
		{
			eColourSourceType = TNLCOLSRCTYPE_AMBIENT;
			break;
		}
		default:
		{
			D3DM_DPF((DPF_WARN,"D3DM_RS_SetMaterialSource: Unhandled render-state %d", dwType));
			return;
		}
	}

	/* Save the new selected diffuse colour-source	*/
	switch(dwData)
	{
		case D3DMMCS_COLOR1:
		case D3DMMCS_COLOR2: