hxflocal.h

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: HXFLocal.h
**	DESCRIPTION: HXform internal header
**
**	AUTHOR: Cian Montgomery
**	CREATED: June 06, 2003
**
 *  $Date: 5/28/04 10:21a $ $Revision: 20 $
 *  $Log: /Intel_Development/Drivers/Marathon/WinCE42/opengles/HXFLocal.h $
 * 
 * 20    5/28/04 10:21a Clmontgo
 * Extened 1/w presicion in Clipper
 *
 * 19    5/16/04 12:53p Clmontgo
 *
 * 18    3/19/04 2:11p Clmontgo
 * Moved  VP xform to after clip and 1/w
 *
 * 17    3/18/04 10:37p Clmontgo
 * Fixes for Clipping and SP clean up
 *
 * 16    3/10/04 10:07a Cmdoan
 * 2 sided lighting fixes
 *
 * 15    2/19/04 11:27a Clmontgo
 *
 * 14    2/18/04 10:45a Clmontgo
 * Fixed potential Slaveport issue and ARGB to RGBA color ording for byte
 * colors
 *
 * 13    2/04/04 5:42p Clmontgo
 * Rewrite of Slaveport code to do incremental writes, should eliminate
 * Slaveport write buffer stalls. Added some error handling to Draw*
 * functions.
 *
 * 12    1/30/04 9:34a Clmontgo
 *
 * 11    1/21/04 2:09p Cmdoan
 * fixed hw level strip cull direction
 *
 * 10    1/19/04 5:34p Clmontgo
 * Added Fog Functionality
 *
 * 9     12/31/03 1:51p Clmontgo
 *
 * 8     12/21/03 12:53p Clmontgo
 *
 * 7     12/17/03 9:21a Clmontgo
 * Added Version ID and log to file headers
\* ************************************************************************* */
#ifndef __HXFLOCAL_H__
#define __HXFLOCAL_H__
#include "HXForm.h"
#include <stdlib.h>
#include <math.h>
#include <memory.h>

#ifndef NULL
#define NULL ((void*)0)
#endif // !defined(NULL)

/* ************************************************************************* *\
** ************************************************************************* **
** Various element sizes for allocation and alignment information
** ************************************************************************* **
\* ************************************************************************* */
#define HXF_INDEX_SIZE (sizeof(HUINT16))
#define HXF_TRANSFORM_SIZE (sizeof(HMATRIX4FX) * 3)  // Vector Transform + Texture[0,1] transform
#define HXF_LIGHT_DATA_SIZE (sizeof(HXFLight)* HXF_MAX_LIGHTS)

/* ************************************************************************* *\
** ************************************************************************* **
** Clip Buffer sizes
** ************************************************************************* **
\* ************************************************************************* */
#define HXF_CLIP_PRIMITIVE_SPACE (100) // 100 Primitives, 300 indices
#define HXF_CLIP_IDX_SPACE (HXF_CLIP_PRIMITIVE_SPACE * 3)
#define HXF_CLIP_VTX_SPACE (100)
#define HXF_CLIP_IDX_SIZE (sizeof(void*))
#define HXF_CLIP_VTX_SIZE (HXF_VTX_MAX_SIZE) // this is the max size of a clip vertex

// Size in bytes of these buffers
#define HXF_CLIP_IDX_STORAGE_SIZE (HXF_CLIP_IDX_SPACE * HXF_CLIP_IDX_SIZE)
#define HXF_CLIP_VTX_STORAGE_SIZE (HXF_CLIP_VTX_SPACE * HXF_CLIP_VTX_SIZE)

// segment data structure for clippers
typedef struct _HXFClipSegment
{
	HBYTE* pVtx;
	HUINT8 Flags; // Clip Flags
	struct _HXFClipSegment* pNext;
} HXFClipSegment;


/* ************************************************************************* *\
** ************************************************************************* **
** Interface to the clippers
** ************************************************************************* **
\* ************************************************************************* */
#define HXF_CLIP_BUFFER_SIZE	(sizeof(HXFClipSegment) * 21)
		// sizeof(ClipSegment) * (18 + 3))
		// See comments in HXFClip_Ref.c for details on the amount.

// FIXME think about these values ??? how many faces and vertices can we generate
// by clipping a single face? These numbers are guesses and probably bad.
// Each plane can potentially add two temporary vertices, even though
// the overall number of vertices can only increase by one per plane.
#define HXF_CLIP_VERTEX_BUFFER_PAD (18)
#define HXF_CLIP_PRIMITIVE_BUFFER_PAD	(18)

// Vertex ClipFlags
#define HXF_VTX_CLIP_FLAG_NEG_X	 (0x01<<0)
#define HXF_VTX_CLIP_FLAG_POS_X	 (0x01<<1)

#define HXF_VTX_CLIP_FLAG_NEG_Y	 (0x01<<2)
#define HXF_VTX_CLIP_FLAG_POS_Y	 (0x01<<3)

#define HXF_VTX_CLIP_FLAG_NEG_Z	 (0x01<<4)
#define HXF_VTX_CLIP_FLAG_POS_Z	 (0x01<<5)

void* HXFInitializeSegmentList(void* pBuffer, HUINT32 BufferSize);

// Flags from HXFAssembleARM.s used in clip triangle
#define HXF_PA_CULLDIR_CW		(0x01 << 28)
#define HXF_PA_CULL_ENABLE		(0x01 << 27)

HINT32 HXFCullTest(void*, void*, void*, HUINT32 bCullDirCW);
void HXFViewportTransform(HXFState* pState, void* pHPos, void* pOutPos);

/* ************************************************************************* *\
** ************************************************************************* **
** Interface to Clipper and Culler
** ************************************************************************* **
\* ************************************************************************* */
// Clip and Cull functions - return HFALSE if the triangle should not be drawn

// Clip functions
HXFState* HXFClipTriangle(HXFState* pState, HBYTE* pV1, HBYTE* pV2, HBYTE* pV3);
HXFState* HXFClipLine(HXFState*, HUINT8*, HUINT8*);

void HXFClipInterpolate(HXFState* pState, void* pIn, void* pOut,
					   HXFClipSegment* pNewNode, HUINT32 boundary);
HXFState* HXFDrawClippedTriangles(HXFState* pState);
HXFState* HXFDrawClippedLines(HXFState* pState);

/* ************************************************************************* *\
** ************************************************************************* **
** Interface to TNL Proc
** ************************************************************************* **
\* ************************************************************************* */
void HXFTransformVertices(HXFState* pState);
void HXFRelightVertices(HXFState* pState);

// TnL Helper procs
void HXFLoadPositionsFIXED2Proc(void);
void HXFLoadPositionsFIXED3Proc(void);
void HXFLoadPositionsFIXED4Proc(void);
void HXFLoadPositionsINT82Proc(void);
void HXFLoadPositionsINT83Proc(void);
void HXFLoadPositionsINT84Proc(void);
void HXFLoadPositionsINT162Proc(void);
void HXFLoadPositionsINT163Proc(void);
void HXFLoadPositionsINT164Proc(void);
void HXFLoadPositionsFLOAT2Proc(void);
void HXFLoadPositionsFLOAT3Proc(void);
void HXFLoadPositionsFLOAT4Proc(void);

void HXFCopyPACKEDColorProc(void);
void HXFCopyUINT8ColorProc(void);
void HXFCopyFIXEDColorProc(void);
void HXFCopyFLOATColorProc(void);

void HXFLoadUINT8DiffuseColorProc(void);
void HXFLoadPACKEDDiffuseColorProc(void);
void HXFLoadFIXEDDiffuseColorProc(void);
void HXFLoadFLOATDiffuseColorProc(void);

void HXFLoadFLOATNormalProc(void);
void HXFLoadFIXEDNormalProc(void);
void HXFLoadINT8NormalProc(void);
void HXFLoadINT16NormalProc(void);
void HXFLoadPACKEDNormalProc(void);

void HXFLoadNormalizeFLOATNormalProc(void);
void HXFLoadNormalizeFIXEDNormalProc(void);
void HXFLoadNormalizeINT8NormalProc(void);
void HXFLoadNormalizeINT16NormalProc(void);

void HXFDirectionalLightProc(void);
void HXFDirectionalLightProc_CM(void);
void HXFDirectionalLightProc_S(void);
void HXFDirectionalLightProc_CMS(void);
void HXFPointLightProc(void);
void HXFPointLightProc_CM(void);
void HXFPointLightProc_S(void);
void HXFPointLightProc_CMS(void);
void HXFSpotLightProc(void);
void HXFSpotLightProc_CM(void);
void HXFSpotLightProc_S(void);
void HXFSpotLightProc_CMS(void);

void HXFCopyTexCoordFIXED2Proc(void);
void HXFCopyTexCoordINT82Proc(void);
void HXFCopyTexCoordINT162Proc(void);
void HXFCopyTexCoordFLOAT2Proc(void);

void HXFTransformTexCoordFIXED2Proc(void);
void HXFTransformTexCoordFIXED3Proc(void);
void HXFTransformTexCoordFIXED4Proc(void);
void HXFTransformTexCoordINT82Proc(void);
void HXFTransformTexCoordINT83Proc(void);
void HXFTransformTexCoordINT84Proc(void);
void HXFTransformTexCoordINT162Proc(void);
void HXFTransformTexCoordINT163Proc(void);
void HXFTransformTexCoordINT164Proc(void);
void HXFTransformTexCoordFLOAT2Proc(void);
void HXFTransformTexCoordFLOAT3Proc(void);
void HXFTransformTexCoordFLOAT4Proc(void);

/* ************************************************************************* *\
** ************************************************************************* **
** Interface to Temp buffer allocation
** ************************************************************************* **
\* ************************************************************************* */
HBOOL HXFAllocateBuffers(HXFState*);
void HXFClearBuffers(HXFState*);
void HXFFreeBuffers(HXFState*);

/* ************************************************************************* *\
** ************************************************************************* **
** Interface to reference primitive assemblers
** ************************************************************************* **
\* ************************************************************************* */
void HXFAssembleIndexedTriList(HXFState* pState);
void HXFAssembleIndexedTriStrip(HXFState* pState);
void HXFAssembleIndexedTriFan(HXFState* pState);
void HXFAssembleIndexedLineList(HXFState* pState);
void HXFAssembleIndexedLineStrip(HXFState* pState);
void HXFAssembleIndexedLineLoop(HXFState* pState);
void HXFAssembleIndexedPoints(HXFState* pState);
void HXFAssembleTriList(HXFState* pState);
void HXFAssembleTriStrip(HXFState* pState);
void HXFAssembleTriFan(HXFState* pState);
void HXFAssembleLineList(HXFState* pState);
void HXFAssembleLineStrip(HXFState* pState);
void HXFAssembleLineLoop(HXFState* pState);
void HXFAssemblePoints(HXFState* pState);

#ifdef HXF_FIX_PRN725
void HXFAssembleIndexedTriListShort(HXFState* pState);
void HXFAssembleIndexedTriStripShort(HXFState* pState);
void HXFAssembleTriListShort(HXFState* pState);
void HXFAssembleTriStripShort(HXFState* pState);
#endif //  HXF_FIX_PRN725

void HXFFlipCullDirection(HXFState* pState);

HXFState* ctlBeginPrimitiveList ( HXFState*, void*, void*, CTLU32 );
HXFState* ctlEndPrimitiveList   ( HXFState* );
HXFState* ctlBeginClipList      ( HXFState* );
HXFState* ctlVertex             ( HXFState*, void*, void*, void* );

/* ************************************************************************* *\
** ************************************************************************* **
** Utility Macros
** ************************************************************************* **
\* ************************************************************************* */
#define HXF_UPDATE_ITOR(p, s) if((p) != NULL && s != 0) { (p) = ((p)) + (s); }
#define HXF_RESET_ITOR(p, cnt, stride)  if((p) != NULL && stride != 0) { (p) = (p) - ((cnt) * (stride)); }

#endif // __HXFLOCAL_H__
/* ************************************************************************* *\
** ************************************************************************* **
** EOF
** ************************************************************************* **
\* ************************************************************************* */