3d.h

Centrality Atlas II development software

	disp_real	*aptr;

	disp_real	*tsptr[DISP_3D_MAX_TMUS];
	disp_real	*ttptr[DISP_3D_MAX_TMUS];
	disp_real	*trptr[DISP_3D_MAX_TMUS];
	disp_real	*tqptr[DISP_3D_MAX_TMUS];

	int		xstride;
	int		ystride;
	int		zstride;
	int		wstride;

	int		rstride;
	int		gstride;
	int		bstride;
	int		astride;

	int		tsstride[DISP_3D_MAX_TMUS];
	int		ttstride[DISP_3D_MAX_TMUS];
	int		trstride[DISP_3D_MAX_TMUS];
	int		tqstride[DISP_3D_MAX_TMUS];

	disp_real	*nxptr;
	disp_real	*nyptr;
	disp_real	*nzptr;

	int		nxstride;
	int		nystride;
	int		nzstride;

	uint32_t	reserved[6];
} disp_3d_data_ptrs_t;

__BEGIN_DECLS

typedef struct disp_3d_pipeline_ctl {
	disp_3d_prim_state_t	tri;
	disp_3d_prim_state_t	line;
	disp_3d_prim_state_t	points;

	void (*prim_begin)(void *context,
	    GLenum primitive, int nvertices, unsigned flags);
	void (*prim_end)(void *context);

	/* For drivers that can do lighting and/or view volume clipping */
	void (*send_vertices)(void *context, int nvertices);

	/* For drivers that can do view volume clipping, but not lighting */
	void (*send_lit_vertices)(void *context,
	    disp_3d_vertex_t *v, int nvertices);

	/* For drivers that take pre-lit, pre-clipped primitives */
	void (*draw_triangle)(void *context,
	    disp_3d_vertex_t *v1, disp_3d_vertex_t *v2, disp_3d_vertex_t *v3);
	void (*draw_line)(void *context,
	    disp_3d_vertex_t *v1, disp_3d_vertex_t *v2);
	void (*draw_points)(void *context, disp_3d_vertex_t *v, int npoints);

	/* Span function supporting OpenGL ES per-fragment operations */
	void (*draw_span)(void *context,
	    int x, int y, int count, disp_3d_span_params_t *params);

	disp_3d_data_ptrs_t	*data_ptrs;
	int			max_vertices;

	/* For drivers with direct access to array data via buffer objects */
	int (*draw_arrays)(void *context, GLenum prim, int first, int nvertices);
	int (*draw_elements)(void *context, GLenum,
	    unsigned nvertices, disp_bufobj_t *obj, unsigned datatype);
	int (*draw_elements_immed)(void *context, GLenum,
	    unsigned nvertices, const void *data, unsigned datatype);

	/* See DISP_3D_PCTL_FLAG_* */
	uint32_t		flags;

	uint32_t		reserved[3];
} disp_3d_pipeline_ctl_t;

typedef struct disp_rendercontext {
	unsigned		new_state;		/* See DISP_3D_STATE_* */
	unsigned		new_global_light_state;	/* See DISP_3D_LIGHT_STATE_* */
	unsigned		new_light_state;	/* Per-light bitmask */
	unsigned		new_tmu_state;		/* Per-tmu bitmask */

	unsigned		flags;			/* See DISP_3D_CTX_FLAG_* */

	unsigned		enabled_features;	/* Driver must check! */

	struct {
		GLboolean	alpha_test;
		GLboolean	blend;
		GLboolean	color_logic_op;
		GLboolean	color_material;
		GLboolean	cull_face;
		GLboolean	depth_test;
		GLboolean	fog;
		GLboolean	lighting;
		GLboolean	line_smooth;
		GLboolean	normalize;
		GLboolean	point_smooth;
		GLboolean	polygon_offset_fill;
		GLboolean	rescale_normal;
		GLboolean	scissor_test;
		GLboolean	stencil_test;
	} enabled;

	int		lights_on;

	struct light_state light[DISP_3D_NUM_LIGHTS];

	struct {
		struct {
			disp_real	r;
			disp_real	g;
			disp_real	b;
			disp_real	a;
		} ambient;
		GLboolean		twoside;
	} lightmodel;

	struct {
		struct {
			disp_real	r;
			disp_real	g;
			disp_real	b;
			disp_real	a;
		} ambient;
		struct {
			disp_real	r;
			disp_real	g;
			disp_real	b;
			disp_real	a;
		} diffuse;
		struct {
			disp_real	r;
			disp_real	g;
			disp_real	b;
			disp_real	a;
		} specular;
		struct {
			disp_real	r;
			disp_real	g;
			disp_real	b;
			disp_real	a;
		} emission;
		disp_real		shininess;
	} material;

	GLenum	frontface;
	GLenum	cullface;

	struct {
		/* Buffer clear values */
		disp_real	r;
		disp_real	g;
		disp_real	b;
		disp_real	a;
		disp_real	depth;
		GLint		stencil;
	} clear;

	struct {
		int		x1;
		int		x2;
		int		y1;
		int		y2;
	} cliprect;

	struct {
		disp_real	near;		
		disp_real	far;
		GLenum		func;
		GLboolean	mask;
	} depth;

	struct {
		GLenum		func;
		GLenum		fail;
		GLenum		zfail;
		GLenum		zpass;
		GLuint		testmask;
		GLuint		planemask;
		GLint		ref;
	} stencil;

	struct {
		int		x;
		int		y;
		int		width;
		int		height;
	} viewport;

	struct {
		disp_real	r;	
		disp_real	g;	
		disp_real	b;	
		disp_real	a;	
	} color;

	struct {
		GLboolean	r;
		GLboolean	g;
		GLboolean	b;
		GLboolean	a;
	} colormask;

	struct {
		GLenum		func;
		disp_real	ref;
	} alpha;

	struct {
		GLenum		sfactor;
		GLenum		dfactor;
	} blend;

	struct {
		GLenum		mode;
		disp_real	density;
		disp_real	start;
		disp_real	end;
		disp_real	r;
		disp_real	g;
		disp_real	b;
		disp_real	a;
	} fog;

	GLenum			rop;

	GLenum			shademodel;

	struct {
		disp_real	x;
		disp_real	y;
		disp_real	z;
	} normal;

	/* Space for matrix stacks */
	disp_real		model_matrix[DISP_3D_MODEL_MATRIX_ENTRIES][16];
	disp_real		proj_matrix[DISP_3D_PROJ_MATRIX_ENTRIES][16];

	disp_3d_matrix_flag	model_matrix_flags[DISP_3D_MODEL_MATRIX_ENTRIES];
	disp_3d_matrix_flag	proj_matrix_flags[DISP_3D_PROJ_MATRIX_ENTRIES];

	/* Indices into matrix stacks */
	int			model_matrix_stackptr;
	int			proj_matrix_stackptr;

	disp_real		point_size;
	disp_real		line_width;

	struct {
		disp_real	factor;
		disp_real	units;
	} polygon_offset;

	disp_tmu_state_t	tmu[DISP_3D_MAX_TMUS];
	int			enabled_tmus;
	int			complete_tmus;

	disp_texture_t		*textures[DISP_3D_MAX_TMUS];

	disp_3d_pipeline_ctl_t	pipeline_ctl;

	uint32_t		ddflags;	/* Driver debugging flags */

	uint32_t		line_stipple;	/* Only 16 bits used */

	struct {
		GLboolean	dither;
		GLboolean	fsaa;
		GLboolean	reserved[2];
	} enabled2;

	uint32_t		vtx_flags;
	uint32_t		reserved[28];
} disp_rendercontext_t;

typedef enum {
	DISP_3D_CAP_ACCEL =			0x00000001,	/* Driver has some form of 3D acceleration support */
	DISP_3D_CAP_INDEPENDANT_PM =		0x00000020	/* 3D engine can be independently power managed (i.e. not tied to 2D engine) */
} disp_3d_cap_flag;

typedef struct disp_3d_caps {
	disp_3d_cap_flag	flags;				/* See DISP_3D_CAP_* */
	int			fixed_point;
	int			max_vertices;
	const char		*extensions;
	unsigned		num_tmus;
	unsigned		max_line_width;
	unsigned		max_point_size;
	unsigned		max_line_width_aa;
	unsigned		max_point_size_aa;
	unsigned		reserved[1];
} disp_3d_caps_t;

typedef struct disp_draw_3dfuncs {
	void * (*init)(disp_adapter_t *adapter, const char *options);
	void (*fini)(void *handle);
	void (*module_info)(disp_adapter_t *adapter, disp_module_info_t *info);

	int (*query_caps)(void *handle, disp_3d_caps_t *caps);

	int (*query_buffer_config)(void *handle,
	    int index, disp_rend_buffer_config_t *config);

	void * (*create_context)(void *handle, disp_rendercontext_t *rctx,
	    disp_rend_context_params_t *params);
	void (*destroy_context)(void *context);

	void * (*create_target)(void *handle,
	    int cfg_index, int width, int height);
	void (*destroy_target)(void *handle, void *target);

	void (*create_texture)(void *context, disp_texture_t *tex);
	void (*destroy_texture)(void *context, disp_texture_t *tex);
	void (*set_tex_image)(void *context, disp_texture_t *tex,
	    int width, int height, int lod, unsigned format,
	    unsigned reqformat, int stride, const void *data, void *palette);
	void (*set_tex_image_copy)(void *context, disp_texture_t *tex,
	    disp_surface_t *src, int sxoff, int syoff, int width, int height,
	    int lod, unsigned reqformat);
	void (*update_tex_image)(void *context, disp_texture_t *tex,
	    int dxoff, int dyoff, int width, int height, int lod,
	    unsigned format, int stride, const void *data, void *palette);
	void (*update_tex_image_copy)(void *context, disp_texture_t *tex,
	    disp_surface_t *src, int sxoff, int syoff, int dxoff, int dyoff,
	    int width, int height, int lod);

	void (*read_image)(void *handle, int sxoff, int syoff,
	    int width, int height, unsigned dformat, int dstride,
	    disp_surface_t * src, void *dst, int y_order_ascending);

	void (*flush)(void *context);
	void (*wait_idle)(void *context);

	void (*make_current)(void *context, void *target);

	void (*set_draw_surface)(void *context, disp_surface_t *surf);

	/* Notifies driver that span rendering is about to occur */
	int (*span_prepare)(void *context);

	GLbitfield (*clear)(void *context, GLbitfield buffer_mask);

	int (*update_state)(void *context);

	int (*set_power_mode)(disp_adapter_t *adapter, pm_power_mode_t mode);

	/* Buffer Objects (optional - may be NULL) */
	int (*bufobj_create)(void *context, disp_bufobj_t *obj);
	void (*bufobj_destroy)(void *context, disp_bufobj_t *obj);
	int (*bufobj_set_data)(void *context, disp_bufobj_t *obj,
	    uintptr_t offset, uintptr_t nbytes, const void *data, int realloc);
	int (*bufobj_set_datasource)(void *context, disp_bufobj_t *obj,
	    unsigned array, uintptr_t offset,
	    unsigned datatype, int stride, int n_elements);
	void (*bufobj_set_enabled)(void *context, unsigned array, int enabled);

	/* Display Lists - UNSUPPORTED */
	void * (*dlist_begin)(void *context);
	int (*dlist_end)(void *context);
	void (*dlist_execute)(void *context, void *dlist);
	void (*dlist_destroy)(void *context, void *dlist);

	/* Driver-specific extension support */
	int (*state_set_enabled)(void *context, GLenum cap, int enabled,
	    int active_tmu, int active_client_tmu, intptr_t reserved);
	void (*(*get_proc_addr)(void *context, const char *procname))();
	int (*query_tex_format)(void *context,
	    GLenum type, int *bpp, unsigned *tex_format);

	void (*reserved[5])(void);
} disp_draw_3dfuncs_t;

typedef int (*get_rendfuncs_t)(disp_adapter_t *adapter,
    disp_draw_3dfuncs_t *funcs, int tabsize);

/* Main draw driver entry points */
extern SOFT3D_API int devg_get_rendfuncs(disp_adapter_t *adapter,
    disp_draw_3dfuncs_t *funcs, int tabsize);

__END_DECLS

#endif /* _GRAPHICS_3D_H_INCLUDED */