utils.c

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

	if(pdwTilesOutY) *pdwTilesOutY = dwInY;

	return;
}

/*----------------------------------------------------------------------------
<function>
 FUNCTION	: RoundToTileGranBoundary
    
 PURPOSE	: Rounds pixel X,Y values up to nearest tile granularity boundary.

 PARAMETERS	: DWORD dwInX			- (in)  x value in pixels
			  DWORD dwInY			- (in)  y value in pixels
			  LPDWORD pdwOutX		- (out) rounded up x value in pixels
			  LPDWORD pdwOutY		- (out) rounded up y value in pixels
			  LPDWORD pdwTilesOutX	- (out) rounded up x value in tiles
			  LPDWORD pdwTilesOutX	- (out) rounded up y value in tiles			  
 RETURNS	: void
</function>
------------------------------------------------------------------------------*/
void RoundToTileGranBoundary(LPD3DM_CONTEXT psContext, BOOL bRoundUp, DWORD dwInX, DWORD dwInY, 
							 LPDWORD pdwOutX, LPDWORD pdwOutY, LPDWORD pdwTilesOutX, 
							 LPDWORD pdwTilesOutY)
{
	DEVICE3D	*p3DDevice = &GetDevInfo(psContext)->sDeviceSpecific.s3D;
	DWORD		dwPixelsInPsuedoTileX = p3DDevice->ui32TileXGran * p3DDevice->ui32PixelsInTileX;
	DWORD		dwPixelsInPsuedoTileY = p3DDevice->ui32TileYGran * p3DDevice->ui32PixelsInTileY;

	if(bRoundUp)
	{
		dwInX += dwPixelsInPsuedoTileX - 1;
		dwInX =  p3DDevice->ui32TileXGran * (dwInX / dwPixelsInPsuedoTileX);

		dwInY += dwPixelsInPsuedoTileY - 1;
		dwInY =  p3DDevice->ui32TileYGran * (dwInY / dwPixelsInPsuedoTileY);
	}
	else
	{
		dwInX /= dwPixelsInPsuedoTileX;
		dwInX *= p3DDevice->ui32TileXGran;

		dwInY /= dwPixelsInPsuedoTileY;
		dwInY *= p3DDevice->ui32TileYGran;
	}


	/*
		Load up the out parameters
	*/
	if(pdwOutX) *pdwOutX = dwInX * p3DDevice->ui32PixelsInTileX;
	if(pdwOutY) *pdwOutY = dwInY * p3DDevice->ui32PixelsInTileY;
	if(pdwTilesOutX) *pdwTilesOutX = dwInX;
	if(pdwTilesOutY) *pdwTilesOutY = dwInY;

	return;
}
/*----------------------------------------------------------------------------
<function>
	FUNCTION:   SetUpAntialias

	PURPOSE:    Interprets D3DM Multisample type and sets appropriate context flags

	PARAMETERS:	In: eAAType - D3DM AA Flags
				In: psContext - Current rendering context
	RETURNS:	Out: PVRSRVAddRenderTarget AA flags for given Multisample type
</function>
------------------------------------------------------------------------------*/
DWORD SetUpAntialias(D3DMMULTISAMPLE_TYPE eAAType, LPD3DM_CONTEXT psContext)
{
	DWORD dwAAFlags = 0;

	/* Validate AA type */
	switch(eAAType)
	{
		case D3DMMULTISAMPLE_NONE:
			break;
		case D3DMMULTISAMPLE_2_SAMPLES:
		{
#ifdef SUPPORT_MBX1		

			psContext->dwFlags |= D3DM_CONTEXT_SWFLAGS_ENABLE_FASTAA;

#else/* SUPPORT_MBX1_LIGHT */

			/*
				By default we do 2XAA using SSX on mbxlight
				this can switched to SSY using registry
			*/
			if(psContext->sRegData.dwFlags & D3DMREG_2XAA_YSUPERSAMPLE && 
			 !(psContext->sRegData.dwFlags & D3DMREG_DISABLE_YSUPERSAMPLE))
			{
				psContext->dwFlags	|= D3DM_CONTEXT_SWFLAGS_SUPERSAMPLEY;
				dwAAFlags			|= PVRSRV_ADDRENDERTARGET_AAY;

			}
			else
			{
				if(!(psContext->sRegData.dwFlags & D3DMREG_DISABLE_XSUPERSAMPLE))
				{
					psContext->dwFlags	|= D3DM_CONTEXT_SWFLAGS_SUPERSAMPLEX;
					dwAAFlags			|= PVRSRV_ADDRENDERTARGET_AAX;
				}
			}
#endif			
			break;
		}
		case D3DMMULTISAMPLE_4_SAMPLES:
		{

#ifdef SUPPORT_MBX1
			if(!(psContext->sRegData.dwFlags & D3DMREG_DISABLE_YSUPERSAMPLE))
			{
				psContext->dwFlags	|= D3DM_CONTEXT_SWFLAGS_SUPERSAMPLEY;
				psContext->dwFlags  |= D3DM_CONTEXT_SWFLAGS_ENABLE_FASTAA;
				dwAAFlags			|= PVRSRV_ADDRENDERTARGET_AAY;
			}

#else/* SUPPORT_MBX1_LIGHT */
			if(!(psContext->sRegData.dwFlags & D3DMREG_DISABLE_XSUPERSAMPLE))
			{
				psContext->dwFlags	|= D3DM_CONTEXT_SWFLAGS_SUPERSAMPLEX;
				dwAAFlags			|= PVRSRV_ADDRENDERTARGET_AAX;
			}

			if(!(psContext->sRegData.dwFlags & D3DMREG_DISABLE_YSUPERSAMPLE))
			{
				psContext->dwFlags	|= D3DM_CONTEXT_SWFLAGS_SUPERSAMPLEY;
				dwAAFlags			|= PVRSRV_ADDRENDERTARGET_AAY;
			}
#endif	
			break;
		}
		default:
		{
			/*FIXME - Should we return an error here*/
			D3DM_DPF((DPF_WARN, "SetUpAntialias:Unsupported AA mode requested - Disabling"));
		}
	}
	
	return dwAAFlags;
}
/*----------------------------------------------------------------------------
<function>
	FUNCTION:   CompareSurfaces

	PURPOSE:    Compares the height, width and format of 2 surfaces

	PARAMETERS:	In: psSurfA - First Surface
				In: psSurfB - Second Surface
	RETURNS:	Out: TRUE if surfaces match
</function>
------------------------------------------------------------------------------*/
BOOL CompareSurfaces(LPD3DM_SURFACE psSurfA, LPD3DM_SURFACE psSurfB)
{
	if(psSurfA->dwWidth  == psSurfB->dwWidth	&&
	   psSurfA->dwHeight == psSurfB->dwHeight	&&
	   psSurfA->eFormat  == psSurfB->eFormat)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}
/*----------------------------------------------------------------------------
<function>
	FUNCTION:   GetTexCoordinateCount

	PURPOSE:    Gets number of texture co-ord from FVF code

	PARAMETERS:	In: ui32FVFcode - FVF Code of vbuffer
				
	RETURNS:	Out: Number of Texture co-ords
</function>
------------------------------------------------------------------------------*/
DWORD GetTexCoordinateCount(IMG_UINT32 ui32FVFcode, IMG_UINT32 ui32Layer)
{
	switch ((ui32FVFcode>>(16+(ui32Layer*2))) & 0x3)
	{
		case D3DMFVF_TEXCOORDCOUNT1:
			return 1;
			break;
		case D3DMFVF_TEXCOORDCOUNT2:
			return 2;
			break;
		case D3DMFVF_TEXCOORDCOUNT3:
			return 3;
			break;
		default:
			//error unsupported
			break;
	}
	return 0;
}
/*----------------------------------------------------------------------------
<function>
	FUNCTION:   ConvertFillColourToHWFormat

	PURPOSE:    Converts 32 bit ARGB to cureent hardware format colour

	PARAMETERS:	In: eFormat - Surface format
				In: ui32FillColour - 32 biut colour
				
	RETURNS:	Out: HW formatted colour value
</function>
------------------------------------------------------------------------------*/
IMG_UINT32 ConvertFillColourToHWFormat(D3DMFORMAT eFormat, IMG_UINT32 ui32FillColour)
{
	if(ui32FillColour == 0) return 0;

    switch(eFormat)
    {
		case D3DMFMT_A8R3G3B2:
		{
			return 	  ((ui32FillColour & 0x000000C0) >> 6)  |
				      ((ui32FillColour & 0x0000E000) >> 11) |
					  ((ui32FillColour & 0x00E00000) >> 16) |
					  ((ui32FillColour & 0xF0000000) >> 16);	
			break;
		}
		case D3DMFMT_R5G6B5:
		{
			return	  ((ui32FillColour & 0x000000F8) >> 3) |
				      ((ui32FillColour & 0x0000FC00) >> 5) |
					  ((ui32FillColour & 0x00F80000) >> 8);	
			break;
		}
		case D3DMFMT_X1R5G5B5:
		case D3DMFMT_A1R5G5B5:
		{
			return	  ((ui32FillColour & 0x000000F8) >> 3) |
				      ((ui32FillColour & 0x0000F800) >> 6) |
					  ((ui32FillColour & 0x00F80000) >> 9) |
					  ((ui32FillColour & 0x80000000) >> 16);
			break;
		}
		case D3DMFMT_X4R4G4B4:
		case D3DMFMT_A4R4G4B4:
		{
			return	  ((ui32FillColour & 0x000000F0) >> 4) |
				      ((ui32FillColour & 0x0000F000) >> 8) |
					  ((ui32FillColour & 0x00F00000) >> 12)|
					  ((ui32FillColour & 0xF0000000) >> 16);
			break;
		}
		case D3DMFMT_X8R8G8B8:
		case D3DMFMT_A8R8G8B8:
        default:
			return ui32FillColour;
    }
}
/*----------------------------------------------------------------------------
<function>
	FUNCTION:   GetFBFormatFromD3DMFormat

	PURPOSE:    Converts D3DMFORMAT to FB format 

	PARAMETERS:	In: eFormat - Surface format
				In: pui32FormatOut - Pointer to result format word
				
	RETURNS:	Out: TRUE if successful
</function>	
------------------------------------------------------------------------------*/
IMG_BOOL GetFBFormatFromD3DMFormat(D3DMFORMAT eFormat, IMG_UINT32 *pui32FormatOut)
{
	switch(eFormat)
	{
		case D3DMFMT_R5G6B5:
		{
			*pui32FormatOut = MBX1_FBCTL_PACKMODE565;
			return IMG_TRUE;
		}
		case D3DMFMT_X8R8G8B8:
		{
			*pui32FormatOut = MBX1_FBCTL_PACKMODEK888;
			return IMG_TRUE;
		}
		case D3DMFMT_A4R4G4B4:
		{
			*pui32FormatOut = MBX1_FBCTL_PACKMODE4444;
			return IMG_TRUE;
		}
		case D3DMFMT_A1R5G5B5:
		{
			*pui32FormatOut = MBX1_FBCTL_PACKMODE1555;
			return IMG_TRUE;
		}
		case D3DMFMT_A8R3G3B2:
		{
			*pui32FormatOut = MBX1_FBCTL_PACKMODE8888;
			return IMG_TRUE;
		}
		default:
		{
			/* Unsupported FB format */
			return IMG_FALSE;
		}
	} 
}
/*----------------------------------------------------------------------------
<function>
	FUNCTION:   CalcNativeVertexOutputSizeDW

	PURPOSE:    Calculates the number of DWORDS required to output all data
				for a single Native Vertex

	PARAMETERS:	In: psContext  - Rendering context
				In: psVertex	- Native vertex to be output
				
	RETURNS:	Out: DWORDS required
</function>	
------------------------------------------------------------------------------*/
IMG_UINT32 CalcNativeVertexOutputSizeDW(LPD3DM_CONTEXT psContext, PVR_NATIVE_VERTEX *psVertex)
{
	IMG_UINT32 ui32DWCount	 = 0, i;
	IMG_UINT32 ui32ISPTSPCtl = psContext->sHWState.sTACtl3DState.dwISPTSPCtl;

	/* X and Y */
	ui32DWCount += 2;

	if(psContext->dwTAPrimCtl & MBX1_TAPRIM_WBUFFERING_ENABLE)
	{
		/* W only */
		ui32DWCount += 1;
	}
	else
	{
		/* Z and W */
		ui32DWCount += 2;
	}

	/* Diffuse Colour */
	ui32DWCount += 1;

	/* Specular Colour ? */
	if(ui32ISPTSPCtl & MBX1_ISPTSPCTL_OFFSET)
	{
		ui32DWCount += 1;
	}

	/* Texture Co-ords */
	if(ui32ISPTSPCtl & MBX1_ISPTSPCTL_UVCOUNT)
	{
		IMG_UINT32	ui32UVCount = (ui32ISPTSPCtl & MBX1_ISPTSPCTL_UVCOUNT) >> MBX1_ISPTSPCTL_UVCOUNTSHIFT;

		for(i=0; i <= ui32UVCount; i++)
		{
			ui32DWCount += 2;
		}
	}
	else if(ui32ISPTSPCtl & MBX1_ISPTSPCTL_NUMPASSESMASK)
	{
		ui32DWCount += 2;
	}

	return ui32DWCount;
}
#if (defined(SUPPORT_VGP) && (COREVERSION >= 13)) || (defined(SUPPORT_VGP_LITE) && (COREVERSION >= 120))
/*----------------------------------------------------------------------------
<function>
	FUNCTION:   SetVGPOutputEnables
	PURPOSE:    Works out which VGP outputs to enable during process vertices

	PARAMETERS:	In:  dwFVF - FVF to decode
				
	RETURNS:	DWORD
</function>
------------------------------------------------------------------------------*/
DWORD SetVGPOutputEnables(LPD3DM_CONTEXT psContext, DWORD dwFVF, DWORD *pdwSizeBytes)
{
	DWORD dwOutputs  = 0;
	DWORD dwTexCount = 0;
	DWORD i = 0;
	DWORD dwSizeBytes = 0;

	/*
		Possible output selects 

		MBX1_VGPPROCVERT_SELECTS_REG0 = Position
		MBX1_VGPPROCVERT_SELECTS_REG1 = Base Colour 
		MBX1_VGPPROCVERT_SELECTS_REG2 = Offset Colour1
		MBX1_VGPPROCVERT_SELECTS_REG3 = Texture Coordinate 0 
		MBX1_VGPPROCVERT_SELECTS_REG4 = Texture Coordinate 1
		MBX1_VGPPROCVERT_SELECTS_REG5 = Clip 0
	*/
	switch (dwFVF & D3DMFVF_POSITION_MASK)
	{
		case D3DMFVF_XYZ_FLOAT:
		case D3DMFVF_XYZRHW_FLOAT:
		case D3DMFVF_XYZ_FIXED:
		case D3DMFVF_XYZRHW_FIXED:
		{
			dwOutputs |= MBX1_VGPPROCVERT_SELECTS_REG0;
			dwSizeBytes += 16;
		}
	}

	if((dwFVF & D3DMFVF_DIFFUSE) == D3DMFVF_DIFFUSE)
	{
		dwOutputs |= MBX1_VGPPROCVERT_SELECTS_REG1;
		dwSizeBytes += 16;
	}

	if((dwFVF & D3DMFVF_SPECULAR) == D3DMFVF_SPECULAR)
	{
		dwOutputs |= MBX1_VGPPROCVERT_SELECTS_REG2;
		dwSizeBytes += 16;
	}
	
	/*
		How many textures
	*/
	switch (dwFVF & D3DMFVF_TEXCOUNT_MASK)
	{
		case D3DMFVF_TEX0:
			dwTexCount = 0;
			break;
		case D3DMFVF_TEX1:
			dwOutputs |= MBX1_VGPPROCVERT_SELECTS_REG3;
			dwSizeBytes += 8;
			dwTexCount = 1;
			break;
		case D3DMFVF_TEX2:
			dwOutputs |= MBX1_VGPPROCVERT_SELECTS_REG4;
			dwTexCount = 8;
			break;
		case D3DMFVF_TEX3:
		case D3DMFVF_TEX4:
		default:
			ASSERT(0);
			/* error - don't support more than 2 layers */
			break;
	}

	/* tex co-ords */
	for (i=0; i<dwTexCount; i++)
	{
		/* Check for copy status of this co-ord set */
		if(!(((psContext->dwFlags & D3DM_CONTEXT_SWFLAGS_PROCVERT_NO_TEX_COPY_MASK) >>
			  (D3DM_CONTEXT_SWFLAGS_PROCVERT_NO_TEX_COPY_SHIFT + i)) & 0x00000001))
		{
			/* Store dest buffer context count */
			switch ((dwFVF>>(16+(i*2))) & 0x3)
			{
				case D3DMFVF_TEXCOORDCOUNT1:
					psContext->sTState.sSWTNLState.dwPVDestTexLayerCoordCount[i] = 1;
					break;
				case D3DMFVF_TEXCOORDCOUNT2:
					psContext->sTState.sSWTNLState.dwPVDestTexLayerCoordCount[i] = 2;
					break;
				case D3DMFVF_TEXCOORDCOUNT3:
					psContext->sTState.sSWTNLState.dwPVDestTexLayerCoordCount[i] = 3;
					if(i == 0)
					{
						if(!(dwOutputs & MBX1_VGPPROCVERT_SELECTS_REG4))
						{
							dwOutputs |= MBX1_VGPPROCVERT_SELECTS_REG4;
							dwSizeBytes += 8;
						}
					}
					else
					{
						if(!(dwOutputs & MBX1_VGPPROCVERT_SELECTS_REG5))
						{
							dwOutputs |= MBX1_VGPPROCVERT_SELECTS_REG5;
							dwSizeBytes += 16;
						}
					}
					break;
			}
		}
	}

	if(pdwSizeBytes != IMG_NULL)
	{
		*pdwSizeBytes = dwSizeBytes;
	}



	return dwOutputs;
}
#endif /*(defined(SUPPORT_VGP) && (COREVERSION >= 13)) || (defined(SUPPORT_VGP_LITE) && (COREVERSION >= 120))*/
/*****************************************************************************
 End of file (Utils.c)
*****************************************************************************/