KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

gallium: Replace gl_rasterization_rules with lower_left_origin and half_pixel_center. 

Squashed commit of the following:

commit 04c5fa2cbb8e89d6f2fa5a75af1cca03b1f6b852
Author: José Fonseca <jfonseca@vmware.com>
Date:   Tue Apr 23 17:37:18 2013 +0100

    gallium: s/lower_left_origin/bottom_edge_rule/

commit 4dff4f64fa83b9737def136fffd161d55e4f1722
Author: José Fonseca <jfonseca@vmware.com>
Date:   Tue Apr 23 17:35:04 2013 +0100

    gallium: Move diagram to docs.

commit 442a63012c8c3c3797f45e03f2ca20ad5f399832
Author: James Benton <jbenton@vmware.com>
Date:   Fri May 11 17:50:55 2012 +0100

    gallium: Replace gl_rasterization_rules with lower_left_origin and half_pixel_center.

    This change is necessary to achieve correct results when using OpenGL
    FBOs.

Reviewed-by: Marek Olšák <maraeo@gmail.com>
This commit is contained in:
José Fonseca 2013-04-23 19:40:05 +01:00
parent b692076420
commit 2737abb44e
57 changed files with 185 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/gallium/auxiliary/draw/draw_context.c
View File

@ -724,7 +724,8 @@ draw_get_rasterizer_no_cull( struct draw_context *draw,
rast.scissor = scissor;
rast.flatshade = flatshade;
rast.front_ccw = 1;
rast.gl_rasterization_rules = draw->rasterizer->gl_rasterization_rules;
rast.half_pixel_center = draw->rasterizer->half_pixel_center;
rast.bottom_edge_rule = draw->rasterizer->bottom_edge_rule;
rast.clip_halfz = draw->rasterizer->clip_halfz;
draw->rasterizer_no_cull[scissor][flatshade] =

10
src/gallium/auxiliary/draw/draw_pipe_wide_line.c
View File

@ -77,11 +77,11 @@ static void wideline_line( struct draw_stage *stage,
const float dx = fabsf(pos0[0] - pos2[0]);
const float dy = fabsf(pos0[1] - pos2[1]);
const boolean gl_rasterization_rules =
stage->draw->rasterizer->gl_rasterization_rules;
const boolean half_pixel_center =
stage->draw->rasterizer->half_pixel_center;
/* small tweak to meet GL specification */
const float bias = gl_rasterization_rules ? 0.125f : 0.0f;
const float bias = half_pixel_center ? 0.125f : 0.0f;
/*
* Draw wide line as a quad (two tris) by "stretching" the line along
@ -95,7 +95,7 @@ static void wideline_line( struct draw_stage *stage,
pos1[1] = pos1[1] + half_width - bias;
pos2[1] = pos2[1] - half_width - bias;
pos3[1] = pos3[1] + half_width - bias;
if (gl_rasterization_rules) {
if (half_pixel_center) {
if (pos0[0] < pos2[0]) {
/* left to right line */
pos0[0] -= 0.5f;
@ -118,7 +118,7 @@ static void wideline_line( struct draw_stage *stage,
pos1[0] = pos1[0] + half_width + bias;
pos2[0] = pos2[0] - half_width + bias;
pos3[0] = pos3[0] + half_width + bias;
if (gl_rasterization_rules) {
if (half_pixel_center) {
if (pos0[1] < pos2[1]) {
/* top to bottom line */
pos0[1] -= 0.5f;

2
src/gallium/auxiliary/draw/draw_pipe_wide_point.c
View File

@ -207,7 +207,7 @@ widepoint_first_point(struct draw_stage *stage,
wide->xbias = 0.0;
wide->ybias = 0.0;
if (rast->gl_rasterization_rules) {
if (rast->half_pixel_center) {
wide->xbias = 0.125;
wide->ybias = -0.125;
}

6
src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline.c
View File

@ -108,9 +108,9 @@ static void fetch_pipeline_prepare( struct draw_pt_middle_end *middle,
fpme->vertex_size,
instance_id_index );
draw_pt_post_vs_prepare( fpme->post_vs,
draw->clip_xy,
draw->clip_z,
draw->clip_user,
draw->clip_xy,
draw->clip_z,
draw->clip_user,
draw->guard_band_xy,
draw->identity_viewport,
draw->rasterizer->clip_halfz,

6
src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c
View File

@ -159,9 +159,9 @@ llvm_middle_end_prepare( struct draw_pt_middle_end *middle,
draw_pt_post_vs_prepare( fpme->post_vs,
draw->clip_xy,
draw->clip_z,
draw->clip_user,
draw->clip_xy,
draw->clip_z,
draw->clip_user,
draw->guard_band_xy,
draw->identity_viewport,
draw->rasterizer->clip_halfz,

3
src/gallium/auxiliary/hud/hud_context.c
View File

@ -990,7 +990,8 @@ hud_create(struct pipe_context *pipe, struct cso_context *cso)
}
/* rasterizer */
hud->rasterizer.gl_rasterization_rules = 1;
hud->rasterizer.half_pixel_center = 1;
hud->rasterizer.bottom_edge_rule = 1;
hud->rasterizer.depth_clip = 1;
hud->rasterizer.line_width = 1;
hud->rasterizer.line_last_pixel = 1;

3
src/gallium/auxiliary/postprocess/pp_program.c
View File

@ -87,7 +87,8 @@ pp_init_prog(struct pp_queue_t *ppq, struct pipe_context *pipe,
PIPE_BLENDFACTOR_INV_SRC_ALPHA;
p->rasterizer.cull_face = PIPE_FACE_NONE;
p->rasterizer.gl_rasterization_rules = 1;
p->rasterizer.half_pixel_center = 1;
p->rasterizer.bottom_edge_rule = 1;
p->rasterizer.depth_clip = 1;
p->sampler.wrap_s = p->sampler.wrap_t = p->sampler.wrap_r =

3
src/gallium/auxiliary/util/u_blit.c
View File

@ -118,7 +118,8 @@ util_create_blit(struct pipe_context *pipe, struct cso_context *cso)
/* rasterizer */
ctx->rasterizer.cull_face = PIPE_FACE_NONE;
ctx->rasterizer.gl_rasterization_rules = 1;
ctx->rasterizer.half_pixel_center = 1;
ctx->rasterizer.bottom_edge_rule = 1;
ctx->rasterizer.depth_clip = 1;
/* samplers */

3
src/gallium/auxiliary/util/u_blitter.c
View File

@ -239,7 +239,8 @@ struct blitter_context *util_blitter_create(struct pipe_context *pipe)
/* rasterizer state */
memset(&rs_state, 0, sizeof(rs_state));
rs_state.cull_face = PIPE_FACE_NONE;
rs_state.gl_rasterization_rules = 1;
rs_state.half_pixel_center = 1;
rs_state.bottom_edge_rule = 1;
rs_state.flatshade = 1;
rs_state.depth_clip = 1;
ctx->rs_state = pipe->create_rasterizer_state(pipe, &rs_state);

3
src/gallium/auxiliary/util/u_dump_state.c
View File

@ -327,7 +327,8 @@ util_dump_rasterizer_state(FILE *stream, const struct pipe_rasterizer_state *sta
util_dump_member(stream, uint, state, line_stipple_pattern);
util_dump_member(stream, bool, state, line_last_pixel);
util_dump_member(stream, bool, state, flatshade_first);
util_dump_member(stream, bool, state, gl_rasterization_rules);
util_dump_member(stream, bool, state, half_pixel_center);
util_dump_member(stream, bool, state, bottom_edge_rule);
util_dump_member(stream, bool, state, rasterizer_discard);
util_dump_member(stream, bool, state, depth_clip);
util_dump_member(stream, uint, state, clip_plane_enable);

3
src/gallium/auxiliary/util/u_gen_mipmap.c
View File

@ -1271,7 +1271,8 @@ util_create_gen_mipmap(struct pipe_context *pipe,
/* rasterizer */
memset(&ctx->rasterizer, 0, sizeof(ctx->rasterizer));
ctx->rasterizer.cull_face = PIPE_FACE_NONE;
ctx->rasterizer.gl_rasterization_rules = 1;
ctx->rasterizer.half_pixel_center = 1;
ctx->rasterizer.bottom_edge_rule = 1;
ctx->rasterizer.depth_clip = 1;
/* sampler state */

3
src/gallium/auxiliary/util/u_inlines.h
View File

@ -485,8 +485,7 @@ util_get_min_point_size(const struct pipe_rasterizer_state *state)
{
/* The point size should be clamped to this value at the rasterizer stage.
*/
return state->gl_rasterization_rules &&
!state->point_quad_rasterization &&
return !state->point_quad_rasterization &&
!state->point_smooth &&
!state->multisample ? 1.0f : 0.0f;
}

3
src/gallium/auxiliary/vl/vl_compositor.c
View File

@ -453,7 +453,8 @@ init_pipe_state(struct vl_compositor *c)
rast.point_size_per_vertex = 1;
rast.offset_units = 1;
rast.offset_scale = 1;
rast.gl_rasterization_rules = 1;
rast.half_pixel_center = 1;
rast.bottom_edge_rule = 1;
rast.depth_clip = 1;
c->rast = c->pipe->create_rasterizer_state(c->pipe, &rast);

3
src/gallium/auxiliary/vl/vl_idct.c
View File

@ -516,7 +516,8 @@ init_state(struct vl_idct *idct)
memset(&rs_state, 0, sizeof(rs_state));
rs_state.point_size = 1;
rs_state.gl_rasterization_rules = true;
rs_state.half_pixel_center = true;
rs_state.bottom_edge_rule = true;
rs_state.depth_clip = 1;
idct->rs_state = idct->pipe->create_rasterizer_state(idct->pipe, &rs_state);
if (!idct->rs_state)

3
src/gallium/auxiliary/vl/vl_matrix_filter.c
View File

@ -168,7 +168,8 @@ vl_matrix_filter_init(struct vl_matrix_filter *filter, struct pipe_context *pipe
filter->pipe = pipe;
memset(&rs_state, 0, sizeof(rs_state));
rs_state.gl_rasterization_rules = true;
rs_state.half_pixel_center = true;
rs_state.bottom_edge_rule = true;
rs_state.depth_clip = 1;
filter->rs_state = pipe->create_rasterizer_state(pipe, &rs_state);
if (!filter->rs_state)

3
src/gallium/auxiliary/vl/vl_mc.c
View File

@ -428,7 +428,8 @@ init_pipe_state(struct vl_mc *r)
rs_state.sprite_coord_mode = PIPE_SPRITE_COORD_UPPER_LEFT;
rs_state.point_quad_rasterization = true;
rs_state.point_size = VL_BLOCK_WIDTH;
rs_state.gl_rasterization_rules = true;
rs_state.half_pixel_center = true;
rs_state.bottom_edge_rule = true;
rs_state.depth_clip = 1;
r->rs_state = r->pipe->create_rasterizer_state(r->pipe, &rs_state);
if (!r->rs_state)

3
src/gallium/auxiliary/vl/vl_median_filter.c
View File

@ -254,7 +254,8 @@ vl_median_filter_init(struct vl_median_filter *filter, struct pipe_context *pipe
filter->pipe = pipe;
memset(&rs_state, 0, sizeof(rs_state));
rs_state.gl_rasterization_rules = true;
rs_state.half_pixel_center = true;
rs_state.bottom_edge_rule = true;
rs_state.depth_clip = 1;
filter->rs_state = pipe->create_rasterizer_state(pipe, &rs_state);
if (!filter->rs_state)

3
src/gallium/auxiliary/vl/vl_zscan.c
View File

@ -270,7 +270,8 @@ init_state(struct vl_zscan *zscan)
assert(zscan);
memset(&rs_state, 0, sizeof(rs_state));
rs_state.gl_rasterization_rules = true;
rs_state.half_pixel_center = true;
rs_state.bottom_edge_rule = true;
rs_state.depth_clip = 1;
zscan->rs_state = zscan->pipe->create_rasterizer_state(zscan->pipe, &rs_state);
if (!zscan->rs_state)

73
src/gallium/docs/source/cso/rasterizer.rst
View File

@ -238,9 +238,76 @@ scissor
multisample
Whether :term:`MSAA` is enabled.
gl_rasterization_rules
Whether the rasterizer should use (0.5, 0.5) pixel centers. When not set,
the rasterizer will use (0, 0) for pixel centers.
half_pixel_center
When true, the rasterizer should use (0.5, 0.5) pixel centers for
determining pixel ownership (e.g, OpenGL, D3D10 and higher)::
0 0.5 1
0 +-----+
| |
0.5 | X |
| |
1 +-----+
When false, the rasterizer should use (0, 0) pixel centers for determining
pixel ownership (e.g., D3D9 or ealier)::
-0.5 0 0.5
-0.5 +-----+
| |
0 | X |
| |
0.5 +-----+
bottom_edge_rule
Determines what happens when a pixel sample lies precisely on a triangle
edge.
When true, a pixel sample is considered to lie inside of a triangle if it
lies on the *bottom edge* or *left edge* (e.g., OpenGL drawables)::
0 x
0 +--------------------->
|
| +-------------+
| | |
| | |
| | |
| +=============+
|
y V
When false, a pixel sample is considered to lie inside of a triangle if it
lies on the *top edge* or *left edge* (e.g., OpenGL FBOs, D3D)::
0 x
0 +--------------------->
|
| +=============+
| | |
| | |
| | |
| +-------------+
|
y V
Where:
- a *top edge* is an edge that is horizontal and is above the other edges;
- a *bottom edge* is an edge that is horizontal and is below the other
edges;
- a *left edge* is an edge that is not horizontal and is on the left side of
the triangle.
.. note::
Actually all graphics APIs use a top-left rasterization rule for pixel
ownership, but their notion of top varies with the axis origin (which
can be either at y = 0 or at y = height). Gallium instead always
assumes that top is always at y=0.
See also:
- http://msdn.microsoft.com/en-us/library/windows/desktop/cc627092.aspx
- http://msdn.microsoft.com/en-us/library/windows/desktop/bb147314.aspx
clip_halfz
When true clip space in the z axis goes from [0..1] (D3D). When false

2
src/gallium/docs/source/tgsi.rst
View File

@ -2168,7 +2168,7 @@ If HALF_INTEGER, the fractionary part of the position will be 0.5
If INTEGER, the fractionary part of the position will be 0.0
Note that this does not affect the set of fragments generated by
rasterization, which is instead controlled by gl_rasterization_rules in the
rasterization, which is instead controlled by half_pixel_center in the
rasterizer.
OpenGL defaults to HALF_INTEGER, and is configurable with the

2
src/gallium/drivers/freedreno/freedreno_rasterizer.c
View File

@ -81,7 +81,7 @@ fd_rasterizer_state_create(struct pipe_context *pctx,
so->pa_cl_clip_cntl = 0; // TODO
so->pa_su_vtx_cntl =
A2XX_PA_SU_VTX_CNTL_PIX_CENTER(cso->gl_rasterization_rules ? PIXCENTER_OGL : PIXCENTER_D3D) |
A2XX_PA_SU_VTX_CNTL_PIX_CENTER(cso->half_pixel_center ? PIXCENTER_OGL : PIXCENTER_D3D) |
A2XX_PA_SU_VTX_CNTL_QUANT_MODE(ONE_SIXTEENTH);
so->pa_su_point_size =

6
src/gallium/drivers/llvmpipe/lp_setup.c
View File

@ -491,14 +491,16 @@ lp_setup_set_triangle_state( struct lp_setup_context *setup,
unsigned cull_mode,
boolean ccw_is_frontface,
boolean scissor,
boolean gl_rasterization_rules)
boolean half_pixel_center,
boolean bottom_edge_rule)
{
LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
setup->ccw_is_frontface = ccw_is_frontface;
setup->cullmode = cull_mode;
setup->triangle = first_triangle;
setup->pixel_offset = gl_rasterization_rules ? 0.5f : 0.0f;
setup->pixel_offset = half_pixel_center ? 0.5f : 0.0f;
setup->bottom_edge_rule = bottom_edge_rule;
if (setup->scissor_test != scissor) {
setup->dirty |= LP_SETUP_NEW_SCISSOR;

3
src/gallium/drivers/llvmpipe/lp_setup.h
View File

@ -77,7 +77,8 @@ lp_setup_set_triangle_state( struct lp_setup_context *setup,
unsigned cullmode,
boolean front_is_ccw,
boolean scissor,
boolean gl_rasterization_rules );
boolean half_pixel_center,
boolean bottom_edge_rule);
void
lp_setup_set_line_state( struct lp_setup_context *setup,

1
src/gallium/drivers/llvmpipe/lp_setup_context.h
View File

@ -98,6 +98,7 @@ struct lp_setup_context
boolean point_size_per_vertex;
boolean rasterizer_discard;
unsigned cullmode;
unsigned bottom_edge_rule;
float pixel_offset;
float line_width;
float point_size;

11
src/gallium/drivers/llvmpipe/lp_setup_line.c
View File

@ -621,17 +621,6 @@ try_setup_line( struct lp_setup_context *setup,
/* correct for top-left vs. bottom-left fill convention.
*
* note that we're overloading gl_rasterization_rules to mean
* both (0.5,0.5) pixel centers *and* bottom-left filling
* convention.
*
* GL actually has a top-left filling convention, but GL's
* notion of "top" differs from gallium's...
*
* Also, sometimes (in FBO cases) GL will render upside down
* to its usual method, in which case it will probably want
* to use the opposite, top-left convention.
*/
if (plane[i].dcdx < 0) {
/* both fill conventions want this - adjust for left edges */

17
src/gallium/drivers/llvmpipe/lp_setup_tri.c
View File

@ -365,7 +365,7 @@ do_triangle_ccw(struct lp_setup_context *setup,
dcdx_zero_mask = _mm_cmpeq_epi32(dcdx, zero);
dcdy_neg_mask = _mm_srai_epi32(dcdy, 31);
top_left_flag = _mm_set1_epi32((setup->pixel_offset == 0) ? ~0 : 0);
top_left_flag = _mm_set1_epi32((setup->bottom_edge_rule == 0) ? ~0 : 0);
c_inc_mask = _mm_or_si128(dcdx_neg_mask,
_mm_and_si128(dcdx_zero_mask,
@ -417,25 +417,14 @@ do_triangle_ccw(struct lp_setup_context *setup,
*/
plane[i].c = plane[i].dcdx * position->x[i] - plane[i].dcdy * position->y[i];
/* correct for top-left vs. bottom-left fill convention.
*
* note that we're overloading gl_rasterization_rules to mean
* both (0.5,0.5) pixel centers *and* bottom-left filling
* convention.
*
* GL actually has a top-left filling convention, but GL's
* notion of "top" differs from gallium's...
*
* Also, sometimes (in FBO cases) GL will render upside down
* to its usual method, in which case it will probably want
* to use the opposite, top-left convention.
/* correct for top-left vs. bottom-left fill convention.
*/
if (plane[i].dcdx < 0) {
/* both fill conventions want this - adjust for left edges */
plane[i].c++;
}
else if (plane[i].dcdx == 0) {
if (setup->pixel_offset == 0) {
if (setup->bottom_edge_rule == 0){
/* correct for top-left fill convention:
*/
if (plane[i].dcdy > 0) plane[i].c++;

19
src/gallium/drivers/llvmpipe/lp_state_rasterizer.c
View File

@ -114,21 +114,22 @@ llvmpipe_bind_rasterizer_state(struct pipe_context *pipe, void *handle)
/* XXX: just pass lp_state directly to setup.
*/
lp_setup_set_triangle_state( llvmpipe->setup,
state->lp_state.cull_face,
state->lp_state.front_ccw,
state->lp_state.scissor,
state->lp_state.gl_rasterization_rules);
state->lp_state.cull_face,
state->lp_state.front_ccw,
state->lp_state.scissor,
state->lp_state.half_pixel_center,
state->lp_state.bottom_edge_rule);
lp_setup_set_flatshade_first( llvmpipe->setup,
state->lp_state.flatshade_first);
lp_setup_set_rasterizer_discard( llvmpipe->setup,
state->lp_state.rasterizer_discard);
lp_setup_set_line_state( llvmpipe->setup,
state->lp_state.line_width);
state->lp_state.line_width);
lp_setup_set_point_state( llvmpipe->setup,
state->lp_state.point_size,
state->lp_state.point_size_per_vertex,
state->lp_state.sprite_coord_enable,
state->lp_state.sprite_coord_mode);
state->lp_state.point_size,
state->lp_state.point_size_per_vertex,
state->lp_state.sprite_coord_enable,
state->lp_state.sprite_coord_mode);
}
else {
llvmpipe->rasterizer = NULL;

2
src/gallium/drivers/llvmpipe/lp_state_setup.c
View File

@ -807,7 +807,7 @@ lp_make_setup_variant_key(struct llvmpipe_context *lp,
key->num_inputs = fs->info.base.num_inputs;
key->flatshade_first = lp->rasterizer->flatshade_first;
key->pixel_center_half = lp->rasterizer->gl_rasterization_rules;
key->pixel_center_half = lp->rasterizer->half_pixel_center;
key->twoside = lp->rasterizer->light_twoside;
key->size = Offset(struct lp_setup_variant_key,
inputs[key->num_inputs]);

2
src/gallium/drivers/nv50/nv50_state.c
View File

@ -57,7 +57,7 @@
* ! pipe_rasterizer_state.flatshade_first also applies to QUADS
* (There's a GL query for that, forcing an exception is just ridiculous.)
*
* ! pipe_rasterizer_state.gl_rasterization_rules is ignored - pixel centers
* ! pipe_rasterizer_state.half_pixel_center is ignored - pixel centers
* are always at half integer coordinates and the top-left rule applies
* (There does not seem to be a hardware switch for this.)
*

2
src/gallium/drivers/nvc0/nvc0_surface.c
View File

@ -1241,7 +1241,7 @@ nvc0_blitctx_create(struct nvc0_context *nvc0)
nvc0->blit->nvc0 = nvc0;
nvc0->blit->rast.pipe.gl_rasterization_rules = 1;
nvc0->blit->rast.pipe.half_pixel_center = 1;
return TRUE;
}

4
src/gallium/drivers/r600/evergreen_state.c
View File

@ -970,11 +970,11 @@ static void *evergreen_create_rs_state(struct pipe_context *ctx,
if (rctx->chip_class == CAYMAN) {
r600_store_context_reg(&rs->buffer, CM_R_028BE4_PA_SU_VTX_CNTL,
S_028C08_PIX_CENTER_HALF(state->gl_rasterization_rules) |
S_028C08_PIX_CENTER_HALF(state->half_pixel_center) |
S_028C08_QUANT_MODE(V_028C08_X_1_256TH));
} else {
r600_store_context_reg(&rs->buffer, R_028C08_PA_SU_VTX_CNTL,
S_028C08_PIX_CENTER_HALF(state->gl_rasterization_rules) |
S_028C08_PIX_CENTER_HALF(state->half_pixel_center) |
S_028C08_QUANT_MODE(V_028C08_X_1_256TH));
}

2
src/gallium/drivers/r600/r600_state.c
View File

@ -960,7 +960,7 @@ static void *r600_create_rs_state(struct pipe_context *ctx,
r600_store_context_reg(&rs->buffer, R_0286D4_SPI_INTERP_CONTROL_0, spi_interp);
r600_store_context_reg(&rs->buffer, R_028A4C_PA_SC_MODE_CNTL, sc_mode_cntl);
r600_store_context_reg(&rs->buffer, R_028C08_PA_SU_VTX_CNTL,
S_028C08_PIX_CENTER_HALF(state->gl_rasterization_rules) |
S_028C08_PIX_CENTER_HALF(state->half_pixel_center) |
S_028C08_QUANT_MODE(V_028C08_X_1_256TH));
r600_store_context_reg(&rs->buffer, R_028DFC_PA_SU_POLY_OFFSET_CLAMP, fui(state->offset_clamp));
r600_store_context_reg(&rs->buffer, R_028814_PA_SU_SC_MODE_CNTL,

2
src/gallium/drivers/radeonsi/si_state.c
View File

@ -460,7 +460,7 @@ static void *si_create_rs_state(struct pipe_context *ctx,
si_pm4_set_reg(pm4, R_028BDC_PA_SC_LINE_CNTL, 0x00000400);
si_pm4_set_reg(pm4, R_028BE4_PA_SU_VTX_CNTL,
S_028BE4_PIX_CENTER(state->gl_rasterization_rules));
S_028BE4_PIX_CENTER(state->half_pixel_center));
si_pm4_set_reg(pm4, R_028BE8_PA_CL_GB_VERT_CLIP_ADJ, 0x3F800000);
si_pm4_set_reg(pm4, R_028BEC_PA_CL_GB_VERT_DISC_ADJ, 0x3F800000);
si_pm4_set_reg(pm4, R_028BF0_PA_CL_GB_HORZ_CLIP_ADJ, 0x3F800000);

2
src/gallium/drivers/softpipe/sp_setup.c
View File

@ -394,7 +394,7 @@ setup_sort_vertices(struct setup_context *setup,
* - pixel center (0.5, 0.5) for GL, or
* - assume (0.0, 0.0) for other APIs.
*/
if (setup->softpipe->rasterizer->gl_rasterization_rules) {
if (setup->softpipe->rasterizer->half_pixel_center) {
setup->pixel_offset = 0.5f;
} else {
setup->pixel_offset = 0.0f;

2
src/gallium/drivers/svga/svga_pipe_rasterizer.c
View File

@ -78,7 +78,7 @@ svga_create_rasterizer_state(struct pipe_context *pipe,
/* point_size_per_vertex - ? */
/* sprite_coord_mode - ??? */
/* flatshade_first - handled by index translation */
/* gl_rasterization_rules - XXX - viewport code */
/* half_pixel_center - XXX - viewport code */
/* line_width - draw module */
/* fill_cw, fill_ccw - draw module or index translation */

2
src/gallium/drivers/svga/svga_state_framebuffer.c
View File

@ -305,7 +305,7 @@ emit_viewport( struct svga_context *svga,
* screen-space coordinates slightly relative to D3D which is
* what hardware implements natively.
*/
if (svga->curr.rast->templ.gl_rasterization_rules) {
if (svga->curr.rast->templ.half_pixel_center) {
float adjust_x = 0.0;
float adjust_y = 0.0;

3
src/gallium/drivers/trace/tr_dump_state.c
View File

@ -146,7 +146,8 @@ void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state)
trace_dump_member(uint, state, line_stipple_pattern);
trace_dump_member(bool, state, line_last_pixel);
trace_dump_member(bool, state, flatshade_first);
trace_dump_member(bool, state, gl_rasterization_rules);
trace_dump_member(bool, state, half_pixel_center);
trace_dump_member(bool, state, bottom_edge_rule);
trace_dump_member(bool, state, rasterizer_discard);
trace_dump_member(bool, state, depth_clip);
trace_dump_member(uint, state, clip_plane_enable);

14
src/gallium/include/pipe/p_state.h
View File

@ -107,18 +107,8 @@ struct pipe_rasterizer_state
*/
unsigned flatshade_first:1;
/**
* When true, triangle rasterization uses (0.5, 0.5) pixel centers
* for determining pixel ownership.
*
* When false, triangle rasterization uses (0,0) pixel centers for
* determining pixel ownership.
*
* Triangle rasterization always uses a 'top,left' rule for pixel
* ownership, this just alters which point we consider the pixel
* center for that test.
*/
unsigned gl_rasterization_rules:1;
unsigned half_pixel_center:1;
unsigned bottom_edge_rule:1;
/**
* When true, rasterization is disabled and no pixels are written.

3
src/gallium/state_trackers/vega/renderer.c
View File

@ -1175,7 +1175,8 @@ struct renderer * renderer_create(struct vg_context *owner)
/* GL rasterization rules */
raster = &renderer->g3d.rasterizer;
memset(raster, 0, sizeof(*raster));
raster->gl_rasterization_rules = 1;
raster->half_pixel_center = 1;
raster->bottom_edge_rule = 1;
raster->depth_clip = 1;
cso_set_rasterizer(renderer->cso, raster);

3
src/gallium/state_trackers/xa/xa_renderer.c
View File

@ -108,7 +108,8 @@ renderer_init_state(struct xa_context *r)
/* XXX: move to renderer_init_state? */
memset(&raster, 0, sizeof(struct pipe_rasterizer_state));
raster.gl_rasterization_rules = 1;
raster.half_pixel_center = 1;
raster.bottom_edge_rule = 1;
raster.depth_clip = 1;
cso_set_rasterizer(r->cso, &raster);

3
src/gallium/state_trackers/xorg/xorg_renderer.c
View File

@ -81,7 +81,8 @@ renderer_init_state(struct xorg_renderer *r)
/* XXX: move to renderer_init_state? */
memset(&raster, 0, sizeof(struct pipe_rasterizer_state));
raster.gl_rasterization_rules = 1;
raster.half_pixel_center = 1;
raster.bottom_edge_rule = 1;
raster.depth_clip = 1;
cso_set_rasterizer(r->cso, &raster);

3
src/gallium/tests/graw/fs-test.c
View File

@ -458,7 +458,8 @@ static void init( void )
void *handle;
memset(&rasterizer, 0, sizeof rasterizer);
rasterizer.cull_face = PIPE_FACE_NONE;
rasterizer.gl_rasterization_rules = 1;
rasterizer.half_pixel_center = 1;
rasterizer.bottom_edge_rule = 1;
rasterizer.depth_clip = 1;
handle = ctx->create_rasterizer_state(ctx, &rasterizer);
ctx->bind_rasterizer_state(ctx, handle);

3
src/gallium/tests/graw/graw_util.h
View File

@ -173,7 +173,8 @@ graw_util_default_state(struct graw_info *info, boolean depth_test)
void *handle;
memset(&rasterizer, 0, sizeof rasterizer);
rasterizer.cull_face = PIPE_FACE_NONE;
rasterizer.gl_rasterization_rules = 1;
rasterizer.half_pixel_center = 1;
rasterizer.bottom_edge_rule = 1;
handle = info->ctx->create_rasterizer_state(info->ctx, &rasterizer);
info->ctx->bind_rasterizer_state(info->ctx, handle);
}

3
src/gallium/tests/graw/gs-test.c
View File

@ -565,7 +565,8 @@ static void init( void )
void *handle;
memset(&rasterizer, 0, sizeof rasterizer);
rasterizer.cull_face = PIPE_FACE_NONE;
rasterizer.gl_rasterization_rules = 1;
rasterizer.half_pixel_center = 1;
rasterizer.bottom_edge_rule = 1;
rasterizer.depth_clip = 1;
handle = ctx->create_rasterizer_state(ctx, &rasterizer);
ctx->bind_rasterizer_state(ctx, handle);

3
src/gallium/tests/graw/quad-sample.c
View File

@ -373,7 +373,8 @@ static void init( void )
void *handle;
memset(&rasterizer, 0, sizeof rasterizer);
rasterizer.cull_face = PIPE_FACE_NONE;
rasterizer.gl_rasterization_rules = 1;
rasterizer.half_pixel_center = 1;
rasterizer.bottom_edge_rule = 1;
rasterizer.depth_clip = 1;
handle = ctx->create_rasterizer_state(ctx, &rasterizer);
ctx->bind_rasterizer_state(ctx, handle);

3
src/gallium/tests/graw/quad-tex.c
View File

@ -188,7 +188,8 @@ static void init( void )
void *handle;
memset(&rasterizer, 0, sizeof rasterizer);
rasterizer.cull_face = PIPE_FACE_NONE;
rasterizer.gl_rasterization_rules = 1;
rasterizer.half_pixel_center = 1;
rasterizer.bottom_edge_rule = 1;
rasterizer.depth_clip = 1;
handle = info.ctx->create_rasterizer_state(info.ctx, &rasterizer);
info.ctx->bind_rasterizer_state(info.ctx, handle);

3
src/gallium/tests/graw/shader-leak.c
View File

@ -250,7 +250,8 @@ static void init( void )
void *handle;
memset(&rasterizer, 0, sizeof rasterizer);
rasterizer.cull_face = PIPE_FACE_NONE;
rasterizer.gl_rasterization_rules = 1;
rasterizer.half_pixel_center = 1;
rasterizer.bottom_edge_rule = 1;
rasterizer.depth_clip = 1;
handle = ctx->create_rasterizer_state(ctx, &rasterizer);
ctx->bind_rasterizer_state(ctx, handle);

3
src/gallium/tests/graw/tri-gs.c
View File

@ -255,7 +255,8 @@ static void init( void )
void *handle;
memset(&rasterizer, 0, sizeof rasterizer);
rasterizer.cull_face = PIPE_FACE_NONE;
rasterizer.gl_rasterization_rules = 1;
rasterizer.half_pixel_center = 1;
rasterizer.bottom_edge_rule = 1;
rasterizer.depth_clip = 1;
handle = ctx->create_rasterizer_state(ctx, &rasterizer);
ctx->bind_rasterizer_state(ctx, handle);

3
src/gallium/tests/graw/tri-instanced.c
View File

@ -306,7 +306,8 @@ static void init( void )
void *handle;
memset(&rasterizer, 0, sizeof rasterizer);
rasterizer.cull_face = PIPE_FACE_NONE;
rasterizer.gl_rasterization_rules = 1;
rasterizer.half_pixel_center = 1;
rasterizer.bottom_edge_rule = 1;
rasterizer.depth_clip = 1;
handle = ctx->create_rasterizer_state(ctx, &rasterizer);
ctx->bind_rasterizer_state(ctx, handle);

3
src/gallium/tests/graw/tri.c
View File

@ -125,7 +125,8 @@ static void init( void )
void *handle;
memset(&rasterizer, 0, sizeof rasterizer);
rasterizer.cull_face = PIPE_FACE_NONE;
rasterizer.gl_rasterization_rules = 1;
rasterizer.half_pixel_center = 1;
rasterizer.bottom_edge_rule = 1;
rasterizer.flatshade = FlatShade;
rasterizer.depth_clip = 1;
handle = info.ctx->create_rasterizer_state(info.ctx, &rasterizer);

3
src/gallium/tests/graw/vs-test.c
View File

@ -453,7 +453,8 @@ static void init( void )
memset(&rasterizer, 0, sizeof rasterizer);
rasterizer.cull_face = PIPE_FACE_NONE;
rasterizer.point_size = 8.0;
rasterizer.gl_rasterization_rules = 1;
rasterizer.half_pixel_center = 1;
rasterizer.bottom_edge_rule = 1;
rasterizer.depth_clip = 1;
handle = ctx->create_rasterizer_state(ctx, &rasterizer);
ctx->bind_rasterizer_state(ctx, handle);

3
src/gallium/tests/trivial/quad-tex.c
View File

@ -197,7 +197,8 @@ static void init_prog(struct program *p)
/* rasterizer */
memset(&p->rasterizer, 0, sizeof(p->rasterizer));
p->rasterizer.cull_face = PIPE_FACE_NONE;
p->rasterizer.gl_rasterization_rules = 1;
p->rasterizer.half_pixel_center = 1;
p->rasterizer.bottom_edge_rule = 1;
p->rasterizer.depth_clip = 1;
/* sampler */

3
src/gallium/tests/trivial/tri.c
View File

@ -152,7 +152,8 @@ static void init_prog(struct program *p)
/* rasterizer */
memset(&p->rasterizer, 0, sizeof(p->rasterizer));
p->rasterizer.cull_face = PIPE_FACE_NONE;
p->rasterizer.gl_rasterization_rules = 1;
p->rasterizer.half_pixel_center = 1;
p->rasterizer.bottom_edge_rule = 1;
p->rasterizer.depth_clip = 1;
surf_tmpl.format = PIPE_FORMAT_B8G8R8A8_UNORM;

5
src/mesa/state_tracker/st_atom_rasterizer.c
View File

@ -228,7 +228,10 @@ static void update_raster_state( struct st_context *st )
/* _NEW_FRAG_CLAMP */
raster->clamp_fragment_color = !st->clamp_frag_color_in_shader &&
ctx->Color._ClampFragmentColor;
raster->gl_rasterization_rules = 1;
raster->half_pixel_center = 1;
if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP)
raster->bottom_edge_rule = 1;
/* _NEW_RASTERIZER_DISCARD */
raster->rasterizer_discard = ctx->RasterDiscard;

3
src/mesa/state_tracker/st_cb_bitmap.c
View File

@ -825,7 +825,8 @@ st_init_bitmap(struct st_context *st)
/* init baseline rasterizer state once */
memset(&st->bitmap.rasterizer, 0, sizeof(st->bitmap.rasterizer));
st->bitmap.rasterizer.gl_rasterization_rules = 1;
st->bitmap.rasterizer.half_pixel_center = 1;
st->bitmap.rasterizer.bottom_edge_rule = 1;
st->bitmap.rasterizer.depth_clip = 1;
/* find a usable texture format */

3
src/mesa/state_tracker/st_cb_clear.c
View File

@ -67,7 +67,8 @@ st_init_clear(struct st_context *st)
{
memset(&st->clear, 0, sizeof(st->clear));
st->clear.raster.gl_rasterization_rules = 1;
st->clear.raster.half_pixel_center = 1;
st->clear.raster.bottom_edge_rule = 1;
st->clear.raster.depth_clip = 1;
}

3
src/mesa/state_tracker/st_cb_drawpixels.c
View File

@ -710,7 +710,8 @@ draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
memset(&rasterizer, 0, sizeof(rasterizer));
rasterizer.clamp_fragment_color = !st->clamp_frag_color_in_shader &&
ctx->Color._ClampFragmentColor;
rasterizer.gl_rasterization_rules = 1;
rasterizer.half_pixel_center = 1;
rasterizer.bottom_edge_rule = 1;
rasterizer.depth_clip = !ctx->Transform.DepthClamp;
rasterizer.scissor = ctx->Scissor.Enabled;
cso_set_rasterizer(cso, &rasterizer);