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

Merge branch 'gallium-0.2' of ssh+git://git.freedesktop.org/git/mesa/mesa into gallium-0.2

Browse source
This commit is contained in:
José Fonseca 2008-09-19 23:49:33 +09:00
commit d310c52c7f
7 changed files with 234 additions and 75 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
src/gallium/auxiliary/rtasm/rtasm_ppc_spe.c
View file

@ -592,11 +592,32 @@ spe_load_int(struct spe_function *p, unsigned rT, int i)
}
}
void spe_load_uint(struct spe_function *p, unsigned rT, unsigned int ui)
{
/* If the whole value is in the lower 18 bits, use ila, which
* doesn't sign-extend. Otherwise, if the two halfwords of
* the constant are identical, use ilh. Otherwise, we have
* to use ilhu followed by iohl.
*/
if ((ui & 0xfffc0000) == ui) {
spe_ila(p, rT, ui);
}
else if ((ui >> 16) == (ui & 0xffff)) {
spe_ilh(p, rT, ui & 0xffff);
}
else {
spe_ilhu(p, rT, ui >> 16);
if (ui & 0xffff)
spe_iohl(p, rT, ui & 0xffff);
}
}
void
spe_splat(struct spe_function *p, unsigned rT, unsigned rA)
{
spe_ila(p, rT, 66051);
/* Duplicate bytes 0, 1, 2, and 3 across the whole register */
spe_ila(p, rT, 0x00010203);
spe_shufb(p, rT, rA, rA, rT);
}

4
src/gallium/auxiliary/rtasm/rtasm_ppc_spe.h
View file

@ -302,6 +302,10 @@ spe_load_float(struct spe_function *p, unsigned rT, float x);
extern void
spe_load_int(struct spe_function *p, unsigned rT, int i);
/** Load/splat immediate unsigned int into rT. */
extern void
spe_load_uint(struct spe_function *p, unsigned rT, unsigned int ui);
/** Replicate word 0 of rA across rT. */
extern void
spe_splat(struct spe_function *p, unsigned rT, unsigned rA);

145
src/gallium/drivers/cell/ppu/cell_gen_fragment.c
View file

@ -902,8 +902,69 @@ gen_logicop(const struct pipe_blend_state *blend,
struct spe_function *f,
int fragRGBA_reg, int fbRGBA_reg)
{
/* XXX to-do */
/* operate on 32-bit packed pixels, not float colors */
/* We've got four 32-bit RGBA packed pixels in each of
* fragRGBA_reg and fbRGBA_reg, not sets of floating-point
* reds, greens, blues, and alphas.
* */
ASSERT(blend->logicop_enable);
switch(blend->logicop_func) {
case PIPE_LOGICOP_CLEAR: /* 0 */
spe_zero(f, fragRGBA_reg);
break;
case PIPE_LOGICOP_NOR: /* ~(s | d) */
spe_nor(f, fragRGBA_reg, fragRGBA_reg, fbRGBA_reg);
break;
case PIPE_LOGICOP_AND_INVERTED: /* ~s & d */
/* andc R, A, B computes R = A & ~B */
spe_andc(f, fragRGBA_reg, fbRGBA_reg, fragRGBA_reg);
break;
case PIPE_LOGICOP_COPY_INVERTED: /* ~s */
spe_complement(f, fragRGBA_reg);
break;
case PIPE_LOGICOP_AND_REVERSE: /* s & ~d */
/* andc R, A, B computes R = A & ~B */
spe_andc(f, fragRGBA_reg, fragRGBA_reg, fbRGBA_reg);
break;
case PIPE_LOGICOP_INVERT: /* ~d */
/* Note that (A nor A) == ~(A|A) == ~A */
spe_nor(f, fragRGBA_reg, fbRGBA_reg, fbRGBA_reg);
break;
case PIPE_LOGICOP_XOR: /* s ^ d */
spe_xor(f, fragRGBA_reg, fragRGBA_reg, fbRGBA_reg);
break;
case PIPE_LOGICOP_NAND: /* ~(s & d) */
spe_nand(f, fragRGBA_reg, fragRGBA_reg, fbRGBA_reg);
break;
case PIPE_LOGICOP_AND: /* s & d */
spe_and(f, fragRGBA_reg, fragRGBA_reg, fbRGBA_reg);
break;
case PIPE_LOGICOP_EQUIV: /* ~(s ^ d) */
spe_xor(f, fragRGBA_reg, fragRGBA_reg, fbRGBA_reg);
spe_complement(f, fragRGBA_reg);
break;
case PIPE_LOGICOP_NOOP: /* d */
spe_move(f, fragRGBA_reg, fbRGBA_reg);
break;
case PIPE_LOGICOP_OR_INVERTED: /* ~s | d */
/* orc R, A, B computes R = A | ~B */
spe_orc(f, fragRGBA_reg, fbRGBA_reg, fragRGBA_reg);
break;
case PIPE_LOGICOP_COPY: /* s */
break;
case PIPE_LOGICOP_OR_REVERSE: /* s | ~d */
/* orc R, A, B computes R = A | ~B */
spe_orc(f, fragRGBA_reg, fragRGBA_reg, fbRGBA_reg);
break;
case PIPE_LOGICOP_OR: /* s | d */
spe_or(f, fragRGBA_reg, fragRGBA_reg, fbRGBA_reg);
break;
case PIPE_LOGICOP_SET: /* 1 */
spe_load_int(f, fragRGBA_reg, 0xffffffff);
break;
default:
ASSERT(0);
}
}
@ -912,12 +973,82 @@ gen_colormask(uint colormask,
struct spe_function *f,
int fragRGBA_reg, int fbRGBA_reg)
{
/* XXX to-do */
/* operate on 32-bit packed pixels, not float colors */
/* We've got four 32-bit RGBA packed pixels in each of
* fragRGBA_reg and fbRGBA_reg, not sets of floating-point
* reds, greens, blues, and alphas.
* */
/* The color mask operation can prevent any set of color
* components in the incoming fragment from being written to the frame
* buffer; we do this by replacing the masked components of the
* fragment with the frame buffer values.
*
* There are only 16 possibilities, with a unique mask for
* each of the possibilities. (Technically, there are only 15
* possibilities, since we shouldn't be called for the one mask
* that does nothing, but the complete implementation is here
* anyway to avoid confusion.)
*
* We implement this via a constant static array which we'll index
* into to get the correct mask.
*
* We're dependent on the mask values being low-order bits,
* with particular values for each bit; so we start with a
* few assertions, which will fail if any of the values were
* to change.
*/
ASSERT(PIPE_MASK_R == 0x1);
ASSERT(PIPE_MASK_G == 0x2);
ASSERT(PIPE_MASK_B == 0x4);
ASSERT(PIPE_MASK_A == 0x8);
/* Here's the list of all possible colormasks, indexed by the
* value of the combined mask specifier.
*/
static const unsigned int colormasks[16] = {
0x00000000, /* 0: all colors masked */
0xff000000, /* 1: PIPE_MASK_R */
0x00ff0000, /* 2: PIPE_MASK_G */
0xffff0000, /* 3: PIPE_MASK_R | PIPE_MASK_G */
0x0000ff00, /* 4: PIPE_MASK_B */
0xff00ff00, /* 5: PIPE_MASK_R | PIPE_MASK_B */
0x00ffff00, /* 6: PIPE_MASK_G | PIPE_MASK_B */
0xffffff00, /* 7: PIPE_MASK_R | PIPE_MASK_G | PIPE_MASK_B */
0x000000ff, /* 8: PIPE_MASK_A */
0xff0000ff, /* 9: PIPE_MASK_R | PIPE_MASK_A */
0x00ff00ff, /* 10: PIPE_MASK_G | PIPE_MASK_A */
0xffff00ff, /* 11: PIPE_MASK_R | PIPE_MASK_G | PIPE_MASK_A */
0x0000ffff, /* 12: PIPE_MASK_B | PIPE_MASK_A */
0xff00ffff, /* 13: PIPE_MASK_R | PIPE_MASK_B | PIPE_MASK_A */
0x00ffffff, /* 14: PIPE_MASK_G | PIPE_MASK_B | PIPE_MASK_A */
0xffffffff /* 15: PIPE_MASK_R | PIPE_MASK_G | PIPE_MASK_B | PIPE_MASK_A */
};
/* Get a temporary register to hold the mask */
int colormask_reg = spe_allocate_available_register(f);
/* Look up the desired mask directly and load it into the mask register.
* This will load the same mask into each of the four words in the
* mask register.
*/
spe_load_uint(f, colormask_reg, colormasks[colormask]);
/* Use the mask register to select between the fragment color
* values and the frame buffer color values. Wherever the
* mask has a 0 bit, the current frame buffer color should override
* the fragment color. Wherever the mask has a 1 bit, the
* fragment color should persevere. The Select Bits (selb rt, rA, rB, rM)
* instruction will select bits from its first operand rA wherever the
* the mask bits rM are 0, and from its second operand rB wherever the
* mask bits rM are 1. That means that the frame buffer color is the
* first operand, and the fragment color the second.
*/
spe_selb(f, fragRGBA_reg, fbRGBA_reg, fragRGBA_reg, colormask_reg);
/* Release the temporary register and we're done */
spe_release_register(f, colormask_reg);
}
/**
* Generate code to pack a quad of float colors into a four 32-bit integers.
*
@ -1223,7 +1354,7 @@ cell_gen_fragment_function(struct cell_context *cell, struct spe_function *f)
gen_logicop(blend, f, rgba_reg, fbRGBA_reg);
}
if (blend->colormask != 0xf) {
if (blend->colormask != PIPE_MASK_RGBA) {
gen_colormask(blend->colormask, f, rgba_reg, fbRGBA_reg);
}

11
src/gallium/winsys/drm/intel/dri/intel_screen.c
View file

@ -365,12 +365,10 @@ intel_flush_frontbuffer( struct pipe_winsys *winsys,
struct pipe_surface *surf,
void *context_private)
{
//struct intel_context *intel = (struct intel_context *) context_private;
//__DRIdrawablePrivate *dPriv = intel->driDrawable;
struct intel_context *intel = (struct intel_context *) context_private;
__DRIdrawablePrivate *dPriv = intel->driDrawable;
//assert((int)"Doesn't work currently" & 0);
//intelDisplaySurface(dPriv, surf, NULL);
intelDisplaySurface(dPriv, surf, NULL);
}
static boolean
@ -565,7 +563,7 @@ intelFillInModes(__DRIscreenPrivate *psp,
configs = driCreateConfigs(fb_format, fb_type,
depth_bits_array, stencil_bits_array,
depth_buffer_factor, back_buffer_modes,
back_buffer_factor);
back_buffer_factor, msaa_samples_array, 1);
if (configs == NULL) {
fprintf(stderr, "[%s:%u] Error creating FBConfig!\n", __func__,
__LINE__);
@ -619,6 +617,7 @@ static const __DRIconfig **intelInitScreen(__DRIscreenPrivate *psp)
*
* Hello chicken. Hello egg. How are you two today?
*/
driInitExtensions( NULL, card_extensions, GL_FALSE );
//intelInitExtensions(NULL, GL_TRUE);
if (!intelInitDriver(psp))

119
src/mesa/drivers/dri/common/utils.c
View file

@ -524,15 +524,12 @@ GLboolean driClipRectToFramebuffer( const GLframebuffer *buffer,
* \c GL_UNSIGNED_3BYTE_8_8_8, \c GL_4FLOAT_32_32_32_32,
* \c GL_4HALF_16_16_16_16, etc. We can cross that bridge when we come to it.
*/
/* XXX: need to re-add msaa support after gallium-0.1 merge
*/
__DRIconfig **
driCreateConfigs(GLenum fb_format, GLenum fb_type,
const u_int8_t * depth_bits, const u_int8_t * stencil_bits,
unsigned num_depth_stencil_bits,
const GLenum * db_modes, unsigned num_db_modes)
const GLenum * db_modes, unsigned num_db_modes,
const u_int8_t * msaa_samples, unsigned num_msaa_modes)
{
static const u_int8_t bits_table[4][4] = {
/* R G B A */
@ -592,9 +589,7 @@ driCreateConfigs(GLenum fb_format, GLenum fb_type,
int index;
__DRIconfig **configs, **c;
__GLcontextModes *modes;
unsigned i;
unsigned j;
unsigned k;
unsigned i, j, k, h;
unsigned num_modes;
unsigned num_accum_bits = 2;
@ -667,7 +662,7 @@ driCreateConfigs(GLenum fb_format, GLenum fb_type,
break;
}
num_modes = num_depth_stencil_bits * num_db_modes * num_accum_bits;
num_modes = num_depth_stencil_bits * num_db_modes * num_accum_bits * num_msaa_modes;
configs = _mesa_calloc((num_modes + 1) * sizeof *configs);
if (configs == NULL)
return NULL;
@ -675,66 +670,72 @@ driCreateConfigs(GLenum fb_format, GLenum fb_type,
c = configs;
for ( k = 0 ; k < num_depth_stencil_bits ; k++ ) {
for ( i = 0 ; i < num_db_modes ; i++ ) {
for ( j = 0 ; j < num_accum_bits ; j++ ) {
*c = _mesa_malloc (sizeof **c);
modes = &(*c)->modes;
c++;
for ( h = 0 ; h < num_msaa_modes; h++ ) {
for ( j = 0 ; j < num_accum_bits ; j++ ) {
*c = _mesa_malloc (sizeof **c);
modes = &(*c)->modes;
c++;
memset(modes, 0, sizeof *modes);
modes->redBits = bits[0];
modes->greenBits = bits[1];
modes->blueBits = bits[2];
modes->alphaBits = bits[3];
modes->redMask = masks[0];
modes->greenMask = masks[1];
modes->blueMask = masks[2];
modes->alphaMask = masks[3];
modes->rgbBits = modes->redBits + modes->greenBits
+ modes->blueBits + modes->alphaBits;
memset(modes, 0, sizeof *modes);
modes->redBits = bits[0];
modes->greenBits = bits[1];
modes->blueBits = bits[2];
modes->alphaBits = bits[3];
modes->redMask = masks[0];
modes->greenMask = masks[1];
modes->blueMask = masks[2];
modes->alphaMask = masks[3];
modes->rgbBits = modes->redBits + modes->greenBits
+ modes->blueBits + modes->alphaBits;
modes->accumRedBits = 16 * j;
modes->accumGreenBits = 16 * j;
modes->accumBlueBits = 16 * j;
modes->accumAlphaBits = (masks[3] != 0) ? 16 * j : 0;
modes->visualRating = (j == 0) ? GLX_NONE : GLX_SLOW_CONFIG;
modes->accumRedBits = 16 * j;
modes->accumGreenBits = 16 * j;
modes->accumBlueBits = 16 * j;
modes->accumAlphaBits = (masks[3] != 0) ? 16 * j : 0;
modes->visualRating = (j == 0) ? GLX_NONE : GLX_SLOW_CONFIG;
modes->stencilBits = stencil_bits[k];
modes->depthBits = depth_bits[k];
modes->stencilBits = stencil_bits[k];
modes->depthBits = depth_bits[k];
modes->transparentPixel = GLX_NONE;
modes->transparentRed = GLX_DONT_CARE;
modes->transparentGreen = GLX_DONT_CARE;
modes->transparentBlue = GLX_DONT_CARE;
modes->transparentAlpha = GLX_DONT_CARE;
modes->transparentIndex = GLX_DONT_CARE;
modes->visualType = GLX_DONT_CARE;
modes->renderType = GLX_RGBA_BIT;
modes->drawableType = GLX_WINDOW_BIT;
modes->rgbMode = GL_TRUE;
modes->transparentPixel = GLX_NONE;
modes->transparentRed = GLX_DONT_CARE;
modes->transparentGreen = GLX_DONT_CARE;
modes->transparentBlue = GLX_DONT_CARE;
modes->transparentAlpha = GLX_DONT_CARE;
modes->transparentIndex = GLX_DONT_CARE;
modes->visualType = GLX_DONT_CARE;
modes->renderType = GLX_RGBA_BIT;
modes->drawableType = GLX_WINDOW_BIT;
modes->rgbMode = GL_TRUE;
if ( db_modes[i] == GLX_NONE ) {
modes->doubleBufferMode = GL_FALSE;
}
else {
modes->doubleBufferMode = GL_TRUE;
modes->swapMethod = db_modes[i];
}
if ( db_modes[i] == GLX_NONE ) {
modes->doubleBufferMode = GL_FALSE;
}
else {
modes->doubleBufferMode = GL_TRUE;
modes->swapMethod = db_modes[i];
}
modes->haveAccumBuffer = ((modes->accumRedBits +
modes->samples = msaa_samples[h];
modes->sampleBuffers = modes->samples ? 1 : 0;
modes->haveAccumBuffer = ((modes->accumRedBits +
modes->accumGreenBits +
modes->accumBlueBits +
modes->accumAlphaBits) > 0);
modes->haveDepthBuffer = (modes->depthBits > 0);
modes->haveStencilBuffer = (modes->stencilBits > 0);
modes->haveDepthBuffer = (modes->depthBits > 0);
modes->haveStencilBuffer = (modes->stencilBits > 0);
modes->bindToTextureRgb = GL_TRUE;
modes->bindToTextureRgba = GL_TRUE;
modes->bindToMipmapTexture = GL_FALSE;
modes->bindToTextureTargets = modes->rgbMode ?
__DRI_ATTRIB_TEXTURE_1D_BIT |
__DRI_ATTRIB_TEXTURE_2D_BIT |
__DRI_ATTRIB_TEXTURE_RECTANGLE_BIT :
0;
modes->bindToTextureRgb = GL_TRUE;
modes->bindToTextureRgba = GL_TRUE;
modes->bindToMipmapTexture = GL_FALSE;
modes->bindToTextureTargets = modes->rgbMode ?
__DRI_ATTRIB_TEXTURE_1D_BIT |
__DRI_ATTRIB_TEXTURE_2D_BIT |
__DRI_ATTRIB_TEXTURE_RECTANGLE_BIT :
0;
}
}
}
}

5
src/mesa/drivers/dri/common/utils.h
View file

@ -129,9 +129,10 @@ struct __DRIconfigRec {
extern __DRIconfig **
driCreateConfigs(GLenum fb_format, GLenum fb_type,
const u_int8_t * depth_bits, const u_int8_t * stencil_bits,
const uint8_t * depth_bits, const uint8_t * stencil_bits,
unsigned num_depth_stencil_bits,
const GLenum * db_modes, unsigned num_db_modes);
const GLenum * db_modes, unsigned num_db_modes,
const uint8_t * msaa_samples, unsigned num_msaa_modes);
const __DRIconfig **driConcatConfigs(__DRIconfig **a, __DRIconfig **b);

2
src/mesa/main/context.c
View file

@ -1316,7 +1316,9 @@ _mesa_free_context_data( GLcontext *ctx )
_mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);
_mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
#if FEATURE_attrib_stack
_mesa_free_attrib_data(ctx);
#endif
_mesa_free_lighting_data( ctx );
#if FEATURE_evaluators
_mesa_free_eval_data( ctx );