hxform.c

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

		OutVtxSize += HXF_VTX_CLIP_POS_SIZE;

		// pad size to 8 byte alignment
		if(0 != (OutVtxSize & HXF_ALIGN_INV_MASK))
		{
			OutVtxSize = (OutVtxSize & HXF_ALIGN_MASK) + HXF_ALIGN;
		}

		pState->OutVertexSize = OutVtxSize;
	}

	// Calc output vertex buffer size
	OutVtxBufferSize = OutVtxSize * pState->NumVertices;

	// Calc output clip flag size
	OutClipSize = pState->NumVertices;

	TotalBufferSize = OutVtxBufferSize + OutClipSize;

	if(TotalBufferSize)
	{
		HUINT32 FreeSysMem = pState->FreeBufferSize;
		HBYTE* pSysMem = pState->pFreeBuffer;

		if(pState->FreeBufferSize < TotalBufferSize)
		{
			if(pState->pFreeBuffer)
			{
				free(pState->pFreeBuffer);
				pState->pFreeBuffer = NULL;
				pState->FreeBufferSize = 0;
			}

			// add extra space to pad for alignment issues
			pState->pFreeBuffer = (HBYTE*)malloc(TotalBufferSize + (HXF_ALIGN<<1));
			if(NULL == pState->pFreeBuffer)
			{
				// Failed to allocate
				HXFClearBuffers(pState);
				return HFALSE;
			}
			pState->FreeBufferSize = TotalBufferSize;
			FreeSysMem = pState->FreeBufferSize;
			pSysMem = pState->pFreeBuffer;
		}

		// OutVertices
		if(!pState->pOutVertices && OutVtxBufferSize)
		{
			// outvtx aligned to start to 8 byte alignment
			HXFASSERT(FreeSysMem >= OutVtxBufferSize);
			pState->pOutVertices = (HUINT8*)(((int)pSysMem) & HXF_ALIGN_MASK) + HXF_ALIGN;
			pSysMem = pState->pOutVertices + OutVtxBufferSize;
			FreeSysMem -= OutVtxBufferSize;
			TotalBufferSize -= OutVtxBufferSize;
		}

		// OutClip Flags
		if(!pState->pOutClipFlags && OutClipSize)
		{
			HXFASSERT( FreeSysMem >= OutClipSize );
			pState->pOutClipFlags = pSysMem;
			pSysMem+=OutClipSize;
			FreeSysMem -= OutClipSize;
			TotalBufferSize -= OutClipSize;
		}
	}

	pState->pEndOutVertex = pState->pOutVertices + (pState->NumVertices * pState->OutVertexSize);

#ifndef HXF_HARNESS
	//pState->pSPProc = s_SPProcs[pState->OutScreenVertexSize>>2];
#endif // HXF_HARNESS
	return HTRUE;
}

/* ************************************************************************* *\
	FUNCTION: HXFClearBuffers
	DESCRIPTION:

\* ************************************************************************* */
void HXFClearBuffers(HXFState* pState)
{
	HXFASSERT(pState);

	pState->NumVertices = 0;		//
	pState->NumPrimitives = 0;		//

	pState->pIndices = NULL;
	pState->BaseIndex = 0;
	pState->pInPosition = NULL;
	pState->InPositionStride = 0;
	pState->pInNormal = NULL;				//
	pState->InNormalStride = 0;
	pState->pInDiffuse = NULL;
	pState->InDiffuseStride = 0;
	pState->pInSpecular = NULL;
	pState->InSpecularStride = 0;
	pState->pInTextureCoordinate1 = NULL;
	pState->InTextureCoordinate1Stride = 0;
	pState->pInTextureCoordinate2 = NULL;
	pState->InTextureCoordinate2Stride = 0;

	pState->pEndOutVertex = NULL;

	pState->pOutVertices = NULL;
	pState->pOutClipFlags = NULL;
	pState->OutVertexSize = 0;
	pState->OutScreenVertexSize = 0;
	pState->OutDiffuseOffset = 0;
	pState->OutSpecularOffset = 0;
	pState->OutTex1Offset = 0;
	pState->OutTex2Offset = 0;

	//pState->pSPProc = 0;
	//pState->SPReservedSpace = 0;
}

/* ************************************************************************* *\
	FUNCTION: HXFFreeBuffers
	DESCRIPTION:

\* ************************************************************************* */
void HXFFreeBuffers(HXFState* pState)
{
	HXFASSERT(pState);

	if(pState->pFreeBuffer)
	{
		free(pState->pFreeBuffer);
		pState->pFreeBuffer = NULL;
		pState->FreeBufferSize = 0;
	}
}

#ifdef DEBUG

/* ************************************************************************* *\
	FUNCTION: ValidateHXFState
	DESCRIPTION: A helper routine that will show miss configurations of the
		the HXFState this is intended for use in debug modes only.



\* ************************************************************************* */
static HBOOL ValidateHXFState(HXFState* pState)
{
	HBOOL bResult = HTRUE;

   // Check alignment of all elements that require it.
   HXFASSERT((((int) pState->pLights) & (HXF_ALIGN_INV_MASK)) == 0);
   HXFASSERT((((int) pState->pTransformMatrix) & (HXF_ALIGN_INV_MASK)) == 0);
	
   HXFASSERT((((int) &(pState->pTransformMatrix[1])) & (HXF_ALIGN_INV_MASK)) == 0);
   HXFASSERT((((int) &(pState->pTransformMatrix[2])) & (HXF_ALIGN_INV_MASK)) == 0);

   HXFASSERT(((int)&(pState->pLights->Position) & (HXF_ALIGN_INV_MASK)) == 0);
   HXFASSERT(((int)&(pState->pLights->Direction) & (HXF_ALIGN_INV_MASK)) == 0);
   HXFASSERT(((int)&(pState->pLights->Ambient) & (HXF_ALIGN_INV_MASK)) == 0);
   HXFASSERT(((int)&(pState->pLights->Diffuse) & (HXF_ALIGN_INV_MASK)) == 0);
   HXFASSERT(((int)&(pState->pLights->Specular) & (HXF_ALIGN_INV_MASK)) == 0);
   HXFASSERT(((int)&(pState->pLights->Attenuation) & (HXF_ALIGN_INV_MASK)) == 0);

   //HXFASSERT(pState->pSPProc);
	HXFASSERT(pState->pfLoadPositionProc);

	// Must have some place to stash the processed data
	HXFASSERT(pState->pOutVertices);

	// Must have some vertices to process
	HXFASSERT(pState->NumVertices != 0);

	// it is ok for the rest of the pointers to be set during calls to the
	// start list

	// make sure we have the proper outputs if we are lighting
	if (pState->Flags & HXF_LIGHT_ENABLE)
	{
		// no place to put lighting results
		HXFASSERT(pState->OutDiffuseOffset);

		HXFASSERT(pState->pfLoadNormalProc);

		if(pState->Flags & HXF_SPECULAR_ENABLE)
		{
			if(pState->Flags & HXF_SEPERATE_SPECULAR)
			{
				HXFASSERT(pState->OutSpecularOffset != 0);
			}
		}
		else
		{ // specular is not enabled
			// no specular calculations.
			HXFASSERT(pState->OutSpecularOffset == 0);
		}

		// validate lighting requirements
		HXFASSERT(pState->pInNormal);
		if(!pState->Flags&HXF_LM_COLOR_CONSTANT)
		{
			HXFASSERT(pState->pInDiffuse);
			HXFASSERT(pState->pfLoadDiffuseProc);
		}
	}
	else
	{
		HXFASSERT(pState->pInDiffuse);
		HXFASSERT(pState->pfLoadDiffuseProc);
	}
	HXFASSERT(pState->OutDiffuseOffset);

	// if clipping is enabled then we must have a place for clip flags
	HXFASSERT(pState->pOutClipFlags);

	if(pState->Flags & HXF_FOG_ENABLE)
	{
		HXFASSERT(pState->pfFogProc);
	}

	if(pState->pInTextureCoordinate1)
	{
		HXFASSERT(pState->OutTex1Offset);
	}

	if(pState->pInTextureCoordinate2)
	{
		HXFASSERT(pState->OutTex2Offset);
	}

	// Validate that any Null pointers have a NULL stride
	if(NULL == pState->pInNormal)
	{
		HXFASSERT(pState->InNormalStride == 0);

	}

	if(NULL == pState->pInDiffuse)
	{
		HXFASSERT(pState->InDiffuseStride == 0);
	}

	if(NULL == pState->pInTextureCoordinate1)
	{
		HXFASSERT(pState->InTextureCoordinate1Stride == 0);
		HXFASSERT(pState->pfLoadTex1Proc == NULL);
	}
	else
	{
		HXFASSERT(pState->pfLoadTex1Proc);
	}

	if(NULL == pState->pInTextureCoordinate2)
	{
		HXFASSERT(pState->InTextureCoordinate2Stride == 0);
		HXFASSERT(pState->pfLoadTex2Proc == NULL);
	}
	else
	{
		HXFASSERT(pState->pfLoadTex2Proc);
	}

	return bResult;
};

#endif // DEBUG

#ifndef HXF_HARNESS

/* ************************************************************************* *\
	FUNCTION: HXFDrawPrimitives
	DESCRIPTION:

\* ************************************************************************* */
HBOOL HXFDrawPrimitives(HXFState* pState)
{
	HBOOL ret = HTRUE;
	HXFASSERT(pState);



	if(ret)
	{
		ret = HXFAllocateBuffers(pState);
	}

#ifdef DEBUG
	if(ret)
	{
		// Do debugging state validation checks.
		ValidateHXFState(pState);
	}
#endif  // _DEBUG


	if(ret)
	{
		HXF_PROFILER_TRANSITION(HXFPROFILE_DRAW_TNL);
		HXFTransformVertices(pState);
	}


#ifdef HXF_FIX_PRN725
/* FIX PRN725 - Detect if an offset color and TexCoord 2 is present
	and Sets up the work around functions if needed.
*/
	if(ret)
	{
		if(pState->OutSpecularOffset != 0 && pState->OutTex2Offset != 0)
		{
			s_AssembleProcs[HXF_PT_TRI_LIST] = HXFAssembleTriListShort;
			s_AssembleProcs[HXF_PT_TRI_STRIP] = HXFAssembleTriStripShort;
			s_AssembleIndexedProcs[HXF_PT_TRI_LIST] = HXFAssembleIndexedTriListShort;
			s_AssembleIndexedProcs[HXF_PT_TRI_STRIP] = HXFAssembleIndexedTriStripShort;
		}
		else
		{
			s_AssembleProcs[HXF_PT_TRI_LIST] = HXFAssembleTriList;
			s_AssembleProcs[HXF_PT_TRI_STRIP] = HXFAssembleTriStrip;
			s_AssembleIndexedProcs[HXF_PT_TRI_LIST] = HXFAssembleIndexedTriList;
			s_AssembleIndexedProcs[HXF_PT_TRI_STRIP] = HXFAssembleIndexedTriStrip;
		}
	}
#endif // HXF_FIX_PRN725

	if(ret)
	{
		HUINT32 pt = HXF_GET_PT(pState->Flags);
		HXFAssembleProc pfAssemble = NULL;

		HXF_PROFILER_TRANSITION(HXFPROFILE_DRAW_ASSEMBLE);
		if(NULL == pState->pIndices)
		{
			pfAssemble = s_AssembleProcs[pt];
		}
		else
		{
			pfAssemble = s_AssembleIndexedProcs[pt];
		}

		HXFASSERT(pfAssemble);

		pfAssemble(pState);
	}

	if(ret && pState->Flags & HXF_LIGHTING_TWO_SIDED
		&& ((pState->Flags & HXF_CULL_FLIP_2SIDED))
		&& pState->Flags & HXF_LIGHT_ENABLE)

	{
		HXF_PROFILER_TRANSITION(HXFPROFILE_DRAW_TNL);
		pState->Flags |= HXF_INVERT_NORMALS;
		HXFRelightVertices(pState);
		pState->Flags &= ~HXF_INVERT_NORMALS;

		if(ret)
		{
			HUINT32 pt = HXF_GET_PT(pState->Flags);
			HXFAssembleProc pfAssemble = NULL;

			HXF_PROFILER_TRANSITION(HXFPROFILE_DRAW_ASSEMBLE);
			if(NULL == pState->pIndices)
			{
				pfAssemble = s_AssembleProcs[pt];
			}
			else
			{
				pfAssemble = s_AssembleIndexedProcs[pt];
			}
			HXFFlipCullDirection(pState);

			HXFASSERT(pfAssemble);
			pfAssemble(pState);

			HXFFlipCullDirection(pState);

		}
	}

	HXF_PROFILER_TRANSITION(HXFPROFILE_DRAW_VALIDATE);

	// Always clear up our buffers
	HXFClearBuffers(pState);

	return ret;
}

#endif // HXF_HARNESS

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