hxform.c

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

/* ************************************************************************* *\
**
**    INTEL Corporation Proprietary Information
**
**    This listing is supplied under the terms of a license
**    agreement with INTEL Corporation and may not be copied
**    nor disclosed except in accordance with the terms of
**    that agreement.
**
**    Copyright (c) 2003 Intel Corporation.
**    All Rights Reserved.
**
** ************************************************************************* **
**	FILE: HXForm.c
**	DESCRIPTION: Provides basic Management of the HTnL handle.
**		Creation, Destruction and State accessors.
**
**	AUTHOR: Cian Montgomery
**	CREATED: June 06, 2003
**
\* ************************************************************************* */
#include "HXFLocal.h"
#include "HXFProfiler.h"
//#include "mbx1defs.h"


HXFTNLPROC g_pfLoadPositionProcs[HXF_NUM_PRIMITIVE_TYPES][3] =
{
	{	// HXF_VF_NONE  = 0,
		NULL, // 2
		NULL,  // 3
		NULL  // 4
	},
	{	// HXF_VF_FIXED = 1,
		HXFLoadPositionsFIXED2Proc,
		HXFLoadPositionsFIXED3Proc,
		HXFLoadPositionsFIXED4Proc
	},
	{	// HXF_VF_FLOAT = 2,
		NULL, // 2
		NULL,  // 3
		NULL  // 4
	},
	{	// HXF_VF_INT16 = 3,
		HXFLoadPositionsINT162Proc,
		HXFLoadPositionsINT163Proc,
		HXFLoadPositionsINT164Proc
	},
	{	// HXF_VF_INT8 =  4,
		HXFLoadPositionsINT82Proc,
		HXFLoadPositionsINT83Proc,
		HXFLoadPositionsINT84Proc
	},
	{	// HXF_VF_UINT8 = 5,
		NULL,
		NULL,
		NULL
	},
	{	// HXF_VF_PACKED = 6,
		NULL,
		NULL,
		NULL
	}
};

HXFTNLPROC g_pfCopyColorProcs[HXF_NUM_PRIMITIVE_TYPES] =
{
	NULL,					// HXF_VF_NONE  = 0,
	HXFCopyFIXEDColorProc,  // HXF_VF_FIXED = 1,
	NULL,  					// HXF_VF_FLOAT = 2,
	NULL , 					// HXF_VF_INT16 = 3,
	NULL , 					// HXF_VF_INT8 =  4,
	HXFCopyUINT8ColorProc, 	// HXF_VF_UINT8 = 5,
	HXFCopyPACKEDColorProc, // HXF_VF_PACKED = 6,
};

HXFTNLPROC g_pfLoadColorProcs[HXF_NUM_PRIMITIVE_TYPES] =
{
	NULL,							// HXF_VF_NONE  = 0,
	HXFLoadFIXEDDiffuseColorProc,   // HXF_VF_FIXED = 1,
	NULL,   						// HXF_VF_FLOAT = 2,
	NULL , 							// HXF_VF_INT16 = 3,
	NULL , 							// HXF_VF_INT8 =  4,
	HXFLoadUINT8DiffuseColorProc, 	// HXF_VF_UINT8 = 5,
	HXFLoadPACKEDDiffuseColorProc,  // HXF_VF_PACKED = 6,
};

HXFTNLPROC g_pfLoadNormalProcs[HXF_NUM_PRIMITIVE_TYPES] =
{
	NULL,					// HXF_VF_NONE  = 0,
	HXFLoadFIXEDNormalProc, // HXF_VF_FIXED = 1,
	NULL, 					// HXF_VF_FLOAT = 2,
	HXFLoadINT16NormalProc, // HXF_VF_INT16 = 3,
	HXFLoadINT8NormalProc, 	// HXF_VF_INT8 =  4,
	NULL, 					// HXF_VF_UINT8 = 5,
	HXFLoadPACKEDNormalProc,// HXF_VF_PACKED = 6,
};

HXFTNLPROC g_pfLoadNormalizeNormalProcs[HXF_NUM_PRIMITIVE_TYPES] =
{
	NULL,								// HXF_VF_NONE  = 0,
	HXFLoadNormalizeFIXEDNormalProc, 	// HXF_VF_FIXED = 1,
	NULL, 								// HXF_VF_FLOAT = 2,
	HXFLoadNormalizeINT16NormalProc, 	// HXF_VF_INT16 = 3,
	HXFLoadNormalizeINT8NormalProc, 	// HXF_VF_INT8 =  4,
	NULL, 								// HXF_VF_UINT8 = 5,
	HXFLoadPACKEDNormalProc, 			// HXF_VF_PACKED = 6,
};


HXFTNLPROC g_pfLightProcs[HXF_NUM_LIGHT_TYPES][4] =
{
	{ // Directional
		HXFDirectionalLightProc,
		HXFDirectionalLightProc_CM,
		HXFDirectionalLightProc_S,
		HXFDirectionalLightProc_CMS
	},
	{	// Point
		HXFPointLightProc,
		HXFPointLightProc_CM,
		HXFPointLightProc_S,
		HXFPointLightProc_CMS
	},
	{	// Directional Spot -- Technically a bad type - but for ease
		HXFDirectionalLightProc,
		HXFDirectionalLightProc_CM,
		HXFDirectionalLightProc_S,
		HXFDirectionalLightProc_CMS
	},
	{	// Spot - Combination of Point and Spot
		HXFSpotLightProc,
		HXFSpotLightProc_CM,
		HXFSpotLightProc_S,
		HXFSpotLightProc_CMS
	}

};

HXFTNLPROC g_pfLoadTexCoordsProcs[HXF_NUM_PRIMITIVE_TYPES][3] =
{
	{	// HXF_VF_NONE  = 0,
		NULL,
		NULL,
		NULL
	},
	{	// HXF_VF_FIXED = 1,
		HXFCopyTexCoordFIXED2Proc,
		HXFCopyTexCoordFIXED2Proc,
		HXFCopyTexCoordFIXED2Proc
	},
	{	// HXF_VF_FLOAT = 2,
		NULL, // 2
		NULL,  // 3
		NULL  // 4
	},
	{	// HXF_VF_INT16 = 3,
		HXFCopyTexCoordINT162Proc,
		HXFCopyTexCoordINT162Proc,
		HXFCopyTexCoordINT162Proc
	},
	{	// HXF_VF_INT8 =  4,
		HXFCopyTexCoordINT82Proc,
		HXFCopyTexCoordINT82Proc,
		HXFCopyTexCoordINT82Proc
	},
	{	// HXF_VF_UINT8 = 5,
		NULL,
		NULL,
		NULL
	},
	{	// HXF_VF_PACKED = 6,
		NULL,
		NULL,
		NULL
	}
};

HXFTNLPROC g_pfTransformTexCoordsProcs[HXF_NUM_PRIMITIVE_TYPES][3] =
{
	{	// HXF_VF_NONE  = 0,
		NULL,
		NULL,
		NULL
	},
	{	// HXF_VF_FIXED = 1,
		HXFTransformTexCoordFIXED2Proc,
		HXFTransformTexCoordFIXED3Proc,
		HXFTransformTexCoordFIXED4Proc
	},
	{	// HXF_VF_FLOAT = 2,
		NULL, // 2
		NULL,  // 3
		NULL  // 4
	},
	{	// HXF_VF_INT16 = 3,
		HXFTransformTexCoordINT162Proc,
		HXFTransformTexCoordINT163Proc,
		HXFTransformTexCoordINT164Proc
	},
	{	// HXF_VF_INT8 =  4,
		HXFTransformTexCoordINT82Proc,
		HXFTransformTexCoordINT83Proc,
		HXFTransformTexCoordINT84Proc
	},

	{	// HXF_VF_UINT8 = 5,
		NULL,
		NULL,
		NULL
	},
	{	// HXF_VF_PACKED = 6,
		NULL,
		NULL,
		NULL
	}
};

#ifndef HXF_HARNESS

typedef void (*HXFAssembleProc)(HXFState*);
static HXFAssembleProc s_AssembleProcs[HXF_NUM_PRIMITIVE_TYPES] =
{
	HXFAssemblePoints,
	HXFAssembleLineList,
	HXFAssembleLineStrip,
	HXFAssembleLineLoop,
	HXFAssembleTriList,
	HXFAssembleTriStrip,
	HXFAssembleTriFan,
	NULL,
};

static HXFAssembleProc s_AssembleIndexedProcs[HXF_NUM_PRIMITIVE_TYPES] =
{
	HXFAssembleIndexedPoints,
	HXFAssembleIndexedLineList,
	HXFAssembleIndexedLineStrip,
	HXFAssembleIndexedLineLoop,
	HXFAssembleIndexedTriList,
	HXFAssembleIndexedTriStrip,
	HXFAssembleIndexedTriFan,
	NULL,
};

#endif / /HXF_HARNESS


/* ************************************************************************* *\
	FUNCTION: HXFAllocateState
	DESCRIPTION: Allocates the state and ensures that it is 8 byte aligned.

	- malloc seems to like to return 8 byte aligned blocks but just to be
	safe, I always over allocate and increment to the first 8 byte aligned
	address after the allocated pointer.
\* ************************************************************************* */
HXFState* HXFAllocateState()
{
	HXFState* pState  = NULL;
	HBYTE* pData  = NULL;
	HUINT32 TotalSize = 0;
	HUINT32 BufferSize = 0;

	BufferSize = sizeof(HXFState)
			+ HXF_TRANSFORM_SIZE
			+ HXF_LIGHT_DATA_SIZE
			+ HXF_CLIP_VTX_STORAGE_SIZE
			+ HXF_CLIP_IDX_STORAGE_SIZE
			+ HXF_CLIP_BUFFER_SIZE;
	TotalSize = BufferSize + (HXF_ALIGN<<1)
			+ sizeof(HBYTE**);

	pData = (HBYTE*)malloc(TotalSize);
	if(NULL == pData)
	{
		return HFALSE;
	}

	// ensure the alignment
	pState = (HXFState*)((((HUINT32)pData + sizeof(HBYTE**)) & HXF_ALIGN_MASK) + HXF_ALIGN);
	// Save the original pointer for deletion
	{
		HBYTE** pAllocPtr = (HBYTE**) pState;
		pAllocPtr--;
		*pAllocPtr = pData;
	}

	// initialize the state.
	memset(pState, 0, BufferSize);

	// Reset the data pointer to have the correct offset for the remaining data
	pData = (HBYTE*)(pState +1);

	// Set up the Transfrom pointer
	pState->pTransformMatrix = (HMATRIX4FX*)pData;
	pData += HXF_TRANSFORM_SIZE;

	// Set up the Light Data pointer
	pState->pLights = (HXFLight*)pData;
	pData += HXF_LIGHT_DATA_SIZE;

	// Set up the clip buffers
	pState->pClipSegments = pData;
	pData += HXF_CLIP_BUFFER_SIZE;

	pState->pClippedIndices = (void**)pData;
	pData += HXF_CLIP_IDX_STORAGE_SIZE;
	pState->NumClippedPrimitives = 0;

	// Set up the clipped vertices buffer -- ensure it is properly aligned
	pState->pClippedVertices =  (HBYTE*)(((HUINT32)pData & HXF_ALIGN_MASK) + HXF_ALIGN);
	pData = pState->pClippedVertices + HXF_CLIP_VTX_STORAGE_SIZE;
	pState->NumClippedVertices = 0;

	return pState;
}

/* ************************************************************************* *\
	FUNCTION: HXFFreeState
	DESCRIPTION: Frees a previously allocated HXFState object.

\* ************************************************************************* */
void HXFFreeState(HXFState* pState)
{
	HBYTE** pAllocPtr = (HBYTE**)pState;
	HXFASSERT(pState);

	HXFFreeBuffers(pState);

	// Original pointer is stored as a pointer just prior to pState pointer
	pAllocPtr--;
	free(*pAllocPtr);
}

/* ************************************************************************* *\
	FUNCTION: HXFAllocateBuffers
	DESCRIPTION: Calculate the buffer sizes and allocate buffers to hold
		the data

\* ************************************************************************* */
HBOOL HXFAllocateBuffers(HXFState* pState)
{
	HUINT32 OutVtxSize = HXF_VTX_BASE_SIZE;
	HUINT32 OutVtxBufferSize = 0;
	HUINT32 OutClipSize = 0;
	HUINT32 TotalBufferSize = 0;

	HXFASSERT(pState && pState->OutVertexSize == 0);

	{
		// Calculate the output vertex size
		if(pState->Flags & HXF_LIGHT_ENABLE)
		{
			pState->OutDiffuseOffset = OutVtxSize;
			OutVtxSize+=HXF_VTX_DIFFUSE_SIZE;

			if(pState->Flags & HXF_SEPERATE_SPECULAR
				|| pState->Flags & HXF_FOG_ENABLE)
			{
				pState->OutSpecularOffset = OutVtxSize;
				OutVtxSize+=HXF_VTX_SPECULAR_SIZE;
			}
		}
		else
		{
			if(pState->pInDiffuse)
			{
				pState->OutDiffuseOffset = OutVtxSize;
				OutVtxSize+=HXF_VTX_DIFFUSE_SIZE;
			}

			if(pState->pInSpecular
				|| pState->Flags & HXF_FOG_ENABLE)
			{
				pState->OutSpecularOffset = OutVtxSize;
				OutVtxSize+=HXF_VTX_SPECULAR_SIZE;
			}
		}

		if(pState->pInTextureCoordinate1)
		{
			pState->OutTex1Offset = OutVtxSize;
			OutVtxSize+=HXF_VTX_TEX1_SIZE;
		}

		if(pState->pInTextureCoordinate2)
		{
			pState->OutTex2Offset = OutVtxSize;
			OutVtxSize+=HXF_VTX_TEX2_SIZE;
		}

		// Store the size of the data that we will
		// transmit to marathon
		pState->OutScreenVertexSize = OutVtxSize;

		pState->OutClipPosOffset = OutVtxSize;