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

Merge commit 'origin/gallium-0.1' into gallium-0.2

Browse source 
Conflicts:

	src/gallium/auxiliary/rtasm/rtasm_execmem.c
	src/mesa/shader/slang/slang_emit.c
	src/mesa/shader/slang/slang_log.c
	src/mesa/state_tracker/st_atom_framebuffer.c
This commit is contained in:
Brian Paul 2008-11-05 15:58:09 -07:00
commit 80a718a63b
21 changed files with 299 additions and 38 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
src/gallium/auxiliary/draw/draw_pt.c
View file

@ -33,6 +33,8 @@
#include "draw/draw_context.h"
#include "draw/draw_private.h"
#include "draw/draw_pt.h"
#include "draw/draw_vs.h"
#include "tgsi/tgsi_dump.h"
static unsigned trim( unsigned count, unsigned first, unsigned incr )
{
@ -195,6 +197,28 @@ draw_arrays(struct draw_context *draw, unsigned prim,
draw->reduced_prim = reduced_prim;
}
#if 0
{
int i;
debug_printf("draw_arrays(prim=%u start=%u count=%u):\n",
prim, start, count);
tgsi_dump(draw->vs.vertex_shader->state.tokens, 0);
debug_printf("Elements:\n");
for (i = 0; i < draw->pt.nr_vertex_elements; i++) {
debug_printf(" format=%s comps=%u\n",
pf_name(draw->pt.vertex_element[i].src_format),
draw->pt.vertex_element[i].nr_components);
}
debug_printf("Buffers:\n");
for (i = 0; i < draw->pt.nr_vertex_buffers; i++) {
debug_printf(" pitch=%u offset=%u ptr=%p\n",
draw->pt.vertex_buffer[i].pitch,
draw->pt.vertex_buffer[i].buffer_offset,
draw->pt.user.vbuffer[i]);
}
}
#endif
/* drawing done here: */
draw_pt_arrays(draw, prim, start, count);
}

3
src/gallium/auxiliary/draw/draw_vs_aos.c
View file

@ -2190,7 +2190,8 @@ static struct draw_vs_varient *varient_aos_sse( struct draw_vertex_shader *vs,
if (!vaos->buffer)
goto fail;
debug_printf("nr_vb: %d const: %x\n", vaos->nr_vb, vaos->base.key.const_vbuffers);
if (0)
debug_printf("nr_vb: %d const: %x\n", vaos->nr_vb, vaos->base.key.const_vbuffers);
#if 0
tgsi_dump(vs->state.tokens, 0);

6
src/gallium/auxiliary/draw/draw_vs_exec.c
View file

@ -123,6 +123,12 @@ vs_exec_run_linear( struct draw_vertex_shader *shader,
input = (const float (*)[4])((const char *)input + input_stride);
}
tgsi_set_exec_mask(machine,
1,
max_vertices > 1,
max_vertices > 2,
max_vertices > 3);
/* run interpreter */
tgsi_exec_machine_run( machine );

14
src/gallium/auxiliary/draw/draw_vs_sse.c
View file

@ -99,9 +99,23 @@ vs_sse_run_linear( struct draw_vertex_shader *base,
struct tgsi_exec_machine *machine = shader->machine;
unsigned int i;
/* By default, execute all channels. XXX move this inside the loop
* below when we support shader conditionals/loops.
*/
tgsi_set_exec_mask(machine, 1, 1, 1, 1);
for (i = 0; i < count; i += MAX_TGSI_VERTICES) {
unsigned int max_vertices = MIN2(MAX_TGSI_VERTICES, count - i);
if (max_vertices < 4) {
/* disable the unused execution channels */
tgsi_set_exec_mask(machine,
1,
max_vertices > 1,
max_vertices > 2,
0);
}
/* run compiled shader
*/
shader->func(machine->Inputs,

4
src/gallium/auxiliary/tgsi/tgsi_exec.c
View file

@ -958,6 +958,10 @@ fetch_src_file_channel(
switch( file ) {
case TGSI_FILE_CONSTANT:
assert(mach->Consts);
assert(index->i[0] >= 0);
assert(index->i[1] >= 0);
assert(index->i[2] >= 0);
assert(index->i[3] >= 0);
chan->f[0] = mach->Consts[index->i[0]][swizzle];
chan->f[1] = mach->Consts[index->i[1]][swizzle];
chan->f[2] = mach->Consts[index->i[2]][swizzle];

25
src/gallium/auxiliary/tgsi/tgsi_exec.h
View file

@ -165,6 +165,10 @@ struct tgsi_exec_labels
#define TGSI_EXEC_TEMP_HALF_I (TGSI_EXEC_NUM_TEMPS + 3)
#define TGSI_EXEC_TEMP_HALF_C 1
/* execution mask, each value is either 0 or ~0 */
#define TGSI_EXEC_MASK_I (TGSI_EXEC_NUM_TEMPS + 3)
#define TGSI_EXEC_MASK_C 2
#define TGSI_EXEC_TEMP_R0 (TGSI_EXEC_NUM_TEMPS + 4)
#define TGSI_EXEC_TEMP_ADDR (TGSI_EXEC_NUM_TEMPS + 5)
@ -265,6 +269,27 @@ void
tgsi_exec_machine_free_data(struct tgsi_exec_machine *mach);
static INLINE void
tgsi_set_kill_mask(struct tgsi_exec_machine *mach, unsigned mask)
{
mach->Temps[TGSI_EXEC_TEMP_KILMASK_I].xyzw[TGSI_EXEC_TEMP_KILMASK_C].u[0] =
mask;
}
/** Set execution mask values prior to executing the shader */
static INLINE void
tgsi_set_exec_mask(struct tgsi_exec_machine *mach,
boolean ch0, boolean ch1, boolean ch2, boolean ch3)
{
int *mask = mach->Temps[TGSI_EXEC_MASK_I].xyzw[TGSI_EXEC_MASK_C].i;
mask[0] = ch0 ? ~0 : 0;
mask[1] = ch1 ? ~0 : 0;
mask[2] = ch2 ? ~0 : 0;
mask[3] = ch3 ? ~0 : 0;
}
#if defined __cplusplus
} /* extern "C" */
#endif

35
src/gallium/auxiliary/tgsi/tgsi_sse2.c
View file

@ -72,6 +72,9 @@
#define TEMP_R0 TGSI_EXEC_TEMP_R0
#define TEMP_ADDR TGSI_EXEC_TEMP_ADDR
#define TEMP_EXEC_MASK_I TGSI_EXEC_MASK_I
#define TEMP_EXEC_MASK_C TGSI_EXEC_MASK_C
/**
* X86 utility functions.
@ -233,6 +236,9 @@ emit_const(
int indirectIndex )
{
if (indirect) {
/* 'vec' is the offset from the address register's value.
* We're loading CONST[ADDR+vec] into an xmm register.
*/
struct x86_reg r0 = get_input_base();
struct x86_reg r1 = get_output_base();
uint i;
@ -243,18 +249,40 @@ emit_const(
x86_push( func, r0 );
x86_push( func, r1 );
/*
* Loop over the four pixels or vertices in the quad.
* Get the value of the address (offset) register for pixel/vertex[i],
* add it to the src offset and index into the constant buffer.
* Note that we're working on SOA data.
* If any of the pixel/vertex execution channels are unused their
* values will be garbage. It's very important that we don't use
* those garbage values as indexes into the constant buffer since
* that'll cause segfaults.
* The solution is to bitwise-AND the offset with the execution mask
* register whose values are either 0 or ~0.
* The caller must setup the execution mask register to indicate
* which channels are valid/alive before running the shader.
* The execution mask will also figure into loops and conditionals
* someday.
*/
for (i = 0; i < QUAD_SIZE; i++) {
x86_lea( func, r0, get_const( vec, chan ) );
/* r1 = address register[i] */
x86_mov( func, r1, x86_make_disp( get_temp( TEMP_ADDR, CHAN_X ), i * 4 ) );
/* r0 = execution mask[i] */
x86_mov( func, r0, x86_make_disp( get_temp( TEMP_EXEC_MASK_I, TEMP_EXEC_MASK_C ), i * 4 ) );
/* r1 = r1 & r0 */
x86_and( func, r1, r0 );
/* r0 = 'vec', the offset */
x86_lea( func, r0, get_const( vec, chan ) );
/* Quick hack to multiply by 16 -- need to add SHL to rtasm.
/* Quick hack to multiply r1 by 16 -- need to add SHL to rtasm.
*/
x86_add( func, r1, r1 );
x86_add( func, r1, r1 );
x86_add( func, r1, r1 );
x86_add( func, r1, r1 );
x86_add( func, r0, r1 );
x86_add( func, r0, r1 ); /* r0 = r0 + r1 */
x86_mov( func, r1, x86_deref( r0 ) );
x86_mov( func, x86_make_disp( get_temp( TEMP_R0, CHAN_X ), i * 4 ), r1 );
}
@ -268,6 +296,7 @@ emit_const(
get_temp( TEMP_R0, CHAN_X ) );
}
else {
/* 'vec' is the index into the src register file, such as TEMP[vec] */
assert( vec >= 0 );
sse_movss(

4
src/gallium/auxiliary/util/u_mm.c
View file

@ -172,6 +172,10 @@ u_mmAllocMem(struct mem_block *heap, int size, int align2, int startSearch)
int startofs = 0;
int endofs;
assert(size >= 0);
assert(align2 >= 0);
assert(align2 <= 12); /* sanity check, 2^12 (4KB) enough? */
if (!heap || align2 < 0 || size <= 0)
return NULL;

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

@ -92,7 +92,8 @@ fs_sse_run( const struct sp_fragment_shader *base,
machine->Temps);
/* init kill mask */
machine->Temps[TGSI_EXEC_TEMP_KILMASK_I].xyzw[TGSI_EXEC_TEMP_KILMASK_C].u[0] = 0x0;
tgsi_set_kill_mask(machine, 0x0);
tgsi_set_exec_mask(machine, 1, 1, 1, 1);
shader->func( machine->Inputs,
machine->Outputs,

2
src/gallium/include/pipe/p_debug.h
View file

@ -49,7 +49,7 @@ extern "C" {
#endif
#ifdef DBG
#if defined(DBG) || defined(DEBUG)
#ifndef DEBUG
#define DEBUG 1
#endif

12
src/mesa/main/texenvprogram.c
View file

@ -233,6 +233,12 @@ static GLbitfield get_fp_input_mask( GLcontext *ctx )
/* Fixed function logic */
GLbitfield varying_inputs = ctx->varying_vp_inputs;
/* These get generated in the setup routine regardless of the
* vertex program:
*/
if (ctx->Point.PointSprite)
varying_inputs |= FRAG_BITS_TEX_ANY;
/* First look at what values may be computed by the generated
* vertex program:
*/
@ -260,6 +266,12 @@ static GLbitfield get_fp_input_mask( GLcontext *ctx )
/* calculate from vp->outputs */
GLbitfield vp_outputs = ctx->VertexProgram._Current->Base.OutputsWritten;
/* These get generated in the setup routine regardless of the
* vertex program:
*/
if (ctx->Point.PointSprite)
vp_outputs |= FRAG_BITS_TEX_ANY;
if (vp_outputs & (1 << VERT_RESULT_COL0)) fp_inputs |= FRAG_BIT_COL0;
if (vp_outputs & (1 << VERT_RESULT_COL1)) fp_inputs |= FRAG_BIT_COL1;

1
src/mesa/shader/prog_uniform.c
View file

@ -87,6 +87,7 @@ _mesa_append_uniform(struct gl_uniform_list *list,
list->Uniforms[oldNum].Name = _mesa_strdup(name);
list->Uniforms[oldNum].VertPos = -1;
list->Uniforms[oldNum].FragPos = -1;
list->Uniforms[oldNum].Initialized = GL_FALSE;
index = oldNum;
list->NumUniforms++;
}

1
src/mesa/shader/prog_uniform.h
View file

@ -50,6 +50,7 @@ struct gl_uniform
const char *Name; /**< Null-terminated string */
GLint VertPos;
GLint FragPos;
GLboolean Initialized; /**< For debug. Has this uniform been set? */
#if 0
GLenum DataType; /**< GL_FLOAT, GL_FLOAT_VEC2, etc */
GLuint Size; /**< Number of components (1..4) */

21
src/mesa/shader/shader_api.c
View file

@ -1512,10 +1512,12 @@ set_program_uniform(GLcontext *ctx, struct gl_program *program,
GLenum type, GLsizei count, GLint elems,
const void *values)
{
struct gl_program_parameter *param =
&program->Parameters->Parameters[index];
assert(offset >= 0);
if (!compatible_types(type,
program->Parameters->Parameters[index].DataType)) {
if (!compatible_types(type, param->DataType)) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(type mismatch)");
return;
}
@ -1525,7 +1527,7 @@ set_program_uniform(GLcontext *ctx, struct gl_program *program,
return;
}
if (program->Parameters->Parameters[index].Type == PROGRAM_SAMPLER) {
if (param->Type == PROGRAM_SAMPLER) {
/* This controls which texture unit which is used by a sampler */
GLuint texUnit, sampler;
@ -1556,9 +1558,9 @@ set_program_uniform(GLcontext *ctx, struct gl_program *program,
else {
/* ordinary uniform variable */
GLsizei k, i;
GLint slots = (program->Parameters->Parameters[index].Size + 3) / 4;
GLint slots = (param->Size + 3) / 4;
if (count * elems > (GLint) program->Parameters->Parameters[index].Size) {
if (count * elems > (GLint) param->Size) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(count too large)");
return;
}
@ -1567,7 +1569,8 @@ set_program_uniform(GLcontext *ctx, struct gl_program *program,
count = slots;
for (k = 0; k < count; k++) {
GLfloat *uniformVal = program->Parameters->ParameterValues[index + offset + k];
GLfloat *uniformVal =
program->Parameters->ParameterValues[index + offset + k];
if (is_integer_type(type)) {
const GLint *iValues = ((const GLint *) values) + k * elems;
for (i = 0; i < elems; i++) {
@ -1582,7 +1585,7 @@ set_program_uniform(GLcontext *ctx, struct gl_program *program,
}
/* if the uniform is bool-valued, convert to 1.0 or 0.0 */
if (is_boolean_type(program->Parameters->Parameters[index].DataType)) {
if (is_boolean_type(param->DataType)) {
for (i = 0; i < elems; i++) {
uniformVal[i] = uniformVal[i] ? 1.0f : 0.0f;
}
@ -1666,6 +1669,8 @@ _mesa_uniform(GLcontext *ctx, GLint location, GLsizei count,
index, offset, type, count, elems, values);
}
}
shProg->Uniforms->Uniforms[location].Initialized = GL_TRUE;
}
@ -1776,6 +1781,8 @@ _mesa_uniform_matrix(GLcontext *ctx, GLint cols, GLint rows,
count, rows, cols, transpose, values);
}
}
shProg->Uniforms->Uniforms[location].Initialized = GL_TRUE;
}

2
src/mesa/shader/slang/slang_codegen.c
View file

@ -3253,7 +3253,7 @@ _slang_gen_array_element(slang_assemble_ctx * A, slang_operation *oper)
index = _slang_gen_operation(A, &oper->children[1]);
if (array && index) {
/* bounds check */
GLint constIndex = 0;
GLint constIndex = -1;
if (index->Opcode == IR_FLOAT) {
constIndex = (int) index->Value[0];
if (constIndex < 0 || constIndex >= arrayLen) {

109
src/mesa/shader/slang/slang_emit.c
View file

@ -330,6 +330,17 @@ constant_to_src_reg(struct prog_src_register *src, GLfloat val,
}
static void
address_to_dst_reg(struct prog_dst_register *dst, GLuint index)
{
assert(index == 0); /* only one address reg at this time */
dst->File = PROGRAM_ADDRESS;
dst->Index = index;
dst->WriteMask = WRITEMASK_X;
}
/**
* Add new instruction at end of given program.
* \param prog the program to append instruction onto
@ -614,6 +625,7 @@ emit_arith(slang_emit_info *emitInfo, slang_ir_node *n)
/* result storage */
alloc_node_storage(emitInfo, n, -1);
assert(n->Store->Index >= 0);
if (n->Store->Size == 2)
n->Writemask = WRITEMASK_XY;
@ -1545,6 +1557,60 @@ emit_swizzle(slang_emit_info *emitInfo, slang_ir_node *n)
}
/**
* Move a block registers from src to dst (or move a single register).
* \param size size of block, in floats (<=4 means one register)
*/
static struct prog_instruction *
move_block(slang_emit_info *emitInfo,
GLuint size, GLboolean relAddr,
const slang_ir_storage *dst,
const slang_ir_storage *src)
{
struct prog_instruction *inst;
if (size > 4) {
/* move matrix/struct etc (block of registers) */
slang_ir_storage dstStore = *dst;
slang_ir_storage srcStore = *src;
//GLint size = srcStore.Size;
/*ASSERT(n->Children[0]->Writemask == WRITEMASK_XYZW);
ASSERT(n->Children[1]->Store->Swizzle == SWIZZLE_NOOP);
*/
dstStore.Size = 4;
srcStore.Size = 4;
while (size >= 4) {
inst = new_instruction(emitInfo, OPCODE_MOV);
inst->Comment = _mesa_strdup("IR_COPY block");
storage_to_dst_reg(&inst->DstReg, &dstStore, WRITEMASK_XYZW);
storage_to_src_reg(&inst->SrcReg[0], &srcStore);
inst->SrcReg[0].RelAddr = relAddr;
srcStore.Index++;
dstStore.Index++;
size -= 4;
}
}
else {
/* single register move */
GLuint writemask;
if (size == 1) {
GLuint comp = GET_SWZ(src->Swizzle, 0);
assert(comp < 4);
writemask = WRITEMASK_X << comp;
}
else {
writemask = WRITEMASK_XYZW;
}
inst = new_instruction(emitInfo, OPCODE_MOV);
storage_to_dst_reg(&inst->DstReg, dst, writemask);
storage_to_src_reg(&inst->SrcReg[0], src);
inst->SrcReg[0].RelAddr = relAddr;
}
return inst;
}
/**
* Dereference array element. Just resolve storage for the array
* element represented by this node.
@ -1587,24 +1653,47 @@ emit_array_element(slang_emit_info *emitInfo, slang_ir_node *n)
else {
/* Variable array index */
struct prog_instruction *inst;
slang_ir_storage dstStore = *n->Store;
/* do codegen for array index expression */
emit(emitInfo, n->Children[1]);
inst = new_instruction(emitInfo, OPCODE_ARL);
/* allocate temp storage for the array element */
assert(n->Store->Index < 0);
n->Store->File = PROGRAM_TEMPORARY;
n->Store->Parent = NULL;
alloc_node_storage(emitInfo, n, -1);
if (dstStore.Size > 4)
dstStore.Size = 4; /* only emit one instruction */
if (n->Store->Size > 4) {
/* need to multiply the index by the element size */
GLint elemSize = (n->Store->Size + 3) / 4;
slang_ir_storage indexTemp;
storage_to_dst_reg(&inst->DstReg, &dstStore, n->Writemask);
storage_to_src_reg(&inst->SrcReg[0], n->Children[1]->Store);
/* allocate 1 float indexTemp */
alloc_local_temp(emitInfo, &indexTemp, 1);
inst->DstReg.File = PROGRAM_ADDRESS;
inst->DstReg.Index = 0; /* always address register [0] */
inst->Comment = _mesa_strdup("ARL ADDR");
/* MUL temp, index, elemSize */
inst = new_instruction(emitInfo, OPCODE_MUL);
storage_to_dst_reg(&inst->DstReg, &indexTemp, WRITEMASK_X);
storage_to_src_reg(&inst->SrcReg[0], n->Children[1]->Store);
constant_to_src_reg(&inst->SrcReg[1], elemSize, emitInfo);
n->Store->RelAddr = GL_TRUE;
/* load ADDR[0].X = temp */
inst = new_instruction(emitInfo, OPCODE_ARL);
storage_to_src_reg(&inst->SrcReg[0], &indexTemp);
address_to_dst_reg(&inst->DstReg, 0);
_slang_free_temp(emitInfo->vt, &indexTemp);
}
else {
/* simply load address reg w/ array index */
inst = new_instruction(emitInfo, OPCODE_ARL);
storage_to_src_reg(&inst->SrcReg[0], n->Children[1]->Store);
address_to_dst_reg(&inst->DstReg, 0);
}
/* copy from array element to temp storage */
move_block(emitInfo, n->Store->Size, GL_TRUE,
n->Store, n->Children[0]->Store);
}
/* if array element size is one, make sure we only access X */

2
src/mesa/shader/slang/slang_log.c
View file

@ -89,7 +89,7 @@ slang_info_log_message(slang_info_log * log, const char *prefix,
slang_string_concat(log->text, "\n");
if (MESA_VERBOSE & VERBOSE_GLSL) {
_mesa_printf("Mesa: GLSL %s\n", log->text);
_mesa_printf("Mesa: GLSL %s", log->text);
}
return 1;

10
src/mesa/state_tracker/st_atom_framebuffer.c
View file

@ -116,10 +116,11 @@ update_framebuffer_state( struct st_context *st )
/* rendering to a GL texture, may have to update surface */
update_renderbuffer_surface(st, strb);
}
assert(strb->surface);
framebuffer->cbufs[framebuffer->num_cbufs] = strb->surface;
framebuffer->num_cbufs++;
if (strb->surface) {
framebuffer->cbufs[framebuffer->num_cbufs] = strb->surface;
framebuffer->num_cbufs++;
}
}
strb = st_renderbuffer(fb->Attachment[BUFFER_DEPTH].Renderbuffer);
@ -130,7 +131,6 @@ update_framebuffer_state( struct st_context *st )
update_renderbuffer_surface(st, strb);
}
assert(strb->surface);
framebuffer->zsbuf = strb->surface;
}
else {

26
src/mesa/state_tracker/st_cb_clear.c
View file

@ -406,13 +406,17 @@ check_clear_stencil_with_quad(GLcontext *ctx, struct gl_renderbuffer *rb)
static void
clear_color_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
{
struct st_renderbuffer *strb = st_renderbuffer(rb);
if (!strb->surface)
return;
if (check_clear_color_with_quad( ctx, rb )) {
/* masking or scissoring */
clear_with_quad(ctx, GL_TRUE, GL_FALSE, GL_FALSE);
}
else {
/* clear whole buffer w/out masking */
struct st_renderbuffer *strb = st_renderbuffer(rb);
uint clearValue;
/* NOTE: we always pass the clear color as PIPE_FORMAT_A8R8G8B8_UNORM
* at this time!
@ -426,13 +430,16 @@ clear_color_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
static void
clear_depth_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
{
struct st_renderbuffer *strb = st_renderbuffer(rb);
if (!strb->surface)
return;
if (check_clear_depth_with_quad(ctx, rb)) {
/* scissoring or we have a combined depth/stencil buffer */
clear_with_quad(ctx, GL_FALSE, GL_TRUE, GL_FALSE);
}
else {
struct st_renderbuffer *strb = st_renderbuffer(rb);
/* simple clear of whole buffer */
uint clearValue = util_pack_z(strb->surface->format, ctx->Depth.Clear);
ctx->st->pipe->clear(ctx->st->pipe, strb->surface, clearValue);
@ -443,13 +450,16 @@ clear_depth_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
static void
clear_stencil_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
{
struct st_renderbuffer *strb = st_renderbuffer(rb);
if (!strb->surface)
return;
if (check_clear_stencil_with_quad(ctx, rb)) {
/* masking or scissoring or combined depth/stencil buffer */
clear_with_quad(ctx, GL_FALSE, GL_FALSE, GL_TRUE);
}
else {
struct st_renderbuffer *strb = st_renderbuffer(rb);
/* simple clear of whole buffer */
GLuint clearValue = ctx->Stencil.Clear;
@ -469,14 +479,16 @@ clear_stencil_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
static void
clear_depth_stencil_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
{
struct st_renderbuffer *strb = st_renderbuffer(rb);
if (!strb->surface)
return;
if (check_clear_depth_stencil_with_quad(ctx, rb)) {
/* masking or scissoring */
clear_with_quad(ctx, GL_FALSE, GL_TRUE, GL_TRUE);
}
else {
struct st_renderbuffer *strb = st_renderbuffer(rb);
/* clear whole buffer w/out masking */
GLuint clearValue = util_pack_z(strb->surface->format, ctx->Depth.Clear);

30
src/mesa/state_tracker/st_draw.c
View file

@ -33,6 +33,7 @@
#include "main/imports.h"
#include "main/image.h"
#include "main/macros.h"
#include "shader/prog_uniform.h"
#include "vbo/vbo.h"
@ -483,6 +484,28 @@ setup_non_interleaved_attribs(GLcontext *ctx,
/**
* Prior to drawing, check that any uniforms referenced by the
* current shader have been set. If a uniform has not been set,
* issue a warning.
*/
static void
check_uniforms(GLcontext *ctx)
{
const struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
if (shProg && shProg->LinkStatus) {
GLuint i;
for (i = 0; i < shProg->Uniforms->NumUniforms; i++) {
const struct gl_uniform *u = &shProg->Uniforms->Uniforms[i];
if (!u->Initialized) {
_mesa_warning(ctx,
"Using shader with uninitialized uniform: %s",
u->Name);
}
}
}
}
/**
* This function gets plugged into the VBO module and is called when
@ -516,6 +539,10 @@ st_draw_vbo(GLcontext *ctx,
vp = ctx->st->vp;
vs = &ctx->st->vp->state;
if (MESA_VERBOSE & VERBOSE_GLSL) {
check_uniforms(ctx);
}
/*
* Setup the vbuffer[] and velements[] arrays.
*/
@ -557,6 +584,9 @@ st_draw_vbo(GLcontext *ctx,
pipe->set_vertex_buffers(pipe, num_vbuffers, vbuffer);
pipe->set_vertex_elements(pipe, num_velements, velements);
if (num_vbuffers == 0 || num_velements == 0)
return;
/* do actual drawing */
if (ib) {
/* indexed primitive */

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

@ -291,7 +291,8 @@ st_notify_swapbuffers_complete(struct st_framebuffer *stfb)
for (i = 0; i < BUFFER_COUNT; i++) {
if (stfb->Base.Attachment[i].Renderbuffer) {
strb = st_renderbuffer(stfb->Base.Attachment[i].Renderbuffer);
strb->surface->status = PIPE_SURFACE_STATUS_UNDEFINED;
if (strb->surface)
strb->surface->status = PIPE_SURFACE_STATUS_UNDEFINED;
}
}
}