fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-08 02:38:04 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

softpipe: Split changing fields of quad_header into input, inout and output parts.

Browse source
This commit is contained in:
Michal Krol 2008-09-06 16:02:24 +02:00
parent 84cde72b3e
commit 01f9e51203
15 changed files with 183 additions and 173 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/gallium/drivers/softpipe/sp_fs_exec.c
View file

@ -106,7 +106,7 @@ exec_run( const struct sp_fragment_shader *base,
/* Compute X, Y, Z, W vals for this quad */
sp_setup_pos_vector(quad->posCoef,
(float)quad->x0, (float)quad->y0,
(float)quad->input.x0, (float)quad->input.y0,
&machine->QuadPos);
return tgsi_exec_machine_run( machine );

2
src/gallium/drivers/softpipe/sp_fs_sse.c
View file

@ -88,7 +88,7 @@ fs_sse_run( const struct sp_fragment_shader *base,
/* Compute X, Y, Z, W vals for this quad -- place in temp[0] for now */
sp_setup_pos_vector(quad->posCoef,
(float)quad->x0, (float)quad->y0,
(float)quad->input.x0, (float)quad->input.y0,
machine->Temps);
/* init kill mask */

29
src/gallium/drivers/softpipe/sp_headers.h
View file

@ -59,20 +59,31 @@
* Encodes everything we need to know about a 2x2 pixel block. Uses
* "Channel-Serial" or "SoA" layout.
*/
struct quad_header {
struct quad_header_input
{
int x0;
int y0;
unsigned mask:4;
float coverage[QUAD_SIZE]; /** fragment coverage for antialiasing */
unsigned facing:1; /**< Front (0) or back (1) facing? */
unsigned prim:2; /**< PRIM_POINT, LINE, TRI */
};
struct {
/** colors in SOA format (rrrr, gggg, bbbb, aaaa) */
float color[PIPE_MAX_COLOR_BUFS][NUM_CHANNELS][QUAD_SIZE];
float depth[QUAD_SIZE];
} outputs;
struct quad_header_inout
{
unsigned mask:4;
};
float coverage[QUAD_SIZE]; /** fragment coverage for antialiasing */
struct quad_header_output
{
/** colors in SOA format (rrrr, gggg, bbbb, aaaa) */
float color[PIPE_MAX_COLOR_BUFS][NUM_CHANNELS][QUAD_SIZE];
float depth[QUAD_SIZE];
};
struct quad_header {
struct quad_header_input input;
struct quad_header_inout inout;
struct quad_header_output output;
const struct tgsi_interp_coef *coef;
const struct tgsi_interp_coef *posCoef;
@ -80,5 +91,5 @@ struct quad_header {
unsigned nr_attrs;
};
#endif /* SP_HEADERS_H */

7
src/gallium/drivers/softpipe/sp_quad_alpha_test.c
View file

@ -17,11 +17,10 @@ alpha_test_quad(struct quad_stage *qs, struct quad_header *quad)
const float ref = softpipe->depth_stencil->alpha.ref;
unsigned passMask = 0x0, j;
const uint cbuf = 0; /* only output[0].alpha is tested */
const float *aaaa = quad->outputs.color[cbuf][3];
const float *aaaa = quad->output.color[cbuf][3];
switch (softpipe->depth_stencil->alpha.func) {
case PIPE_FUNC_NEVER:
quad->mask = 0x0;
break;
case PIPE_FUNC_LESS:
/*
@ -76,9 +75,9 @@ alpha_test_quad(struct quad_stage *qs, struct quad_header *quad)
assert(0);
}
quad->mask &= passMask;
quad->inout.mask &= passMask;
if (quad->mask)
if (quad->inout.mask)
qs->next->run(qs->next, quad);
}

16
src/gallium/drivers/softpipe/sp_quad_blend.c
View file

@ -114,14 +114,14 @@ logicop_quad(struct quad_stage *qs, struct quad_header *quad)
struct softpipe_cached_tile *
tile = sp_get_cached_tile(softpipe,
softpipe->cbuf_cache[cbuf],
quad->x0, quad->y0);
float (*quadColor)[4] = quad->outputs.color[cbuf];
quad->input.x0, quad->input.y0);
float (*quadColor)[4] = quad->output.color[cbuf];
uint i, j;
/* get/swizzle dest colors */
for (j = 0; j < QUAD_SIZE; j++) {
int x = (quad->x0 & (TILE_SIZE-1)) + (j & 1);
int y = (quad->y0 & (TILE_SIZE-1)) + (j >> 1);
int x = (quad->input.x0 & (TILE_SIZE-1)) + (j & 1);
int y = (quad->input.y0 & (TILE_SIZE-1)) + (j >> 1);
for (i = 0; i < 4; i++) {
dest[i][j] = tile->data.color[y][x][i];
}
@ -244,14 +244,14 @@ blend_quad(struct quad_stage *qs, struct quad_header *quad)
struct softpipe_cached_tile *tile
= sp_get_cached_tile(softpipe,
softpipe->cbuf_cache[cbuf],
quad->x0, quad->y0);
float (*quadColor)[4] = quad->outputs.color[cbuf];
quad->input.x0, quad->input.y0);
float (*quadColor)[4] = quad->output.color[cbuf];
uint i, j;
/* get/swizzle dest colors */
for (j = 0; j < QUAD_SIZE; j++) {
int x = (quad->x0 & (TILE_SIZE-1)) + (j & 1);
int y = (quad->y0 & (TILE_SIZE-1)) + (j >> 1);
int x = (quad->input.x0 & (TILE_SIZE-1)) + (j & 1);
int y = (quad->input.y0 & (TILE_SIZE-1)) + (j >> 1);
for (i = 0; i < 4; i++) {
dest[i][j] = tile->data.color[y][x][i];
}

8
src/gallium/drivers/softpipe/sp_quad_colormask.c
View file

@ -56,14 +56,14 @@ colormask_quad(struct quad_stage *qs, struct quad_header *quad)
struct softpipe_cached_tile *tile
= sp_get_cached_tile(softpipe,
softpipe->cbuf_cache[cbuf],
quad->x0, quad->y0);
float (*quadColor)[4] = quad->outputs.color[cbuf];
quad->input.x0, quad->input.y0);
float (*quadColor)[4] = quad->output.color[cbuf];
uint i, j;
/* get/swizzle dest colors */
for (j = 0; j < QUAD_SIZE; j++) {
int x = (quad->x0 & (TILE_SIZE-1)) + (j & 1);
int y = (quad->y0 & (TILE_SIZE-1)) + (j >> 1);
int x = (quad->input.x0 & (TILE_SIZE-1)) + (j & 1);
int y = (quad->input.y0 & (TILE_SIZE-1)) + (j >> 1);
for (i = 0; i < 4; i++) {
dest[i][j] = tile->data.color[y][x][i];
}

14
src/gallium/drivers/softpipe/sp_quad_coverage.c
View file

@ -47,19 +47,19 @@ coverage_quad(struct quad_stage *qs, struct quad_header *quad)
{
struct softpipe_context *softpipe = qs->softpipe;
if ((softpipe->rasterizer->poly_smooth && quad->prim == PRIM_TRI) ||
(softpipe->rasterizer->line_smooth && quad->prim == PRIM_LINE) ||
(softpipe->rasterizer->point_smooth && quad->prim == PRIM_POINT)) {
if ((softpipe->rasterizer->poly_smooth && quad->input.prim == PRIM_TRI) ||
(softpipe->rasterizer->line_smooth && quad->input.prim == PRIM_LINE) ||
(softpipe->rasterizer->point_smooth && quad->input.prim == PRIM_POINT)) {
uint cbuf;
/* loop over colorbuffer outputs */
for (cbuf = 0; cbuf < softpipe->framebuffer.num_cbufs; cbuf++) {
float (*quadColor)[4] = quad->outputs.color[cbuf];
float (*quadColor)[4] = quad->output.color[cbuf];
unsigned j;
for (j = 0; j < QUAD_SIZE; j++) {
assert(quad->coverage[j] >= 0.0);
assert(quad->coverage[j] <= 1.0);
quadColor[3][j] *= quad->coverage[j];
assert(quad->input.coverage[j] >= 0.0);
assert(quad->input.coverage[j] <= 1.0);
quadColor[3][j] *= quad->input.coverage[j];
}
}
}

52
src/gallium/drivers/softpipe/sp_quad_depth_test.c
View file

@ -60,7 +60,7 @@ sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
unsigned zmask = 0;
unsigned j;
struct softpipe_cached_tile *tile
= sp_get_cached_tile(softpipe, softpipe->zsbuf_cache, quad->x0, quad->y0);
= sp_get_cached_tile(softpipe, softpipe->zsbuf_cache, quad->input.x0, quad->input.y0);
assert(ps); /* shouldn't get here if there's no zbuffer */
@ -79,12 +79,12 @@ sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
float scale = 65535.0;
for (j = 0; j < QUAD_SIZE; j++) {
qzzzz[j] = (unsigned) (quad->outputs.depth[j] * scale);
qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
}
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1);
bzzzz[j] = tile->data.depth16[y][x];
}
}
@ -94,12 +94,12 @@ sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
double scale = (double) (uint) ~0UL;
for (j = 0; j < QUAD_SIZE; j++) {
qzzzz[j] = (unsigned) (quad->outputs.depth[j] * scale);
qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
}
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1);
bzzzz[j] = tile->data.depth32[y][x];
}
}
@ -111,12 +111,12 @@ sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
float scale = (float) ((1 << 24) - 1);
for (j = 0; j < QUAD_SIZE; j++) {
qzzzz[j] = (unsigned) (quad->outputs.depth[j] * scale);
qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
}
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1);
bzzzz[j] = tile->data.depth32[y][x] & 0xffffff;
}
}
@ -128,12 +128,12 @@ sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
float scale = (float) ((1 << 24) - 1);
for (j = 0; j < QUAD_SIZE; j++) {
qzzzz[j] = (unsigned) (quad->outputs.depth[j] * scale);
qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
}
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1);
bzzzz[j] = tile->data.depth32[y][x] >> 8;
}
}
@ -192,14 +192,14 @@ sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
assert(0);
}
quad->mask &= zmask;
quad->inout.mask &= zmask;
if (softpipe->depth_stencil->depth.writemask) {
/* This is also efficient with sse / spe instructions:
*/
for (j = 0; j < QUAD_SIZE; j++) {
if (quad->mask & (1 << j)) {
if (quad->inout.mask & (1 << j)) {
bzzzz[j] = qzzzz[j];
}
}
@ -208,8 +208,8 @@ sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
switch (format) {
case PIPE_FORMAT_Z16_UNORM:
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1);
tile->data.depth16[y][x] = (ushort) bzzzz[j];
}
break;
@ -218,15 +218,15 @@ sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
/* (yes, this falls through to a different case than above) */
case PIPE_FORMAT_Z32_UNORM:
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1);
tile->data.depth32[y][x] = bzzzz[j];
}
break;
case PIPE_FORMAT_S8Z24_UNORM:
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1);
uint s8z24 = tile->data.depth32[y][x];
s8z24 = (s8z24 & 0xff000000) | bzzzz[j];
tile->data.depth32[y][x] = s8z24;
@ -234,8 +234,8 @@ sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
break;
case PIPE_FORMAT_Z24S8_UNORM:
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1);
uint z24s8 = tile->data.depth32[y][x];
z24s8 = (z24s8 & 0xff) | (bzzzz[j] << 8);
tile->data.depth32[y][x] = z24s8;
@ -243,8 +243,8 @@ sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
break;
case PIPE_FORMAT_Z24X8_UNORM:
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1);
tile->data.depth32[y][x] = bzzzz[j] << 8;
}
break;
@ -260,7 +260,7 @@ depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
{
sp_depth_test_quad(qs, quad);
if (quad->mask)
if (quad->inout.mask)
qs->next->run(qs->next, quad);
}

12
src/gallium/drivers/softpipe/sp_quad_earlyz.c
View file

@ -45,16 +45,16 @@ earlyz_quad(
struct quad_stage *qs,
struct quad_header *quad )
{
const float fx = (float) quad->x0;
const float fy = (float) quad->y0;
const float fx = (float) quad->input.x0;
const float fy = (float) quad->input.y0;
const float dzdx = quad->posCoef->dadx[2];
const float dzdy = quad->posCoef->dady[2];
const float z0 = quad->posCoef->a0[2] + dzdx * fx + dzdy * fy;
quad->outputs.depth[0] = z0;
quad->outputs.depth[1] = z0 + dzdx;
quad->outputs.depth[2] = z0 + dzdy;
quad->outputs.depth[3] = z0 + dzdx + dzdy;
quad->output.depth[0] = z0;
quad->output.depth[1] = z0 + dzdx;
quad->output.depth[2] = z0 + dzdy;
quad->output.depth[3] = z0 + dzdx + dzdy;
qs->next->run( qs->next, quad );
}

22
src/gallium/drivers/softpipe/sp_quad_fs.c
View file

@ -85,7 +85,7 @@ shade_quad(
machine->InterpCoefs = quad->coef;
/* run shader */
quad->mask &= softpipe->fs->run( softpipe->fs,
quad->inout.mask &= softpipe->fs->run( softpipe->fs,
&qss->machine,
quad );
@ -101,16 +101,16 @@ shade_quad(
case TGSI_SEMANTIC_COLOR:
{
uint cbuf = sem_index[i];
memcpy(quad->outputs.color[cbuf],
memcpy(quad->output.color[cbuf],
&machine->Outputs[i].xyzw[0].f[0],
sizeof(quad->outputs.color[0]) );
sizeof(quad->output.color[0]) );
}
break;
case TGSI_SEMANTIC_POSITION:
{
uint j;
for (j = 0; j < 4; j++) {
quad->outputs.depth[j] = machine->Outputs[0].xyzw[2].f[j];
quad->output.depth[j] = machine->Outputs[0].xyzw[2].f[j];
}
z_written = TRUE;
}
@ -122,20 +122,20 @@ shade_quad(
if (!z_written) {
/* compute Z values now, as in the quad earlyz stage */
/* XXX we should really only do this if the earlyz stage is not used */
const float fx = (float) quad->x0;
const float fy = (float) quad->y0;
const float fx = (float) quad->input.x0;
const float fy = (float) quad->input.y0;
const float dzdx = quad->posCoef->dadx[2];
const float dzdy = quad->posCoef->dady[2];
const float z0 = quad->posCoef->a0[2] + dzdx * fx + dzdy * fy;
quad->outputs.depth[0] = z0;
quad->outputs.depth[1] = z0 + dzdx;
quad->outputs.depth[2] = z0 + dzdy;
quad->outputs.depth[3] = z0 + dzdx + dzdy;
quad->output.depth[0] = z0;
quad->output.depth[1] = z0 + dzdx;
quad->output.depth[2] = z0 + dzdy;
quad->output.depth[3] = z0 + dzdx + dzdy;
}
/* shader may cull fragments */
if( quad->mask ) {
if( quad->inout.mask ) {
qs->next->run( qs->next, quad );
}
}

2
src/gallium/drivers/softpipe/sp_quad_occlusion.c
View file

@ -54,7 +54,7 @@ occlusion_count_quad(struct quad_stage *qs, struct quad_header *quad)
{
struct softpipe_context *softpipe = qs->softpipe;
softpipe->occlusion_count += count_bits(quad->mask);
softpipe->occlusion_count += count_bits(quad->inout.mask);
qs->next->run(qs->next, quad);
}

10
src/gallium/drivers/softpipe/sp_quad_output.c
View file

@ -41,8 +41,8 @@ static void
output_quad(struct quad_stage *qs, struct quad_header *quad)
{
/* in-tile pos: */
const int itx = quad->x0 % TILE_SIZE;
const int ity = quad->y0 % TILE_SIZE;
const int itx = quad->input.x0 % TILE_SIZE;
const int ity = quad->input.y0 % TILE_SIZE;
struct softpipe_context *softpipe = qs->softpipe;
uint cbuf;
@ -52,13 +52,13 @@ output_quad(struct quad_stage *qs, struct quad_header *quad)
struct softpipe_cached_tile *tile
= sp_get_cached_tile(softpipe,
softpipe->cbuf_cache[cbuf],
quad->x0, quad->y0);
float (*quadColor)[4] = quad->outputs.color[cbuf];
quad->input.x0, quad->input.y0);
float (*quadColor)[4] = quad->output.color[cbuf];
int i, j;
/* get/swizzle dest colors */
for (j = 0; j < QUAD_SIZE; j++) {
if (quad->mask & (1 << j)) {
if (quad->inout.mask & (1 << j)) {
int x = itx + (j & 1);
int y = ity + (j >> 1);
for (i = 0; i < 4; i++) { /* loop over color chans */

44
src/gallium/drivers/softpipe/sp_quad_stencil.c
View file

@ -206,9 +206,9 @@ stencil_test_quad(struct quad_stage *qs, struct quad_header *quad)
ubyte ref, wrtMask, valMask;
ubyte stencilVals[QUAD_SIZE];
struct softpipe_cached_tile *tile
= sp_get_cached_tile(softpipe, softpipe->zsbuf_cache, quad->x0, quad->y0);
= sp_get_cached_tile(softpipe, softpipe->zsbuf_cache, quad->input.x0, quad->input.y0);
uint j;
uint face = quad->facing;
uint face = quad->input.facing;
if (!softpipe->depth_stencil->stencil[1].enabled) {
/* single-sided stencil test, use front (face=0) state */
@ -231,22 +231,22 @@ stencil_test_quad(struct quad_stage *qs, struct quad_header *quad)
switch (ps->format) {
case PIPE_FORMAT_S8Z24_UNORM:
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1);
stencilVals[j] = tile->data.depth32[y][x] >> 24;
}
break;
case PIPE_FORMAT_Z24S8_UNORM:
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1);
stencilVals[j] = tile->data.depth32[y][x] & 0xff;
}
break;
case PIPE_FORMAT_S8_UNORM:
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1);
stencilVals[j] = tile->data.stencil8[y][x];
}
break;
@ -258,35 +258,35 @@ stencil_test_quad(struct quad_stage *qs, struct quad_header *quad)
{
unsigned passMask, failMask;
passMask = do_stencil_test(stencilVals, func, ref, valMask);
failMask = quad->mask & ~passMask;
quad->mask &= passMask;
failMask = quad->inout.mask & ~passMask;
quad->inout.mask &= passMask;
if (failOp != PIPE_STENCIL_OP_KEEP) {
apply_stencil_op(stencilVals, failMask, failOp, ref, wrtMask);
}
}
if (quad->mask) {
if (quad->inout.mask) {
/* now the pixels that passed the stencil test are depth tested */
if (softpipe->depth_stencil->depth.enabled) {
const unsigned origMask = quad->mask;
const unsigned origMask = quad->inout.mask;
sp_depth_test_quad(qs, quad); /* quad->mask is updated */
/* update stencil buffer values according to z pass/fail result */
if (zFailOp != PIPE_STENCIL_OP_KEEP) {
const unsigned failMask = origMask & ~quad->mask;
const unsigned failMask = origMask & ~quad->inout.mask;
apply_stencil_op(stencilVals, failMask, zFailOp, ref, wrtMask);
}
if (zPassOp != PIPE_STENCIL_OP_KEEP) {
const unsigned passMask = origMask & quad->mask;
const unsigned passMask = origMask & quad->inout.mask;
apply_stencil_op(stencilVals, passMask, zPassOp, ref, wrtMask);
}
}
else {
/* no depth test, apply Zpass operator to stencil buffer values */
apply_stencil_op(stencilVals, quad->mask, zPassOp, ref, wrtMask);
apply_stencil_op(stencilVals, quad->inout.mask, zPassOp, ref, wrtMask);
}
}
@ -295,8 +295,8 @@ stencil_test_quad(struct quad_stage *qs, struct quad_header *quad)
switch (ps->format) {
case PIPE_FORMAT_S8Z24_UNORM:
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1);
uint s8z24 = tile->data.depth32[y][x];
s8z24 = (stencilVals[j] << 24) | (s8z24 & 0xffffff);
tile->data.depth32[y][x] = s8z24;
@ -304,8 +304,8 @@ stencil_test_quad(struct quad_stage *qs, struct quad_header *quad)
break;
case PIPE_FORMAT_Z24S8_UNORM:
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1);
uint z24s8 = tile->data.depth32[y][x];
z24s8 = (z24s8 & 0xffffff00) | stencilVals[j];
tile->data.depth32[y][x] = z24s8;
@ -313,8 +313,8 @@ stencil_test_quad(struct quad_stage *qs, struct quad_header *quad)
break;
case PIPE_FORMAT_S8_UNORM:
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
int x = quad->input.x0 % TILE_SIZE + (j & 1);
int y = quad->input.y0 % TILE_SIZE + (j >> 1);
tile->data.stencil8[y][x] = stencilVals[j];
}
break;
@ -322,7 +322,7 @@ stencil_test_quad(struct quad_stage *qs, struct quad_header *quad)
assert(0);
}
if (quad->mask)
if (quad->inout.mask)
qs->next->run(qs->next, quad);
}

22
src/gallium/drivers/softpipe/sp_quad_stipple.c
View file

@ -19,17 +19,17 @@ stipple_quad(struct quad_stage *qs, struct quad_header *quad)
static const uint bit31 = 1 << 31;
static const uint bit30 = 1 << 30;
if (quad->prim == PRIM_TRI) {
if (quad->input.prim == PRIM_TRI) {
struct softpipe_context *softpipe = qs->softpipe;
/* need to invert Y to index into OpenGL's stipple pattern */
int y0, y1;
uint stipple0, stipple1;
if (softpipe->rasterizer->origin_lower_left) {
y0 = softpipe->framebuffer.height - 1 - quad->y0;
y0 = softpipe->framebuffer.height - 1 - quad->input.y0;
y1 = y0 - 1;
}
else {
y0 = quad->y0;
y0 = quad->input.y0;
y1 = y0 + 1;
}
stipple0 = softpipe->poly_stipple.stipple[y0 % 32];
@ -37,18 +37,18 @@ stipple_quad(struct quad_stage *qs, struct quad_header *quad)
#if 1
{
const int col0 = quad->x0 % 32;
const int col0 = quad->input.x0 % 32;
if ((stipple0 & (bit31 >> col0)) == 0)
quad->mask &= ~MASK_TOP_LEFT;
quad->inout.mask &= ~MASK_TOP_LEFT;
if ((stipple0 & (bit30 >> col0)) == 0)
quad->mask &= ~MASK_TOP_RIGHT;
quad->inout.mask &= ~MASK_TOP_RIGHT;
if ((stipple1 & (bit31 >> col0)) == 0)
quad->mask &= ~MASK_BOTTOM_LEFT;
quad->inout.mask &= ~MASK_BOTTOM_LEFT;
if ((stipple1 & (bit30 >> col0)) == 0)
quad->mask &= ~MASK_BOTTOM_RIGHT;
quad->inout.mask &= ~MASK_BOTTOM_RIGHT;
}
#else
/* We'd like to use this code, but we'd need to redefine
@ -56,11 +56,11 @@ stipple_quad(struct quad_stage *qs, struct quad_header *quad)
* and similarly for the BOTTOM bits. But that may have undesirable
* side effects elsewhere.
*/
const int col0 = 30 - (quad->x0 % 32);
quad->mask &= (((stipple0 >> col0) & 0x3) |
const int col0 = 30 - (quad->input.x0 % 32);
quad->inout.mask &= (((stipple0 >> col0) & 0x3) |
(((stipple1 >> col0) & 0x3) << 2));
#endif
if (!quad->mask)
if (!quad->inout.mask)
return;
}

114
src/gallium/drivers/softpipe/sp_setup.c
View file

@ -298,22 +298,22 @@ quad_clip( struct setup_context *setup, struct quad_header *quad )
const int miny = (int) cliprect->miny;
const int maxy = (int) cliprect->maxy;
if (quad->x0 >= maxx ||
quad->y0 >= maxy ||
quad->x0 + 1 < minx ||
quad->y0 + 1 < miny) {
if (quad->input.x0 >= maxx ||
quad->input.y0 >= maxy ||
quad->input.x0 + 1 < minx ||
quad->input.y0 + 1 < miny) {
/* totally clipped */
quad->mask = 0x0;
quad->inout.mask = 0x0;
return;
}
if (quad->x0 < minx)
quad->mask &= (MASK_BOTTOM_RIGHT | MASK_TOP_RIGHT);
if (quad->y0 < miny)
quad->mask &= (MASK_BOTTOM_LEFT | MASK_BOTTOM_RIGHT);
if (quad->x0 == maxx - 1)
quad->mask &= (MASK_BOTTOM_LEFT | MASK_TOP_LEFT);
if (quad->y0 == maxy - 1)
quad->mask &= (MASK_TOP_LEFT | MASK_TOP_RIGHT);
if (quad->input.x0 < minx)
quad->inout.mask &= (MASK_BOTTOM_RIGHT | MASK_TOP_RIGHT);
if (quad->input.y0 < miny)
quad->inout.mask &= (MASK_BOTTOM_LEFT | MASK_BOTTOM_RIGHT);
if (quad->input.x0 == maxx - 1)
quad->inout.mask &= (MASK_BOTTOM_LEFT | MASK_TOP_LEFT);
if (quad->input.y0 == maxy - 1)
quad->inout.mask &= (MASK_TOP_LEFT | MASK_TOP_RIGHT);
}
@ -324,7 +324,7 @@ static INLINE void
clip_emit_quad( struct setup_context *setup, struct quad_header *quad, uint thread )
{
quad_clip( setup, quad );
if (quad->mask) {
if (quad->inout.mask) {
struct softpipe_context *sp = setup->softpipe;
sp->quad[thread].first->run( sp->quad[thread].first, quad );
@ -355,9 +355,9 @@ emit_quad( struct setup_context *setup, int x, int y, unsigned mask, struct quad
{
struct softpipe_context *sp = setup->softpipe;
quad->x0 = x;
quad->y0 = y;
quad->mask = mask;
quad->input.x0 = x;
quad->input.y0 = y;
quad->inout.mask = mask;
#if DEBUG_FRAGS
if (mask & 1) setup->numFragsEmitted++;
if (mask & 2) setup->numFragsEmitted++;
@ -366,7 +366,7 @@ emit_quad( struct setup_context *setup, int x, int y, unsigned mask, struct quad
#endif
sp->quad[thread].first->run( sp->quad[thread].first, quad );
#if DEBUG_FRAGS
mask = quad->mask;
mask = quad->inout.mask;
if (mask & 1) setup->numFragsWritten++;
if (mask & 2) setup->numFragsWritten++;
if (mask & 4) setup->numFragsWritten++;
@ -577,7 +577,7 @@ static boolean setup_sort_vertices( struct setup_context *setup,
* - the GLSL gl_FrontFacing fragment attribute (bool)
* - two-sided stencil test
*/
setup->quad.facing = (det > 0.0) ^ (setup->softpipe->rasterizer->front_winding == PIPE_WINDING_CW);
setup->quad.input.facing = (det > 0.0) ^ (setup->softpipe->rasterizer->front_winding == PIPE_WINDING_CW);
return TRUE;
}
@ -774,7 +774,7 @@ static void setup_tri_coefficients( struct setup_context *setup )
if (spfs->info.input_semantic_name[fragSlot] == TGSI_SEMANTIC_FOG) {
/* FOG.y = front/back facing XXX fix this */
setup->coef[fragSlot].a0[1] = 1.0f - setup->quad.facing;
setup->coef[fragSlot].a0[1] = 1.0f - setup->quad.input.facing;
setup->coef[fragSlot].dadx[1] = 0.0;
setup->coef[fragSlot].dady[1] = 0.0;
}
@ -944,7 +944,7 @@ void setup_tri( struct setup_context *setup,
setup_tri_coefficients( setup );
setup_tri_edges( setup );
setup->quad.prim = PRIM_TRI;
setup->quad.input.prim = PRIM_TRI;
setup->span.y = 0;
setup->span.y_flags = 0;
@ -1085,7 +1085,7 @@ setup_line_coefficients(struct setup_context *setup,
if (spfs->info.input_semantic_name[fragSlot] == TGSI_SEMANTIC_FOG) {
/* FOG.y = front/back facing XXX fix this */
setup->coef[fragSlot].a0[1] = 1.0f - setup->quad.facing;
setup->coef[fragSlot].a0[1] = 1.0f - setup->quad.input.facing;
setup->coef[fragSlot].dadx[1] = 0.0;
setup->coef[fragSlot].dady[1] = 0.0;
}
@ -1106,20 +1106,20 @@ plot(struct setup_context *setup, int x, int y)
const int quadY = y - iy;
const int mask = (1 << ix) << (2 * iy);
if (quadX != setup->quad.x0 ||
quadY != setup->quad.y0)
if (quadX != setup->quad.input.x0 ||
quadY != setup->quad.input.y0)
{
/* flush prev quad, start new quad */
if (setup->quad.x0 != -1)
if (setup->quad.input.x0 != -1)
CLIP_EMIT_QUAD(setup);
setup->quad.x0 = quadX;
setup->quad.y0 = quadY;
setup->quad.mask = 0x0;
setup->quad.input.x0 = quadX;
setup->quad.input.y0 = quadY;
setup->quad.inout.mask = 0x0;
}
setup->quad.mask |= mask;
setup->quad.inout.mask |= mask;
}
@ -1180,16 +1180,16 @@ setup_line(struct setup_context *setup,
assert(dx >= 0);
assert(dy >= 0);
setup->quad.x0 = setup->quad.y0 = -1;
setup->quad.mask = 0x0;
setup->quad.prim = PRIM_LINE;
setup->quad.input.x0 = setup->quad.input.y0 = -1;
setup->quad.inout.mask = 0x0;
setup->quad.input.prim = PRIM_LINE;
/* XXX temporary: set coverage to 1.0 so the line appears
* if AA mode happens to be enabled.
*/
setup->quad.coverage[0] =
setup->quad.coverage[1] =
setup->quad.coverage[2] =
setup->quad.coverage[3] = 1.0;
setup->quad.input.coverage[0] =
setup->quad.input.coverage[1] =
setup->quad.input.coverage[2] =
setup->quad.input.coverage[3] = 1.0;
if (dx > dy) {
/*** X-major line ***/
@ -1233,7 +1233,7 @@ setup_line(struct setup_context *setup,
}
/* draw final quad */
if (setup->quad.mask) {
if (setup->quad.inout.mask) {
CLIP_EMIT_QUAD(setup);
}
@ -1331,21 +1331,21 @@ setup_point( struct setup_context *setup,
if (spfs->info.input_semantic_name[fragSlot] == TGSI_SEMANTIC_FOG) {
/* FOG.y = front/back facing XXX fix this */
setup->coef[fragSlot].a0[1] = 1.0f - setup->quad.facing;
setup->coef[fragSlot].a0[1] = 1.0f - setup->quad.input.facing;
setup->coef[fragSlot].dadx[1] = 0.0;
setup->coef[fragSlot].dady[1] = 0.0;
}
}
setup->quad.prim = PRIM_POINT;
setup->quad.input.prim = PRIM_POINT;
if (halfSize <= 0.5 && !round) {
/* special case for 1-pixel points */
const int ix = ((int) x) & 1;
const int iy = ((int) y) & 1;
setup->quad.x0 = (int) x - ix;
setup->quad.y0 = (int) y - iy;
setup->quad.mask = (1 << ix) << (2 * iy);
setup->quad.input.x0 = (int) x - ix;
setup->quad.input.y0 = (int) y - iy;
setup->quad.inout.mask = (1 << ix) << (2 * iy);
CLIP_EMIT_QUAD(setup);
}
else {
@ -1366,15 +1366,15 @@ setup_point( struct setup_context *setup,
for (ix = ixmin; ix <= ixmax; ix += 2) {
float dx, dy, dist2, cover;
setup->quad.mask = 0x0;
setup->quad.inout.mask = 0x0;
dx = (ix + 0.5f) - x;
dy = (iy + 0.5f) - y;
dist2 = dx * dx + dy * dy;
if (dist2 <= rmax2) {
cover = 1.0F - (dist2 - rmin2) * cscale;
setup->quad.coverage[QUAD_TOP_LEFT] = MIN2(cover, 1.0f);
setup->quad.mask |= MASK_TOP_LEFT;
setup->quad.input.coverage[QUAD_TOP_LEFT] = MIN2(cover, 1.0f);
setup->quad.inout.mask |= MASK_TOP_LEFT;
}
dx = (ix + 1.5f) - x;
@ -1382,8 +1382,8 @@ setup_point( struct setup_context *setup,
dist2 = dx * dx + dy * dy;
if (dist2 <= rmax2) {
cover = 1.0F - (dist2 - rmin2) * cscale;
setup->quad.coverage[QUAD_TOP_RIGHT] = MIN2(cover, 1.0f);
setup->quad.mask |= MASK_TOP_RIGHT;
setup->quad.input.coverage[QUAD_TOP_RIGHT] = MIN2(cover, 1.0f);
setup->quad.inout.mask |= MASK_TOP_RIGHT;
}
dx = (ix + 0.5f) - x;
@ -1391,8 +1391,8 @@ setup_point( struct setup_context *setup,
dist2 = dx * dx + dy * dy;
if (dist2 <= rmax2) {
cover = 1.0F - (dist2 - rmin2) * cscale;
setup->quad.coverage[QUAD_BOTTOM_LEFT] = MIN2(cover, 1.0f);
setup->quad.mask |= MASK_BOTTOM_LEFT;
setup->quad.input.coverage[QUAD_BOTTOM_LEFT] = MIN2(cover, 1.0f);
setup->quad.inout.mask |= MASK_BOTTOM_LEFT;
}
dx = (ix + 1.5f) - x;
@ -1400,13 +1400,13 @@ setup_point( struct setup_context *setup,
dist2 = dx * dx + dy * dy;
if (dist2 <= rmax2) {
cover = 1.0F - (dist2 - rmin2) * cscale;
setup->quad.coverage[QUAD_BOTTOM_RIGHT] = MIN2(cover, 1.0f);
setup->quad.mask |= MASK_BOTTOM_RIGHT;
setup->quad.input.coverage[QUAD_BOTTOM_RIGHT] = MIN2(cover, 1.0f);
setup->quad.inout.mask |= MASK_BOTTOM_RIGHT;
}
if (setup->quad.mask) {
setup->quad.x0 = ix;
setup->quad.y0 = iy;
if (setup->quad.inout.mask) {
setup->quad.input.x0 = ix;
setup->quad.input.y0 = iy;
CLIP_EMIT_QUAD(setup);
}
}
@ -1451,9 +1451,9 @@ setup_point( struct setup_context *setup,
mask &= (MASK_BOTTOM_LEFT | MASK_TOP_LEFT);
}
setup->quad.mask = mask;
setup->quad.x0 = ix;
setup->quad.y0 = iy;
setup->quad.inout.mask = mask;
setup->quad.input.x0 = ix;
setup->quad.input.y0 = iy;
CLIP_EMIT_QUAD(setup);
}
}