fgl.h

6410BSP3

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

#if TARGET_FIMG_VERSION == _FIMG3DSE_VER_2_0
FGL_Error fglGetExeState(FGL_ExeState status);

FGL_Error fglSetNextStep(void);
#endif

/***************************************************************************** 
 * 
 *  Host Interface Register-level API
 * 
 *****************************************************************************/
#if TARGET_FIMG_VERSION < _FIMG3DSE_VER_2_0
FGL_Error fglGetNumEmptyFIFOSlots ( unsigned int *pNumSlots );

FGL_Error fglSendToFIFO ( unsigned int bytes, void *buffer );
FGL_Error _fglSendToFIFO32 ( unsigned int bytes, void *buffer, unsigned int dest );
#define fglSendToFIFO32( x, y )    _fglSendToFIFO32(x, y, FGHI_FIFO_ENTRY)

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

FGL_Error fglSetHInterface( FGL_HInterface *pHI );

FGL_Error fglSetIndexOffset( unsigned int offset );

#if TARGET_FIMG_VERSION < _FIMG3DSE_VER_2_0
FGL_Error fglSetVtxBufferAddr( unsigned int addr );

FGL_Error fglSendToVtxBuffer ( unsigned int data );
#endif

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

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

#if TARGET_FIMG_VERSION == _FIMG3DSE_VER_2_0                   
FGL_Error fglSetHIInstructions(
                    unsigned int    baseAddr,
                    FGL_AddrMode    addrMode,
                    unsigned int    instCount                        
                        );
                        
FGL_Error fglGetNextInstAddr(unsigned int *pNextAddr);
                        
FGL_Error fglGetRemainInstCount(unsigned int *pInstCount);

FGL_Error fglInstSFRAD(
                    FGL_InstOption instOption, unsigned int numSFRPairs, 
                    unsigned int addrSrc, FGL_AddrMode addrMode    
                        );
                        
FGL_Error fglInstSFRIM(
                    FGL_InstOption instOption, unsigned int addrDst, unsigned int SFRVal
                        );
                        
FGL_Error fglInstSFRAI(
                    FGL_InstOption instOption, unsigned int addrDst, unsigned int numSFR, 
                    unsigned int addrSrc, FGL_AddrMode addrMode
                        );
            
FGL_Error fglInstVBWR(
                    FGL_InstOption instOption, unsigned int addrDst, 
                    unsigned int numWord, unsigned int addrSrc, FGL_AddrMode addrMode
                        );
                        
FGL_Error fglInstNOP(FGL_InstOption instOption);

FGL_Error fglInstINDEX(
                    FGL_InstOption instOption, FGL_IndexDataType indexType,
                    unsigned int numIndices, unsigned int addrIndex, FGL_AddrMode addrMode
                        );
                        
FGL_Error fglInstINDEXAI(
                    FGL_InstOption instOption, unsigned int numIndices, unsigned int startIndex
                        );
                        
FGL_Error fglEXEControl(FG_BOOL interrupt, FG_BOOL wait);

FGL_Error fglSetVBSize(FGL_VBSizeMode VBSizeMode);

FGL_Error fglClearPreVC(void);

FGL_Error fglClearPostVC(void);

#endif

/***************************************************************************** 
 * 
 *  Vertex Shader Register-level API
 * 
 *****************************************************************************/
FGL_Error fglVSSetIgnorePCEnd ( FGL_BOOL enable );

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

FGL_Error fglVSSetPCRangeEXT ( 
                    unsigned int start, 
                    unsigned int end,
                    FGL_BOOL ignorePCEnd
                );

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 fglSetVertexCtx ( FGL_VertexCtx *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 fglSetDepthOffsetParamf ( 
                            FGL_DepthOffsetParam     param, 
                            float                   value
                       );

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 fglSetPSMode ( FGL_ExecuteMode mode );

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

FGL_Error fglPSSetPCRangeEXT ( unsigned int start,
                                unsigned int end,
                                FGL_BOOL ignorePCEnd );

FGL_Error fglPSSetIgnorePCEnd ( FGL_BOOL enable );

FGL_Error fglPSSetAttributeNum ( unsigned int attributeNum );

FGL_Error fglPSSetAttribNum ( unsigned int attributeNum );

FGL_Error fglPSGetInBufferStatus ( unsigned int *ready );

FGL_Error fglSetPSParams( unsigned int attrubNum,
                            unsigned int startPC,
                            unsigned int endPC,
                            FGL_BOOL ignorePCEnd );

/***************************************************************************** 
 * 
 *  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,
                    unsigned int *maxLev
        );

FGL_Error fglCalculateMipmapOffsetS3TC(
                    unsigned int unit,
                    unsigned int uSize,
                    unsigned int vSize,
                    unsigned int *maxLev
        );

FGL_Error fglCalculateMipmapOffsetYUV(
                    unsigned int unit,
                    unsigned int uSize,
                    unsigned int vSize,
                    unsigned int *maxLev
        );

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 fglSetScissor ( 
                        FGL_BOOL enable,
                        unsigned int xMax, 
                        unsigned int xMin,
                           unsigned int yMax, 
                           unsigned int yMin
                      );

FGL_Error fglSetAlphaParams ( unsigned int refAlpha, FGL_CompareFunc mode );

FGL_Error fglSetAlpha (
                FGL_BOOL enable,
                unsigned int refAlpha,
                FGL_CompareFunc mode
                );

FGL_Error fglSetStencilParams (pFGL_StencilParam stencilParam );

FGL_Error fglSetFrontStencil( FGL_BOOL enable, pFGL_Stencil stencilParam );

FGL_Error fglSetBackStencil( pFGL_Stencil stencilParam );

FGL_Error fglSetDepthParams ( FGL_CompareFunc mode );

FGL_Error fglSetDepth( FGL_BOOL enable,  FGL_CompareFunc mode );

FGL_Error fglSetBlendParams ( pFGL_BlendParam blendParam );

// Software workaround for bug ID 82 (v1.21), 32 (v1.51)
FGL_Error fglSetBlendParamsWorkAround ( pFGL_BlendParam blendParam );

FGL_Error fglSetBlend( FGL_BOOL enable, pFGL_Blend blendParam );

// Software workaround for bug ID 82 (v1.21), 32 (v1.51)
FGL_Error fglSetBlendWorkAround( FGL_BOOL enable, pFGL_Blend blendParam );

FGL_Error fglSetBlendColor ( unsigned int blendColor );

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

FGL_Error fglSetLogicalOp ( FGL_BOOL enable,
                            FGL_LogicalOp alphaOp,
                            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
    FGL_Error fglSetStencilBufWriteMask( FGL_Face face, unsigned int mask );
#endif

FGL_Error fglSetZBufWriteMask ( FGL_BOOL enable );

FGL_Error fglSetDepthStencilWriteMask ( 
                unsigned int     backStencilMask, 
                unsigned int     frontStencilMask,
                FGL_BOOL        bDepthBufferMask 
            );

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 TARGET_FIMG_VERSION == _FIMG3DSE_VER_2_0
/***************************************************************************** 
 * 
 *  Pre-Depth Test Unit Register-level API 
 * 
 *****************************************************************************/
FGL_Error fglSetPreStencilTest ( FGL_BOOL enable );
FGL_Error fglSetPreDepthTest ( FGL_BOOL enable );
FGL_Error fglSetPDTStencilParams (pFGL_StencilParam stencilParam );
FGL_Error fglSetPDTDepthParams ( FGL_CompareFunc mode );
FGL_Error fglSetPDTStencilBufWriteMask( FGL_Face face, unsigned int mask );
FGL_Error fglSetPDTZBufWriteMask ( FGL_BOOL enable );
FGL_Error fglSetPDTZBufBaseAddr ( unsigned int addr );
FGL_Error fglSetPDTFrameBufWidth ( unsigned int width );
#endif /* TARGET_FIMG_VERSION == _FIMG3DSE_VER_2_0 */

#if defined __cplusplus
}
#endif

#endif    /* __FIMG_H__ */