X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fauxiliary%2Fdraw%2Fdraw_private.h;h=ba93b09337753508e413aca2ca075a25d6a96265;hb=662a4d4a120cb0a07023f00e3c5e4a0809428a53;hp=2ef05cea37d37ad82d805050ffdac647b81af84c;hpb=4df3e76949e1ca7b29f844ad9a715b442396a024;p=mesa.git diff --git a/src/gallium/auxiliary/draw/draw_private.h b/src/gallium/auxiliary/draw/draw_private.h index 2ef05cea37d..ba93b093377 100644 --- a/src/gallium/auxiliary/draw/draw_private.h +++ b/src/gallium/auxiliary/draw/draw_private.h @@ -47,10 +47,19 @@ #include "tgsi/tgsi_scan.h" #ifdef HAVE_LLVM -#include +struct draw_llvm; +struct gallivm_state; #endif +/** Sum of frustum planes and user-defined planes */ +#define DRAW_TOTAL_CLIP_PLANES (6 + PIPE_MAX_CLIP_PLANES) + +/** + * The largest possible index of a vertex that can be fetched. + */ +#define DRAW_MAX_FETCH_IDX 0xffffffff + struct pipe_context; struct draw_vertex_shader; struct draw_context; @@ -58,19 +67,30 @@ struct draw_stage; struct vbuf_render; struct tgsi_exec_machine; struct tgsi_sampler; +struct draw_pt_front_end; +struct draw_assembler; +/** + * Represents the mapped vertex buffer. + */ +struct draw_vertex_buffer { + const void *map; + uint32_t size; +}; + /** * Basic vertex info. * Carry some useful information around with the vertices in the prim pipe. */ struct vertex_header { - unsigned clipmask:12; + unsigned clipmask:DRAW_TOTAL_CLIP_PLANES; unsigned edgeflag:1; - unsigned pad:3; + unsigned have_clipdist:1; unsigned vertex_id:16; float clip[4]; + float pre_clip_pos[4]; /* This will probably become float (*data)[4] soon: */ @@ -81,6 +101,9 @@ struct vertex_header { #define UNDEFINED_VERTEX_ID 0xffff +/* maximum number of shader variants we can cache */ +#define DRAW_MAX_SHADER_VARIANTS 128 + /** * Private context for the drawing module. */ @@ -111,6 +134,7 @@ struct draw_context float wide_point_threshold; /**< convert pnts to tris if larger than this */ float wide_line_threshold; /**< convert lines to tris if wider than this */ + boolean wide_point_sprites; /**< convert points to tris for sprite mode */ boolean line_stipple; /**< do line stipple? */ boolean point_sprite; /**< convert points to quads for sprites? */ @@ -127,20 +151,36 @@ struct draw_context /* Support prototype passthrough path: */ struct { + /* Current active frontend */ + struct draw_pt_front_end *frontend; + unsigned prim; + unsigned opt; /**< bitmask of PT_x flags */ + unsigned eltSize; /* saved eltSize for flushing */ + + boolean rebind_parameters; + struct { struct draw_pt_middle_end *fetch_emit; struct draw_pt_middle_end *fetch_shade_emit; struct draw_pt_middle_end *general; + struct draw_pt_middle_end *llvm; } middle; struct { - struct draw_pt_front_end *vcache; - struct draw_pt_front_end *varray; + struct draw_pt_front_end *vsplit; } front; struct pipe_vertex_buffer vertex_buffer[PIPE_MAX_ATTRIBS]; unsigned nr_vertex_buffers; + /* + * This is the largest legal index value for the current set of + * bound vertex buffers. Regardless of any other consideration, + * all vertex lookups need to be clamped to 0..max_index to + * prevent out-of-bound access. + */ + unsigned max_index; + struct pipe_vertex_element vertex_element[PIPE_MAX_ATTRIBS]; unsigned nr_vertex_elements; @@ -149,16 +189,24 @@ struct draw_context /** vertex element/index buffer (ex: glDrawElements) */ const void *elts; /** bytes per index (0, 1, 2 or 4) */ + unsigned eltSizeIB; unsigned eltSize; + unsigned eltMax; + int eltBias; unsigned min_index; unsigned max_index; /** vertex arrays */ - const void *vbuffer[PIPE_MAX_ATTRIBS]; + struct draw_vertex_buffer vbuffer[PIPE_MAX_ATTRIBS]; - /** constant buffer (for vertex/geometry shader) */ + /** constant buffers (for vertex/geometry shader) */ const void *vs_constants[PIPE_MAX_CONSTANT_BUFFERS]; + unsigned vs_constants_size[PIPE_MAX_CONSTANT_BUFFERS]; const void *gs_constants[PIPE_MAX_CONSTANT_BUFFERS]; + unsigned gs_constants_size[PIPE_MAX_CONSTANT_BUFFERS]; + + /* pointer to planes */ + float (*planes)[DRAW_TOTAL_CLIP_PLANES][4]; } user; boolean test_fse; /* enable FSE even though its not correct (eg for softpipe) */ @@ -166,13 +214,23 @@ struct draw_context } pt; struct { - boolean bypass_clipping; - boolean bypass_vs; + boolean bypass_clip_xy; + boolean bypass_clip_z; + boolean guard_band_xy; } driver; + boolean quads_always_flatshade_last; + boolean flushing; /**< debugging/sanity */ boolean suspend_flushing; /**< internally set */ - boolean bypass_clipping; /**< set if either api or driver bypass_clipping true */ + + /* Flags set if API requires clipping in these planes and the + * driver doesn't indicate that it can do it for us. + */ + boolean clip_xy; + boolean clip_z; + boolean clip_user; + boolean guard_band_xy; boolean force_passthrough; /**< never clip or shade */ @@ -188,31 +246,24 @@ struct draw_context /** Rasterizer CSOs without culling/stipple/etc */ void *rasterizer_no_cull[2][2]; - struct pipe_viewport_state viewport; + struct pipe_viewport_state viewports[PIPE_MAX_VIEWPORTS]; boolean identity_viewport; + /** Vertex shader state */ struct { struct draw_vertex_shader *vertex_shader; uint num_vs_outputs; /**< convenience, from vertex_shader */ uint position_output; uint edgeflag_output; + uint clipvertex_output; + uint clipdistance_output[2]; - /** TGSI program interpreter runtime state */ - struct tgsi_exec_machine *machine; - - uint num_samplers; - struct tgsi_sampler **samplers; - - /* Here's another one: - */ - struct aos_machine *aos_machine; - - - const void *aligned_constants[PIPE_MAX_CONSTANT_BUFFERS]; - - const void *aligned_constant_storage[PIPE_MAX_CONSTANT_BUFFERS]; - unsigned const_storage_size[PIPE_MAX_CONSTANT_BUFFERS]; + /** Fields for TGSI interpreter / execution */ + struct { + struct tgsi_exec_machine *machine; + struct tgsi_sampler *sampler; + } tgsi; struct translate *fetch; struct translate_cache *fetch_cache; @@ -220,46 +271,109 @@ struct draw_context struct translate_cache *emit_cache; } vs; + /** Geometry shader state */ struct { struct draw_geometry_shader *geometry_shader; uint num_gs_outputs; /**< convenience, from geometry_shader */ uint position_output; - /** TGSI program interpreter runtime state */ - struct tgsi_exec_machine *machine; + /** Fields for TGSI interpreter / execution */ + struct { + struct tgsi_exec_machine *machine; + + struct tgsi_sampler *sampler; + } tgsi; - uint num_samplers; - struct tgsi_sampler **samplers; } gs; + /** Fragment shader state */ + struct { + struct draw_fragment_shader *fragment_shader; + } fs; + + /** Stream output (vertex feedback) state */ + struct { + struct draw_so_target *targets[PIPE_MAX_SO_BUFFERS]; + uint num_targets; + } so; + /* Clip derived state: */ - float plane[12][4]; - unsigned nr_planes; + float plane[DRAW_TOTAL_CLIP_PLANES][4]; /* If a prim stage introduces new vertex attributes, they'll be stored here */ struct { - uint semantic_name; - uint semantic_index; - int slot; + uint num; + uint semantic_name[10]; + uint semantic_index[10]; + uint slot[10]; } extra_shader_outputs; - unsigned reduced_prim; - unsigned instance_id; + unsigned start_instance; + unsigned start_index; #ifdef HAVE_LLVM - LLVMExecutionEngineRef engine; - bool use_llvm; + struct draw_llvm *llvm; #endif + + /** Texture sampler and sampler view state. + * Note that we have arrays indexed by shader type. At this time + * we only handle vertex and geometry shaders in the draw module, but + * there may be more in the future (ex: hull and tessellation). + */ + struct pipe_sampler_view *sampler_views[PIPE_SHADER_TYPES][PIPE_MAX_SHADER_SAMPLER_VIEWS]; + unsigned num_sampler_views[PIPE_SHADER_TYPES]; + const struct pipe_sampler_state *samplers[PIPE_SHADER_TYPES][PIPE_MAX_SAMPLERS]; + unsigned num_samplers[PIPE_SHADER_TYPES]; + + struct pipe_query_data_pipeline_statistics statistics; + boolean collect_statistics; + + struct draw_assembler *ia; + void *driver_private; }; + +struct draw_fetch_info { + boolean linear; + unsigned start; + const unsigned *elts; + unsigned count; +}; + +struct draw_vertex_info { + struct vertex_header *verts; + unsigned vertex_size; + unsigned stride; + unsigned count; +}; + +/* these flags are set if the primitive is a segment of a larger one */ +#define DRAW_SPLIT_BEFORE 0x1 +#define DRAW_SPLIT_AFTER 0x2 + +struct draw_prim_info { + boolean linear; + unsigned start; + + const ushort *elts; + unsigned count; + + unsigned prim; + unsigned flags; + unsigned *primitive_lengths; + unsigned primitive_count; +}; + + /******************************************************************************* * Draw common initialization code */ boolean draw_init(struct draw_context *draw); +void draw_new_instance(struct draw_context *draw); /******************************************************************************* * Vertex shader code: @@ -267,27 +381,12 @@ boolean draw_init(struct draw_context *draw); boolean draw_vs_init( struct draw_context *draw ); void draw_vs_destroy( struct draw_context *draw ); -void draw_vs_set_viewport( struct draw_context *, - const struct pipe_viewport_state * ); - -void -draw_vs_set_constants(struct draw_context *, - unsigned slot, - const void *constants, - unsigned size); - - /******************************************************************************* * Geometry shading code: */ boolean draw_gs_init( struct draw_context *draw ); -void -draw_gs_set_constants(struct draw_context *, - unsigned slot, - const void *constants, - unsigned size); void draw_gs_destroy( struct draw_context *draw ); @@ -296,6 +395,18 @@ void draw_gs_destroy( struct draw_context *draw ); */ uint draw_current_shader_outputs(const struct draw_context *draw); uint draw_current_shader_position_output(const struct draw_context *draw); +uint draw_current_shader_viewport_index_output(const struct draw_context *draw); +uint draw_current_shader_clipvertex_output(const struct draw_context *draw); +uint draw_current_shader_clipdistance_output(const struct draw_context *draw, int index); +uint draw_current_shader_num_written_clipdistances(const struct draw_context *draw); +uint draw_current_shader_culldistance_output(const struct draw_context *draw, int index); +uint draw_current_shader_num_written_culldistances(const struct draw_context *draw); +int draw_alloc_extra_vertex_attrib(struct draw_context *draw, + uint semantic_name, uint semantic_index); +void draw_remove_extra_vertex_attribs(struct draw_context *draw); +boolean draw_current_shader_uses_viewport_index( + const struct draw_context *draw); + /******************************************************************************* * Vertex processing (was passthrough) code: @@ -303,6 +414,7 @@ uint draw_current_shader_position_output(const struct draw_context *draw); boolean draw_pt_init( struct draw_context *draw ); void draw_pt_destroy( struct draw_context *draw ); void draw_pt_reset_vertex_ids( struct draw_context *draw ); +void draw_pt_flush( struct draw_context *draw, unsigned flags ); /******************************************************************************* @@ -316,35 +428,24 @@ void draw_pipeline_destroy( struct draw_context *draw ); -/* We use the top few bits in the elts[] parameter to convey a little - * API information. This limits the number of vertices we can address - * to only 4096 -- if that becomes a problem, we can switch to 32-bit - * draw indices. - * - * These flags expected at first vertex of lines & triangles when - * unfilled and/or line stipple modes are operational. +/* + * These flags are used by the pipeline when unfilled and/or line stipple modes + * are operational. */ -#define DRAW_PIPE_MAX_VERTICES (0x1<<12) -#define DRAW_PIPE_EDGE_FLAG_0 (0x1<<12) -#define DRAW_PIPE_EDGE_FLAG_1 (0x2<<12) -#define DRAW_PIPE_EDGE_FLAG_2 (0x4<<12) -#define DRAW_PIPE_EDGE_FLAG_ALL (0x7<<12) -#define DRAW_PIPE_RESET_STIPPLE (0x8<<12) -#define DRAW_PIPE_FLAG_MASK (0xf<<12) +#define DRAW_PIPE_EDGE_FLAG_0 0x1 +#define DRAW_PIPE_EDGE_FLAG_1 0x2 +#define DRAW_PIPE_EDGE_FLAG_2 0x4 +#define DRAW_PIPE_EDGE_FLAG_ALL 0x7 +#define DRAW_PIPE_RESET_STIPPLE 0x8 void draw_pipeline_run( struct draw_context *draw, - unsigned prim, - struct vertex_header *vertices, - unsigned vertex_count, - unsigned stride, - const ushort *elts, - unsigned count ); + const struct draw_vertex_info *vert, + const struct draw_prim_info *prim); void draw_pipeline_run_linear( struct draw_context *draw, - unsigned prim, - struct vertex_header *vertices, - unsigned count, - unsigned stride ); + const struct draw_vertex_info *vert, + const struct draw_prim_info *prim); + @@ -357,8 +458,9 @@ void draw_pipeline_flush( struct draw_context *draw, * Flushing */ -#define DRAW_FLUSH_STATE_CHANGE 0x8 -#define DRAW_FLUSH_BACKEND 0x10 +#define DRAW_FLUSH_PARAMETER_CHANGE 0x1 /**< Constants, viewport, etc */ +#define DRAW_FLUSH_STATE_CHANGE 0x2 /**< Other/heavy state changes */ +#define DRAW_FLUSH_BACKEND 0x4 /**< Flush the output buffer */ void draw_do_flush( struct draw_context *draw, unsigned flags ); @@ -370,5 +472,42 @@ draw_get_rasterizer_no_cull( struct draw_context *draw, boolean scissor, boolean flatshade ); +void +draw_stats_clipper_primitives(struct draw_context *draw, + const struct draw_prim_info *prim_info); + +/** + * Return index i from the index buffer. + * If the index buffer would overflow we return the + * maximum possible index. + */ +#define DRAW_GET_IDX(_elts, _i) \ + (((_i) >= draw->pt.user.eltMax) ? DRAW_MAX_FETCH_IDX : (_elts)[_i]) + +/** + * Return index of the given viewport clamping it + * to be between 0 <= and < PIPE_MAX_VIEWPORTS + */ +static INLINE unsigned +draw_clamp_viewport_idx(int idx) +{ + return ((PIPE_MAX_VIEWPORTS > idx || idx < 0) ? idx : 0); +} + +/** + * Adds two unsigned integers and if the addition + * overflows then it returns the value from + * from the overflow_value variable. + */ +static INLINE unsigned +draw_overflow_uadd(unsigned a, unsigned b, + unsigned overflow_value) +{ + unsigned res = a + b; + if (res < a || res < b) { + res = overflow_value; + } + return res; +} #endif /* DRAW_PRIVATE_H */