primindexed.c

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

			if (bStartPrimitive)
			{
				/*
					Start a new primitive block
				*/
				TACSWritePrimHdr(psContext, psContext->dwTAPrimCtl, MBX1_TAOBJTYPE_POINTS);
				TACSWriteLinePointSize(psContext, 0x3F000000/*0.5*/);
				bStartPrimitive = IMG_FALSE;
			}

			ValidateVertex(psContext, &apsVertex[0], 1);
			
			OutputVertices(psContext, &apsVertex[0], 1);
		}
	}

ErrorExit:
	
	/*
		Finish the primitive block
	*/
	if(!bStartPrimitive)
	{
		TACSWriteLastPrim(psContext);
#ifdef FIX_HW_PRN_299
		TACSWriteTACtlAnd3DState ( 	psContext,
									MBX1_TASTATEPRES_ISPCTL,
								 	&psContext->sHWState.sTACtl3DState,
								 	TRUE);
#endif		
	}
}
/***********************************************************************************
 Function Name      : IndexedLineList
************************************************************************************/
IMG_VOID IndexedLineList(LPD3DM_CONTEXT psContext,
					 IMG_UINT32	ui32FVFcode, 
					 BYTE *pbVBData,
					 IMG_UINT32 ui32VBByteStride,
					 BYTE *pbIBData,
					 IMG_UINT32 ui32IBByteStride,
					 IMG_UINT32 ui32PrimCount)
{
#ifdef VGP
#else
	IMG_UINT32 i, ui32NumVerts;
	IMG_UINT32 ui32ClipCode;
	PVR_NATIVE_VERTEX asVertex[2], **ppsVertex, *apsVertex[2];
	IMG_BOOL bStartPrimitive = IMG_TRUE;
	IMG_UINT32			ui32IndexMask;
	UNALIGNED IMG_UINT32	*pui32IBData = (UNALIGNED IMG_UINT32*)pbIBData;

	ui32IndexMask = psContext->ui32IndexMask;

	/* set up ptr array */
	apsVertex[0] = &asVertex[0];
	apsVertex[1] = &asVertex[1];

	for(i=0; i<ui32PrimCount; i++)
	{
		/* construct native vertices */
		/* Validate index value to prevent access violations */
		if(!VALIDATE_INDEX(psContext, (*pui32IBData & ui32IndexMask)))
		{
			psContext->hrLastError = D3DMERR_INVALIDCALL;
			goto ErrorExit;
		}	
		SetupNativeVertex(psContext, (IMG_UINT32*)(pbVBData + ((*pui32IBData & ui32IndexMask) * ui32VBByteStride)),
							ui32FVFcode,
							apsVertex[0]);

		/* Advance pointer */
		pbIBData	+= ui32IBByteStride;
		pui32IBData = (UNALIGNED IMG_UINT32*)pbIBData;

		/* Validate index value to prevent access violations */
		if(!VALIDATE_INDEX(psContext, (*pui32IBData & ui32IndexMask)))
		{
			psContext->hrLastError = D3DMERR_INVALIDCALL;
			goto ErrorExit;
		}	
		SetupNativeVertex(psContext, (IMG_UINT32*)(pbVBData + ((*pui32IBData & ui32IndexMask) * ui32VBByteStride)),
							ui32FVFcode,
							apsVertex[1]);

		/* Advance pointer */
		pbIBData	+= ui32IBByteStride;
		pui32IBData = (UNALIGNED IMG_UINT32*)pbIBData;

		/* Store pointers to colours for flat shading */
		psContext->sTState.sSWTNLState.psCurrentFlatShadeDiffuse  = &apsVertex[0]->sDiffuseOut;
		psContext->sTState.sSWTNLState.psCurrentFlatShadeSpecular = &apsVertex[0]->sSpecularOut;

		/**********************
			clip test
		**********************/
		DoClipTestandVPTransform(psContext, &apsVertex[0], 2);
		
		/* any vertices clipped? */
		ui32ClipCode =	 (apsVertex[0]->ui32Flags | apsVertex[1]->ui32Flags) & D3DM_CLIPFLAG_MASK;
		
		if (ui32ClipCode == 0)	/* no clipping: */
		{
			if (bStartPrimitive)
			{
				/*
					Start a new primitive block
				*/
				TACSWritePrimHdr(psContext, psContext->dwTAPrimCtl, MBX1_TAOBJTYPE_VERTEXLINESTRIP);
				TACSWriteLinePointSize(psContext, 0x3F000000/*0.5*/);
				bStartPrimitive = IMG_FALSE;
			}

			ValidateVertex(psContext, &apsVertex[0], 2);
			
			OutputVertices(psContext, &apsVertex[0], 2);

			TACSWriteEndPrim(psContext);
		}
		else if(!(apsVertex[0]->ui32Flags 
				& apsVertex[1]->ui32Flags 
				& D3DM_CLIPFLAG_MASK))
		{
			if (bStartPrimitive)
			{
				/*
					Start a new primitive block
				*/
				TACSWritePrimHdr(psContext, psContext->dwTAPrimCtl, MBX1_TAOBJTYPE_VERTEXLINESTRIP);
				TACSWriteLinePointSize(psContext, 0x3F000000/*0.5*/);
				bStartPrimitive = IMG_FALSE;
			}

			ValidateVertex(psContext, &apsVertex[0], 2);

			ui32NumVerts = DoLineClip(psContext, apsVertex[0], apsVertex[1], ui32ClipCode);

			ppsVertex = psContext->sTState.sSWTNLState.ppsOutputArray;

			OutputVertices(psContext, ppsVertex, ui32NumVerts);

			TACSWriteEndPrim(psContext);
		}
	}

ErrorExit:

	/*
		End the primitive-block if we've had geometry
	*/
	if(!bStartPrimitive)
	{
		TACSWriteLastPrim(psContext);
#ifdef FIX_HW_PRN_299
		TACSWriteTACtlAnd3DState ( 	psContext,
									MBX1_TASTATEPRES_ISPCTL,
								 	&psContext->sHWState.sTACtl3DState,
								 	TRUE);
#endif				
	}
#endif
}
/***********************************************************************************
 Function Name      : IndexedLineStrip
************************************************************************************/
IMG_VOID IndexedLineStrip(LPD3DM_CONTEXT psContext,
					 IMG_UINT32	ui32FVFcode, 
					 BYTE *pbVBData,
					 IMG_UINT32 ui32VBByteStride,
					 BYTE *pbIBData,
					 IMG_UINT32 ui32IBByteStride,
					 IMG_UINT32 ui32PrimCount)
{
#ifdef VGP
#else
	IMG_UINT32			i, ui32NumVerts;
	IMG_UINT32			ui32ClipCode;
	PVR_NATIVE_VERTEX	asVertex[2], **ppsVertex, *apsVertex[2], *psVTmp;
	IMG_BOOL			bNewStrip = IMG_TRUE;
	IMG_UINT32			ui32NumStrips = 0;
	IMG_UINT32			ui32IndexMask;
	UNALIGNED IMG_UINT32	*pui32IBData = (UNALIGNED IMG_UINT32*)pbIBData;

	ui32IndexMask = psContext->ui32IndexMask;
	
	/* set up ptr array */
	apsVertex[0] = &asVertex[0];
	apsVertex[1] = &asVertex[1];

	/* Validate index value to prevent access violations */
	if(!VALIDATE_INDEX(psContext, (*pui32IBData & ui32IndexMask)))
	{
		psContext->hrLastError = D3DMERR_INVALIDCALL;
		goto ErrorExit;
	}

	/* construct native vertices */
	SetupNativeVertex(psContext, (IMG_UINT32*)(pbVBData + ((*pui32IBData & ui32IndexMask) * ui32VBByteStride)),
						ui32FVFcode,
						apsVertex[0]);

	/* Advance pointer */
	pbIBData	+= ui32IBByteStride;
	pui32IBData = (UNALIGNED IMG_UINT32*)pbIBData;

	/**********************
		clip test
	**********************/
	DoClipTestandVPTransform(psContext, &apsVertex[0], 1);

	for(i=0; i<ui32PrimCount; i++)
	{
		/* Validate index value to prevent access violations */
		if(!VALIDATE_INDEX(psContext, (*pui32IBData & ui32IndexMask)))
		{
			psContext->hrLastError = D3DMERR_INVALIDCALL;
			goto ErrorExit;
		}

		/* construct native vertices */
		SetupNativeVertex(psContext, (IMG_UINT32*)(pbVBData + ((*pui32IBData & ui32IndexMask) * ui32VBByteStride)),
							ui32FVFcode,
							apsVertex[1]);

		/* Advance pointer */
		pbIBData	+= ui32IBByteStride;
		pui32IBData = (UNALIGNED IMG_UINT32*)pbIBData;

		/* Store pointers to colours for flat shading */
		psContext->sTState.sSWTNLState.psCurrentFlatShadeDiffuse  = &apsVertex[0]->sDiffuseOut;
		psContext->sTState.sSWTNLState.psCurrentFlatShadeSpecular = &apsVertex[0]->sSpecularOut;

		/**********************
			clip test
		**********************/
		DoClipTestandVPTransform(psContext, &apsVertex[1], 1);
		
		/* any vertices clipped? */
		ui32ClipCode =	 (apsVertex[0]->ui32Flags | apsVertex[1]->ui32Flags) & D3DM_CLIPFLAG_MASK;
		
		if (ui32ClipCode == 0)	/* no clipping: */
		{
			if(bNewStrip)
			{
				if(ui32NumStrips)
				{
					TACSWriteEndPrim(psContext);
				}
				else
				{
					/* Start a new primitive block */
					TACSWritePrimHdr(psContext, psContext->dwTAPrimCtl, MBX1_TAOBJTYPE_VERTEXLINESTRIP);
					TACSWriteLinePointSize(psContext, 0x3F000000/*0.5*/);
					bNewStrip = IMG_FALSE;
				}
				
				ui32NumStrips++;

				ValidateVertex(psContext, &apsVertex[0], 2);
				OutputVertices(psContext, &apsVertex[0], 2);
			}
			else
			{
				ValidateVertex(psContext, &apsVertex[1], 1);
				OutputVertices(psContext, &apsVertex[1], 1);
			}
		}
		else if (!(	apsVertex[0]->ui32Flags 
				&	apsVertex[1]->ui32Flags & D3DM_CLIPFLAG_MASK)) /* clipped line: */
		{
			ValidateVertex(psContext, &apsVertex[0], 2);
			
			ui32NumVerts = DoLineClip(psContext, apsVertex[0], apsVertex[1], ui32ClipCode);

			ppsVertex = psContext->sTState.sSWTNLState.ppsOutputArray;

			if(ui32NumStrips)
			{
				TACSWriteEndPrim(psContext);
			}
			else
			{
				TACSWritePrimHdr(psContext, psContext->dwTAPrimCtl, MBX1_TAOBJTYPE_VERTEXLINESTRIP);
				TACSWriteLinePointSize(psContext, 0x3F000000/*0.5*/);
			}
			ui32NumStrips++;
			
			OutputVertices(psContext, ppsVertex, ui32NumVerts);

			bNewStrip = IMG_TRUE;
		}
		else
		{
			bNewStrip = IMG_TRUE;			
		}

		/* advance vertices */
		psVTmp = apsVertex[0];
		apsVertex[0] = apsVertex[1];
		apsVertex[1] = psVTmp;
	}

ErrorExit:

	/*
		End the primitive-block if we've had geometry
	*/
	if(ui32NumStrips)
	{
		TACSWriteLastPrim(psContext);
#ifdef FIX_HW_PRN_299
		TACSWriteTACtlAnd3DState ( 	psContext,
									MBX1_TASTATEPRES_ISPCTL,
								 	&psContext->sHWState.sTACtl3DState,
								 	TRUE);
#endif		
	}
#endif
}
/***********************************************************************************
 Function Name      : IndexedTriListLine
************************************************************************************/
IMG_VOID IndexedTriListLine(LPD3DM_CONTEXT psContext,
							IMG_UINT32	ui32FVFcode, 
							BYTE *pbVBData,
							IMG_UINT32 ui32VBByteStride,
							BYTE *pbIBData,
							IMG_UINT32 ui32IBByteStride,
							IMG_UINT32 ui32PrimCount)
{
#ifdef VGP
#else
	IMG_UINT32			i, j, ui32NumVerts;
	IMG_UINT32			ui32ClipCode;
	PVR_NATIVE_VERTEX	asVertex[3], **ppsVertex, *apsVertex[4];
	IMG_BOOL			bStartPrimitive = IMG_TRUE;
	IMG_UINT32			ui32IndexMask;
	UNALIGNED IMG_UINT32	*pui32IBData = (UNALIGNED IMG_UINT32*)pbIBData;
	NTV_TYPE			ntvDepthM = D3DM_Zero;

	ui32IndexMask = psContext->ui32IndexMask;
	
	/* set up ptr array */
	apsVertex[0] = &asVertex[0];
	apsVertex[1] = &asVertex[1];
	apsVertex[2] = &asVertex[2];
	apsVertex[3] = &asVertex[0];/* wrap to close the triangle */

	for(i=0; i<ui32PrimCount; i++)
	{
		/* construct native vertices */
		/* Validate index value to prevent access violations */
		if(!VALIDATE_INDEX(psContext, (*pui32IBData & ui32IndexMask)))
		{
			psContext->hrLastError = D3DMERR_INVALIDCALL;
			goto ErrorExit;
		}	
		SetupNativeVertex(psContext, (IMG_UINT32*)(pbVBData + ((*pui32IBData & ui32IndexMask) * ui32VBByteStride)),
							ui32FVFcode,
							apsVertex[0]);

		/* Advance pointer */
		pbIBData	+= ui32IBByteStride;
		pui32IBData = (UNALIGNED IMG_UINT32*)pbIBData;

		/* Validate index value to prevent access violations */
		if(!VALIDATE_INDEX(psContext, (*pui32IBData & ui32IndexMask)))
		{
			psContext->hrLastError = D3DMERR_INVALIDCALL;
			goto ErrorExit;
		}	
		SetupNativeVertex(psContext, (IMG_UINT32*)(pbVBData + ((*pui32IBData & ui32IndexMask) * ui32VBByteStride)),
							ui32FVFcode,
							apsVertex[1]);

		/* Advance pointer */
		pbIBData	+= ui32IBByteStride;
		pui32IBData = (UNALIGNED IMG_UINT32*)pbIBData;

		/* Validate index value to prevent access violations */
		if(!VALIDATE_INDEX(psContext, (*pui32IBData & ui32IndexMask)))
		{
			psContext->hrLastError = D3DMERR_INVALIDCALL;
			goto ErrorExit;
		}	
		SetupNativeVertex(psContext, (IMG_UINT32*)(pbVBData + ((*pui32IBData & ui32IndexMask) * ui32VBByteStride)),
							ui32FVFcode,
							apsVertex[2]);

		/* Advance pointer */
		pbIBData	+= ui32IBByteStride;
		pui32IBData = (UNALIGNED IMG_UINT32*)pbIBData;

		/* Store pointers to colours for flat shading */
		psContext->sTState.sSWTNLState.psCurrentFlatShadeDiffuse  = &apsVertex[0]->sDiffuseOut;
		psContext->sTState.sSWTNLState.psCurrentFlatShadeSpecular = &apsVertex[0]->sSpecularOut;

		/**********************
			clip test
		**********************/
		DoClipTestandVPTransform(psContext, &apsVertex[0], 3);
		
		/**********************
			Depth bias
		**********************/
		if(psContext->sTState.dwRSFlags & TSTATE_RSFLAGS_DEPTHBIAS)
		{
			/* Calculate value of m */
			NTV_TYPE ntvNewDepthM = TriangleMaxDepthSlope(apsVertex[0]);

			/* if m is different from previous m then calculate depth bias offset */
			if(ntvNewDepthM != ntvDepthM)
			{
				CalculateDepthBias(psContext,ntvNewDepthM);

				ntvDepthM = ntvNewDepthM;
			}
		}
		
		/* any vertices clipped? */
		ui32ClipCode =	( apsVertex[0]->ui32Flags 
						| apsVertex[1]->ui32Flags 
						| apsVertex[2]->ui32Flags ) & D3DM_CLIPFLAG_MASK;
		
		if (ui32ClipCode == 0)	/* no clipping: */
		{
			if (bStartPrimitive)
			{
				/*
					Start a new primitive block
				*/
				TACSWritePrimHdr(psContext, psContext->dwTAPrimCtl, MBX1_TAOBJTYPE_VERTEXLINESTRIP);
				TACSWriteLinePointSize(psContext, 0x3F000000/*0.5*/);
				bStartPrimitive = IMG_FALSE;
			}

			ValidateVertex(psContext, &apsVertex[0], 3);
			
			OutputVertices(psContext, &apsVertex[0], 4);

			TACSWriteEndPrim(psContext);
		}
		else if(!( apsVertex[0]->ui32Flags 
				&  apsVertex[1]->ui32Flags 
				&  apsVertex[2]->ui32Flags & D3DM_CLIPFLAG_MASK)) /* clipped line: */
		{

			ValidateVertex(psContext, &apsVertex[0], 3);

			/* go through segments */
			for (j=0; j<3; j++)
			{
				ui32NumVerts = DoLineClip(psContext, apsVertex[j], apsVertex[j+1], ui32ClipCode);
				if(ui32NumVerts)
				{
					if (bStartPrimitive)
					{
						/* Start a new primitive block */
						TACSWritePrimHdr(psContext, psContext->dwTAPrimCtl, MBX1_TAOBJTYPE_VERTEXLINESTRIP);
						TACSWriteLinePointSize(psContext, 0x3F000000/*0.5*/);
						bStartPrimitive = IMG_FALSE;
					}
					ppsVertex = psContext->sTState.sSWTNLState.ppsOutputArray;		
					OutputVertices(psContext, ppsVertex, ui32NumVerts);
					TACSWriteEndPrim(psContext);
				}
			}
		}
		else
		{
			/* completely clipped out */
		}
	}
	
ErrorExit:

	/*
		End the primitive-block if we've had geometry
	*/
	if(!bStartPrimitive)
	{
		TACSWriteLastPrim(psContext);
#ifdef FIX_HW_PRN_299
		TACSWriteTACtlAnd3DState ( 	psContext,
									MBX1_TASTATEPRES_ISPCTL,
								 	&psContext->sHWState.sTACtl3DState,
								 	TRUE);
#endif				
	}
#endif
}
/***********************************************************************************
 Function Name      : IndexedTriStripLine
************************************************************************************/
IMG_VOID IndexedTriStripLine(LPD3DM_CONTEXT psContext,
					 IMG_UINT32	ui32FVFcode, 
					 BYTE *pbVBData,
					 IMG_UINT32 ui32VBByteStride,
					 BYTE *pbIBData,
					 IMG_UINT32 ui32IBByteStride,
					 IMG_UINT32 ui32PrimCount)
{
	IMG_UINT32 i, j;
	PVR_NATIVE_VERTEX asVertex[3], *apsVertex[4], *psVTmp, **ppsVertex;
	IMG_UINT32 ui32ClipCode;
	IMG_BOOL bNewStrip = IMG_TRUE;
	IMG_UINT32 ui32NumStrips = 0;
	IMG_UINT32 ui32NumVerts;
	IMG_UINT32			ui32IndexMask;
	UNALIGNED IMG_UINT32	*pui32IBData = (UNALIGNED IMG_UINT32*)pbIBData;
	NTV_TYPE			ntvDepthM = D3DM_Zero;

	ui32IndexMask = psContext->ui32IndexMask;

	/* initialise the vertex ptr array */
	apsVertex[0] = &asVertex[0];
	apsVertex[1] = &asVertex[1];
	apsVertex[2] = &asVertex[2];
	apsVertex[3] = &asVertex[0];/* and wrap to first vertex */

	/* construct native vertices */
	/* Validate index value to prevent access violations */
	if(!VALIDATE_INDEX(psContext, (*pui32IBData & ui32IndexMask)))
	{
		psContext->hrLastError = D3DMERR_INVALIDCALL;
		goto ErrorExit;
	}	
	SetupNativeVertex(psContext, (IMG_UINT32*)(pbVBData + ((*pui32IBData & ui32IndexMask) * ui32VBByteStride)),
						ui32FVFcode,
						apsVertex[0]);

	/* Advance pointer */