fgl.h

6410BSP3

    FGL_TEX_SIZE_512P,
    FGL_TEX_SIZE_1024P,
    FGL_TEX_SIZE_2048P
} FGL_TexSize;

typedef enum FGL_MipmapLevelTag {
    FGL_MIPMAP_MIN_LEVEL,
    FGL_MIPMAP_MAX_LEVEL
} FGL_MipmapLevel;

// Per-fragment Unit
typedef enum FGL_PerFragUnitTag
{
    FGL_PF_SCISSOR        = SET_BIT(0),
    FGL_PF_ALPHA        = SET_BIT(1),
    FGL_PF_STENCIL        = SET_BIT(2),
    FGL_PF_DEPTH        = SET_BIT(3),
    FGL_PF_BLENDING        = SET_BIT(4),
    FGL_PF_LOGICALOP    = SET_BIT(5)
} FGL_PerFragUnit;

typedef enum FGL_CompareFuncTag
{
    FGL_COMP_NEVER,
    FGL_COMP_ALWAYS,
    FGL_COMP_LESS,
    FGL_COMP_LEQUAL,
    FGL_COMP_EQUAL,
    FGL_COMP_GREATER,
    FGL_COMP_GEQUAL,
    FGL_COMP_NOTEQUAL
} FGL_CompareFunc;

typedef enum FGL_StencilActTag
{
    FGL_ACT_KEEP,
    FGL_ACT_ZERO,
    FGL_ACT_REPLACE,
    FGL_ACT_INCR,
    FGL_ACT_DECR,
    FGL_ACT_INVERT,
    FGL_ACT_INCRWRAP,
    FGL_ACT_DECRWRAP

} FGL_StencilAct;

typedef enum FGL_BlendFuncTag
{                                       /*     source      destination  */
    FGL_BLEND_ZERO,                     /*     ok          ok(default) */
    FGL_BLEND_ONE,                      /*     ok(default) ok */
    FGL_BLEND_SRC_COLOR,                /*     ok          ok */
    FGL_BLEND_ONE_MINUS_SRC_COLOR,      /*     ok          ok */
    FGL_BLEND_DST_COLOR,                /*     ok          ok */
    FGL_BLEND_ONE_MINUS_DST_COLOR,      /*     ok          ok */
    FGL_BLEND_SRC_ALPHA,                /*     ok          ok */
    FGL_BLEND_ONE_MINUS_SRC_ALPHA,      /*     ok          ok */
    FGL_BLEND_DST_ALPHA,                /*     ok          ok */
    FGL_BLEND_ONE_MINUS_DST_ALPHA,      /*     ok          ok */
    FGL_BLEND_CONSTANT_COLOR,           /*     ok          ok */
    FGL_BLEND_ONE_MINUS_CONSTANT_COLOR, /*     ok          ok */
    FGL_BLEND_CONSTANT_ALPHA,           /*     ok          ok */
    FGL_BLEND_ONE_MINUS_CONSTANT_ALPHA, /*     ok          ok */
    FGL_BLEND_SRC_ALPHA_SATURATE        /*     ok          n/a */
} FGL_BlendFunc;

typedef enum FGL_BlendEquaTag
{
    FGL_EQ_ADD,
    FGL_EQ_SUBTRACT,
    FGL_EQ_REV_SUBTRACT,
    FGL_EQ_MIN,
    FGL_EQ_MAX
} FGL_BlendEqua;

typedef enum FGL_LogicalOpTag
{
    FGL_OP_CLEAR,
    FGL_OP_AND,
    FGL_OP_AND_REVERSE,
    FGL_OP_COPY,
    FGL_OP_AND_INVERTED,
    FGL_OP_NOOP,
    FGL_OP_XOR,
    FGL_OP_OR,
    FGL_OP_NOR,
    FGL_OP_EQUIV,
    FGL_OP_INVERT,
    FGL_OP_OR_REVERSE,
    FGL_OP_COPY_INVERTED,
    FGL_OP_OR_INVERTED,
    FGL_OP_NAND,
    FGL_OP_SET
} FGL_LogicalOp;

typedef enum FGL_PixelFormatTag
{
    FGL_PIXEL_RGB555,
    FGL_PIXEL_RGB565,
    FGL_PIXEL_ARGB4444,
    FGL_PIXEL_ARGB1555,
    FGL_PIXEL_ARGB0888,
    FGL_PIXEL_ARGB8888
} FGL_PixelFormat;

// Memory Access Arbiter
typedef enum FGL_DMAPriorityTag
{
    FGL_DMA_FIXED,
    FGL_DMA_ROTATING,
    FGL_DMA_PARTIALLY_FIXED
} FGL_DMAPriority;

typedef enum FGL_DMAAccessOrderTag
{
    FGL_ORDER_0123,
    FGL_ORDER_1230,
    FGL_ORDER_2301,
    FGL_ORDER_3012
} FGL_DMAAccessOrder;
 
/****************************************************************************
 *  Data structures
 ****************************************************************************/

// global registers (Chapter 0)

#if 0
typedef struct FGL_PipelineStatusTag
{
    FG_BOOL isEmptyPF1;            // per-fragment #2
    FG_BOOL isEmptyPF0;            // per-fragment #1
    FG_BOOL isEmptyPS1;            // pixel shader #2
    FG_BOOL isEmptyPS0;            // pixel shader #1
    FG_BOOL isEmptyRA;            // raster engine
    FG_BOOL isEmptyTSE;            // triangle setup engine
    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;
#if TARGET_FIMG_VERSION == _FIMG3DSE_VER_2_0
    FGL_AddrMode        addrMode;
#endif
    
} FGL_Attribute;

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

} FGL_VtxBufAttrib;

#if TARGET_FIMG_VERSION == _FIMG3DSE_VER_2_0
typedef struct FGL_HIInstOptionTag
{
    unsigned int pipeMask;
    FG_BOOL wait;
    FG_BOOL interrupt;    
} FGL_InstOption;
#endif

// 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;

typedef struct FGL_VertexCtxTag
{
    FGL_Primitive     prim;
    FGL_BOOL         enablePointSize;        

    // excluding position, the number of output of VS
    unsigned char     numVSOut;
    //ith lsb is set if ith varying needs flat interpolation
    unsigned int    varyingInterpolation;
} FGL_VertexCtx;


// Vertex/Pixel shader data structure
typedef enum FGL_ExecuteModeTag
{
    FGL_HOST_ACCESS_MODE = 0,
    FGL_PS_EXECUTE_MODE
} FGL_ExecuteMode;

// 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_StencilTag 
{
    FGL_StencilAct         zpass;
    FGL_StencilAct         zfail;
    FGL_StencilAct         sfail;
    unsigned int         mask; 
    unsigned int         ref;
    FGL_CompareFunc     mode;
} FGL_Stencil, *pFGL_Stencil;

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_BlendTag 
{
    FGL_BlendEqua     colorEqua;
    FGL_BlendEqua     alphaEqua;
    FGL_BlendFunc     dstAlpha; 
    FGL_BlendFunc     dstColor;
    FGL_BlendFunc     srcAlpha; 
    FGL_BlendFunc     srcColor;
} FGL_Blend, *pFGL_Blend;


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);