From a407636efb6c32cee81b9a1525dbc804aacd957b Mon Sep 17 00:00:00 2001 From: Roland Scheidegger Date: Tue, 12 Jan 2010 15:54:13 +0100 Subject: gallium: remove point_size_min and point_size_max from rasterizer state The state tracker is responsible for clamping to any graphics API enforced size min/max limits for both the static point_size setting as well as per vertex point size (in the vertex shader). Note that mesa state tracker didn't actually use these values. --- src/mesa/state_tracker/st_atom_rasterizer.c | 3 --- 1 file changed, 3 deletions(-) (limited to 'src/mesa/state_tracker') diff --git a/src/mesa/state_tracker/st_atom_rasterizer.c b/src/mesa/state_tracker/st_atom_rasterizer.c index 36b28cb4df..710574f361 100644 --- a/src/mesa/state_tracker/st_atom_rasterizer.c +++ b/src/mesa/state_tracker/st_atom_rasterizer.c @@ -188,9 +188,6 @@ static void update_raster_state( struct st_context *st ) */ raster->point_size = ctx->Point.Size; - raster->point_size_min = 0; /* temporary, will go away */ - raster->point_size_max = 1000; /* temporary, will go away */ - raster->point_smooth = ctx->Point.SmoothFlag; raster->point_sprite = ctx->Point.PointSprite; for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) { -- cgit v1.2.3 From 4a4daa75a85db22cd37ebd533ebbccb427e07077 Mon Sep 17 00:00:00 2001 From: Roland Scheidegger Date: Wed, 3 Feb 2010 17:25:14 +0100 Subject: gallium: clean up point sprite rasterizer state Don't need sprite coord origin per coord. Also, don't need separate sprite enable bit - if all coords have it diabled, then there are no point sprites (technically, there's a distinction in pre-GL3, but it only differs in having more leniency in clamping to max size, something the state tracker would need to handle and the hardware won't bother anyway). Also, use packed field for the per-coord enables. All in all, should save 3 dwords in rasterizer state (from 10 down to 7). --- src/gallium/auxiliary/draw/draw_pipe_validate.c | 6 +++--- src/gallium/auxiliary/draw/draw_pipe_wide_point.c | 16 ++++++++------ src/gallium/docs/source/cso/rasterizer.rst | 7 ++++-- src/gallium/drivers/i965/brw_sf.c | 17 ++++++++------- src/gallium/drivers/i965/brw_sf_state.c | 2 +- src/gallium/drivers/nv10/nv10_state.c | 4 ++-- src/gallium/drivers/nv20/nv20_state.c | 4 ++-- src/gallium/drivers/nv30/nv30_state.c | 4 ++-- src/gallium/drivers/nv40/nv40_state.c | 4 ++-- src/gallium/drivers/nv50/nv50_program.c | 14 ++++++------ src/gallium/drivers/nv50/nv50_state.c | 2 +- src/gallium/drivers/softpipe/sp_video_context.c | 3 +-- src/gallium/drivers/svga/svga_pipe_rasterizer.c | 2 +- src/gallium/drivers/trace/tr_dump_state.c | 5 ++--- src/gallium/include/pipe/p_defines.h | 5 ++--- src/gallium/include/pipe/p_state.h | 4 ++-- .../state_trackers/python/retrace/interpreter.py | 2 +- src/mesa/state_tracker/st_atom_rasterizer.c | 25 +++++++++++----------- 18 files changed, 64 insertions(+), 62 deletions(-) (limited to 'src/mesa/state_tracker') diff --git a/src/gallium/auxiliary/draw/draw_pipe_validate.c b/src/gallium/auxiliary/draw/draw_pipe_validate.c index bea90e50d3..ac29634d67 100644 --- a/src/gallium/auxiliary/draw/draw_pipe_validate.c +++ b/src/gallium/auxiliary/draw/draw_pipe_validate.c @@ -105,7 +105,7 @@ draw_need_pipeline(const struct draw_context *draw, return TRUE; /* point sprites */ - if (rasterizer->point_sprite && draw->pipeline.point_sprite) + if (rasterizer->sprite_coord_enable && draw->pipeline.point_sprite) return TRUE; } @@ -165,7 +165,7 @@ static struct draw_stage *validate_pipeline( struct draw_stage *stage ) && !draw->rasterizer->line_smooth); /* drawing large points? */ - if (draw->rasterizer->point_sprite && draw->pipeline.point_sprite) + if (draw->rasterizer->sprite_coord_enable && draw->pipeline.point_sprite) wide_points = TRUE; else if (draw->rasterizer->point_smooth && draw->pipeline.aapoint) wide_points = FALSE; @@ -197,7 +197,7 @@ static struct draw_stage *validate_pipeline( struct draw_stage *stage ) precalc_flat = 1; } - if (wide_points || draw->rasterizer->point_sprite) { + if (wide_points || draw->rasterizer->sprite_coord_enable) { draw->pipeline.wide_point->next = next; next = draw->pipeline.wide_point; } diff --git a/src/gallium/auxiliary/draw/draw_pipe_wide_point.c b/src/gallium/auxiliary/draw/draw_pipe_wide_point.c index f723e658e1..d9d4d2a8b6 100644 --- a/src/gallium/auxiliary/draw/draw_pipe_wide_point.c +++ b/src/gallium/auxiliary/draw/draw_pipe_wide_point.c @@ -69,8 +69,9 @@ struct widepoint_stage { float ybias; uint texcoord_slot[PIPE_MAX_SHADER_OUTPUTS]; - uint texcoord_mode[PIPE_MAX_SHADER_OUTPUTS]; + uint texcoord_enable[PIPE_MAX_SHADER_OUTPUTS]; uint num_texcoords; + uint texcoord_mode; int psize_slot; @@ -96,10 +97,10 @@ static void set_texcoords(const struct widepoint_stage *wide, { uint i; for (i = 0; i < wide->num_texcoords; i++) { - if (wide->texcoord_mode[i] != PIPE_SPRITE_COORD_NONE) { + if (wide->texcoord_enable[i]) { uint j = wide->texcoord_slot[i]; v->data[j][0] = tc[0]; - if (wide->texcoord_mode[i] == PIPE_SPRITE_COORD_LOWER_LEFT) + if (wide->texcoord_mode == PIPE_SPRITE_COORD_LOWER_LEFT) v->data[j][1] = 1.0f - tc[1]; else v->data[j][1] = tc[1]; @@ -129,7 +130,7 @@ static void widepoint_point( struct draw_stage *stage, { const struct widepoint_stage *wide = widepoint_stage(stage); const unsigned pos = draw_current_shader_position_output(stage->draw); - const boolean sprite = (boolean) stage->draw->rasterizer->point_sprite; + const boolean sprite = (boolean) stage->draw->rasterizer->sprite_coord_enable; float half_size; float left_adj, right_adj, bot_adj, top_adj; @@ -222,21 +223,22 @@ static void widepoint_first_point( struct draw_stage *stage, /* XXX we won't know the real size if it's computed by the vertex shader! */ if ((draw->rasterizer->point_size > draw->pipeline.wide_point_threshold) || - (draw->rasterizer->point_sprite && draw->pipeline.point_sprite)) { + (draw->rasterizer->sprite_coord_enable && draw->pipeline.point_sprite)) { stage->point = widepoint_point; } else { stage->point = draw_pipe_passthrough_point; } - if (draw->rasterizer->point_sprite) { + if (draw->rasterizer->sprite_coord_enable) { /* find vertex shader texcoord outputs */ const struct draw_vertex_shader *vs = draw->vs.vertex_shader; uint i, j = 0; + wide->texcoord_mode = draw->rasterizer->sprite_coord_mode; for (i = 0; i < vs->info.num_outputs; i++) { if (vs->info.output_semantic_name[i] == TGSI_SEMANTIC_GENERIC) { wide->texcoord_slot[j] = i; - wide->texcoord_mode[j] = draw->rasterizer->sprite_coord_mode[j]; + wide->texcoord_enable[j] = (draw->rasterizer->sprite_coord_enable >> j) & 1; j++; } } diff --git a/src/gallium/docs/source/cso/rasterizer.rst b/src/gallium/docs/source/cso/rasterizer.rst index 5ffd6007be..89c3c061f0 100644 --- a/src/gallium/docs/source/cso/rasterizer.rst +++ b/src/gallium/docs/source/cso/rasterizer.rst @@ -83,7 +83,10 @@ point_size_per_vertex point_size The size of points, if not specified per-vertex. point_sprite - Whether points are drawn as sprites (textured quads) + Whether points are drawn as sprites (textured quads). This is mutually + exclusive with point_smooth. Note that sprite_coord_mode set to + PIPE_SPRITE_COORD_NONE for all coords and point_sprite enabled is basically + equivalent to point_sprite disabled. sprite_coord_mode Specifies how the value for each shader output should be computed when drawing sprites. If PIPE_SPRITE_COORD_NONE, don't change the vertex @@ -98,7 +101,7 @@ sprite_coord_mode sprite rendering. Note that when geometry shaders are available, this state could be removed. A special geometry shader defined by the state tracker could - converts the incoming points into quads with the proper texture coords. + convert the incoming points into quads with the proper texture coords. scissor Whether the scissor test is enabled. diff --git a/src/gallium/drivers/i965/brw_sf.c b/src/gallium/drivers/i965/brw_sf.c index e1986a9dbb..fc3102b531 100644 --- a/src/gallium/drivers/i965/brw_sf.c +++ b/src/gallium/drivers/i965/brw_sf.c @@ -128,6 +128,7 @@ static enum pipe_error compile_sf_prog( struct brw_context *brw, static enum pipe_error upload_sf_prog(struct brw_context *brw) { const struct brw_fs_signature *sig = &brw->curr.fragment_shader->signature; + const struct pipe_rasterizer_state *rast = &brw->curr.rast->templ; struct brw_sf_prog_key key; enum pipe_error ret; unsigned i; @@ -166,8 +167,8 @@ static enum pipe_error upload_sf_prog(struct brw_context *brw) case PIPE_PRIM_TRIANGLES: /* PIPE_NEW_RAST */ - if (brw->curr.rast->templ.fill_cw != PIPE_POLYGON_MODE_FILL || - brw->curr.rast->templ.fill_ccw != PIPE_POLYGON_MODE_FILL) + if (rast->fill_cw != PIPE_POLYGON_MODE_FILL || + rast->fill_ccw != PIPE_POLYGON_MODE_FILL) key.primitive = SF_UNFILLED_TRIS; else key.primitive = SF_TRIANGLES; @@ -180,14 +181,14 @@ static enum pipe_error upload_sf_prog(struct brw_context *brw) break; } - key.do_point_sprite = brw->curr.rast->templ.point_sprite; - key.sprite_origin_lower_left = 0; /* XXX: ctx->Point.SpriteOrigin - fix rast state */ - key.do_flat_shading = brw->curr.rast->templ.flatshade; - key.do_twoside_color = brw->curr.rast->templ.light_twoside; + key.do_point_sprite = rast->sprite_coord_enable ? 1 : 0; + key.sprite_origin_lower_left = (rast->sprite_coord_mode == PIPE_SPRITE_COORD_LOWER_LEFT); + key.point_coord_replace_attrs = rast->sprite_coord_enable; + key.do_flat_shading = rast->flatshade; + key.do_twoside_color = rast->light_twoside; if (key.do_twoside_color) { - key.frontface_ccw = (brw->curr.rast->templ.front_winding == - PIPE_WINDING_CCW); + key.frontface_ccw = (rast->front_winding == PIPE_WINDING_CCW); } if (brw_search_cache(&brw->cache, BRW_SF_PROG, diff --git a/src/gallium/drivers/i965/brw_sf_state.c b/src/gallium/drivers/i965/brw_sf_state.c index 663a688772..0ad91e0307 100644 --- a/src/gallium/drivers/i965/brw_sf_state.c +++ b/src/gallium/drivers/i965/brw_sf_state.c @@ -123,7 +123,7 @@ sf_unit_populate_key(struct brw_context *brw, struct brw_sf_unit_key *key) key->line_last_pixel_enable = rast->line_last_pixel; key->gl_rasterization_rules = rast->gl_rasterization_rules; - key->point_sprite = rast->point_sprite; + key->point_sprite = rast->sprite_coord_enable ? 1 : 0; key->point_attenuated = rast->point_size_per_vertex; key->point_size = rast->point_size; diff --git a/src/gallium/drivers/nv10/nv10_state.c b/src/gallium/drivers/nv10/nv10_state.c index ffc6be3c40..6f674d6e13 100644 --- a/src/gallium/drivers/nv10/nv10_state.c +++ b/src/gallium/drivers/nv10/nv10_state.c @@ -299,10 +299,10 @@ nv10_rasterizer_state_create(struct pipe_context *pipe, break; } - if (cso->point_sprite) { + if (cso->sprite_coord_enable) { rs->point_sprite = (1 << 0); for (i = 0; i < 8; i++) { - if (cso->sprite_coord_mode[i] != PIPE_SPRITE_COORD_NONE) + if ((cso->sprite_coord_enable >> i) & 1) rs->point_sprite |= (1 << (8 + i)); } } else { diff --git a/src/gallium/drivers/nv20/nv20_state.c b/src/gallium/drivers/nv20/nv20_state.c index 3a82e63423..3d9a276fa1 100644 --- a/src/gallium/drivers/nv20/nv20_state.c +++ b/src/gallium/drivers/nv20/nv20_state.c @@ -292,10 +292,10 @@ nv20_rasterizer_state_create(struct pipe_context *pipe, break; } - if (cso->point_sprite) { + if (cso->sprite_coord_enable) { rs->point_sprite = (1 << 0); for (i = 0; i < 8; i++) { - if (cso->sprite_coord_mode[i] != PIPE_SPRITE_COORD_NONE) + if ((cso->sprite_coord_enable >> i) & 1) rs->point_sprite |= (1 << (8 + i)); } } else { diff --git a/src/gallium/drivers/nv30/nv30_state.c b/src/gallium/drivers/nv30/nv30_state.c index a80dfb0488..ab9fc5293c 100644 --- a/src/gallium/drivers/nv30/nv30_state.c +++ b/src/gallium/drivers/nv30/nv30_state.c @@ -391,11 +391,11 @@ nv30_rasterizer_state_create(struct pipe_context *pipe, } so_method(so, rankine, NV34TCL_POINT_SPRITE, 1); - if (cso->point_sprite) { + if (cso->sprite_coord_enable) { unsigned psctl = (1 << 0), i; for (i = 0; i < 8; i++) { - if (cso->sprite_coord_mode[i] != PIPE_SPRITE_COORD_NONE) + if ((cso->sprite_coord_enable >> i) & 1) psctl |= (1 << (8 + i)); } diff --git a/src/gallium/drivers/nv40/nv40_state.c b/src/gallium/drivers/nv40/nv40_state.c index ed0ca9e02c..a5c5e291f3 100644 --- a/src/gallium/drivers/nv40/nv40_state.c +++ b/src/gallium/drivers/nv40/nv40_state.c @@ -401,11 +401,11 @@ nv40_rasterizer_state_create(struct pipe_context *pipe, } so_method(so, curie, NV40TCL_POINT_SPRITE, 1); - if (cso->point_sprite) { + if (cso->sprite_coord_enable) { unsigned psctl = (1 << 0), i; for (i = 0; i < 8; i++) { - if (cso->sprite_coord_mode[i] != PIPE_SPRITE_COORD_NONE) + if ((cso->sprite_coord_enable >> i) & 1) psctl |= (1 << (8 + i)); } diff --git a/src/gallium/drivers/nv50/nv50_program.c b/src/gallium/drivers/nv50/nv50_program.c index e16fa479e5..593d743603 100644 --- a/src/gallium/drivers/nv50/nv50_program.c +++ b/src/gallium/drivers/nv50/nv50_program.c @@ -4067,15 +4067,13 @@ nv50_pntc_replace(struct nv50_context *nv50, uint32_t pntc[8], unsigned base) } if (j < vp->info.num_outputs) { - ubyte mode = - nv50->rasterizer->pipe.sprite_coord_mode[si]; + ubyte enable = + (nv50->rasterizer->pipe.sprite_coord_enable >> si) & 1; - if (mode == PIPE_SPRITE_COORD_NONE) { + if (enable == 0) { m += n; continue; - } else - if (mode == PIPE_SPRITE_COORD_LOWER_LEFT) - origin = 0; + } } /* this is either PointCoord or replaced by sprite coords */ @@ -4086,7 +4084,7 @@ nv50_pntc_replace(struct nv50_context *nv50, uint32_t pntc[8], unsigned base) ++m; } } - return origin; + return (nv50->rasterizer->pipe.sprite_coord_mode == PIPE_SPRITE_COORD_LOWER_LEFT ? 0 : origin); } static int @@ -4202,7 +4200,7 @@ nv50_linkage_validate(struct nv50_context *nv50) so_method(so, tesla, NV50TCL_NOPERSPECTIVE_BITMAP(0), 4); so_datap (so, lin, 4); - if (nv50->rasterizer->pipe.point_sprite) { + if (nv50->rasterizer->pipe.sprite_coord_enable) { so_method(so, tesla, NV50TCL_POINT_SPRITE_CTRL, 1); so_data (so, nv50_pntc_replace(nv50, pcrd, (reg[4] >> 8) & 0xff)); diff --git a/src/gallium/drivers/nv50/nv50_state.c b/src/gallium/drivers/nv50/nv50_state.c index 1f67df814b..cbe2f349c2 100644 --- a/src/gallium/drivers/nv50/nv50_state.c +++ b/src/gallium/drivers/nv50/nv50_state.c @@ -318,7 +318,7 @@ nv50_rasterizer_state_create(struct pipe_context *pipe, so_data (so, fui(cso->point_size)); so_method(so, tesla, NV50TCL_POINT_SPRITE_ENABLE, 1); - so_data (so, cso->point_sprite); + so_data (so, cso->sprite_coord_enable ? 1 : 0); so_method(so, tesla, NV50TCL_POLYGON_MODE_FRONT, 3); if (cso->front_winding == PIPE_WINDING_CCW) { diff --git a/src/gallium/drivers/softpipe/sp_video_context.c b/src/gallium/drivers/softpipe/sp_video_context.c index cae2d3efc5..7dde3c1330 100644 --- a/src/gallium/drivers/softpipe/sp_video_context.c +++ b/src/gallium/drivers/softpipe/sp_video_context.c @@ -167,7 +167,7 @@ init_pipe_state(struct sp_mpeg12_context *ctx) rast.scissor = 0; rast.poly_smooth = 0; rast.poly_stipple_enable = 0; - rast.point_sprite = 0; + rast.sprite_coord_enable = 0; rast.point_size_per_vertex = 0; rast.multisample = 0; rast.line_smooth = 0; @@ -181,7 +181,6 @@ init_pipe_state(struct sp_mpeg12_context *ctx) rast.point_size = 1; rast.offset_units = 1; rast.offset_scale = 1; - /*rast.sprite_coord_mode[i] = ;*/ ctx->rast = ctx->pipe->create_rasterizer_state(ctx->pipe, &rast); ctx->pipe->bind_rasterizer_state(ctx->pipe, ctx->rast); diff --git a/src/gallium/drivers/svga/svga_pipe_rasterizer.c b/src/gallium/drivers/svga/svga_pipe_rasterizer.c index b5ecc4c56c..0a613cb553 100644 --- a/src/gallium/drivers/svga/svga_pipe_rasterizer.c +++ b/src/gallium/drivers/svga/svga_pipe_rasterizer.c @@ -71,7 +71,7 @@ svga_create_rasterizer_state(struct pipe_context *pipe, /* light_twoside - XXX: need fragment shader varient */ /* poly_smooth - XXX: no fallback available */ /* poly_stipple_enable - draw module */ - /* point_sprite - ? */ + /* sprite_coord_enable - ? */ /* point_size_per_vertex - ? */ /* sprite_coord_mode - ??? */ /* bypass_vs_viewport_and_clip - handled by viewport setup */ diff --git a/src/gallium/drivers/trace/tr_dump_state.c b/src/gallium/drivers/trace/tr_dump_state.c index 0e7b7ec123..ed327f60f0 100644 --- a/src/gallium/drivers/trace/tr_dump_state.c +++ b/src/gallium/drivers/trace/tr_dump_state.c @@ -112,7 +112,8 @@ void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state) trace_dump_member(bool, state, poly_smooth); trace_dump_member(bool, state, poly_stipple_enable); trace_dump_member(bool, state, point_smooth); - trace_dump_member(bool, state, point_sprite); + trace_dump_member(uint, state, sprite_coord_enable); + trace_dump_member(bool, state, sprite_coord_mode); trace_dump_member(bool, state, point_size_per_vertex); trace_dump_member(bool, state, multisample); trace_dump_member(bool, state, line_smooth); @@ -129,8 +130,6 @@ void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state) trace_dump_member(float, state, offset_units); trace_dump_member(float, state, offset_scale); - trace_dump_member_array(uint, state, sprite_coord_mode); - trace_dump_struct_end(); } diff --git a/src/gallium/include/pipe/p_defines.h b/src/gallium/include/pipe/p_defines.h index 35f3830ebc..a85a170153 100644 --- a/src/gallium/include/pipe/p_defines.h +++ b/src/gallium/include/pipe/p_defines.h @@ -364,9 +364,8 @@ enum pipe_transfer_usage { /** * Point sprite coord modes */ -#define PIPE_SPRITE_COORD_NONE 0 -#define PIPE_SPRITE_COORD_UPPER_LEFT 1 -#define PIPE_SPRITE_COORD_LOWER_LEFT 2 +#define PIPE_SPRITE_COORD_UPPER_LEFT 0 +#define PIPE_SPRITE_COORD_LOWER_LEFT 1 /** diff --git a/src/gallium/include/pipe/p_state.h b/src/gallium/include/pipe/p_state.h index ea3ec201ea..50a4cd6e13 100644 --- a/src/gallium/include/pipe/p_state.h +++ b/src/gallium/include/pipe/p_state.h @@ -101,7 +101,8 @@ struct pipe_rasterizer_state unsigned poly_smooth:1; unsigned poly_stipple_enable:1; unsigned point_smooth:1; - unsigned point_sprite:1; + unsigned sprite_coord_enable:PIPE_MAX_SHADER_OUTPUTS; + unsigned sprite_coord_mode:1; /**< PIPE_SPRITE_COORD_ */ unsigned point_size_per_vertex:1; /**< size computed in vertex shader */ unsigned multisample:1; /* XXX maybe more ms state in future */ unsigned line_smooth:1; @@ -143,7 +144,6 @@ struct pipe_rasterizer_state float point_size; /**< used when no per-vertex size */ float offset_units; float offset_scale; - ubyte sprite_coord_mode[PIPE_MAX_SHADER_OUTPUTS]; /**< PIPE_SPRITE_COORD_ */ }; diff --git a/src/gallium/state_trackers/python/retrace/interpreter.py b/src/gallium/state_trackers/python/retrace/interpreter.py index a68709f5cf..bb61979d07 100755 --- a/src/gallium/state_trackers/python/retrace/interpreter.py +++ b/src/gallium/state_trackers/python/retrace/interpreter.py @@ -113,7 +113,7 @@ struct_factories = { member_array_factories = { - "pipe_rasterizer_state": {"sprite_coord_mode": gallium.ByteArray}, + #"pipe_rasterizer_state": {"sprite_coord_mode": gallium.ByteArray}, "pipe_poly_stipple": {"stipple": gallium.UnsignedArray}, "pipe_viewport_state": {"scale": gallium.FloatArray, "translate": gallium.FloatArray}, #"pipe_clip_state": {"ucp": gallium.FloatArray}, diff --git a/src/mesa/state_tracker/st_atom_rasterizer.c b/src/mesa/state_tracker/st_atom_rasterizer.c index 710574f361..16c842d2f6 100644 --- a/src/mesa/state_tracker/st_atom_rasterizer.c +++ b/src/mesa/state_tracker/st_atom_rasterizer.c @@ -188,18 +188,19 @@ static void update_raster_state( struct st_context *st ) */ raster->point_size = ctx->Point.Size; - raster->point_smooth = ctx->Point.SmoothFlag; - raster->point_sprite = ctx->Point.PointSprite; - for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) { - if (ctx->Point.CoordReplace[i]) { - if ((ctx->Point.SpriteOrigin == GL_UPPER_LEFT) ^ - (st_fb_orientation(ctx->DrawBuffer) == Y_0_BOTTOM)) - raster->sprite_coord_mode[i] = PIPE_SPRITE_COORD_UPPER_LEFT; - else - raster->sprite_coord_mode[i] = PIPE_SPRITE_COORD_LOWER_LEFT; - } - else { - raster->sprite_coord_mode[i] = PIPE_SPRITE_COORD_NONE; + if (!ctx->Point.PointSprite && ctx->Point.SmoothFlag) + raster->point_smooth = 1; + + if (ctx->Point.PointSprite) { + if ((ctx->Point.SpriteOrigin == GL_UPPER_LEFT) ^ + (st_fb_orientation(ctx->DrawBuffer) == Y_0_BOTTOM)) + raster->sprite_coord_mode = PIPE_SPRITE_COORD_UPPER_LEFT; + else + raster->sprite_coord_mode = PIPE_SPRITE_COORD_LOWER_LEFT; + for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) { + if (ctx->Point.CoordReplace[i]) { + raster->sprite_coord_enable |= 1 << i; + } } } -- cgit v1.2.3 From 2c326e72664e65166c68b027b26aaf373f3be36d Mon Sep 17 00:00:00 2001 From: Roland Scheidegger Date: Thu, 4 Feb 2010 19:23:09 +0100 Subject: gallium: add point size clamp to implementation limits in vertex shader The point size min/max registers (unused by mesa state tracker) were removed since most hardware couldn't do much with them. However, we don't want to have to rely on hw to do point size clamping correctly to implementation dependent limits, hence have to do that in the vertex shader. This should also solve a potential problem with (non-AA) points smaller than 1.0 which according to OGL still have size 1.0. Note that OGL point rendering is odd, in particular point sprites are rasterized differently to points. Some hardware might support those different modes, but in any case the different clamping values used for smooth/multisampled/sprite enabled points might help a bit for hw which rasterizes points the same as point sprites. Also tweak mesa's ff to vertex shader translation so don't have to clamp twice in case of point attenuation. --- src/mesa/main/ffvertex_prog.c | 2 +- src/mesa/shader/prog_statevars.c | 64 ++++++++++++++++++++++++++++++++ src/mesa/shader/prog_statevars.h | 2 + src/mesa/state_tracker/st_extensions.c | 5 +++ src/mesa/state_tracker/st_mesa_to_tgsi.c | 36 ++++++++++++++++++ 5 files changed, 108 insertions(+), 1 deletion(-) (limited to 'src/mesa/state_tracker') diff --git a/src/mesa/main/ffvertex_prog.c b/src/mesa/main/ffvertex_prog.c index 2d1db29cbf..867a55242c 100644 --- a/src/mesa/main/ffvertex_prog.c +++ b/src/mesa/main/ffvertex_prog.c @@ -1496,7 +1496,7 @@ static void build_texture_transform( struct tnl_program *p ) static void build_atten_pointsize( struct tnl_program *p ) { struct ureg eye = get_eye_position_z(p); - struct ureg state_size = register_param1(p, STATE_POINT_SIZE); + struct ureg state_size = register_param2(p, STATE_INTERNAL, STATE_POINT_SIZE_CLAMPED); struct ureg state_attenuation = register_param1(p, STATE_POINT_ATTENUATION); struct ureg out = register_output(p, VERT_RESULT_PSIZ); struct ureg ut = get_temp(p); diff --git a/src/mesa/shader/prog_statevars.c b/src/mesa/shader/prog_statevars.c index 058d4bbafb..460ecd44a8 100644 --- a/src/mesa/shader/prog_statevars.c +++ b/src/mesa/shader/prog_statevars.c @@ -444,6 +444,61 @@ _mesa_fetch_state(GLcontext *ctx, const gl_state_index state[], value[3] = (GLfloat)(ctx->Fog.Density * ONE_DIV_SQRT_LN2); return; + case STATE_POINT_SIZE_CLAMPED: + { + /* this includes implementation dependent limits, to avoid + * another potentially necessary clamp. + * Note: for sprites, point smooth (point AA) is ignored + * and we'll clamp to MinPointSizeAA and MaxPointSize, because we + * expect drivers will want to say their minimum for AA size is 0.0 + * but for non-AA it's 1.0 (because normal points with size below 1.0 + * need to get rounded up to 1.0, hence never disappear). GL does + * not specify max clamp size for sprites, other than it needs to be + * at least as large as max AA size, hence use non-AA size there. + */ + GLfloat minImplSize; + GLfloat maxImplSize; + if (ctx->Point.PointSprite) { + minImplSize = ctx->Const.MinPointSizeAA; + maxImplSize = ctx->Const.MaxPointSize; + } + else if (ctx->Point.SmoothFlag || ctx->Multisample._Enabled) { + minImplSize = ctx->Const.MinPointSizeAA; + maxImplSize = ctx->Const.MaxPointSizeAA; + } + else { + minImplSize = ctx->Const.MinPointSize; + maxImplSize = ctx->Const.MaxPointSize; + } + value[0] = ctx->Point.Size; + value[1] = ctx->Point.MinSize >= minImplSize ? ctx->Point.MinSize : minImplSize; + value[2] = ctx->Point.MaxSize <= maxImplSize ? ctx->Point.MaxSize : maxImplSize; + value[3] = ctx->Point.Threshold; + } + return; + case STATE_POINT_SIZE_IMPL_CLAMP: + { + /* for implementation clamp only in vs */ + GLfloat minImplSize; + GLfloat maxImplSize; + if (ctx->Point.PointSprite) { + minImplSize = ctx->Const.MinPointSizeAA; + maxImplSize = ctx->Const.MaxPointSize; + } + else if (ctx->Point.SmoothFlag || ctx->Multisample._Enabled) { + minImplSize = ctx->Const.MinPointSizeAA; + maxImplSize = ctx->Const.MaxPointSizeAA; + } + else { + minImplSize = ctx->Const.MinPointSize; + maxImplSize = ctx->Const.MaxPointSize; + } + value[0] = ctx->Point.Size; + value[1] = minImplSize; + value[2] = maxImplSize; + value[3] = ctx->Point.Threshold; + } + return; case STATE_LIGHT_SPOT_DIR_NORMALIZED: { /* here, state[2] is the light number */ @@ -639,6 +694,9 @@ _mesa_program_state_flags(const gl_state_index state[STATE_LENGTH]) return _NEW_TEXTURE; case STATE_FOG_PARAMS_OPTIMIZED: return _NEW_FOG; + case STATE_POINT_SIZE_CLAMPED: + case STATE_POINT_SIZE_IMPL_CLAMP: + return _NEW_POINT | _NEW_MULTISAMPLE; case STATE_LIGHT_SPOT_DIR_NORMALIZED: case STATE_LIGHT_POSITION: case STATE_LIGHT_POSITION_NORMALIZED: @@ -830,6 +888,12 @@ append_token(char *dst, gl_state_index k) case STATE_FOG_PARAMS_OPTIMIZED: append(dst, "fogParamsOptimized"); break; + case STATE_POINT_SIZE_CLAMPED: + append(dst, "pointSizeClamped"); + break; + case STATE_POINT_SIZE_IMPL_CLAMP: + append(dst, "pointSizeImplClamp"); + break; case STATE_LIGHT_SPOT_DIR_NORMALIZED: append(dst, "lightSpotDirNormalized"); break; diff --git a/src/mesa/shader/prog_statevars.h b/src/mesa/shader/prog_statevars.h index 1180d9eaa4..1753471ffb 100644 --- a/src/mesa/shader/prog_statevars.h +++ b/src/mesa/shader/prog_statevars.h @@ -108,6 +108,8 @@ typedef enum gl_state_index_ { STATE_NORMAL_SCALE, STATE_TEXRECT_SCALE, STATE_FOG_PARAMS_OPTIMIZED, /* for faster fog calc */ + STATE_POINT_SIZE_CLAMPED, /* includes implementation dependent size clamp */ + STATE_POINT_SIZE_IMPL_CLAMP, /* for implementation clamp only in vs */ STATE_LIGHT_SPOT_DIR_NORMALIZED, /* pre-normalized spot dir */ STATE_LIGHT_POSITION, /* object vs eye space */ STATE_LIGHT_POSITION_NORMALIZED, /* object vs eye space */ diff --git a/src/mesa/state_tracker/st_extensions.c b/src/mesa/state_tracker/st_extensions.c index 35e08749df..7684ccd702 100644 --- a/src/mesa/state_tracker/st_extensions.c +++ b/src/mesa/state_tracker/st_extensions.c @@ -114,6 +114,11 @@ void st_init_limits(struct st_context *st) = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH)); c->MaxPointSizeAA = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH_AA)); + /* these are not queryable. Note that GL basically mandates a 1.0 minimum + * for non-aa sizes, but we can go down to 0.0 for aa points. + */ + c->MinPointSize = 1.0f; + c->MinPointSizeAA = 0.0f; c->MaxTextureMaxAnisotropy = _maxf(2.0f, screen->get_paramf(screen, PIPE_CAP_MAX_TEXTURE_ANISOTROPY)); diff --git a/src/mesa/state_tracker/st_mesa_to_tgsi.c b/src/mesa/state_tracker/st_mesa_to_tgsi.c index e788008dfe..4830a8f383 100644 --- a/src/mesa/state_tracker/st_mesa_to_tgsi.c +++ b/src/mesa/state_tracker/st_mesa_to_tgsi.c @@ -57,6 +57,10 @@ struct st_translate { struct ureg_src inputs[PIPE_MAX_SHADER_INPUTS]; struct ureg_dst address[1]; struct ureg_src samplers[PIPE_MAX_SAMPLERS]; + struct ureg_dst psizregreal; + struct ureg_src pointSizeConst; + GLint psizoutindex; + GLboolean prevInstWrotePsiz; const GLuint *inputMapping; const GLuint *outputMapping; @@ -145,6 +149,8 @@ dst_register( struct st_translate *t, return t->temps[index]; case PROGRAM_OUTPUT: + if (index == t->psizoutindex) + t->prevInstWrotePsiz = GL_TRUE; return t->outputs[t->outputMapping[index]]; case PROGRAM_ADDRESS: @@ -787,6 +793,8 @@ st_translate_mesa_program( t->inputMapping = inputMapping; t->outputMapping = outputMapping; t->ureg = ureg; + t->psizoutindex = -1; + t->prevInstWrotePsiz = GL_FALSE; /*_mesa_print_program(program);*/ @@ -845,6 +853,21 @@ st_translate_mesa_program( t->outputs[i] = ureg_DECL_output( ureg, outputSemanticName[i], outputSemanticIndex[i] ); + if ((outputSemanticName[i] == TGSI_SEMANTIC_PSIZE) && program->Id) { + static const gl_state_index pointSizeClampState[STATE_LENGTH] + = { STATE_INTERNAL, STATE_POINT_SIZE_IMPL_CLAMP, 0, 0, 0 }; + /* XXX: note we are modifying the incoming shader here! Need to + * do this before emitting the constant decls below, or this + * will be missed: + */ + unsigned pointSizeClampConst = _mesa_add_state_reference(program->Parameters, + pointSizeClampState); + struct ureg_dst psizregtemp = ureg_DECL_temporary( ureg ); + t->pointSizeConst = ureg_DECL_constant( ureg, pointSizeClampConst ); + t->psizregreal = t->outputs[i]; + t->psizoutindex = i; + t->outputs[i] = psizregtemp; + } } if (passthrough_edgeflags) emit_edgeflags( t, program ); @@ -910,6 +933,19 @@ st_translate_mesa_program( for (i = 0; i < program->NumInstructions; i++) { set_insn_start( t, ureg_get_instruction_number( ureg )); compile_instruction( t, &program->Instructions[i] ); + + /* note can't do that easily at the end of prog due to + possible early return */ + if (t->prevInstWrotePsiz && program->Id) { + set_insn_start( t, ureg_get_instruction_number( ureg )); + ureg_MAX( t->ureg, ureg_writemask(t->outputs[t->psizoutindex], WRITEMASK_X), + ureg_src(t->outputs[t->psizoutindex]), + ureg_swizzle(t->pointSizeConst, 1,1,1,1)); + ureg_MIN( t->ureg, ureg_writemask(t->psizregreal, WRITEMASK_X), + ureg_src(t->outputs[t->psizoutindex]), + ureg_swizzle(t->pointSizeConst, 2,2,2,2)); + } + t->prevInstWrotePsiz = GL_FALSE; } /* Fix up all emitted labels: -- cgit v1.2.3 From 68f93ea3eb83cfad014b8ec93cec3564c1aa9833 Mon Sep 17 00:00:00 2001 From: Roland Scheidegger Date: Thu, 4 Feb 2010 21:35:28 +0100 Subject: gallium: add point_quad_rasterization bit to rasterizer state This determines if points should be rasterized according to GL point rules or as normal quads (GL point sprites / d3d points / d3d point sprites). --- src/gallium/auxiliary/draw/draw_pipe_wide_point.c | 1 + src/gallium/docs/source/cso/rasterizer.rst | 14 ++++++++++++-- src/gallium/drivers/nv30/nv30_state.c | 2 +- src/gallium/drivers/nv40/nv40_state.c | 2 +- src/gallium/drivers/nv50/nv50_state.c | 2 +- src/gallium/drivers/softpipe/sp_video_context.c | 1 + src/gallium/drivers/svga/svga_pipe_rasterizer.c | 1 + src/gallium/drivers/trace/tr_dump_state.c | 1 + src/gallium/include/pipe/p_state.h | 1 + src/mesa/state_tracker/st_atom_rasterizer.c | 3 ++- 10 files changed, 22 insertions(+), 6 deletions(-) (limited to 'src/mesa/state_tracker') diff --git a/src/gallium/auxiliary/draw/draw_pipe_wide_point.c b/src/gallium/auxiliary/draw/draw_pipe_wide_point.c index d9d4d2a8b6..fdabce7d44 100644 --- a/src/gallium/auxiliary/draw/draw_pipe_wide_point.c +++ b/src/gallium/auxiliary/draw/draw_pipe_wide_point.c @@ -128,6 +128,7 @@ static void set_texcoords(const struct widepoint_stage *wide, static void widepoint_point( struct draw_stage *stage, struct prim_header *header ) { + /* XXX should take point_quad_rasterization into account? */ const struct widepoint_stage *wide = widepoint_stage(stage); const unsigned pos = draw_current_shader_position_output(stage->draw); const boolean sprite = (boolean) stage->draw->rasterizer->sprite_coord_enable; diff --git a/src/gallium/docs/source/cso/rasterizer.rst b/src/gallium/docs/source/cso/rasterizer.rst index 721229d67d..00d65fc598 100644 --- a/src/gallium/docs/source/cso/rasterizer.rst +++ b/src/gallium/docs/source/cso/rasterizer.rst @@ -85,8 +85,10 @@ point_size sprite_coord_enable Specifies if a coord has its texture coordinates replaced or not. This is a packed bitfield containing the enable for all coords - if all are 0 - point sprites are effectively disabled. If any coord is non-zero, - point_smooth should be disabled. + point sprites are effectively disabled, though points may still be + rendered slightly different according to point_quad_rasterization. + If any coord is non-zero, point_smooth should be disabled, and + point_quad_rasterization enabled. If enabled, the four vertices of the resulting quad will be assigned texture coordinates, according to sprite_coord_mode. sprite_coord_mode @@ -103,6 +105,14 @@ sprite_coord_mode Note that when geometry shaders are available, this state could be removed. A special geometry shader defined by the state tracker could convert the incoming points into quads with the proper texture coords. +point_quad_rasterization + This determines if points should be rasterized as quads or points. + d3d always uses quad rasterization for points, regardless if point sprites + are enabled or not, but OGL has different rules. If point_quad_rasterization + is set, point_smooth should be disabled, and points will be rendered as + squares even if multisample is enabled. + sprite_coord_enable should be zero if point_quad_rasterization is not + enabled. scissor Whether the scissor test is enabled. diff --git a/src/gallium/drivers/nv30/nv30_state.c b/src/gallium/drivers/nv30/nv30_state.c index ab9fc5293c..66096de61e 100644 --- a/src/gallium/drivers/nv30/nv30_state.c +++ b/src/gallium/drivers/nv30/nv30_state.c @@ -391,7 +391,7 @@ nv30_rasterizer_state_create(struct pipe_context *pipe, } so_method(so, rankine, NV34TCL_POINT_SPRITE, 1); - if (cso->sprite_coord_enable) { + if (cso->point_quad_rasterization) { unsigned psctl = (1 << 0), i; for (i = 0; i < 8; i++) { diff --git a/src/gallium/drivers/nv40/nv40_state.c b/src/gallium/drivers/nv40/nv40_state.c index a5c5e291f3..5084c48eeb 100644 --- a/src/gallium/drivers/nv40/nv40_state.c +++ b/src/gallium/drivers/nv40/nv40_state.c @@ -401,7 +401,7 @@ nv40_rasterizer_state_create(struct pipe_context *pipe, } so_method(so, curie, NV40TCL_POINT_SPRITE, 1); - if (cso->sprite_coord_enable) { + if (cso->point_quad_rasterization) { unsigned psctl = (1 << 0), i; for (i = 0; i < 8; i++) { diff --git a/src/gallium/drivers/nv50/nv50_state.c b/src/gallium/drivers/nv50/nv50_state.c index cbe2f349c2..f19a21d5cc 100644 --- a/src/gallium/drivers/nv50/nv50_state.c +++ b/src/gallium/drivers/nv50/nv50_state.c @@ -318,7 +318,7 @@ nv50_rasterizer_state_create(struct pipe_context *pipe, so_data (so, fui(cso->point_size)); so_method(so, tesla, NV50TCL_POINT_SPRITE_ENABLE, 1); - so_data (so, cso->sprite_coord_enable ? 1 : 0); + so_data (so, cso->point_quad_rasterization ? 1 : 0); so_method(so, tesla, NV50TCL_POLYGON_MODE_FRONT, 3); if (cso->front_winding == PIPE_WINDING_CCW) { diff --git a/src/gallium/drivers/softpipe/sp_video_context.c b/src/gallium/drivers/softpipe/sp_video_context.c index 7dde3c1330..cfa2a0b2f1 100644 --- a/src/gallium/drivers/softpipe/sp_video_context.c +++ b/src/gallium/drivers/softpipe/sp_video_context.c @@ -178,6 +178,7 @@ init_pipe_state(struct sp_mpeg12_context *ctx) rast.bypass_vs_clip_and_viewport = 0; rast.line_width = 1; rast.point_smooth = 0; + rast.point_quad_rasterization = 0; rast.point_size = 1; rast.offset_units = 1; rast.offset_scale = 1; diff --git a/src/gallium/drivers/svga/svga_pipe_rasterizer.c b/src/gallium/drivers/svga/svga_pipe_rasterizer.c index 0a613cb553..09ccb71884 100644 --- a/src/gallium/drivers/svga/svga_pipe_rasterizer.c +++ b/src/gallium/drivers/svga/svga_pipe_rasterizer.c @@ -72,6 +72,7 @@ svga_create_rasterizer_state(struct pipe_context *pipe, /* poly_smooth - XXX: no fallback available */ /* poly_stipple_enable - draw module */ /* sprite_coord_enable - ? */ + /* point_quad_rasterization - ? */ /* point_size_per_vertex - ? */ /* sprite_coord_mode - ??? */ /* bypass_vs_viewport_and_clip - handled by viewport setup */ diff --git a/src/gallium/drivers/trace/tr_dump_state.c b/src/gallium/drivers/trace/tr_dump_state.c index ed327f60f0..720b6cd1ff 100644 --- a/src/gallium/drivers/trace/tr_dump_state.c +++ b/src/gallium/drivers/trace/tr_dump_state.c @@ -114,6 +114,7 @@ void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state) trace_dump_member(bool, state, point_smooth); trace_dump_member(uint, state, sprite_coord_enable); trace_dump_member(bool, state, sprite_coord_mode); + trace_dump_member(bool, state, point_quad_rasterization); trace_dump_member(bool, state, point_size_per_vertex); trace_dump_member(bool, state, multisample); trace_dump_member(bool, state, line_smooth); diff --git a/src/gallium/include/pipe/p_state.h b/src/gallium/include/pipe/p_state.h index 50a4cd6e13..4387b92be2 100644 --- a/src/gallium/include/pipe/p_state.h +++ b/src/gallium/include/pipe/p_state.h @@ -103,6 +103,7 @@ struct pipe_rasterizer_state unsigned point_smooth:1; unsigned sprite_coord_enable:PIPE_MAX_SHADER_OUTPUTS; unsigned sprite_coord_mode:1; /**< PIPE_SPRITE_COORD_ */ + unsigned point_quad_rasterization:1; /** points rasterized as quads or points */ unsigned point_size_per_vertex:1; /**< size computed in vertex shader */ unsigned multisample:1; /* XXX maybe more ms state in future */ unsigned line_smooth:1; diff --git a/src/mesa/state_tracker/st_atom_rasterizer.c b/src/mesa/state_tracker/st_atom_rasterizer.c index 16c842d2f6..9c9a99bcfc 100644 --- a/src/mesa/state_tracker/st_atom_rasterizer.c +++ b/src/mesa/state_tracker/st_atom_rasterizer.c @@ -183,7 +183,7 @@ static void update_raster_state( struct st_context *st ) if (ctx->Polygon.StippleFlag) raster->poly_stipple_enable = 1; - + /* _NEW_POINT */ raster->point_size = ctx->Point.Size; @@ -202,6 +202,7 @@ static void update_raster_state( struct st_context *st ) raster->sprite_coord_enable |= 1 << i; } } + raster->point_quad_rasterization = 1; } /* ST_NEW_VERTEX_PROGRAM -- cgit v1.2.3 From dd7be07c9685012b3e9fdfbaa13dc638abf6a9d1 Mon Sep 17 00:00:00 2001 From: Roland Scheidegger Date: Mon, 8 Feb 2010 18:48:08 +0100 Subject: st/mesa: fix wrong initialization of MaxPointSize --- src/mesa/state_tracker/st_extensions.c | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'src/mesa/state_tracker') diff --git a/src/mesa/state_tracker/st_extensions.c b/src/mesa/state_tracker/st_extensions.c index 7684ccd702..cf31a0c06e 100644 --- a/src/mesa/state_tracker/st_extensions.c +++ b/src/mesa/state_tracker/st_extensions.c @@ -114,6 +114,10 @@ void st_init_limits(struct st_context *st) = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH)); c->MaxPointSizeAA = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH_AA)); + /* called after _mesa_create_context/_mesa_init_point, fix default user + * settable max point size up + */ + st->ctx->Point.MaxSize = MAX2(c->MaxPointSize, c->MaxPointSizeAA); /* these are not queryable. Note that GL basically mandates a 1.0 minimum * for non-aa sizes, but we can go down to 0.0 for aa points. */ -- cgit v1.2.3