rstate.c

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

			DBGSETSTR(pszZFuncDesc, "Always");
			break;
		}

		default:
		{
			/* Unhandled depth-compare mode. Defaulting to ALWAYS */
			D3DM_DPF((DPF_WARN,"D3DM_RS_ZFunc: Unknown D3D depth-compare-func %d", dwData));
			DBGSETSTR(pszZFuncDesc, "Unknown - Setting \"Always\"");
			dwDepthCtl |= MBX1_ISPTSPCTL_DCMPMODEALWAYS;
			break;
		}
	}
	psContext->sTState.dwDepthCtl = dwDepthCtl;

	/* Update the depth-related HW state */
	ProcessDepthState(psContext);

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

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

	PURPOSE:    

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

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

	/* Update the required HW alpha-blend mode */
	dwHWBlendMode = psContext->sTState.dwBlendMode;

	dwHWBlendMode &= MBX1_ISPTSPCTL_SRCBLENDCLRMASK;
	switch (dwData)
	{
		case D3DMBLEND_ZERO:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_SRCBLENDZERO;
			DBGSETSTR(pszSrcBlendDesc, "Zero");
			break;
		}

		case D3DMBLEND_ONE:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_SRCBLENDONE;
			DBGSETSTR(pszSrcBlendDesc, "One");
			break;
		}

		case D3DMBLEND_SRCALPHA:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_SRCBLENDSRCALPHA;
			DBGSETSTR(pszSrcBlendDesc, "SrcAlpha");
			break;
		}

		case D3DMBLEND_INVSRCALPHA:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_SRCBLENDINVSRCALPHA;
			DBGSETSTR(pszSrcBlendDesc, "InvSrcAlpha");
			break;
		}

		case D3DMBLEND_DESTALPHA:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_SRCBLENDDESTALPHA;
			DBGSETSTR(pszSrcBlendDesc, "DestAlpha");
			break;
		}

		case D3DMBLEND_INVDESTALPHA:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_SRCBLENDINVDESTALPHA;
			DBGSETSTR(pszSrcBlendDesc, "InvDestAlpha");
			break;
		}

		case D3DMBLEND_DESTCOLOR:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_SRCBLENDDESTCOL;
			DBGSETSTR(pszSrcBlendDesc, "DestColour");
			break;
		}

		case D3DMBLEND_INVDESTCOLOR:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_SRCBLENDINVDESTCOL;
			DBGSETSTR(pszSrcBlendDesc, "InvDestColour");
			break;
		}

		case D3DMBLEND_SRCCOLOR:
		case D3DMBLEND_INVSRCCOLOR:
		case D3DMBLEND_SRCALPHASAT:
		default:
		{
			/* Unsupported mode, Default to one */
			dwHWBlendMode |= MBX1_ISPTSPCTL_SRCBLENDONE;
			DBGSETSTR(pszSrcBlendDesc, "Unsupported - setting \"one\"");
			break;
		}
	}
	psContext->sTState.dwBlendMode = dwHWBlendMode;

	/* Update the overall HW alpha-blending state */
	ProcessAlphaBlendState(psContext);

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

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

	PURPOSE:    

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

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

	/* Update the required HW alpha-blend mode */
	dwHWBlendMode = psContext->sTState.dwBlendMode;

	dwHWBlendMode &= MBX1_ISPTSPCTL_DESTBLENDCLRMASK;
	switch (dwData)
	{
		case D3DMBLEND_ZERO:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_DESTBLENDZERO;
			DBGSETSTR(pszDestBlendDesc, "Zero");
			break;
		}

		case D3DMBLEND_ONE:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_DESTBLENDONE;
			DBGSETSTR(pszDestBlendDesc, "One");
			break;
		}

		case D3DMBLEND_SRCCOLOR:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_DESTBLENDSRCCOL;
			DBGSETSTR(pszDestBlendDesc, "SrcColour");
			break;
		}

		case D3DMBLEND_INVSRCCOLOR:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_DESTBLENDINVSRCCOL;
			DBGSETSTR(pszDestBlendDesc, "InvSrcColour");
			break;
		}

		case D3DMBLEND_SRCALPHA:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_DESTBLENDSRCALPHA;
			DBGSETSTR(pszDestBlendDesc, "SrcAlpha");
			break;
		}

		case D3DMBLEND_INVSRCALPHA:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_DESTBLENDINVSRCALPHA;
			DBGSETSTR(pszDestBlendDesc, "InvSrcAlpha");
			break;
		}

		case D3DMBLEND_DESTALPHA:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_DESTBLENDDESTALPHA;
			DBGSETSTR(pszDestBlendDesc, "DestAlpha");
			break;
		}

		case D3DMBLEND_INVDESTALPHA:
		{
			dwHWBlendMode |= MBX1_ISPTSPCTL_DESTBLENDINVDESTALPHA;
			DBGSETSTR(pszDestBlendDesc, "InvDestAlpha");
			break;
		}

		case D3DMBLEND_DESTCOLOR:
		case D3DMBLEND_INVDESTCOLOR:
		case D3DMBLEND_SRCALPHASAT:
		default:
		{
			/* Unsupported mode, Default to one */
			dwHWBlendMode |= MBX1_ISPTSPCTL_SRCBLENDONE;
			DBGSETSTR(pszDestBlendDesc, "Unsupported - setting \"one\"");
			break;
		}
	}

	psContext->sTState.dwBlendMode = dwHWBlendMode;

	/* Update the overall HW alpha-blending state */
	ProcessAlphaBlendState(psContext);

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

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

	PURPOSE:    

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

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

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

	/* Update the overall HW alpha-blending state */
	ProcessAlphaBlendState(psContext);

	D3DM_DPF((DPF_STATE," D3DM_RS_AlphaBlendEnable: Data = %d (%hs)", dwData, pszAlphaBlendEnableDesc));
	D3DM_DPF((DPF_EXIT, "<-D3DM_RS_AlphaBlendEnable"));
}
/*----------------------------------------------------------------------------
<function>
	FUNCTION:   D3DM_RS_CullMode

	PURPOSE:    

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

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

	/* Set the new HW cull-mode (in TA-primitive block header word)	*/
	dwTAPrimCtl = psContext->dwTAPrimCtl;

	dwTAPrimCtl &= MBX1_TAPRIM_CULLMODECLRMASK;
	switch	(dwData)
	{
		case D3DMCULL_CW:
		{
			dwTAPrimCtl |= MBX1_TAPRIM_CULLMODECW;
			DBGSETSTR(pszCullModeDesc, "CW");
			break;
		}

		case D3DMCULL_CCW:
		{
			dwTAPrimCtl |= MBX1_TAPRIM_CULLMODECCW;
			DBGSETSTR(pszCullModeDesc, "CCW");
			break;
		}

		case D3DMCULL_NONE:
		{
			dwTAPrimCtl |= MBX1_TAPRIM_CULLMODENONE;
			DBGSETSTR(pszCullModeDesc, "None");
			break;
		}

		default: 
		{
			D3DM_DPF((DPF_WARN, "D3DM_RS_CullMode: Unknown D3D cull-mode %d", dwData));
			dwTAPrimCtl |= MBX1_TAPRIM_CULLMODENONE;
			DBGSETSTR(pszCullModeDesc, "Unknown - setting None");
			break;
		}
	}
	psContext->dwTAPrimCtl = dwTAPrimCtl;

	D3DM_DPF((DPF_STATE, "D3DM_RS_CullMode: Data = %d (%hs)", dwData, pszCullModeDesc));
	D3DM_DPF((DPF_EXIT, "<-D3DM_RS_CullMode"));
}
/*----------------------------------------------------------------------------
<function>
	FUNCTION:   D3DM_RS_AlphaRef

	PURPOSE:    

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

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

	/* Update the reference value in the HW alpha-control */
	dwAlphaTestCtl = psContext->sTState.dwAlphaTest;

	dwAlphaTestCtl &= MBX1_TSPOBJ_ALPHAREFCLRMASK;
	dwAlphaTestCtl |= (dwData << MBX1_TSPOBJ_ALPHAREFSHIFT) & 
					  (~MBX1_TSPOBJ_ALPHAREFCLRMASK);

	psContext->sTState.dwAlphaTest = dwAlphaTestCtl;

	/* Update alpha-test related HW-state */
	ProcessAlphaTestState(psContext);

	D3DM_DPF((DPF_STATE, "D3DM_RS_AlphaRef : Data = 0x%08X", dwData));
	D3DM_DPF((DPF_EXIT, "<-D3DM_RS_AlphaRef"));
}
/*----------------------------------------------------------------------------
<function>
	FUNCTION:   D3DM_RS_LastPixel

	PURPOSE:    

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

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

	if(dwData)
	{
		psContext->dwTAPrimCtl |= MBX1_TAPRIM_DRAW_LASTPIXEL;
		DBGSETSTR(pszLastPixelEnableDesc, "Enable");
	}
	else
	{
		psContext->dwTAPrimCtl &= ~MBX1_TAPRIM_DRAW_LASTPIXEL;
		DBGSETSTR(pszLastPixelEnableDesc, "Disable");
	}

	D3DM_DPF((DPF_STATE, "D3DM_RS_LastPixel: Data = %d (%hs)", dwData, pszLastPixelEnableDesc));
	D3DM_DPF((DPF_EXIT, "<-D3DM_RS_LastPixel"));
}
/*----------------------------------------------------------------------------
<function>
	FUNCTION:   D3DM_RS_AlphaTestEnable

	PURPOSE:    

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

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

	if(dwData)
	{
		psContext->sTState.dwRSFlags |= TSTATE_RSFLAGS_ALPHATEST;
		DBGSETSTR(pszAlphaTestEnableDesc, "Enable");
	}
	else
	{
		psContext->sTState.dwRSFlags &= ~TSTATE_RSFLAGS_ALPHATEST;
		DBGSETSTR(pszAlphaTestEnableDesc, "Disable");
	}

	/* Update alpha-test related HW-state */
	ProcessAlphaTestState(psContext);

	D3DM_DPF((DPF_STATE, "D3DM_RS_AlphaTestEnable: Data = %d (%hs)", dwData, pszAlphaTestEnableDesc));
	D3DM_DPF((DPF_EXIT, "<-D3DM_RS_AlphaTestEnable"));
}
/*----------------------------------------------------------------------------
<function>
	FUNCTION:   D3DM_RS_AlphaFunc

	PURPOSE:    

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

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

	/*
		Set the new HW alpha-compare mode required
	*/
	dwAlphaTestCtl = psContext->sTState.dwAlphaTest;

	dwAlphaTestCtl &= MBX1_TSPOBJ_ALPHACMPCLRMASK;
	switch (dwData)
	{
		case D3DMCMP_NEVER:
		{
			dwAlphaTestCtl |= MBX1_TSPOBJ_ACMPMODENEVER;
			DBGSETSTR(pszAlphaFuncDesc, "Never");
			break;
		}

		case D3DMCMP_LESS:
		{
			dwAlphaTestCtl |= MBX1_TSPOBJ_ACMPMODELT;
			DBGSETSTR(pszAlphaFuncDesc, "Less");
			break;
		}

		case D3DMCMP_EQUAL:
		{
			dwAlphaTestCtl |= MBX1_TSPOBJ_ACMPMODEEQ;
			DBGSETSTR(pszAlphaFuncDesc, "Equal");
			break;
		}

		case D3DMCMP_LESSEQUAL:
		{
			dwAlphaTestCtl |= MBX1_TSPOBJ_ACMPMODELE;
			DBGSETSTR(pszAlphaFuncDesc, "Less or Equal");
			break;
		}