fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-01-31 20:00:24 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

cell: remove old texture code

Browse source
This commit is contained in:
Brian Paul 2008-10-13 11:16:04 -06:00
parent 3b07c28dee
commit c8fb368261
6 changed files with 7 additions and 181 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/gallium/drivers/cell/spu/spu_command.c
View file

@ -302,11 +302,9 @@ cmd_state_sampler(const struct cell_command_sampler *sampler)
spu.sampler[sampler->unit] = sampler->state;
if (spu.sampler[sampler->unit].min_img_filter == PIPE_TEX_FILTER_LINEAR) {
spu.sample_texture[sampler->unit] = sample_texture_bilinear;
spu.sample_texture4[sampler->unit] = sample_texture4_bilinear;
}
else {
spu.sample_texture[sampler->unit] = sample_texture_nearest;
spu.sample_texture4[sampler->unit] = sample_texture4_nearest;
}
}

19
src/gallium/drivers/cell/spu/spu_funcs.c
View file

@ -104,27 +104,8 @@ static struct vec_4x4
spu_txp(vector float s, vector float t, vector float r, vector float q,
unsigned unit)
{
//const uint unit = 0;
struct vec_4x4 colors;
#if 0
vector float coords[4];
coords[0] = s;
coords[1] = t;
coords[2] = r;
coords[3] = q;
_transpose_matrix4x4(coords, coords);
/* get four texture samples */
colors.v[0] = spu.sample_texture[unit](unit, coords[0]);
colors.v[1] = spu.sample_texture[unit](unit, coords[1]);
colors.v[2] = spu.sample_texture[unit](unit, coords[2]);
colors.v[3] = spu.sample_texture[unit](unit, coords[3]);
_transpose_matrix4x4(colors.v, colors.v);
#else
spu.sample_texture4[unit](s, t, r, q, unit, colors.v);
#endif
return colors;
}

4
src/gallium/drivers/cell/spu/spu_main.h
View file

@ -64,9 +64,6 @@ typedef union {
/** Function for sampling textures */
typedef vector float (*spu_sample_texture_func)(uint unit,
vector float texcoord);
typedef void (*spu_sample_texture4_func)(vector float s,
vector float t,
vector float r,
@ -168,7 +165,6 @@ struct spu_global
spu_fragment_program_func fragment_program;
/** Current texture sampler function */
spu_sample_texture_func sample_texture[CELL_MAX_SAMPLERS];
spu_sample_texture4_func sample_texture4[CELL_MAX_SAMPLERS];
/** Fragment program constants */

88
src/gallium/drivers/cell/spu/spu_texture.c
View file

@ -120,21 +120,9 @@ get_four_texels(uint unit, vec_uint4 x, vec_uint4 y, vec_uint4 *texels)
}
/**
* Get texture sample at texcoord.
*/
vector float
sample_texture_nearest(uint unit, vector float texcoord)
{
vector float tc = spu_mul(texcoord, spu.texture[unit].tex_size);
vector unsigned int itc = spu_convtu(tc, 0); /* convert to int */
itc = spu_and(itc, spu.texture[unit].tex_size_mask); /* mask (GL_REPEAT) */
uint texel = get_texel(unit, itc);
return spu_unpack_A8R8G8B8(texel);
}
/**
* Do nearest texture sampling for four pixels.
* \param colors returned colors in SOA format (rrrr, gggg, bbbb, aaaa).
*/
void
@ -148,7 +136,7 @@ sample_texture4_nearest(vector float s, vector float t,
vector unsigned int it = spu_convtu(tt, 0);
vec_uint4 texels[4];
/* GL_REPEAT wrap mode: */
/* PIPE_TEX_WRAP_REPEAT */
is = spu_and(is, spu.texture[unit].tex_size_x_mask);
it = spu_and(it, spu.texture[unit].tex_size_y_mask);
@ -159,74 +147,10 @@ sample_texture4_nearest(vector float s, vector float t,
}
vector float
sample_texture_bilinear(uint unit, vector float texcoord)
{
static const vec_uint4 offset_x = {0, 0, 1, 1};
static const vec_uint4 offset_y = {0, 1, 0, 1};
vector float tc = spu_mul(texcoord, spu.texture[unit].tex_size);
tc = spu_add(tc, spu_splats(-0.5f)); /* half texel bias */
/* integer texcoords S,T: */
vec_uint4 itc = spu_convtu(tc, 0); /* convert to int */
vec_uint4 texels[4];
/* setup texcoords for quad:
* +-----+-----+
* |x0,y0|x1,y1|
* +-----+-----+
* |x2,y2|x3,y3|
* +-----+-----+
*/
vec_uint4 x = spu_splats(spu_extract(itc, 0));
vec_uint4 y = spu_splats(spu_extract(itc, 1));
x = spu_add(x, offset_x);
y = spu_add(y, offset_y);
/* GL_REPEAT wrap mode: */
x = spu_and(x, spu.texture[unit].tex_size_x_mask);
y = spu_and(y, spu.texture[unit].tex_size_y_mask);
get_four_texels(unit, x, y, texels);
/* integer A8R8G8B8 to float texel conversion */
vector float texel00 = spu_unpack_A8R8G8B8(spu_extract(texels[0], 0));
vector float texel01 = spu_unpack_A8R8G8B8(spu_extract(texels[1], 0));
vector float texel10 = spu_unpack_A8R8G8B8(spu_extract(texels[2], 0));
vector float texel11 = spu_unpack_A8R8G8B8(spu_extract(texels[3], 0));
/* Compute weighting factors in [0,1]
* Multiply texcoord by 1024, AND with 1023, convert back to float.
*/
vector float tc1024 = spu_mul(tc, spu_splats(1024.0f));
vector signed int itc1024 = spu_convts(tc1024, 0);
itc1024 = spu_and(itc1024, spu_splats((1 << 10) - 1));
vector float weight = spu_convtf(itc1024, 10);
/* smeared frac and 1-frac */
vector float sfrac = spu_splats(spu_extract(weight, 0));
vector float tfrac = spu_splats(spu_extract(weight, 1));
vector float sfrac1 = spu_sub(spu_splats(1.0f), sfrac);
vector float tfrac1 = spu_sub(spu_splats(1.0f), tfrac);
/* multiply the samples (colors) by the S/T weights */
texel00 = spu_mul(spu_mul(texel00, sfrac1), tfrac1);
texel10 = spu_mul(spu_mul(texel10, sfrac ), tfrac1);
texel01 = spu_mul(spu_mul(texel01, sfrac1), tfrac );
texel11 = spu_mul(spu_mul(texel11, sfrac ), tfrac );
/* compute sum of weighted samples */
vector float texel_sum = spu_add(texel00, texel01);
texel_sum = spu_add(texel_sum, texel10);
texel_sum = spu_add(texel_sum, texel11);
return texel_sum;
}
/**
* Do bilinear texture sampling for four pixels.
* \param colors returned colors in SOA format (rrrr, gggg, bbbb, aaaa).
*/
void
sample_texture4_bilinear(vector float s, vector float t,
vector float r, vector float q,

8
src/gallium/drivers/cell/spu/spu_texture.h
View file

@ -36,20 +36,12 @@ extern void
invalidate_tex_cache(void);
extern vector float
sample_texture_nearest(uint unit, vector float texcoord);
extern void
sample_texture4_nearest(vector float s, vector float t,
vector float r, vector float q,
uint unit, vector float colors[4]);
extern vector float
sample_texture_bilinear(uint unit, vector float texcoord);
extern void
sample_texture4_bilinear(vector float s, vector float t,
vector float r, vector float q,

67
src/gallium/drivers/cell/spu/spu_tri.c
View file

@ -286,72 +286,7 @@ emit_quad( int x, int y, mask_t mask)
spu.cur_ctile_status = TILE_STATUS_DIRTY;
spu.cur_ztile_status = TILE_STATUS_DIRTY;
if (0/*spu.texture[0].start*/) {
/*
* Temporary texture mapping path
* This will go away when fragment programs support TEX inst.
*/
const uint unit = 0;
vector float colors[4];
vector float texcoords[4];
eval_coeff(2, (float) x, (float) y, texcoords);
if (spu_extract(mask, 0))
colors[0] = spu.sample_texture[unit](unit, texcoords[0]);
if (spu_extract(mask, 1))
colors[1] = spu.sample_texture[unit](unit, texcoords[1]);
if (spu_extract(mask, 2))
colors[2] = spu.sample_texture[unit](unit, texcoords[2]);
if (spu_extract(mask, 3))
colors[3] = spu.sample_texture[unit](unit, texcoords[3]);
if (spu.texture[1].start) {
/* multi-texture mapping */
const uint unit = 1;
vector float colors1[4];
eval_coeff(2, (float) x, (float) y, texcoords);
if (spu_extract(mask, 0))
colors1[0] = spu.sample_texture[unit](unit, texcoords[0]);
if (spu_extract(mask, 1))
colors1[1] = spu.sample_texture[unit](unit, texcoords[1]);
if (spu_extract(mask, 2))
colors1[2] = spu.sample_texture[unit](unit, texcoords[2]);
if (spu_extract(mask, 3))
colors1[3] = spu.sample_texture[unit](unit, texcoords[3]);
/* hack: modulate first texture by second */
colors[0] = spu_mul(colors[0], colors1[0]);
colors[1] = spu_mul(colors[1], colors1[1]);
colors[2] = spu_mul(colors[2], colors1[2]);
colors[3] = spu_mul(colors[3], colors1[3]);
}
{
/* Convert fragment data from AoS to SoA format.
* I.e. (RGBA,RGBA,RGBA,RGBA) -> (RRRR,GGGG,BBBB,AAAA)
* This is temporary!
*/
vector float soa_frag[4];
_transpose_matrix4x4(soa_frag, colors);
vector float fragZ = eval_z((float) x, (float) y);
/* Do all per-fragment/quad operations here, including:
* alpha test, z test, stencil test, blend and framebuffer writing.
*/
spu.fragment_ops(ix, iy, &spu.ctile, &spu.ztile,
fragZ,
soa_frag[0], soa_frag[1],
soa_frag[2], soa_frag[3],
mask,
setup.facing);
}
}
else {
{
/*
* Run fragment shader, execute per-fragment ops, update fb/tile.
*/