fgl.h

SMDK6410 BSP 测试程序,里面有各外设资源程序。

    } bit;
    unsigned int word;
};

enum { CENTER, LEFTTOP };
enum { BACKFACE, FRONTFACE, FRONTBACK = 3 };
enum { LOD = 1, DDX = 2, DDY = 4 };

// ----------------------------------------------------------------------
// Texture Units Data Structure
// ----------------------------------------------------------------------

// Need a test for struct padding
#if 1

struct texture_info {
	fglenum		textype;
	fglenum	    ckey;
	bool		use_expansion;
	bool        rgba_order;
	fglenum     palfmt;
	fglenum 	texmfmt;
	fglenum	    umode;
	fglenum	    vmode;
	fglenum	    wmode;
	bool		non_parametric;
	bool		use_magfilter;
	bool		use_minfilter;
	fglenum     mipmap_filter;
	
	uint32      usize;
	uint32      vsize;
	uint32      psize;
	uint32      address;
};

#else

struct texture_info {
	fglenum		textype;
	fglenum	    ckey;
	fglenum     palfmt;
	fglenum 	texmfmt;
	fglenum	    umode;
	fglenum	    vmode;
	fglenum	    wmode;
	fglenum     mipmap_filter;
	
	uint32      usize;
	uint32      vsize;
	uint32      psize;
	uint32      address;
	
	bool		use_expansion;
	bool        rgba_order;
	bool		non_parametric;
	bool		use_magfilter;
	bool		use_minfilter;
};

#endif

struct vtxtex_info {	
	fglenum     umode;
	fglenum     vmode;
	uint32   	usize;
	uint32  	vsize;
	uint32      base;
};

/* Texture type */
enum { TEX_2D = 1, TEX_CUBE, TEX_3D };
/* Texel format */
enum {
	TFMT_ARGB1555,
	TFMT_RGB565,
	TFMT_ARGB4444,
	TFMT_DEPTH24,
	TFMT_IA88,
	TFMT_I8,
	TFMT_ARGB8888,
	TFMT_1BPP,
	TFMT_2BPP,
	TFMT_4BPP,
	TFMT_8BPP,
	TFMT_S3TC,
	TFMT_Y1VY0U,
	TFMT_VY1UY0,
	TFMT_Y1UY0V,
	TFMT_UY1VY0
};
/* Palette format */
enum { PAL_ARGB1555, PAL_RGB565, PAL_ARGB4444, PAL_ARGB8888 };
/* Texture wrap mode */
enum { TWM_REPEAT, TWM_FLIP, TWM_CLAMP };
enum { CKEY0 = 0, CKEY1 = 1, CKEY2 = 3 };
/* Texture filter */
enum { TFLR_NONE, TF_NEAREST, TF_LINEAR };


// ----------------------------------------------------------------------
// Per-fragment Unit Data Structure
// ----------------------------------------------------------------------

struct stencil_info {
	fglenum         face;
	fglenum 		zpass;
	fglenum 		zfail;
	fglenum 		sfail;
	uint32 		    mask; 
	uint32 		    ref;
	fglenum 	    func;
};

struct blend_info {
	uint32 	       color;
	fglenum 	   cequa;
	fglenum 	   aequa;
	fglenum 	   dalpha; 
	fglenum 	   dcolor;
	fglenum 	   salpha; 
	fglenum 	   scolor;
};

struct fbctrl_info {
	uint32         threshold;
	uint32         alpha; 
	fglenum        format;
	bool           opaque; 
	bool	       dither;
};

/* Comparison function */
enum { CF_NEVER, CF_ALWAYS, CF_LESS, CF_LEQUAL, CF_EQUAL, CF_GREATER, CF_GEQUAL, CF_NOTEQUAL };
/* Stencil operation function */
enum { SOP_KEEP, SOP_ZERO, SOP_REPLACE, SOP_INCR, SOP_DECR, SOP_INVERT, SOP_INCRWRAP, SOP_DECRWRAP };
/* Blend equation function */
enum { BEQ_ADD, BEQ_SUBTRACT, BEQ_REV_SUBTRACT, BEQ_MIN, BEQ_MAX };
/* Color buffer pixel format*/
enum { FBF_RGB555, FBF_RGB565, FBF_ARGB4444, FBF_ARGB1555, FBF_ARGB0888, FBF_ARGB8888 };
/* Blend function */
enum {                               /*     source      destination  */
    	BF_ZERO,                     /*     ok          ok(default) */
    	BF_ONE,                      /*     ok(default) ok */
    	BF_SRC_COLOR,                /*     ok          ok */
    	BF_ONE_MINUS_SRC_COLOR,      /*     ok          ok */
    	BF_DST_COLOR,                /*     ok          ok */
    	BF_ONE_MINUS_DST_COLOR,      /*     ok          ok */
    	BF_SRC_ALPHA,                /*     ok          ok */
    	BF_ONE_MINUS_SRC_ALPHA,      /*     ok          ok */
    	BF_DST_ALPHA,                /*     ok          ok */
    	BF_ONE_MINUS_DST_ALPHA,      /*     ok          ok */
    	BF_CONSTANT_COLOR,           /*     ok          ok */
    	BF_ONE_MINUS_CONSTANT_COLOR, /*     ok          ok */
    	BF_CONSTANT_ALPHA,           /*     ok          ok */
    	BF_ONE_MINUS_CONSTANT_ALPHA, /*     ok          ok */
    	BF_SRC_ALPHA_SATURATE        /*     ok          n/a */
};
/* Logic op function */
enum { LOP_CLEAR, LOP_AND,  LOP_AND_REVERSE, LOP_COPY,  LOP_AND_INVERTED, LOP_NOOP,
	   LOP_XOR,   LOP_OR,   LOP_NOR,         LOP_EQUIV, LOP_INVERT,       LOP_OR_REVERSE,
	   LOP_COPY_INVERTED,   LOP_OR_INVERTED, LOP_NAND,  LOP_SET };


// ----------------------------------------------------------------------
// Shader Data Structure
// ----------------------------------------------------------------------

enum { ACCSSIBLE, EXECUTE };

struct shader_hdr
{
	uint32	    magic;
	uint32	    version;
	uint32	    header;
	uint32      in_tbl;
	uint32	    out_tbl;
	uint32	    sampler;
	uint32	    instruct;
	uint32	    const_float;
	uint32	    const_int;
	uint32	    const_bool;
	uint32	    reserved[6]; 
};

struct shader_bin_hdr
{
    uint32      magic;
    uint32      compiler;
    uint32      header;
    uint32      hwver;
	uint32	    instruct;
	uint32	    const_float;
	uint32	    const_int;
	uint32	    const_bool;
    uint32      dcl_btype_tbl[4];
    uint32      dcl_array_tbl[4];
    uint32      dcl_string_tbl;
    uint32      body;
};

// ----------------------------------------------------------------------
// Control Register-level API
// ----------------------------------------------------------------------
FGLAPI fgl_pipeline_status  ( uint32 * flag );
FGLAPI fgl_pipeline_isempty ( const uint32 flag );
FGLAPI fgl_flush_cache      ( const uint32 flag );
FGLAPI fgl_soft_reset       ( void );
FGLAPI fgl_version          ( uint32 * major, uint32 * minor );
FGLAPI fgl_clear_pending_int ( void );
FGLAPI fgl_get_pending_int   ( uint32 * state );
FGLAPI fgl_enable_int        ( void );
FGLAPI fgl_disable_int       ( void );
FGLAPI fgl_interrupt_mask    ( const uint32 flag ); 
FGLAPI fgl_interrupt_target  ( const uint32 flag ); 
FGLAPI fgl_interrupt_status  ( uint32 * status ); 


// ----------------------------------------------------------------------
// Host Interface Register-level API
// ----------------------------------------------------------------------
FGLAPI fgl_get_empty_slots  ( uint32 * slots );
FGLAPI fgl_transfer_fifo    ( void * src, uint32 size );
FGLAPI fgl_host_interface   ( void * hostinfo );
FGLAPI fgl_index_offset     ( const uint32 offset );
FGLAPI fgl_attribute        ( const uint32 count, void * attrib );
FGLAPI fgl_transfer_vtxbuf  ( void * vbdata, uint32 words );
FGLAPI fgl_vtxbuf_attribute ( const uint32 index, const uint32 stride, const uint32 count, const uint32 base );


// ----------------------------------------------------------------------
// Vertex Shader Register-level API
// ----------------------------------------------------------------------
FGLAPI fgl_vs_pc         ( const uint32 start, const uint32 end, const bool endignore );
FGLAPI fgl_vs_inattrib   ( const uint32 size );
int32  fgl_load_vs       ( const uint32 *program );
//uint32 fgl_write_cfmem   ( uint32 offset, uint32 size, float *data );

// ----------------------------------------------------------------------
// Fragment Shader Register-level API
// ----------------------------------------------------------------------
int32  fgl_execute_mode ( fglenum mode );
FGLAPI fgl_fs_pc        ( const uint32 start, const uint32 end, bool endignore );
FGLAPI fgl_fs_inattrib  ( const uint32 size );
int32  fgl_load_fs      ( const uint32 * program );

// ----------------------------------------------------------------------
// Orion Shader Compiler Register-level API
// ----------------------------------------------------------------------
int32  fgl_load_binary  ( void * binary );

            					   
// ----------------------------------------------------------------------
// Primitive Engine Register-level API
// ----------------------------------------------------------------------
FGLAPI fgl_vertex      ( void * context );
FGLAPI fgl_viewport    ( void * viewport );
FGLAPI fgl_depth_range ( const float near, const float far );	


// ----------------------------------------------------------------------
// Raster Engine Register-level API
// ----------------------------------------------------------------------
FGLAPI fgl_pixel_sampos ( const fglenum pos );
FGLAPI fgl_disable_doffset ( void );
FGLAPI fgl_doffset      ( const float factor, const float units);
FGLAPI fgl_doffset_r    ( const float rval );
FGLAPI fgl_disable_cullface ( void );
FGLAPI fgl_cull_face    ( const bool clockwise, const fglenum mode );
FGLAPI fgl_clip_plan    ( const uint32 left, const uint32 right, const uint32 bottom, const uint32 top );
FGLAPI fgl_lodctrl      ( const uint32 lod );
FGLAPI fgl_point_width  ( const float width );
FGLAPI fgl_psize_minmax ( const float min, const float max );
FGLAPI fgl_replace_coord( const uint32 coord );
FGLAPI fgl_line_width   ( const float width );


// ----------------------------------------------------------------------
// Texture Units Register-level API
// ----------------------------------------------------------------------
FGLAPI fgl_texture       ( const uint32 unit, void * texinfo );
FGLAPI fgl_mipmap_level  ( const uint32 uint, const uint32 min, const uint32 max); 
FGLAPI fgl_ckey          ( const uint32 unit, const uint32 red, const uint32 green, const uint32 blue );
FGLAPI fgl_ckey_yuv      ( const uint32 u /*cb*/, const uint32 v/*cr*/ );
FGLAPI fgl_ckey_mask     ( const uint32 mask );
FGLAPI fgl_load_palettet ( const void * palette, const fglenum format, const uint32 size );
FGLAPI fgl_vtxtex        ( const uint32 unit, void * vtxtex );


// ----------------------------------------------------------------------
// Per-fragment Unit Register-level API
// ----------------------------------------------------------------------
FGLAPI fgl_scissor         ( const int32 x, const int32 y, const int32 width, const int32 height );
FGLAPI fgl_disable_scissor ( void );
FGLAPI fgl_alpha           ( const fglenum func, const uint32 ref );
FGLAPI fgl_disable_alpha   ( void );
FGLAPI fgl_stencil         ( void * stencilinfo );
FGLAPI fgl_disable_stencil ( void );
FGLAPI fgl_depth           ( const fglenum func);
FGLAPI fgl_disable_depth   ( void );
FGLAPI fgl_blend           ( void * blendinfo );
FGLAPI fgl_disable_blend   ( void );                     
FGLAPI fgl_blend_color     ( const uint32 r, const uint32 g, const uint32 b, const uint32 a );
FGLAPI fgl_logicop         ( const fglenum opcode );
FGLAPI fgl_disable_logicop ( void );
FGLAPI fgl_color_mask      ( const bool r, const bool g, const bool b, const bool a );
FGLAPI fgl_stencil_depth_mask ( const uint32 fsmask, const uint32 bsmask, const bool dmask );
FGLAPI fgl_colorbuf        ( void * fbinfo );
FGLAPI fgl_depthbuf_base   ( const uint32 base );
FGLAPI fgl_colorbuf_base   ( const uint32 base );
FGLAPI fgl_framebuf_stride ( const uint32 stride );


#if defined __cplusplus
}
#endif

#endif	/* __FIMG_H__ */