fgl.h

SMDK6410 Test Code Revision 02. s3c6410 official test code, shifting all the controller functional

	FG_BOOL isEmptyPE;			// primitive engine
	FG_BOOL isEmptyVS;			// vertex shader
	FG_BOOL isEmptyVC;			// vertex cache
	FG_BOOL isEmptyHI2VS;		// FIFO between host interface and vertex shader
	FG_BOOL isEmptyHI; 			// host interface
	FG_BOOL isEmptyHOSTFIFO; 	// host-fifo
} FGL_PipelineStatus;

typedef struct FGL_PipelineTargetStateTag
{
	FG_BOOL isNotEmptyPF1;		// per-fragment #2
	FG_BOOL isNotEmptyPF0;		// per-fragment #1
	FG_BOOL isNotEmptyPS1;		// pixel shader #2
	FG_BOOL isNotEmptyPS0;		// pixel shader #1
	FG_BOOL isNotEmptyRA;		// raster engine
	FG_BOOL isNotEmptyTSE;		// triangle setup engine
	FG_BOOL isNotEmptyPE;		// primitive engine
	FG_BOOL isNotEmptyVS;		// vertex shader
	FG_BOOL isNotEmptyVC;		// vertex cache
	FG_BOOL isNotEmptyHI2VS;	// FIFO between host interface and vertex shader
	FG_BOOL isNotEmptyHI; 		// host interface
	FG_BOOL isNotEmptyHOSTFIFO;	// host-fifo
} FGL_PipelineTargetState;
#else
typedef struct FGL_PipelineStatusTag
{
	FG_BOOL isNotEmptyPF;			// per-fragment
	FG_BOOL isNotEmptyPS;		// pixel shader
	FG_BOOL isNotEmptyRA;		// raster engine
	FG_BOOL isNotEmptyTSE;		// triangle setup engine
	FG_BOOL isNotEmptyPE;		// primitive engine
	FG_BOOL isNotEmptyVS;		// vertex shader
	FG_BOOL isNotEmptyVC;		// vertex cache
	FG_BOOL isNotEmptyHI2VS;	// FIFO between host interface and vertex shader
	FG_BOOL isNotEmptyHI; 		// host interface
	FG_BOOL isNotEmptyHOSTFIFO;	// host-fifo
} FGL_PipelineStatus;

//typedef struct FGL_PipelineTargetStateTag
//{
//	FG_BOOL isNotEmptyPF;		// per-fragment
//	FG_BOOL isNotEmptyPS;		// pixel shader
//	FG_BOOL isNotEmptyRA;		// raster engine
//	FG_BOOL isNotEmptyTSE;		// triangle setup engine
//	FG_BOOL isNotEmptyPE;		// primitive engine
//	FG_BOOL isNotEmptyVS;		// vertex shader
//	FG_BOOL isNotEmptyVC;		// vertex cache
//	FG_BOOL isNotEmptyHI2VS;	// FIFO between host interface and vertex shader
//	FG_BOOL isNotEmptyHI; 		// host interface
//	FG_BOOL isNotEmptyHOSTFIFO;	// host-fifo
//} FGL_PipelineTargetState;
#endif

// Host Interface Data Structure

typedef struct FGL_HInterfaceTag
{
	FGL_BOOL 			enableVtxBuffer;
	FGL_IndexDataType 	idxType;
	FGL_BOOL 			enableAutoInc; // auto increment
	FGL_BOOL 			enableVtxCache;
	unsigned char 		numVSOut;
} FGL_HInterface;

typedef struct FGL_AttributeTag
{
	unsigned char 		numComp;
	FGL_AttribCompOrder srcX;
	FGL_AttribCompOrder srcY;
	FGL_AttribCompOrder srcZ;
	FGL_AttribCompOrder srcW;
	FGL_AttribDataType 	type;
	FGL_BOOL 			bEndFlag;
} FGL_Attribute;

typedef struct FGL_VtxBufAttribTag
{
	unsigned char 	stride;
	unsigned int 	num;
	unsigned int 	addr;

} FGL_VtxBufAttrib;

// Primitive Engine Data Structure

typedef struct FGL_VertexTag
{
	FGL_Primitive 	prim;
	FGL_BOOL 	enablePointSize;		
	unsigned char numVSOut;		// excluding position, the number of output of VS
	FGL_Shading 	shadeModel;
	unsigned char	colorAttribIdx;	// this value is meaningful only when shadeModel is FGL_SHADING_FLAT
} FGL_Vertex;

// Vertex/Pixel shader data structure

// Shader Program Header Structure
typedef struct FGL_ShaderHeaderTag
{
	unsigned int	Magic;
	unsigned int	Version;
	unsigned int	HeaderSize;
	unsigned int	InTableSize;
	unsigned int	OutTableSize;
	unsigned int	SamTableSize;
	unsigned int	InstructSize;
	unsigned int	ConstFloatSize;
	unsigned int	ConstIntSize;
	unsigned int	ConstBoolSize;
	unsigned int	reserved[6]; 
} FGL_ShaderHeader, *pFGL_ShaderHeader;


typedef struct FGL_ShaderAttribTable_TAG
{
	FGL_BOOL		validTableInfo;
	unsigned int	outAttribTableSize;
	unsigned int	inAttribTableSize;
	unsigned int	vsOutAttribTable[12];
	unsigned int	psInAttribTable[12];
} FGL_ShaderAttribTable, *pFGL_ShaderAttribTable;


// Texture Units Data Structure


typedef struct FGL_TexUnitParamsTag
{
    FGL_TexType 		eType;
    FGL_CKeySel 		eColorkey;
    FG_BOOL 			bUseExpansion; // duplication or 0 expansion
    FGL_PaletteFormat   ePaletteFormat;
    FGL_TexelFormat 	eFormat;
    FGL_TexWrapMode		eUMode;
    FGL_TexWrapMode		eVMode;
//    FGL_TexWrapMode		ePMode;
    FG_BOOL				bIsNonparametric;
    FG_BOOL				bUseMagFilter;
    FG_BOOL				bUseMinFilter;
    FGL_MipMapFilter 	eMipMapFilter;
    unsigned int 		uUSize;
    unsigned int 		uVSize;
    unsigned int 		uPSize;
} FGL_TexUnitParams;


typedef struct FGL_TexStatusParamsTag
{
	FGL_TexType		eType;
	FGL_CKeySel		eColorKey;
	FG_BOOL			bUseExpansion; // duplication or 0 expansion
	FGL_PaletteFormat   ePaletteFormat;
	FGL_TexelFormat 	eFormat;
	FGL_TexWrapMode		eUMode;
	FGL_TexWrapMode		eVMode;
	FG_BOOL				bIsNonparametric;
	FG_BOOL				bUseMagFilter;
	FG_BOOL				bUseMinFilter;
	FGL_MipMapFilter 	eMipMapFilter;
} FGL_TexStatusParams;


typedef struct FGL_TexCKeyTag	// color key
{
	unsigned char r;
	unsigned char g;
	unsigned char b;
} FGL_TexCKey;


typedef struct FGL_VtxTexStatusRegTag // vertex texture
{	
	FGL_TexWrapMode uMode;
	FGL_TexWrapMode vMode;
	FGL_TexSize 	uSize;
	FGL_TexSize 	vSize;
} FGL_VtxTexStatusReg;

// Per-fragemtn Unit Data Structure

typedef struct FGL_StencilParamTag 
{
	FGL_Face 			face;
	FGL_StencilAct 		zpass;
	FGL_StencilAct 		zfail;
	FGL_StencilAct 		sfail;
	unsigned int 		mask; 
	unsigned int 		ref;
	FGL_CompareFunc 	mode;
} FGL_StencilParam, *pFGL_StencilParam;

typedef struct FGL_BlendParamTag 
{
	unsigned int 	constColor;
	FGL_BlendEqua 	colorEqua;
	FGL_BlendEqua 	alphaEqua;
	FGL_BlendFunc 	dstAlpha; 
	FGL_BlendFunc 	dstColor;
	FGL_BlendFunc 	srcAlpha; 
	FGL_BlendFunc 	srcColor;
} FGL_BlendParam, *pFGL_BlendParam;


typedef struct FGL_FBCtrlParamTag 
{
	FGL_BOOL        opaqueAlpha; 
	unsigned int    thresholdAlpha;
	unsigned int    constAlpha; 
	FGL_BOOL	    dither;
	FGL_PixelFormat format;
} FGL_FBCtrlParam, *pFGL_FBCtrlParam;


/****************************************************************************
 *  EXPORT FUNCTIONS
 ****************************************************************************/

/***************************************************************************** 
 * 
 *  Global SFRs Register-level API
 * 
 *****************************************************************************/
FGL_Error fglGetPipelineStatus(FGL_PipelineStatus *status );

FGL_Error fglFlush(unsigned int pipelineFlags);

FGL_Error fglClearCache(unsigned int clearFlags);

//FGL_Error fglReset(FGL_ResetFlags resetFlags);

//FGL_Error fglSetDMAParams( 
//					FGL_DMAPriority 	policy, 
//					FGL_DMAAccessOrder 	order
//				);

FGL_Error fglSoftReset(void);

FGL_Error fglGetVersion(unsigned int* ver);

FGL_Error fglGetInterrupt(FG_BOOL* isGenInterrupt);

FGL_Error fglPendInterrupt(void);

FGL_Error fglEnableInterrupt(void);

FGL_Error fglDisableInterrupt(void);

FGL_Error fglSetInterruptBlock(unsigned int pipeMask);

FGL_Error fglSetInterruptState(FGL_PipelineStatus status);

FGL_Error fglGetInterruptState(FGL_PipelineStatus* status);

/***************************************************************************** 
 * 
 *  Host Interface Register-level API
 * 
 *****************************************************************************/
FGL_Error fglGetNumEmptyFIFOSlots ( unsigned int *pNumSlots );

FGL_Error fglSendToFIFO ( unsigned int bytes, void *buffer );


FGL_Error fglDrawNonIndexArrays(
				int numAttribs,
				FGL_Attribute *pAttrib,
				int numVertices,
				void **ppData
			);


FGL_Error fglSetHInterface( FGL_HInterface *pHI );

FGL_Error fglSetIndexOffset( unsigned int offset );

FGL_Error fglSetVtxBufferAddr( unsigned int addr );

FGL_Error fglSendToVtxBuffer ( unsigned int data );

FGL_Error fglSetAttribute ( 
					unsigned char 	attribIdx, 
					FGL_Attribute 	*pAttribInfo
				);

FGL_Error fglSetVtxBufAttrib ( 
						unsigned char 		attribIdx, 
					 	FGL_VtxBufAttrib 	*pAttribInfo
				   );


/***************************************************************************** 
 * 
 *  Vertex Shader Register-level API
 * 
 *****************************************************************************/
FGL_Error fglVSSetIgnorePCEnd ( FGL_BOOL enable );
    				 
FGL_Error fglVSSetPCRange ( 
            					unsigned int start, 
            					unsigned int end
            			  );

FGL_Error fglVSSetAttribNum ( 
            						//unsigned int outAttribNum, 
            						unsigned int inAttribNum
            				);

FGL_Error fglMakeShaderAttribTable (
            							const unsigned int *pVertexShader, 
            							const unsigned int *pPixelShader,
            							pFGL_ShaderAttribTable attribTable 
            					   );

FGL_Error fglRemapVShaderOutAttrib (
        								pFGL_ShaderAttribTable pShaderAttribTable
        						   );

FGL_Error fglSetVShaderAttribTable (
            							FGL_AttribTableIdx idx,
            							unsigned int value
            					   );
            					   
            					   
/***************************************************************************** 
 * 
 *  Primitive Engine Register-level API
 * 
 *****************************************************************************/
FGL_Error fglSetVertex ( FGL_Vertex *pVtx );

FGL_Error fglSetViewportParams (
						FGL_BOOL 	bYFlip, 
						float 		x0, 
						float 		y0, 
						float 		px, 
						float 		py, 
						float 		H
				  );

FGL_Error fglSetDepthRange ( float n, float f );


/***************************************************************************** 
 * 
 *  Raster Engine Register-level API
 * 
 *****************************************************************************/
FGL_Error fglSetPixelSamplePos ( FGL_Sample samp );

FGL_Error fglEnableDepthOffset ( FG_BOOL enable );

FGL_Error fglSetDepthOffsetParam ( 
							FGL_DepthOffsetParam 	param, 
							unsigned int 			value
					   );

FGL_Error fglSetFaceCullControl ( 
							FG_BOOL 		enable, 
							FG_BOOL		 	bCW, 
							FGL_Face 		face
					  );

FGL_Error fglSetYClip ( unsigned int ymin, unsigned int ymax );

FGL_Error fglSetLODControl ( unsigned int ctl );

FGL_Error fglSetLODRegister (
					FGL_LodCoeff lodCon0,
					FGL_LodCoeff lodCon1,
					FGL_LodCoeff lodCon2,
					FGL_LodCoeff lodCon3,
					FGL_LodCoeff lodCon4,
					FGL_LodCoeff lodCon5,
					FGL_LodCoeff lodCon6,
					FGL_LodCoeff lodCon7
				);

FGL_Error fglSetXClip( unsigned int xmin, unsigned int xmax );

FGL_Error fglSetPointWidth(float pWidth);

FGL_Error fglSetMinimumPointWidth(float pWidthMin);

FGL_Error fglSetMaximumPointWidth(float pWidthMax);

FGL_Error fglSetCoordReplace(unsigned int coordReplaceNum);

FGL_Error fglSetLineWidth(float lWidth);

/***************************************************************************** 
 * 
 *  Pixel Shader Register-level API
 * 
 *****************************************************************************/
FGL_Error fglLoadVShader ( const unsigned int *pShaderCode );

FGL_Error fglLoadPShader ( const unsigned int *pShaderCode );

FGL_Error fglPSSetPCRange ( unsigned int start, unsigned int end );

FGL_Error fglPSSetIgnorePCEnd ( FGL_BOOL enable );

FGL_Error fglPSSetAttributeNum ( unsigned int attributeNum );

FGL_Error fglPSGetInBufferStatus ( unsigned int *ready );


/***************************************************************************** 
 * 
 *  Texture Units Register-level API
 * 
 *****************************************************************************/
FGL_Error fglSetTexUnitParams ( unsigned int unit, FGL_TexUnitParams *params );

FGL_Error fglSetTexStatusParams(unsigned int unit, FGL_TexStatusParams *params);

FGL_Error fglSetTexUSize(unsigned int unit, unsigned int uSize);

FGL_Error fglSetTexVSize(unsigned int unit, unsigned int vSize);

FGL_Error fglSetTexPSize(unsigned int unit, unsigned int pSize);

FGL_Error fglCalculateMipmapOffset(
					unsigned int unit,
					unsigned int uSize,
					unsigned int vSize
		);

FGL_Error fglSetTexMipmapLevel (
						unsigned int 	unit, 
						FGL_MipmapLevel level, 
						unsigned int 	value 
					 );

FGL_Error fglSetTexBaseAddr( unsigned int unit, unsigned int addr );

FGL_Error fglSetTexColorKey( unsigned int unit, FGL_TexCKey ckey ); // CK 0 or 1

FGL_Error fglSetTexColorKeyYUV( unsigned char g, unsigned char b );

FGL_Error fglSetTexColorKeyMask( unsigned char bitsToMask );

FGL_Error fglSetTexPaletteAddr( unsigned int addr );

FGL_Error fglSetTexPaletteEntry( unsigned int entry );

FGL_Error fglSetVtxTexUnitParams( unsigned int unit, FGL_VtxTexStatusReg *vts );

FGL_Error fglSetVtxTexBaseAddr ( unsigned int unit, unsigned int addr );


/***************************************************************************** 
 * 
 *  Per-fragment Unit Register-level API 
 * 
 *****************************************************************************/
FGL_Error fglEnablePerFragUnit ( FGL_PerFragUnit unit, FGL_BOOL enable );

FGL_Error fglSetScissorParams ( 
						unsigned int xMax, 
						unsigned int xMin,
   						unsigned int yMax, 
   						unsigned int yMin
   					);

FGL_Error fglSetAlphaParams ( unsigned int refAlpha, FGL_CompareFunc mode );

FGL_Error fglSetStencilParams (pFGL_StencilParam stencilParam );

FGL_Error fglSetDepthParams ( FGL_CompareFunc mode );

FGL_Error fglSetBlendParams ( pFGL_BlendParam blendParam );

/* Just only use OpenGL|ES 1.1 */
FGL_Error fglSetLogicalOpParams ( FGL_LogicalOp colorOp );

FGL_Error fglSetColorBufWriteMask(
					FGL_BOOL r,
					FGL_BOOL g,
					FGL_BOOL b,
					FGL_BOOL a
				);

#if TARGET_FIMG_VERSION == _FIMG3DSE_VER_1_2_1
    FGL_Error fglSetStencilBufWriteMask( FGL_Face face, unsigned int mask );
#endif

FGL_Error fglSetZBufWriteMask ( FGL_BOOL enable );

FGL_Error fglSetFrameBufParams ( pFGL_FBCtrlParam fbctrlParam );

FGL_Error fglSetZBufBaseAddr ( unsigned int addr );

FGL_Error fglSetColorBufBaseAddr ( unsigned int addr );

FGL_Error fglSetFrameBufWidth ( unsigned int width );



#if defined __cplusplus
}
#endif

#endif	/* __FIMG_H__ */