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

cell: implement colormask on fallback path

Browse Source 
Also, some var renaming and additional comments
This commit is contained in:
Brian Paul
2008-09-12 11:43:37 -06:00
parent 9defef29c5
commit 38bacb6f32
1 changed files with 110 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/gallium/drivers/cell/spu/spu_per_fragment_op.c
+110 -54
View File
@@ -60,9 +60,12 @@ spu_fallback_fragment_ops(uint x, uint y,
vector unsigned int mask)
{
vector float frag_aos[4];
unsigned int c0, c1, c2, c3;
unsigned int fbc0, fbc1, fbc2, fbc3 ; /* framebuffer/tile colors */
unsigned int fragc0, fragc1, fragc2, fragc3; /* fragment colors */
/* do alpha test */
/*
* Do alpha test
*/
if (spu.depth_stencil_alpha.alpha.enabled) {
vector float ref = spu_splats(spu.depth_stencil_alpha.alpha.ref);
vector unsigned int amask;
@@ -102,7 +105,10 @@ spu_fallback_fragment_ops(uint x, uint y,
mask = spu_and(mask, amask);
}
/* Z and/or stencil testing... */
/*
* Z and/or stencil testing...
*/
if (spu.depth_stencil_alpha.depth.enabled ||
spu.depth_stencil_alpha.stencil[0].enabled) {
@@ -178,6 +184,32 @@ spu_fallback_fragment_ops(uint x, uint y,
}
}
/*
* If we'll need the current framebuffer/tile colors for blending
* or logicop or colormask, fetch them now.
*/
if (spu.blend.blend_enable ||
spu.blend.logicop_enable ||
spu.blend.colormask != 0xf) {
#if LINEAR_QUAD_LAYOUT /* See comments/diagram below */
fbc0 = colorTile->ui[y][x*2+0];
fbc1 = colorTile->ui[y][x*2+1];
fbc2 = colorTile->ui[y][x*2+2];
fbc3 = colorTile->ui[y][x*2+3];
#else
fbc0 = colorTile->ui[y+0][x+0];
fbc1 = colorTile->ui[y+0][x+1];
fbc2 = colorTile->ui[y+1][x+0];
fbc3 = colorTile->ui[y+1][x+1];
#endif
}
/*
* Do blending
*/
if (spu.blend.blend_enable) {
/* blending terms, misc regs */
vector float term1r, term1g, term1b, term1a;
@@ -186,39 +218,26 @@ spu_fallback_fragment_ops(uint x, uint y,
vector float fbRGBA[4]; /* current framebuffer colors */
/* get colors from framebuffer/tile */
/* convert framebuffer colors from packed int to vector float */
{
vector float fc[4];
uint c0, c1, c2, c3;
#if LINEAR_QUAD_LAYOUT /* See comments/diagram below */
c0 = colorTile->ui[y][x*2+0];
c1 = colorTile->ui[y][x*2+1];
c2 = colorTile->ui[y][x*2+2];
c3 = colorTile->ui[y][x*2+3];
#else
c0 = colorTile->ui[y+0][x+0];
c1 = colorTile->ui[y+0][x+1];
c2 = colorTile->ui[y+1][x+0];
c3 = colorTile->ui[y+1][x+1];
#endif
vector float temp[4]; /* float colors in AOS form */
switch (spu.fb.color_format) {
case PIPE_FORMAT_B8G8R8A8_UNORM:
fc[0] = spu_unpack_B8G8R8A8(c0);
fc[1] = spu_unpack_B8G8R8A8(c1);
fc[2] = spu_unpack_B8G8R8A8(c2);
fc[3] = spu_unpack_B8G8R8A8(c3);
temp[0] = spu_unpack_B8G8R8A8(fbc0);
temp[1] = spu_unpack_B8G8R8A8(fbc1);
temp[2] = spu_unpack_B8G8R8A8(fbc2);
temp[3] = spu_unpack_B8G8R8A8(fbc3);
break;
case PIPE_FORMAT_A8R8G8B8_UNORM:
fc[0] = spu_unpack_A8R8G8B8(c0);
fc[1] = spu_unpack_A8R8G8B8(c1);
fc[2] = spu_unpack_A8R8G8B8(c2);
fc[3] = spu_unpack_A8R8G8B8(c3);
temp[0] = spu_unpack_A8R8G8B8(fbc0);
temp[1] = spu_unpack_A8R8G8B8(fbc1);
temp[2] = spu_unpack_A8R8G8B8(fbc2);
temp[3] = spu_unpack_A8R8G8B8(fbc3);
break;
default:
ASSERT(0);
}
_transpose_matrix4x4(fbRGBA, fc);
_transpose_matrix4x4(fbRGBA, temp); /* fbRGBA = transpose(temp) */
}
/*
@@ -384,21 +403,20 @@ spu_fallback_fragment_ops(uint x, uint y,
#endif
/*
* Pack float colors into 32-bit RGBA words.
* Pack fragment float colors into 32-bit RGBA words.
*/
switch (spu.fb.color_format) {
case PIPE_FORMAT_A8R8G8B8_UNORM:
c0 = spu_pack_A8R8G8B8(frag_aos[0]);
c1 = spu_pack_A8R8G8B8(frag_aos[1]);
c2 = spu_pack_A8R8G8B8(frag_aos[2]);
c3 = spu_pack_A8R8G8B8(frag_aos[3]);
fragc0 = spu_pack_A8R8G8B8(frag_aos[0]);
fragc1 = spu_pack_A8R8G8B8(frag_aos[1]);
fragc2 = spu_pack_A8R8G8B8(frag_aos[2]);
fragc3 = spu_pack_A8R8G8B8(frag_aos[3]);
break;
case PIPE_FORMAT_B8G8R8A8_UNORM:
c0 = spu_pack_B8G8R8A8(frag_aos[0]);
c1 = spu_pack_B8G8R8A8(frag_aos[1]);
c2 = spu_pack_B8G8R8A8(frag_aos[2]);
c3 = spu_pack_B8G8R8A8(frag_aos[3]);
fragc0 = spu_pack_B8G8R8A8(frag_aos[0]);
fragc1 = spu_pack_B8G8R8A8(frag_aos[1]);
fragc2 = spu_pack_B8G8R8A8(frag_aos[2]);
fragc3 = spu_pack_B8G8R8A8(frag_aos[3]);
break;
default:
fprintf(stderr, "SPU: Bad pixel format in spu_default_fragment_ops\n");
@@ -407,20 +425,57 @@ spu_fallback_fragment_ops(uint x, uint y,
/*
* Color masking
* Do color masking
*/
if (spu.blend.colormask != 0xf) {
/* XXX to do */
/* apply color mask to 32-bit packed colors */
uint cmask = 0x0; /* each byte corresponds to a color channel */
/* Form bitmask depending on color buffer format and colormask bits */
switch (spu.fb.color_format) {
case PIPE_FORMAT_A8R8G8B8_UNORM:
if (spu.blend.colormask & (1<<0))
cmask |= 0x00ff0000; /* red */
if (spu.blend.colormask & (1<<1))
cmask |= 0x0000ff00; /* green */
if (spu.blend.colormask & (1<<2))
cmask |= 0x000000ff; /* blue */
if (spu.blend.colormask & (1<<3))
cmask |= 0xff000000; /* alpha */
break;
case PIPE_FORMAT_B8G8R8A8_UNORM:
if (spu.blend.colormask & (1<<0))
cmask |= 0x0000ff00; /* red */
if (spu.blend.colormask & (1<<1))
cmask |= 0x00ff0000; /* green */
if (spu.blend.colormask & (1<<2))
cmask |= 0xff000000; /* blue */
if (spu.blend.colormask & (1<<3))
cmask |= 0x000000ff; /* alpha */
break;
default:
ASSERT(0);
}
/*
* Apply color mask to the 32-bit packed colors.
* if (cmask[i])
* frag color[i] = frag color[i];
* else
* frag color[i] = framebuffer color[i];
*/
fragc0 = (fragc0 & cmask) | (fbc0 & ~cmask);
fragc1 = (fragc1 & cmask) | (fbc1 & ~cmask);
fragc2 = (fragc2 & cmask) | (fbc2 & ~cmask);
fragc3 = (fragc3 & cmask) | (fbc3 & ~cmask);
}
/*
* Logic Ops
* Do logic ops
*/
if (spu.blend.logicop_enable) {
/* XXX to do */
/* apply logicop to 32-bit packed colors */
/* apply logicop to 32-bit packed colors (fragcx and fbcx) */
}
@@ -431,45 +486,46 @@ spu_fallback_fragment_ops(uint x, uint y,
spu.cur_ctile_status = TILE_STATUS_DIRTY;
}
else {
/* write no fragments */
return;
}
/*
* Write new quad colors to the framebuffer/tile.
* Write new fragment/quad colors to the framebuffer/tile.
* Only write pixels where the corresponding mask word is set.
*/
#if LINEAR_QUAD_LAYOUT
/*
* Quad layout:
* +--+--+--+--+
* |p0|p1|p2|p3|
* |p0|p1|p2|p3|...
* +--+--+--+--+
*/
if (spu_extract(mask, 0))
colorTile->ui[y][x*2] = c0;
colorTile->ui[y][x*2] = fragc0;
if (spu_extract(mask, 1))
colorTile->ui[y][x*2+1] = c1;
colorTile->ui[y][x*2+1] = fragc1;
if (spu_extract(mask, 2))
colorTile->ui[y][x*2+2] = c2;
colorTile->ui[y][x*2+2] = fragc2;
if (spu_extract(mask, 3))
colorTile->ui[y][x*2+3] = c3;
colorTile->ui[y][x*2+3] = fragc3;
#else
/*
* Quad layout:
* +--+--+
* |p0|p1|
* |p0|p1|...
* +--+--+
* |p2|p3|
* |p2|p3|...
* +--+--+
*/
if (spu_extract(mask, 0))
colorTile->ui[y+0][x+0] = c0;
colorTile->ui[y+0][x+0] = fragc0;
if (spu_extract(mask, 1))
colorTile->ui[y+0][x+1] = c1;
colorTile->ui[y+0][x+1] = fragc1;
if (spu_extract(mask, 2))
colorTile->ui[y+1][x+0] = c2;
colorTile->ui[y+1][x+0] = fragc2;
if (spu_extract(mask, 3))
colorTile->ui[y+1][x+1] = c3;
colorTile->ui[y+1][x+1] = fragc3;
#endif
}