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

Merge branch 'mesa_7_5_branch'

Browse source 
Conflicts:
	src/mesa/state_tracker/st_cb_fbo.c
	src/mesa/state_tracker/st_framebuffer.c
This commit is contained in:
José Fonseca 2009-06-11 16:34:56 +01:00
commit bf89ecb6c9
23 changed files with 514 additions and 278 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
docs/relnotes-7.5.html
View file

@ -74,6 +74,7 @@ including GL_ATI_separate_stencil, GL_EXT_stencil_two_side and OpenGL 2.0
<h2>Bug fixes</h2>
<ul>
<li>Lots of i965 driver bug fixes
<li>Fixed some GLSL preprocessor bugs
</ul>

19
progs/fp/SConscript
View file

@ -11,7 +11,20 @@ env.Prepend(CPPPATH = [
env.Prepend(LIBS = ['$GLUT_LIB'])
env.Program(
target = 'fp-tri',
source = ['fp-tri.c'],
progs = [
'fp-tri',
'tri-depth',
'tri-depth2',
'tri-depthwrite',
'tri-depthwrite2',
'tri-inv',
'tri-param',
'tri-tex',
'point-position',
]
for prog in progs:
env.Program(
target = prog,
source = [prog + '.c'],
)

2
progs/fp/fp-tri.c
View file

@ -89,7 +89,7 @@ static void Init( void )
}
fprintf(stderr, "%.*s\n", sz, buf);
if (!glutExtensionSupported("GL_ARB_fragment_program")) {
if (!GLEW_ARB_fragment_program) {
printf("Error: GL_ARB_fragment_program not supported!\n");
exit(1);
}

7
progs/fp/point-position.c
View file

@ -2,9 +2,8 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define GL_GLEXT_PROTOTYPES
#include <GL/glew.h>
#include <GL/glut.h>
#include "GL/gl.h"
@ -17,7 +16,7 @@ static void Init( void )
;
GLuint modulateProg;
if (!glutExtensionSupported("GL_ARB_fragment_program")) {
if (!GLEW_ARB_fragment_program) {
printf("Error: GL_ARB_fragment_program not supported!\n");
exit(1);
}
@ -109,6 +108,8 @@ int main(int argc, char **argv)
exit(1);
}
glewInit();
Init();
glutReshapeFunc(Reshape);

9
progs/fp/tri-depth.c
View file

@ -2,9 +2,8 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define GL_GLEXT_PROTOTYPES
#include <GL/glew.h>
#include <GL/glut.h>
#include "GL/gl.h"
@ -19,7 +18,7 @@ static void Init( void )
;
GLuint modulateProg;
if (!glutExtensionSupported("GL_ARB_fragment_program")) {
if (!GLEW_ARB_fragment_program) {
printf("Error: GL_ARB_fragment_program not supported!\n");
exit(1);
}
@ -89,8 +88,6 @@ int main(int argc, char **argv)
glutInit(&argc, argv);
glutInitWindowPosition(0, 0); glutInitWindowSize( 250, 250);
type = GLUT_RGB;
@ -101,6 +98,8 @@ int main(int argc, char **argv)
exit(1);
}
glewInit();
Init();
glutReshapeFunc(Reshape);

7
progs/fp/tri-depth2.c
View file

@ -2,9 +2,8 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define GL_GLEXT_PROTOTYPES
#include <GL/glew.h>
#include <GL/glut.h>
#include "GL/gl.h"
@ -21,7 +20,7 @@ static void Init( void )
;
GLuint modulateProg;
if (!glutExtensionSupported("GL_ARB_fragment_program")) {
if (!GLEW_ARB_fragment_program) {
printf("Error: GL_ARB_fragment_program not supported!\n");
exit(1);
}
@ -106,6 +105,8 @@ int main(int argc, char **argv)
exit(1);
}
glewInit();
Init();
glutReshapeFunc(Reshape);

6
progs/fp/tri-depthwrite.c
View file

@ -2,7 +2,7 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define GL_GLEXT_PROTOTYPES
#include <GL/glew.h>
#include <GL/glut.h>
@ -16,7 +16,7 @@ static void Init(void)
;
GLuint modulateProg;
if (!glutExtensionSupported("GL_ARB_fragment_program")) {
if (!GLEW_ARB_fragment_program) {
printf("Error: GL_ARB_fragment_program not supported!\n");
exit(1);
}
@ -97,6 +97,8 @@ int main(int argc, char **argv)
exit(1);
}
glewInit();
Init();
glutReshapeFunc(Reshape);

6
progs/fp/tri-depthwrite2.c
View file

@ -2,7 +2,7 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define GL_GLEXT_PROTOTYPES
#include <GL/glew.h>
#include <GL/glut.h>
@ -16,7 +16,7 @@ static void Init(void)
;
GLuint modulateProg;
if (!glutExtensionSupported("GL_ARB_fragment_program")) {
if (!GLEW_ARB_fragment_program) {
printf("Error: GL_ARB_fragment_program not supported!\n");
exit(1);
}
@ -97,6 +97,8 @@ int main(int argc, char **argv)
exit(1);
}
glewInit();
Init();
glutReshapeFunc(Reshape);

6
progs/fp/tri-inv.c
View file

@ -2,7 +2,7 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define GL_GLEXT_PROTOTYPES
#include <GL/glew.h>
#include <GL/glut.h>
@ -17,7 +17,7 @@ static void Init( void )
;
GLuint modulateProg;
if (!glutExtensionSupported("GL_ARB_fragment_program")) {
if (!GLEW_ARB_fragment_program) {
printf("Error: GL_ARB_fragment_program not supported!\n");
exit(1);
}
@ -99,6 +99,8 @@ int main(int argc, char **argv)
exit(1);
}
glewInit();
Init();
glutReshapeFunc(Reshape);

8
progs/fp/tri-param.c
View file

@ -2,9 +2,9 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define GL_GLEXT_PROTOTYPES
#include <GL/glew.h>
#include <GL/glut.h>
#include "GL/gl.h"
static void Init( void )
{
@ -15,7 +15,7 @@ static void Init( void )
;
GLuint modulateProg;
if (!glutExtensionSupported("GL_ARB_fragment_program")) {
if (!GLEW_ARB_fragment_program) {
printf("Error: GL_ARB_fragment_program not supported!\n");
exit(1);
}
@ -104,6 +104,8 @@ int main(int argc, char **argv)
exit(1);
}
glewInit();
Init();
glutReshapeFunc(Reshape);

6
progs/fp/tri-tex.c
View file

@ -3,7 +3,7 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define GL_GLEXT_PROTOTYPES
#include <GL/glew.h>
#include <GL/glut.h>
#include "readtex.c"
@ -23,7 +23,7 @@ static void Init( void )
GLuint modulateProg;
GLuint Texture;
if (!glutExtensionSupported("GL_ARB_fragment_program")) {
if (!GLEW_ARB_fragment_program) {
printf("Error: GL_ARB_fragment_program not supported!\n");
exit(1);
}
@ -120,6 +120,8 @@ int main(int argc, char **argv)
exit(1);
}
glewInit();
Init();
glutReshapeFunc(Reshape);

2
src/gallium/auxiliary/util/u_gen_mipmap.c
View file

@ -1385,7 +1385,7 @@ set_vertex_data(struct gen_mipmap_state *ctx,
* Not +/-1 to avoid cube face selection ambiguity near the edges,
* though that can still sometimes happen with this scale factor...
*/
const float scale = 0.9999;
const float scale = 0.9999f;
const float sc = (2.0f * st[i][0] - 1.0f) * scale;
const float tc = (2.0f * st[i][1] - 1.0f) * scale;

12
src/gallium/include/pipe/p_format.h
View file

@ -536,6 +536,18 @@ pf_get_nblocks(const struct pipe_format_block *block, unsigned width, unsigned h
return pf_get_nblocksx(block, width)*pf_get_nblocksy(block, height);
}
static INLINE size_t
pf_get_stride(const struct pipe_format_block *block, unsigned width)
{
return pf_get_nblocksx(block, width)*block->size;
}
static INLINE size_t
pf_get_2d_size(const struct pipe_format_block *block, size_t stride, unsigned height)
{
return pf_get_nblocksy(block, height)*stride;
}
static INLINE boolean
pf_is_depth_stencil( enum pipe_format format )
{

223
src/gallium/state_trackers/python/tests/texture_sample.py
View file

@ -99,7 +99,7 @@ def is_pot(n):
return n & (n - 1) == 0
class TextureTest(TestCase):
class TextureColorSampleTest(TestCase):
tags = (
'target',
@ -286,6 +286,206 @@ class TextureTest(TestCase):
self.assert_rgba(cbuf, x, y, w, h, expected_rgba, 4.0/256, 0.85)
class TextureDepthSampleTest(TestCase):
tags = (
'target',
'format',
'width',
'height',
'depth',
'last_level',
'face',
'level',
'zslice',
)
def test(self):
dev = self.dev
target = self.target
format = self.format
width = self.width
height = self.height
depth = self.depth
last_level = self.last_level
face = self.face
level = self.level
zslice = self.zslice
tex_usage = PIPE_TEXTURE_USAGE_SAMPLER
geom_flags = 0
if width != height:
geom_flags |= PIPE_TEXTURE_GEOM_NON_SQUARE
if not is_pot(width) or not is_pot(height) or not is_pot(depth):
geom_flags |= PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO
if not dev.is_format_supported(format, target, tex_usage, geom_flags):
raise TestSkip
ctx = self.dev.context_create()
# disabled blending/masking
blend = Blend()
blend.rgb_src_factor = PIPE_BLENDFACTOR_ONE
blend.alpha_src_factor = PIPE_BLENDFACTOR_ONE
blend.rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
blend.alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
blend.colormask = PIPE_MASK_RGBA
ctx.set_blend(blend)
# depth/stencil/alpha
depth_stencil_alpha = DepthStencilAlpha()
depth_stencil_alpha.depth.enabled = 1
depth_stencil_alpha.depth.writemask = 1
depth_stencil_alpha.depth.func = PIPE_FUNC_LESS
ctx.set_depth_stencil_alpha(depth_stencil_alpha)
# rasterizer
rasterizer = Rasterizer()
rasterizer.front_winding = PIPE_WINDING_CW
rasterizer.cull_mode = PIPE_WINDING_NONE
rasterizer.bypass_vs_clip_and_viewport = 1
ctx.set_rasterizer(rasterizer)
# samplers
sampler = Sampler()
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST
sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
sampler.normalized_coords = 1
sampler.min_lod = 0
sampler.max_lod = PIPE_MAX_TEXTURE_LEVELS - 1
ctx.set_sampler(0, sampler)
# texture
texture = dev.texture_create(
target = target,
format = format,
width = width,
height = height,
depth = depth,
last_level = last_level,
tex_usage = tex_usage,
)
expected_rgba = FloatArray(height*width*4)
texture.get_surface(
face = face,
level = level,
zslice = zslice,
).sample_rgba(expected_rgba)
ctx.set_sampler_texture(0, texture)
# framebuffer
cbuf_tex = dev.texture_create(
PIPE_FORMAT_A8R8G8B8_UNORM,
width,
height,
tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET,
)
zsbuf_tex = dev.texture_create(
PIPE_FORMAT_Z24X8_UNORM,
width,
height,
tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET,
)
cbuf = cbuf_tex.get_surface()
zsbuf = zsbuf_tex.get_surface()
fb = Framebuffer()
fb.width = width
fb.height = height
fb.nr_cbufs = 1
fb.set_cbuf(0, cbuf)
fb.set_zsbuf(zsbuf)
ctx.set_framebuffer(fb)
rgba = FloatArray(4);
rgba[0] = 0.5
rgba[1] = 0.5
rgba[2] = 0.5
rgba[3] = 0.5
ctx.clear(PIPE_CLEAR_DEPTHSTENCIL, rgba, 1.0, 0)
del fb
# vertex shader
vs = Shader('''
VERT1.1
DCL IN[0], POSITION, CONSTANT
DCL IN[1], GENERIC, CONSTANT
DCL OUT[0], POSITION, CONSTANT
DCL OUT[1], GENERIC, CONSTANT
0:MOV OUT[0], IN[0]
1:MOV OUT[1], IN[1]
2:END
''')
#vs.dump()
ctx.set_vertex_shader(vs)
# fragment shader
op = {
PIPE_TEXTURE_1D: "1D",
PIPE_TEXTURE_2D: "2D",
PIPE_TEXTURE_3D: "3D",
PIPE_TEXTURE_CUBE: "CUBE",
}[target]
fs = Shader('''
FRAG1.1
DCL IN[0], GENERIC[0], LINEAR
DCL SAMP[0], CONSTANT
DCL OUT[0].z, POSITION
0:TEX OUT[0].z, IN[0], SAMP[0], %s
1:END
''' % op)
#fs.dump()
ctx.set_fragment_shader(fs)
nverts = 4
nattrs = 2
verts = FloatArray(nverts * nattrs * 4)
x = 0
y = 0
w, h = minify((width, height), level)
pos = [
[x, y],
[x+w, y],
[x+w, y+h],
[x, y+h],
]
tex = tex_coords(texture, face, level, zslice)
for i in range(0, 4):
j = 8*i
verts[j + 0] = pos[i][0] # x
verts[j + 1] = pos[i][1] # y
verts[j + 2] = 0.0 # z
verts[j + 3] = 1.0 # w
verts[j + 4] = tex[i][0] # s
verts[j + 5] = tex[i][1] # r
verts[j + 6] = tex[i][2] # q
verts[j + 7] = 1.0
ctx.draw_vertices(PIPE_PRIM_TRIANGLE_FAN,
nverts,
nattrs,
verts)
ctx.flush()
zsbuf = zsbuf_tex.get_surface()
self.assert_rgba(zsbuf, x, y, w, h, expected_rgba, 4.0/256, 0.85)
def main():
dev = Device()
@ -304,11 +504,10 @@ def main():
PIPE_FORMAT_R5G6B5_UNORM,
PIPE_FORMAT_A1R5G5B5_UNORM,
PIPE_FORMAT_A4R4G4B4_UNORM,
#PIPE_FORMAT_Z32_UNORM,
#PIPE_FORMAT_Z24S8_UNORM,
#PIPE_FORMAT_Z24X8_UNORM,
#PIPE_FORMAT_Z16_UNORM,
#PIPE_FORMAT_S8_UNORM,
PIPE_FORMAT_Z32_UNORM,
PIPE_FORMAT_Z24S8_UNORM,
PIPE_FORMAT_Z24X8_UNORM,
PIPE_FORMAT_Z16_UNORM,
PIPE_FORMAT_A8_UNORM,
PIPE_FORMAT_L8_UNORM,
PIPE_FORMAT_YCBCR,
@ -347,7 +546,17 @@ def main():
for level in range(0, last_level + 1):
zslice = 0
while zslice < depth >> level:
test = TextureTest(
if format in (
PIPE_FORMAT_Z32_UNORM,
PIPE_FORMAT_Z24S8_UNORM,
PIPE_FORMAT_Z24X8_UNORM,
PIPE_FORMAT_Z16_UNORM,
):
klass = TextureDepthSampleTest
else:
klass = TextureColorSampleTest
test = klass(
dev = dev,
target = target,
format = format,

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

@ -2874,7 +2874,7 @@ extract_uint_indexes(GLuint n, GLuint indexes[],
}
else {
for (i = 0; i < n; i++)
indexes[i] = s[i] & 0xfff; /* lower 8 bits */
indexes[i] = s[i] & 0xff; /* lower 8 bits */
}
}
break;

10
src/mesa/main/matrix.c
View file

@ -160,11 +160,21 @@ _mesa_MatrixMode( GLenum mode )
ctx->CurrentStack = &ctx->ProjectionMatrixStack;
break;
case GL_TEXTURE:
/* This error check is disabled because if we're called from
* glPopAttrib() when the active texture unit is >= MaxTextureCoordUnits
* we'll generate an unexpected error.
* From the GL_ARB_vertex_shader spec it sounds like we should instead
* do error checking in other places when we actually try to access
* texture matrices beyond MaxTextureCoordUnits.
*/
#if 0
if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glMatrixMode(invalid tex unit %d)",
ctx->Texture.CurrentUnit);
return;
}
#endif
ASSERT(ctx->Texture.CurrentUnit < Elements(ctx->TextureMatrixStack));
ctx->CurrentStack = &ctx->TextureMatrixStack[ctx->Texture.CurrentUnit];
break;
case GL_COLOR:

242
src/mesa/state_tracker/st_cb_accum.c
View file

@ -48,10 +48,6 @@
#include "util/u_tile.h"
#define UNCLAMPED_FLOAT_TO_SHORT(us, f) \
us = ( (short) ( CLAMP((f), -1.0, 1.0) * 32767.0F) )
/**
* For hardware that supports deep color buffers, we could accelerate
* most/all the accum operations with blending/texturing.
@ -59,74 +55,20 @@
*/
/**
* Wrapper for pipe_get_tile_rgba(). Do format/cpp override to make the
* tile util function think the surface is 16bit/channel, even if it's not.
* See also: st_renderbuffer_alloc_storage()
*/
static void
acc_get_tile_rgba(struct pipe_context *pipe, struct pipe_transfer *acc_pt,
uint x, uint y, uint w, uint h, float *p)
{
const enum pipe_format f = acc_pt->format;
const struct pipe_format_block b = acc_pt->block;
acc_pt->format = DEFAULT_ACCUM_PIPE_FORMAT;
acc_pt->block.size = 8;
acc_pt->block.width = 1;
acc_pt->block.height = 1;
pipe_get_tile_rgba(acc_pt, x, y, w, h, p);
acc_pt->format = f;
acc_pt->block = b;
}
/**
* Wrapper for pipe_put_tile_rgba(). Do format/cpp override to make the
* tile util function think the surface is 16bit/channel, even if it's not.
* See also: st_renderbuffer_alloc_storage()
*/
static void
acc_put_tile_rgba(struct pipe_context *pipe, struct pipe_transfer *acc_pt,
uint x, uint y, uint w, uint h, const float *p)
{
enum pipe_format f = acc_pt->format;
const struct pipe_format_block b = acc_pt->block;
acc_pt->format = DEFAULT_ACCUM_PIPE_FORMAT;
acc_pt->block.size = 8;
acc_pt->block.width = 1;
acc_pt->block.height = 1;
pipe_put_tile_rgba(acc_pt, x, y, w, h, p);
acc_pt->format = f;
acc_pt->block = b;
}
void
st_clear_accum_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
{
struct st_renderbuffer *acc_strb = st_renderbuffer(rb);
struct pipe_transfer *acc_pt;
struct pipe_screen *screen = ctx->st->pipe->screen;
const GLint xpos = ctx->DrawBuffer->_Xmin;
const GLint ypos = ctx->DrawBuffer->_Ymin;
const GLint width = ctx->DrawBuffer->_Xmax - xpos;
const GLint height = ctx->DrawBuffer->_Ymax - ypos;
GLubyte *map;
size_t stride = acc_strb->stride;
GLubyte *data = acc_strb->data;
acc_pt = st_cond_flush_get_tex_transfer(st_context(ctx), acc_strb->texture,
0, 0, 0,
PIPE_TRANSFER_WRITE, xpos, ypos,
width, height);
map = screen->transfer_map(screen, acc_pt);
/* note acc_strb->format might not equal acc_pt->format */
if(!data)
return;
switch (acc_strb->format) {
case PIPE_FORMAT_R16G16B16A16_SNORM:
{
@ -136,7 +78,7 @@ st_clear_accum_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
GLshort a = FLOAT_TO_SHORT(ctx->Accum.ClearColor[3]);
int i, j;
for (i = 0; i < height; i++) {
GLshort *dst = (GLshort *) (map + i * acc_pt->stride + xpos * 8);
GLshort *dst = (GLshort *) (data + (ypos + i) * stride + xpos * 8);
for (j = 0; j < width; j++) {
dst[0] = r;
dst[1] = g;
@ -150,9 +92,6 @@ st_clear_accum_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
default:
_mesa_problem(ctx, "unexpected format in st_clear_accum_buffer()");
}
screen->transfer_unmap(screen, acc_pt);
screen->tex_transfer_destroy(acc_pt);
}
@ -162,27 +101,18 @@ accum_mad(GLcontext *ctx, GLfloat scale, GLfloat bias,
GLint xpos, GLint ypos, GLint width, GLint height,
struct st_renderbuffer *acc_strb)
{
struct pipe_screen *screen = ctx->st->pipe->screen;
struct pipe_transfer *acc_pt;
GLubyte *map;
size_t stride = acc_strb->stride;
GLubyte *data = acc_strb->data;
acc_pt = st_cond_flush_get_tex_transfer(st_context(ctx), acc_strb->texture,
0, 0, 0,
PIPE_TRANSFER_READ_WRITE,
xpos, ypos,
width, height);
map = screen->transfer_map(screen, acc_pt);
/* note acc_strb->format might not equal acc_pt->format */
switch (acc_strb->format) {
case PIPE_FORMAT_R16G16B16A16_SNORM:
{
int i, j;
for (i = 0; i < height; i++) {
GLshort *acc = (GLshort *) (map + (ypos + i) * acc_pt->stride + xpos * 8);
GLshort *acc = (GLshort *) (data + (ypos + i) * stride + xpos * 8);
for (j = 0; j < width * 4; j++) {
float val = SHORT_TO_FLOAT(acc[j]) * scale + bias;
acc[j] = FLOAT_TO_SHORT(val);
float val = SHORT_TO_FLOAT(*acc) * scale + bias;
*acc++ = FLOAT_TO_SHORT(val);
}
}
}
@ -190,9 +120,6 @@ accum_mad(GLcontext *ctx, GLfloat scale, GLfloat bias,
default:
_mesa_problem(NULL, "unexpected format in st_clear_accum_buffer()");
}
screen->transfer_unmap(screen, acc_pt);
screen->tex_transfer_destroy(acc_pt);
}
@ -204,39 +131,39 @@ accum_accum(struct st_context *st, GLfloat value,
{
struct pipe_context *pipe = st->pipe;
struct pipe_screen *screen = pipe->screen;
struct pipe_transfer *acc_trans, *color_trans;
GLfloat *colorBuf, *accBuf;
GLint i;
acc_trans = st_cond_flush_get_tex_transfer(st, acc_strb->texture, 0, 0, 0,
PIPE_TRANSFER_READ, xpos, ypos,
width, height);
struct pipe_transfer *color_trans;
size_t stride = acc_strb->stride;
GLubyte *data = acc_strb->data;
GLfloat *buf;
color_trans = st_cond_flush_get_tex_transfer(st, color_strb->texture,
0, 0, 0,
PIPE_TRANSFER_READ, xpos, ypos,
width, height);
colorBuf = (GLfloat *) _mesa_malloc(width * height * 4 * sizeof(GLfloat));
accBuf = (GLfloat *) _mesa_malloc(width * height * 4 * sizeof(GLfloat));
buf = (GLfloat *) _mesa_malloc(width * height * 4 * sizeof(GLfloat));
pipe_get_tile_rgba(color_trans, 0, 0, width, height, colorBuf);
acc_get_tile_rgba(pipe, acc_trans, 0, 0, width, height, accBuf);
pipe_get_tile_rgba(color_trans, 0, 0, width, height, buf);
for (i = 0; i < 4 * width * height; i++) {
accBuf[i] = accBuf[i] + colorBuf[i] * value;
switch (acc_strb->format) {
case PIPE_FORMAT_R16G16B16A16_SNORM:
{
const GLfloat *color = buf;
int i, j;
for (i = 0; i < height; i++) {
GLshort *acc = (GLshort *) (data + (ypos + i) * stride + xpos * 8);
for (j = 0; j < width * 4; j++) {
float val = *color++ * value;
*acc++ += FLOAT_TO_SHORT(val);
}
}
}
break;
default:
_mesa_problem(NULL, "unexpected format in st_clear_accum_buffer()");
}
screen->tex_transfer_destroy(acc_trans);
acc_trans = st_no_flush_get_tex_transfer(st, acc_strb->texture, 0, 0, 0,
PIPE_TRANSFER_WRITE, xpos, ypos,
width, height);
acc_put_tile_rgba(pipe, acc_trans, 0, 0, width, height, accBuf);
_mesa_free(colorBuf);
_mesa_free(accBuf);
screen->tex_transfer_destroy(acc_trans);
_mesa_free(buf);
screen->tex_transfer_destroy(color_trans);
}
@ -249,13 +176,10 @@ accum_load(struct st_context *st, GLfloat value,
{
struct pipe_context *pipe = st->pipe;
struct pipe_screen *screen = pipe->screen;
struct pipe_transfer *acc_trans, *color_trans;
struct pipe_transfer *color_trans;
size_t stride = acc_strb->stride;
GLubyte *data = acc_strb->data;
GLfloat *buf;
GLint i;
acc_trans = st_cond_flush_get_tex_transfer(st, acc_strb->texture, 0, 0, 0,
PIPE_TRANSFER_WRITE, xpos, ypos,
width, height);
color_trans = st_cond_flush_get_tex_transfer(st, color_strb->texture,
0, 0, 0,
@ -266,14 +190,25 @@ accum_load(struct st_context *st, GLfloat value,
pipe_get_tile_rgba(color_trans, 0, 0, width, height, buf);
for (i = 0; i < 4 * width * height; i++) {
buf[i] = buf[i] * value;
switch (acc_strb->format) {
case PIPE_FORMAT_R16G16B16A16_SNORM:
{
const GLfloat *color = buf;
int i, j;
for (i = 0; i < height; i++) {
GLshort *acc = (GLshort *) (data + (ypos + i) * stride + xpos * 8);
for (j = 0; j < width * 4; j++) {
float val = *color++ * value;
*acc++ = FLOAT_TO_SHORT(val);
}
}
}
break;
default:
_mesa_problem(NULL, "unexpected format in st_clear_accum_buffer()");
}
acc_put_tile_rgba(pipe, acc_trans, 0, 0, width, height, buf);
_mesa_free(buf);
screen->tex_transfer_destroy(acc_trans);
screen->tex_transfer_destroy(color_trans);
}
@ -287,48 +222,58 @@ accum_return(GLcontext *ctx, GLfloat value,
struct pipe_context *pipe = ctx->st->pipe;
struct pipe_screen *screen = pipe->screen;
const GLubyte *colormask = ctx->Color.ColorMask;
struct pipe_transfer *acc_trans, *color_trans;
GLfloat *abuf, *cbuf = NULL;
GLint i, ch;
enum pipe_transfer_usage usage;
struct pipe_transfer *color_trans;
size_t stride = acc_strb->stride;
const GLubyte *data = acc_strb->data;
GLfloat *buf;
abuf = (GLfloat *) _mesa_malloc(width * height * 4 * sizeof(GLfloat));
acc_trans = st_cond_flush_get_tex_transfer(st_context(ctx),
acc_strb->texture, 0, 0, 0,
PIPE_TRANSFER_READ, xpos, ypos,
width, height);
buf = (GLfloat *) _mesa_malloc(width * height * 4 * sizeof(GLfloat));
if (!colormask[0] || !colormask[1] || !colormask[2] || !colormask[3])
usage = PIPE_TRANSFER_READ_WRITE;
else
usage = PIPE_TRANSFER_WRITE;
color_trans = st_cond_flush_get_tex_transfer(st_context(ctx),
color_strb->texture, 0, 0, 0,
PIPE_TRANSFER_READ_WRITE,
usage,
xpos, ypos,
width, height);
acc_get_tile_rgba(pipe, acc_trans, 0, 0, width, height, abuf);
if (usage != PIPE_TRANSFER_WRITE)
pipe_get_tile_rgba(color_trans, 0, 0, width, height, buf);
if (!colormask[0] || !colormask[1] || !colormask[2] || !colormask[3]) {
cbuf = (GLfloat *) _mesa_malloc(width * height * 4 * sizeof(GLfloat));
pipe_get_tile_rgba(color_trans, 0, 0, width, height, cbuf);
}
for (i = 0; i < width * height; i++) {
for (ch = 0; ch < 4; ch++) {
if (colormask[ch]) {
GLfloat val = abuf[i * 4 + ch] * value;
abuf[i * 4 + ch] = CLAMP(val, 0.0f, 1.0f);
}
else {
abuf[i * 4 + ch] = cbuf[i * 4 + ch];
switch (acc_strb->format) {
case PIPE_FORMAT_R16G16B16A16_SNORM:
{
GLfloat *color = buf;
int i, j, ch;
for (i = 0; i < height; i++) {
const GLshort *acc = (const GLshort *) (data + (ypos + i) * stride + xpos * 8);
for (j = 0; j < width; j++) {
for (ch = 0; ch < 4; ch++) {
if (colormask[ch]) {
GLfloat val = SHORT_TO_FLOAT(*acc * value);
*color = CLAMP(val, 0.0f, 1.0f);
}
else {
/* No change */
}
++acc;
++color;
}
}
}
}
break;
default:
_mesa_problem(NULL, "unexpected format in st_clear_accum_buffer()");
}
pipe_put_tile_rgba(color_trans, 0, 0, width, height, abuf);
pipe_put_tile_rgba(color_trans, 0, 0, width, height, buf);
_mesa_free(abuf);
if (cbuf)
_mesa_free(cbuf);
screen->tex_transfer_destroy(acc_trans);
_mesa_free(buf);
screen->tex_transfer_destroy(color_trans);
}
@ -347,6 +292,9 @@ st_Accum(GLcontext *ctx, GLenum op, GLfloat value)
const GLint width = ctx->DrawBuffer->_Xmax - xpos;
const GLint height = ctx->DrawBuffer->_Ymax - ypos;
if(!acc_strb->data)
return;
/* make sure color bufs aren't cached */
st_flush( st, PIPE_FLUSH_RENDER_CACHE, NULL );

27
src/mesa/state_tracker/st_cb_drawpixels.c
View file

@ -630,6 +630,7 @@ draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
struct pipe_context *pipe = st->pipe;
struct pipe_screen *screen = pipe->screen;
struct st_renderbuffer *strb;
enum pipe_transfer_usage usage;
struct pipe_transfer *pt;
const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
GLint skipPixels;
@ -642,8 +643,14 @@ draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
y = ctx->DrawBuffer->Height - y - height;
}
if(format != GL_DEPTH_STENCIL &&
pf_get_component_bits( strb->format, PIPE_FORMAT_COMP_Z ) != 0)
usage = PIPE_TRANSFER_READ_WRITE;
else
usage = PIPE_TRANSFER_WRITE;
pt = st_cond_flush_get_tex_transfer(st_context(ctx), strb->texture, 0, 0, 0,
PIPE_TRANSFER_WRITE, x, y,
usage, x, y,
width, height);
stmap = screen->transfer_map(screen, pt);
@ -694,6 +701,7 @@ draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
case PIPE_FORMAT_S8_UNORM:
{
ubyte *dest = stmap + spanY * pt->stride + spanX;
assert(usage == PIPE_TRANSFER_WRITE);
memcpy(dest, sValues, spanWidth);
}
break;
@ -701,6 +709,7 @@ draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
if (format == GL_DEPTH_STENCIL) {
uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
GLint k;
assert(usage == PIPE_TRANSFER_WRITE);
for (k = 0; k < spanWidth; k++) {
dest[k] = zValues[k] | (sValues[k] << 24);
}
@ -708,6 +717,7 @@ draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
else {
uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
GLint k;
assert(usage == PIPE_TRANSFER_READ_WRITE);
for (k = 0; k < spanWidth; k++) {
dest[k] = (dest[k] & 0xffffff) | (sValues[k] << 24);
}
@ -717,13 +727,15 @@ draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
if (format == GL_DEPTH_STENCIL) {
uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
GLint k;
assert(usage == PIPE_TRANSFER_WRITE);
for (k = 0; k < spanWidth; k++) {
dest[k] = zValues[k] | (sValues[k] << 24);
dest[k] = (zValues[k] << 8) | (sValues[k] & 0xff);
}
}
else {
uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
GLint k;
assert(usage == PIPE_TRANSFER_READ_WRITE);
for (k = 0; k < spanWidth; k++) {
dest[k] = (dest[k] & 0xffffff00) | (sValues[k] & 0xff);
}
@ -811,6 +823,7 @@ copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
{
struct st_renderbuffer *rbDraw = st_renderbuffer(ctx->DrawBuffer->_StencilBuffer);
struct pipe_screen *screen = ctx->st->pipe->screen;
enum pipe_transfer_usage usage;
struct pipe_transfer *ptDraw;
ubyte *drawMap;
ubyte *buffer;
@ -827,9 +840,14 @@ copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
GL_STENCIL_INDEX, GL_UNSIGNED_BYTE,
&ctx->DefaultPacking, buffer);
if(pf_get_component_bits( rbDraw->format, PIPE_FORMAT_COMP_Z ) != 0)
usage = PIPE_TRANSFER_READ_WRITE;
else
usage = PIPE_TRANSFER_WRITE;
ptDraw = st_cond_flush_get_tex_transfer(st_context(ctx),
rbDraw->texture, 0, 0, 0,
PIPE_TRANSFER_WRITE, dstx, dsty,
usage, dstx, dsty,
width, height);
assert(ptDraw->block.width == 1);
@ -859,6 +877,7 @@ copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
{
uint *dst4 = (uint *) dst;
int j;
assert(usage == PIPE_TRANSFER_READ_WRITE);
for (j = 0; j < width; j++) {
*dst4 = (*dst4 & 0xffffff) | (src[j] << 24);
dst4++;
@ -869,6 +888,7 @@ copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
{
uint *dst4 = (uint *) dst;
int j;
assert(usage == PIPE_TRANSFER_READ_WRITE);
for (j = 0; j < width; j++) {
*dst4 = (*dst4 & 0xffffff00) | (src[j] & 0xff);
dst4++;
@ -876,6 +896,7 @@ copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
}
break;
case PIPE_FORMAT_S8_UNORM:
assert(usage == PIPE_TRANSFER_WRITE);
memcpy(dst, src, width);
break;
default:

153
src/mesa/state_tracker/st_cb_fbo.c
View file

@ -88,93 +88,92 @@ st_renderbuffer_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
{
struct pipe_context *pipe = ctx->st->pipe;
struct st_renderbuffer *strb = st_renderbuffer(rb);
struct pipe_texture template;
unsigned surface_usage;
/* Free the old surface and texture
*/
pipe_surface_reference( &strb->surface, NULL );
pipe_texture_reference( &strb->texture, NULL );
/* Setup new texture template.
*/
memset(&template, 0, sizeof(template));
template.target = PIPE_TEXTURE_2D;
if (strb->format != PIPE_FORMAT_NONE) {
template.format = strb->format;
}
else {
template.format = st_choose_renderbuffer_format(pipe, internalFormat);
}
pf_get_block(template.format, &template.block);
template.width[0] = width;
template.height[0] = height;
template.depth[0] = 1;
template.last_level = 0;
template.nr_samples = rb->NumSamples;
if (pf_is_depth_stencil(template.format)) {
template.tex_usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
}
else {
template.tex_usage = (PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
PIPE_TEXTURE_USAGE_RENDER_TARGET);
}
enum pipe_format format;
if (strb->format != PIPE_FORMAT_NONE)
format = strb->format;
else
format = st_choose_renderbuffer_format(pipe, internalFormat);
/* init renderbuffer fields */
strb->Base.Width = width;
strb->Base.Height = height;
init_renderbuffer_bits(strb, template.format);
init_renderbuffer_bits(strb, format);
strb->defined = GL_FALSE; /* undefined contents now */
/* Probably need dedicated flags for surface usage too:
*/
surface_usage = (PIPE_BUFFER_USAGE_GPU_READ |
PIPE_BUFFER_USAGE_GPU_WRITE);
#if 0
PIPE_BUFFER_USAGE_CPU_READ |
PIPE_BUFFER_USAGE_CPU_WRITE);
#endif
if(strb->software) {
struct pipe_format_block block;
size_t size;
_mesa_free(strb->data);
strb->texture = pipe->screen->texture_create( pipe->screen,
&template );
/* Special path for accum buffers.
*
* Try a different surface format. Since accum buffers are s/w
* only for now, the surface pixel format doesn't really matter,
* only that the buffer is large enough.
*/
if (!strb->texture && template.format == DEFAULT_ACCUM_PIPE_FORMAT)
{
/* Actually, just setting this usage value should be sufficient
* to tell the driver to go ahead and allocate the buffer, even
* if HW doesn't support the format.
assert(strb->format != PIPE_FORMAT_NONE);
pf_get_block(strb->format, &block);
strb->stride = pf_get_stride(&block, width);
size = pf_get_2d_size(&block, strb->stride, height);
strb->data = _mesa_malloc(size);
return strb->data != NULL;
}
else {
struct pipe_texture template;
unsigned surface_usage;
/* Free the old surface and texture
*/
template.tex_usage = 0;
surface_usage = (PIPE_BUFFER_USAGE_CPU_READ |
pipe_surface_reference( &strb->surface, NULL );
pipe_texture_reference( &strb->texture, NULL );
/* Setup new texture template.
*/
memset(&template, 0, sizeof(template));
template.target = PIPE_TEXTURE_2D;
template.format = format;
pf_get_block(format, &template.block);
template.width[0] = width;
template.height[0] = height;
template.depth[0] = 1;
template.last_level = 0;
template.nr_samples = rb->NumSamples;
if (pf_is_depth_stencil(format)) {
template.tex_usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
}
else {
template.tex_usage = (PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
PIPE_TEXTURE_USAGE_RENDER_TARGET);
}
/* Probably need dedicated flags for surface usage too:
*/
surface_usage = (PIPE_BUFFER_USAGE_GPU_READ |
PIPE_BUFFER_USAGE_GPU_WRITE);
#if 0
PIPE_BUFFER_USAGE_CPU_READ |
PIPE_BUFFER_USAGE_CPU_WRITE);
#endif
strb->texture = pipe->screen->texture_create( pipe->screen,
&template );
if (!strb->texture)
return FALSE;
strb->surface = pipe->screen->get_tex_surface( pipe->screen,
strb->texture,
0, 0, 0,
surface_usage );
assert(strb->surface->texture);
assert(strb->surface->format);
assert(strb->surface->width == width);
assert(strb->surface->height == height);
return strb->surface != NULL;
}
if (!strb->texture)
return FALSE;
strb->surface = pipe->screen->get_tex_surface( pipe->screen,
strb->texture,
0, 0, 0,
surface_usage );
assert(strb->surface->texture);
assert(strb->surface->format);
assert(strb->surface->width == width);
assert(strb->surface->height == height);
return strb->surface != NULL;
}
@ -188,6 +187,7 @@ st_renderbuffer_delete(struct gl_renderbuffer *rb)
ASSERT(strb);
pipe_surface_reference(&strb->surface, NULL);
pipe_texture_reference(&strb->texture, NULL);
_mesa_free(strb->data);
_mesa_free(strb);
}
@ -244,7 +244,7 @@ st_new_renderbuffer(GLcontext *ctx, GLuint name)
* renderbuffer). The window system code determines the format.
*/
struct gl_renderbuffer *
st_new_renderbuffer_fb(enum pipe_format format, int samples)
st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw)
{
struct st_renderbuffer *strb;
@ -258,7 +258,8 @@ st_new_renderbuffer_fb(enum pipe_format format, int samples)
strb->Base.ClassID = 0x4242; /* just a unique value */
strb->Base.NumSamples = samples;
strb->format = format;
strb->software = sw;
switch (format) {
case PIPE_FORMAT_A8R8G8B8_UNORM:
case PIPE_FORMAT_B8G8R8A8_UNORM:
@ -289,7 +290,7 @@ st_new_renderbuffer_fb(enum pipe_format format, int samples)
strb->Base.InternalFormat = GL_STENCIL_INDEX8_EXT;
strb->Base._BaseFormat = GL_STENCIL_INDEX;
break;
case DEFAULT_ACCUM_PIPE_FORMAT: /*PIPE_FORMAT_R16G16B16A16_SNORM*/
case PIPE_FORMAT_R16G16B16A16_SNORM:
strb->Base.InternalFormat = GL_RGBA16;
strb->Base._BaseFormat = GL_RGBA;
break;
@ -536,7 +537,7 @@ check_create_front_buffer(GLcontext *ctx, struct gl_framebuffer *fb,
samples = back->Base.NumSamples;
/* create front renderbuffer */
front = st_new_renderbuffer_fb(colorFormat, samples);
front = st_new_renderbuffer_fb(colorFormat, samples, FALSE);
_mesa_add_renderbuffer(fb, frontIndex, front);
/* alloc texture/surface for new front buffer */

13
src/mesa/state_tracker/st_cb_fbo.h
View file

@ -30,10 +30,6 @@
#define ST_CB_FBO_H
#define DEFAULT_ACCUM_PIPE_FORMAT PIPE_FORMAT_R16G16B16A16_SNORM
/**
* Derived renderbuffer class. Just need to add a pointer to the
* pipe surface.
@ -46,6 +42,13 @@ struct st_renderbuffer
enum pipe_format format; /** preferred format, or PIPE_FORMAT_NONE */
GLboolean defined; /**< defined contents? */
/**
* Used only when hardware accumulation buffers are not supported.
*/
boolean software;
size_t stride;
void *data;
struct st_texture_object *rtt; /**< GL render to texture's texture */
int rtt_level, rtt_face, rtt_slice;
@ -63,7 +66,7 @@ st_renderbuffer(struct gl_renderbuffer *rb)
extern struct gl_renderbuffer *
st_new_renderbuffer_fb(enum pipe_format format, int samples);
st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw);
extern void
st_init_fbo_functions(struct dd_function_table *functions);

13
src/mesa/state_tracker/st_cb_readpixels.c
View file

@ -112,7 +112,7 @@ st_read_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
case PIPE_FORMAT_S8Z24_UNORM:
if (format == GL_DEPTH_STENCIL) {
const uint *src = (uint *) (stmap + srcY * pt->stride);
const GLfloat scale = 1.0 / (0xffffff);
const GLfloat scale = 1.0f / (0xffffff);
GLint k;
for (k = 0; k < width; k++) {
sValues[k] = src[k] >> 24;
@ -130,7 +130,7 @@ st_read_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
case PIPE_FORMAT_Z24S8_UNORM:
if (format == GL_DEPTH_STENCIL) {
const uint *src = (uint *) (stmap + srcY * pt->stride);
const GLfloat scale = 1.0 / (0xffffff);
const GLfloat scale = 1.0f / (0xffffff);
GLint k;
for (k = 0; k < width; k++) {
sValues[k] = src[k] & 0xff;
@ -445,11 +445,16 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
}
}
else {
/* untested, but simple: */
/* XXX: unreachable code -- should be before st_read_stencil_pixels */
assert(format == GL_DEPTH_STENCIL_EXT);
for (i = 0; i < height; i++) {
GLuint *zshort = (GLuint *)dst;
pipe_get_tile_raw(trans, 0, y, width, 1, dst, 0);
y += yStep;
/* Reverse into 24/8 */
for (j = 0; j < width; j++) {
zshort[j] = (zshort[j] << 8) | (zshort[j] >> 24);
}
dst += dstStride;
}
}
@ -472,7 +477,7 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
}
}
else {
/* untested, but simple: */
/* XXX: unreachable code -- should be before st_read_stencil_pixels */
assert(format == GL_DEPTH_STENCIL_EXT);
for (i = 0; i < height; i++) {
pipe_get_tile_raw(trans, 0, y, width, 1, dst, 0);

17
src/mesa/state_tracker/st_framebuffer.c
View file

@ -60,7 +60,7 @@ st_create_framebuffer( const __GLcontextModes *visual,
if (visual->doubleBufferMode) {
struct gl_renderbuffer *rb
= st_new_renderbuffer_fb(colorFormat, samples);
= st_new_renderbuffer_fb(colorFormat, samples, FALSE);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_BACK_LEFT, rb);
}
else {
@ -69,14 +69,14 @@ st_create_framebuffer( const __GLcontextModes *visual,
* See check_create_front_buffers().
*/
struct gl_renderbuffer *rb
= st_new_renderbuffer_fb(colorFormat, samples);
= st_new_renderbuffer_fb(colorFormat, samples, FALSE);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_FRONT_LEFT, rb);
}
if (depthFormat == stencilFormat && depthFormat != PIPE_FORMAT_NONE) {
/* combined depth/stencil buffer */
struct gl_renderbuffer *depthStencilRb
= st_new_renderbuffer_fb(depthFormat, samples);
= st_new_renderbuffer_fb(depthFormat, samples, FALSE);
/* note: bind RB to two attachment points */
_mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthStencilRb);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_STENCIL, depthStencilRb);
@ -87,34 +87,35 @@ st_create_framebuffer( const __GLcontextModes *visual,
if (visual->depthBits == 32) {
/* 32-bit depth buffer */
struct gl_renderbuffer *depthRb
= st_new_renderbuffer_fb(depthFormat, samples);
= st_new_renderbuffer_fb(depthFormat, samples, FALSE);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthRb);
}
else if (visual->depthBits == 24) {
/* 24-bit depth buffer, ignore stencil bits */
struct gl_renderbuffer *depthRb
= st_new_renderbuffer_fb(depthFormat, samples);
= st_new_renderbuffer_fb(depthFormat, samples, FALSE);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthRb);
}
else if (visual->depthBits > 0) {
/* 16-bit depth buffer */
struct gl_renderbuffer *depthRb
= st_new_renderbuffer_fb(depthFormat, samples);
= st_new_renderbuffer_fb(depthFormat, samples, FALSE);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthRb);
}
if (visual->stencilBits > 0) {
/* 8-bit stencil */
struct gl_renderbuffer *stencilRb
= st_new_renderbuffer_fb(stencilFormat, samples);
= st_new_renderbuffer_fb(stencilFormat, samples, FALSE);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_STENCIL, stencilRb);
}
}
if (visual->accumRedBits > 0) {
/* 16-bit/channel accum */
/* TODO: query the pipe screen for accumulation buffer format support */
struct gl_renderbuffer *accumRb
= st_new_renderbuffer_fb(DEFAULT_ACCUM_PIPE_FORMAT, 0); /* XXX accum isn't multisampled right? */
= st_new_renderbuffer_fb(PIPE_FORMAT_R16G16B16A16_SNORM, 0, TRUE);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_ACCUM, accumRb);
}

1
src/mesa/swrast/s_context.c
View file

@ -289,6 +289,7 @@ _swrast_update_specular_vertex_add(GLcontext *ctx)
#define _SWRAST_NEW_DERIVED (_SWRAST_NEW_RASTERMASK | \
_NEW_PROGRAM_CONSTANTS | \
_NEW_TEXTURE | \
_NEW_HINT | \
_NEW_POLYGON )