diff options
Diffstat (limited to 'src')
35 files changed, 864 insertions, 138 deletions
diff --git a/src/mesa/main/context.c b/src/mesa/main/context.c index 563a89e686..a9f9bd9da4 100644 --- a/src/mesa/main/context.c +++ b/src/mesa/main/context.c @@ -554,8 +554,13 @@ alloc_shared_state( GLcontext *ctx ) (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultCubeMap); if (ss->DefaultRect) (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultRect); - if (ss) - _mesa_free(ss); + if (ss->Default1DArray) + (*ctx->Driver.DeleteTexture)(ctx, ss->Default1DArray); + if (ss->Default2DArray) + (*ctx->Driver.DeleteTexture)(ctx, ss->Default2DArray); + + _mesa_free(ss); + return GL_FALSE; } @@ -678,6 +683,9 @@ free_shared_state( GLcontext *ctx, struct gl_shared_state *ss ) ctx->Driver.DeleteTexture(ctx, ss->Default3D); ctx->Driver.DeleteTexture(ctx, ss->DefaultCubeMap); ctx->Driver.DeleteTexture(ctx, ss->DefaultRect); + ctx->Driver.DeleteTexture(ctx, ss->Default1DArray); + ctx->Driver.DeleteTexture(ctx, ss->Default2DArray); + /* all other textures */ _mesa_HashDeleteAll(ss->TexObjects, delete_texture_cb, ctx); _mesa_DeleteHashTable(ss->TexObjects); diff --git a/src/mesa/main/ffvertex_prog.c b/src/mesa/main/ffvertex_prog.c index 8fcb9e5b14..4a9a0cd975 100644 --- a/src/mesa/main/ffvertex_prog.c +++ b/src/mesa/main/ffvertex_prog.c @@ -1,6 +1,6 @@ /************************************************************************** * - * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas. + * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a @@ -1529,6 +1529,8 @@ _mesa_get_fixed_func_vertex_program(GLcontext *ctx) prog = (struct gl_vertex_program *) ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0); + if (!prog) + return NULL; create_new_program( key, prog, ctx->Const.VertexProgram.MaxTemps ); @@ -1541,10 +1543,8 @@ _mesa_get_fixed_func_vertex_program(GLcontext *ctx) _mesa_program_cache_insert(ctx, ctx->VertexProgram.Cache, key, sizeof(*key), &prog->Base); } - else { - /* use cached program */ - _mesa_free(key); - } + + _mesa_free(key); return prog; } diff --git a/src/mesa/pipe/cell/ppu/Makefile b/src/mesa/pipe/cell/ppu/Makefile index f597784d65..2758e1b77f 100644 --- a/src/mesa/pipe/cell/ppu/Makefile +++ b/src/mesa/pipe/cell/ppu/Makefile @@ -17,9 +17,12 @@ SPU_CODE_MODULE = ../spu/g3d_spu.a SOURCES = \ cell_context.c \ + cell_draw_arrays.c \ cell_flush.c \ + cell_render.c \ cell_state_blend.c \ cell_state_clip.c \ + cell_state_derived.c \ cell_state_fs.c \ cell_state_rasterizer.c \ cell_state_sampler.c \ diff --git a/src/mesa/pipe/cell/ppu/cell_context.c b/src/mesa/pipe/cell/ppu/cell_context.c index 281fc6ec31..82b69ac33e 100644 --- a/src/mesa/pipe/cell/ppu/cell_context.c +++ b/src/mesa/pipe/cell/ppu/cell_context.c @@ -40,7 +40,9 @@ #include "pipe/cell/common.h" #include "pipe/draw/draw_context.h" #include "cell_context.h" +#include "cell_draw_arrays.h" #include "cell_flush.h" +#include "cell_render.h" #include "cell_state.h" #include "cell_surface.h" #include "cell_spu.h" @@ -212,12 +214,9 @@ cell_create_context(struct pipe_winsys *winsys, struct cell_winsys *cws) cell->pipe.set_vertex_buffer = cell_set_vertex_buffer; cell->pipe.set_vertex_element = cell_set_vertex_element; -#if 0 - cell->pipe.set_feedback_buffer = cell_set_feedback_buffer; cell->pipe.draw_arrays = cell_draw_arrays; cell->pipe.draw_elements = cell_draw_elements; -#endif cell->pipe.clear = cell_clear_surface; cell->pipe.flush = cell_flush; @@ -235,6 +234,10 @@ cell_create_context(struct pipe_winsys *winsys, struct cell_winsys *cws) cell->draw = draw_create(); + cell->render_stage = cell_draw_render_stage(cell); + draw_set_rasterize_stage(cell->draw, cell->render_stage); + + /* * SPU stuff */ diff --git a/src/mesa/pipe/cell/ppu/cell_context.h b/src/mesa/pipe/cell/ppu/cell_context.h index f8d6cc5d32..5f6f987d8f 100644 --- a/src/mesa/pipe/cell/ppu/cell_context.h +++ b/src/mesa/pipe/cell/ppu/cell_context.h @@ -31,9 +31,25 @@ #include "pipe/p_context.h" +#include "pipe/p_defines.h" +#include "pipe/draw/draw_vertex.h" #include "cell_winsys.h" +struct cell_vertex_shader_state +{ + struct pipe_shader_state shader; + void *draw_data; +}; + + +struct cell_fragment_shader_state +{ + struct pipe_shader_state shader; + void *data; +}; + + struct cell_context { struct pipe_context pipe; @@ -44,6 +60,8 @@ struct cell_context const struct pipe_sampler_state *sampler[PIPE_MAX_SAMPLERS]; const struct pipe_depth_stencil_alpha_state *depth_stencil; const struct pipe_rasterizer_state *rasterizer; + const struct cell_vertex_shader_state *vs; + const struct cell_fragment_shader_state *fs; struct pipe_blend_color blend_color; struct pipe_clip_state clip; @@ -55,13 +73,20 @@ struct cell_context struct pipe_viewport_state viewport; struct pipe_vertex_buffer vertex_buffer[PIPE_ATTRIB_MAX]; struct pipe_vertex_element vertex_element[PIPE_ATTRIB_MAX]; + + uint dirty; /** The primitive drawing context */ struct draw_context *draw; - struct draw_stage *setup; + struct draw_stage *render_stage; struct draw_stage *vbuf; + struct vertex_info vertex_info; + + /** Mapped constant buffers */ + void *mapped_constants[PIPE_SHADER_TYPES]; + uint num_spus; diff --git a/src/mesa/pipe/cell/ppu/cell_draw_arrays.c b/src/mesa/pipe/cell/ppu/cell_draw_arrays.c new file mode 100644 index 0000000000..c014f5b29d --- /dev/null +++ b/src/mesa/pipe/cell/ppu/cell_draw_arrays.c @@ -0,0 +1,169 @@ +/************************************************************************** + * + * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sub license, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial portions + * of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. + * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + **************************************************************************/ + +/* Author: + * Brian Paul + * Keith Whitwell + */ + + +#include "pipe/p_defines.h" +#include "pipe/p_context.h" +#include "pipe/p_winsys.h" + +#include "cell_context.h" +#include "cell_draw_arrays.h" +#include "cell_state.h" + +#include "pipe/draw/draw_context.h" + + + +static void +cell_map_constant_buffers(struct cell_context *sp) +{ + struct pipe_winsys *ws = sp->pipe.winsys; + uint i; + for (i = 0; i < 2; i++) { + if (sp->constants[i].size) + sp->mapped_constants[i] = ws->buffer_map(ws, sp->constants[i].buffer, + PIPE_BUFFER_FLAG_READ); + } + + draw_set_mapped_constant_buffer(sp->draw, + sp->mapped_constants[PIPE_SHADER_VERTEX]); +} + +static void +cell_unmap_constant_buffers(struct cell_context *sp) +{ + struct pipe_winsys *ws = sp->pipe.winsys; + uint i; + for (i = 0; i < 2; i++) { + if (sp->constants[i].size) + ws->buffer_unmap(ws, sp->constants[i].buffer); + sp->mapped_constants[i] = NULL; + } +} + + +boolean +cell_draw_arrays(struct pipe_context *pipe, unsigned mode, + unsigned start, unsigned count) +{ + return cell_draw_elements(pipe, NULL, 0, mode, start, count); +} + + + +/** + * Draw vertex arrays, with optional indexing. + * Basically, map the vertex buffers (and drawing surfaces), then hand off + * the drawing to the 'draw' module. + * + * XXX should the element buffer be specified/bound with a separate function? + */ +boolean +cell_draw_elements(struct pipe_context *pipe, + struct pipe_buffer_handle *indexBuffer, + unsigned indexSize, + unsigned mode, unsigned start, unsigned count) +{ + struct cell_context *sp = cell_context(pipe); + struct draw_context *draw = sp->draw; + unsigned i; + + /* first, check that the primitive is not malformed. It is the + * state tracker's responsibility to do send only correctly formed + * primitives down. It currently isn't doing that though... + */ +#if 1 + count = draw_trim_prim( mode, count ); +#else + if (!draw_validate_prim( mode, count )) + assert(0); +#endif + + if (sp->dirty) + cell_update_derived( sp ); + +#if 0 + cell_map_surfaces(sp); +#endif + cell_map_constant_buffers(sp); + + /* + * Map vertex buffers + */ + for (i = 0; i < PIPE_ATTRIB_MAX; i++) { + if (sp->vertex_buffer[i].buffer) { + void *buf + = pipe->winsys->buffer_map(pipe->winsys, + sp->vertex_buffer[i].buffer, + PIPE_BUFFER_FLAG_READ); + draw_set_mapped_vertex_buffer(draw, i, buf); + } + } + /* Map index buffer, if present */ + if (indexBuffer) { + void *mapped_indexes + = pipe->winsys->buffer_map(pipe->winsys, indexBuffer, + PIPE_BUFFER_FLAG_READ); + draw_set_mapped_element_buffer(draw, indexSize, mapped_indexes); + } + else { + /* no index/element buffer */ + draw_set_mapped_element_buffer(draw, 0, NULL); + } + + + /* draw! */ + draw_arrays(draw, mode, start, count); + + /* always flush for now */ + draw_flush(draw); + + /* + * unmap vertex/index buffers + */ + for (i = 0; i < PIPE_ATTRIB_MAX; i++) { + if (sp->vertex_buffer[i].buffer) { + pipe->winsys->buffer_unmap(pipe->winsys, sp->vertex_buffer[i].buffer); + draw_set_mapped_vertex_buffer(draw, i, NULL); + } + } + if (indexBuffer) { + pipe->winsys->buffer_unmap(pipe->winsys, indexBuffer); + draw_set_mapped_element_buffer(draw, 0, NULL); + } + + + /* Note: leave drawing surfaces mapped */ + cell_unmap_constant_buffers(sp); + + return TRUE; +} diff --git a/src/mesa/pipe/cell/ppu/cell_draw_arrays.h b/src/mesa/pipe/cell/ppu/cell_draw_arrays.h new file mode 100644 index 0000000000..bd5b703f3b --- /dev/null +++ b/src/mesa/pipe/cell/ppu/cell_draw_arrays.h @@ -0,0 +1,42 @@ +/************************************************************************** + * + * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sub license, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial portions + * of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. + * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + **************************************************************************/ + +#ifndef CELL_DRAW_ARRAYS_H +#define CELL_DRAW_ARRAYS_H + + +boolean cell_draw_arrays(struct pipe_context *pipe, unsigned mode, + unsigned start, unsigned count); + +boolean cell_draw_elements(struct pipe_context *pipe, + struct pipe_buffer_handle *indexBuffer, + unsigned indexSize, + unsigned mode, unsigned start, unsigned count); + + + +#endif /* CELL_DRAW_ARRAYS_H */ diff --git a/src/mesa/pipe/cell/ppu/cell_render.c b/src/mesa/pipe/cell/ppu/cell_render.c new file mode 100644 index 0000000000..c7f0cf6be6 --- /dev/null +++ b/src/mesa/pipe/cell/ppu/cell_render.c @@ -0,0 +1,129 @@ +/************************************************************************** + * + * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sub license, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial portions + * of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. + * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + **************************************************************************/ + +/** + * \brief Last stage of 'draw' pipeline: send tris to SPUs. + * \author Brian Paul + */ + +#include "cell_context.h" +#include "cell_render.h" +#include "pipe/p_util.h" +#include "pipe/draw/draw_private.h" + + +struct render_stage { + struct draw_stage stage; /**< This must be first (base class) */ + + struct cell_context *cell; +}; + + +static INLINE struct render_stage * +render_stage(struct draw_stage *stage) +{ + return (struct render_stage *) stage; +} + + +static void render_begin( struct draw_stage *stage ) +{ +#if 0 + struct render_stage *render = render_stage(stage); + struct cell_context *sp = render->cell; + const struct pipe_shader_state *fs = &render->cell->fs->shader; + render->quad.nr_attrs = render->cell->nr_frag_attrs; + + render->firstFpInput = fs->input_semantic_name[0]; + + sp->quad.first->begin(sp->quad.first); +#endif +} + + +static void render_end( struct draw_stage *stage ) +{ +} + + +static void reset_stipple_counter( struct draw_stage *stage ) +{ + struct render_stage *render = render_stage(stage); + /*render->cell->line_stipple_counter = 0;*/ +} + + +static void +render_point(struct draw_stage *stage, struct prim_header *prim) +{ +} + + +static void +render_line(struct draw_stage *stage, struct prim_header *prim) +{ +} + + +static void +render_tri(struct draw_stage *stage, struct prim_header *prim) +{ + printf("Cell render tri\n"); +} + + +static void render_destroy( struct draw_stage *stage ) +{ + FREE( stage ); +} + + +/** + * Create a new draw/render stage. This will be plugged into the + * draw module as the last pipeline stage. + */ +struct draw_stage *cell_draw_render_stage( struct cell_context *cell ) +{ + struct render_stage *render = CALLOC_STRUCT(render_stage); + + render->cell = cell; + render->stage.draw = cell->draw; + render->stage.begin = render_begin; + render->stage.point = render_point; + render->stage.line = render_line; + render->stage.tri = render_tri; + render->stage.end = render_end; + render->stage.reset_stipple_counter = reset_stipple_counter; + render->stage.destroy = render_destroy; + + /* + render->quad.coef = render->coef; + render->quad.posCoef = &render->posCoef; + */ + + return &render->stage; +} diff --git a/src/mesa/pipe/cell/ppu/cell_render.h b/src/mesa/pipe/cell/ppu/cell_render.h new file mode 100644 index 0000000000..d66e1bdb79 --- /dev/null +++ b/src/mesa/pipe/cell/ppu/cell_render.h @@ -0,0 +1,36 @@ +/************************************************************************** + * + * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sub license, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial portions + * of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. + * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + **************************************************************************/ + +#ifndef CELL_RENDER_H +#define CELL_RENDER_H + +struct cell_context; +struct draw_stage; + +extern struct draw_stage *cell_draw_render_stage( struct cell_context *cell ); + +#endif /* CELL_RENDER_H */ diff --git a/src/mesa/pipe/cell/ppu/cell_state.h b/src/mesa/pipe/cell/ppu/cell_state.h index 63dbac2f02..d2091f8edf 100644 --- a/src/mesa/pipe/cell/ppu/cell_state.h +++ b/src/mesa/pipe/cell/ppu/cell_state.h @@ -104,4 +104,6 @@ void cell_set_viewport_state( struct pipe_context *, const struct pipe_viewport_state * ); +void cell_update_derived( struct cell_context *softpipe ); + #endif diff --git a/src/mesa/pipe/cell/ppu/cell_state_derived.c b/src/mesa/pipe/cell/ppu/cell_state_derived.c new file mode 100644 index 0000000000..ee7c0204b8 --- /dev/null +++ b/src/mesa/pipe/cell/ppu/cell_state_derived.c @@ -0,0 +1,222 @@ +/************************************************************************** + * + * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sub license, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial portions + * of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. + * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + **************************************************************************/ + +#include "pipe/p_util.h" +#include "pipe/p_shader_tokens.h" +#include "pipe/draw/draw_context.h" +#include "pipe/draw/draw_vertex.h" +#include "cell_context.h" +#include "cell_state.h" + + +/** + * Determine which post-transform / pre-rasterization vertex attributes + * we need. + * Derived from: fs, setup states. + */ +static void calculate_vertex_layout( struct cell_context *cell ) +{ +#if 0 + const struct pipe_shader_state *vs = cell->vs->state; + const struct pipe_shader_state *fs = &cell->fs->shader; + const enum interp_mode colorInterp + = cell->rasterizer->flatshade ? INTERP_CONSTANT : INTERP_LINEAR; + struct vertex_info *vinfo = &cell->vertex_info; + boolean emitBack0 = FALSE, emitBack1 = FALSE, emitPsize = FALSE; + uint front0 = 0, back0 = 0, front1 = 0, back1 = 0; + uint i; +#endif + const enum interp_mode colorInterp + = cell->rasterizer->flatshade ? INTERP_CONSTANT : INTERP_LINEAR; + struct vertex_info *vinfo = &cell->vertex_info; + uint front0; + + memset(vinfo, 0, sizeof(*vinfo)); + +#if 0 + if (fs->input_semantic_name[0] == TGSI_SEMANTIC_POSITION) { + /* Need Z if depth test is enabled or the fragment program uses the + * fragment position (XYZW). + */ + } + + cell->psize_slot = -1; +#endif + + /* always emit vertex pos */ + draw_emit_vertex_attr(vinfo, FORMAT_4F, INTERP_LINEAR); + +#if 1 + front0 = draw_emit_vertex_attr(vinfo, FORMAT_4F, colorInterp); +#endif + +#if 0 + /* + * XXX I think we need to reconcile the vertex shader outputs with + * the fragment shader inputs here to make sure the slots line up. + * Might just be getting lucky so far. + * Or maybe do that in the state tracker? + */ + + for (i = 0; i < vs->num_outputs; i++) { + switch (vs->output_semantic_name[i]) { + + case TGSI_SEMANTIC_POSITION: + /* vertex programs always emit position, but might not be + * needed for fragment progs. + */ + /* no-op */ + break; + + case TGSI_SEMANTIC_COLOR: + if (vs->output_semantic_index[i] == 0) { + front0 = draw_emit_vertex_attr(vinfo, FORMAT_4F, colorInterp); + } + else { + assert(vs->output_semantic_index[i] == 1); + front1 = draw_emit_vertex_attr(vinfo, FORMAT_4F, colorInterp); + } + break; + + case TGSI_SEMANTIC_BCOLOR: + if (vs->output_semantic_index[i] == 0) { + emitBack0 = TRUE; + } + else { + assert(vs->output_semantic_index[i] == 1); + emitBack1 = TRUE; + } + break; + + case TGSI_SEMANTIC_FOG: + draw_emit_vertex_attr(vinfo, FORMAT_1F, INTERP_PERSPECTIVE); + break; + + case TGSI_SEMANTIC_PSIZE: + /* XXX only emit if drawing points or front/back polygon mode + * is point mode + */ + emitPsize = TRUE; + break; + + case TGSI_SEMANTIC_GENERIC: + /* this includes texcoords and varying vars */ + draw_emit_vertex_attr(vinfo, FORMAT_4F, INTERP_PERSPECTIVE); + break; + + default: + assert(0); + } + } + + cell->nr_frag_attrs = fs->num_inputs; + + /* We want these after all other attribs since they won't get passed + * to the fragment shader. All prior vertex output attribs should match + * up 1:1 with the fragment shader inputs. + */ + if (emitBack0) { + back0 = draw_emit_vertex_attr(vinfo, FORMAT_4F, colorInterp); + } + if (emitBack1) { + back1 = draw_emit_vertex_attr(vinfo, FORMAT_4F, colorInterp); + } + if (emitPsize) { + cell->psize_slot + = draw_emit_vertex_attr(vinfo, FORMAT_1F, INTERP_CONSTANT); + } + + /* If the attributes have changed, tell the draw module about + * the new vertex layout. + */ + /* XXX we also need to do this when the shading mode (interp modes) change: */ +#endif + + if (1/*vinfo->attr_mask != cell->attr_mask*/) { + /*cell->attr_mask = vinfo->attr_mask;*/ + + draw_set_vertex_info( cell->draw, vinfo); + +#if 0 + draw_set_twoside_attributes(cell->draw, + front0, back0, front1, back1); +#endif + } +} + + +#if 0 +/** + * Recompute cliprect from scissor bounds, scissor enable and surface size. + */ +static void +compute_cliprect(struct cell_context *sp) +{ + unsigned surfWidth, surfHeight; + + if (sp->framebuffer.num_cbufs > 0) { + surfWidth = sp->framebuffer.cbufs[0]->width; + surfHeight = sp->framebuffer.cbufs[0]->height; + } + else { + /* no surface? */ + surfWidth = sp->scissor.maxx; + surfHeight = sp->scissor.maxy; + } + + if (sp->rasterizer->scissor) { + /* clip to scissor rect */ + sp->cliprect.minx = MAX2(sp->scissor.minx, 0); + sp->cliprect.miny = MAX2(sp->scissor.miny, 0); + sp->cliprect.maxx = MIN2(sp->scissor.maxx, surfWidth); + sp->cliprect.maxy = MIN2(sp->scissor.maxy, surfHeight); + } + else { + /* clip to surface bounds */ + sp->cliprect.minx = 0; + sp->cliprect.miny = 0; + sp->cliprect.maxx = surfWidth; + sp->cliprect.maxy = surfHeight; + } +} +#endif + + +void cell_update_derived( struct cell_context *cell ) +{ + if (cell->dirty & (CELL_NEW_RASTERIZER | CELL_NEW_FS)) + calculate_vertex_layout( cell ); + +#if 0 + if (cell->dirty & (CELL_NEW_SCISSOR | + CELL_NEW_DEPTH_STENCIL_ALPHA | + CELL_NEW_FRAMEBUFFER)) + compute_cliprect(cell); +#endif + + cell->dirty = 0; +} diff --git a/src/mesa/pipe/cell/ppu/cell_state_fs.c b/src/mesa/pipe/cell/ppu/cell_state_fs.c index 910f210cdc..5a935f2de1 100644 --- a/src/mesa/pipe/cell/ppu/cell_state_fs.c +++ b/src/mesa/pipe/cell/ppu/cell_state_fs.c @@ -28,8 +28,8 @@ #include "pipe/p_defines.h" #include "pipe/p_util.h" #include "pipe/p_winsys.h" -#if 0 #include "pipe/draw/draw_context.h" +#if 0 #include "pipe/p_shader_tokens.h" #include "pipe/llvm/gallivm.h" #include "pipe/tgsi/util/tgsi_dump.h" @@ -40,25 +40,22 @@ #include "cell_state.h" -void * cell_create_fs_state(struct pipe_context *pipe, - const struct pipe_shader_state *templ) +void * +cell_create_fs_state(struct pipe_context *pipe, + const struct pipe_shader_state *templ) { struct cell_context *cell = cell_context(pipe); + struct cell_fragment_shader_state *state; - return malloc(5); /* XXX temp */ - -#if 0 - /* Decide whether we'll be codegenerating this shader and if so do - * that now. - */ + state = CALLOC_STRUCT(cell_fragment_shader_state); + if (!state) + return NULL; - struct sp_fragment_shader_state *state = MALLOC( sizeof(struct sp_fragment_shader_state) ); state->shader = *templ; - if( cell->dump_fs ) { - tgsi_dump( - state->shader.tokens, - 0 ); +#if 0 + if (cell->dump_fs) { + tgsi_dump(state->shader.tokens, 0); } #if defined(__i386__) || defined(__386__) @@ -76,32 +73,32 @@ void * cell_create_fs_state(struct pipe_context *pipe, else gallivm_cpu_jit_compile(gallivm_global_cpu_engine(), state->llvm_prog); #endif - return state; #endif + + return state; } -void cell_bind_fs_state(struct pipe_context *pipe, void *fs) + +void +cell_bind_fs_state(struct pipe_context *pipe, void *fs) { struct cell_context *cell = cell_context(pipe); -#if 0 - cell->fs = (struct sp_fragment_shader_state *) fs; - cell->dirty |= SP_NEW_FS; -#endif + cell->fs = (struct cell_fragment_shader_state *) fs; + + cell->dirty |= CELL_NEW_FS; } -void cell_delete_fs_state(struct pipe_context *pipe, - void *shader) + +void +cell_delete_fs_state(struct pipe_context *pipe, void *fs) { -#if 0 - struct sp_fragment_shader_state *state = shader; + struct cell_context *cell = cell_context(pipe); -#if defined(__i386__) || defined(__386__) - x86_release_func( &state->sse2_program ); -#endif + struct cell_fragment_shader_state *state = + (struct cell_fragment_shader_state *) fs; FREE( state ); -#endif } @@ -109,73 +106,56 @@ void * cell_create_vs_state(struct pipe_context *pipe, const struct pipe_shader_state *templ) { - return malloc(5); /* XXX */ -#if 0 struct cell_context *cell = cell_context(pipe); - struct sp_vertex_shader_state *state; + struct cell_vertex_shader_state *state; - state = MALLOC( sizeof(struct sp_vertex_shader_state) ); - if (state == NULL ) { + state = CALLOC_STRUCT(cell_vertex_shader_state); + if (!state) return NULL; - } - state->state = MALLOC( sizeof(struct pipe_shader_state) ); - if (state->state == NULL) { - FREE( state ); - return NULL; - } - memcpy( state->state, templ, sizeof(struct pipe_shader_state) ); + state->shader = *templ; - state->draw_data = draw_create_vertex_shader(cell->draw, - state->state); + state->draw_data = draw_create_vertex_shader(cell->draw, &state->shader); if (state->draw_data == NULL) { - FREE( state->state ); FREE( state ); return NULL; } return state; -#endif } - void cell_bind_vs_state(struct pipe_context *pipe, void *vs) { -#if 0 struct cell_context *cell = cell_context(pipe); - cell->vs = (const struct sp_vertex_shader_state *)vs; + cell->vs = (const struct cell_vertex_shader_state *) vs; draw_bind_vertex_shader(cell->draw, cell->vs->draw_data); - cell->dirty |= SP_NEW_VS; -#endif + cell->dirty |= CELL_NEW_VS; } + void cell_delete_vs_state(struct pipe_context *pipe, void *vs) { -#if 0 struct cell_context *cell = cell_context(pipe); - struct sp_vertex_shader_state *state = - (struct sp_vertex_shader_state *)vs; + struct cell_vertex_shader_state *state = + (struct cell_vertex_shader_state *) vs; draw_delete_vertex_shader(cell->draw, state->draw_data); - FREE( state->state ); FREE( state ); -#endif } - -void cell_set_constant_buffer(struct pipe_context *pipe, - uint shader, uint index, - const struct pipe_constant_buffer *buf) +void +cell_set_constant_buffer(struct pipe_context *pipe, + uint shader, uint index, + const struct pipe_constant_buffer *buf) { -#if 0 struct cell_context *cell = cell_context(pipe); struct pipe_winsys *ws = pipe->winsys; @@ -188,8 +168,5 @@ void cell_set_constant_buffer(struct pipe_context *pipe, buf->buffer); cell->constants[shader].size = buf->size; - cell->dirty |= SP_NEW_CONSTANTS; -#endif + cell->dirty |= CELL_NEW_CONSTANTS; } - - diff --git a/src/mesa/pipe/cell/spu/tri.c b/src/mesa/pipe/cell/spu/tri.c index 90452f14ba..cd648db360 100644 --- a/src/mesa/pipe/cell/spu/tri.c +++ b/src/mesa/pipe/cell/spu/tri.c @@ -42,6 +42,7 @@ #include "pipe/p_compiler.h" +#include "pipe/p_format.h" #include "pipe/p_util.h" #include "main.h" #include "tri.h" @@ -235,8 +236,16 @@ pack_color(const float color[4]) uint g = (uint) (color[1] * 255.0); uint b = (uint) (color[2] * 255.0); uint a = (uint) (color[3] * 255.0); - uint icolor = (b << 24) | (g << 16) | (r << 8) | a; - return icolor; + const enum pipe_format format = PIPE_FORMAT_A8R8G8B8_UNORM; /* XXX temp */ + switch (format) { + case PIPE_FORMAT_A8R8G8B8_UNORM: + return (a << 24) | (r << 16) | (g << 8) | b; + case PIPE_FORMAT_B8G8R8A8_UNORM: + return (b << 24) | (g << 16) | (r << 8) | a; + default: + assert(0); + return 0; + } } diff --git a/src/mesa/pipe/cso_cache/cso_hash.c b/src/mesa/pipe/cso_cache/cso_hash.c index fe033c9e91..0338cb3b47 100644 --- a/src/mesa/pipe/cso_cache/cso_hash.c +++ b/src/mesa/pipe/cso_cache/cso_hash.c @@ -101,8 +101,15 @@ static void *cso_data_allocate_node(struct cso_hash_data *hash) return malloc(hash->nodeSize); } -static void cso_data_free_node(void *node) +static void cso_data_free_node(struct cso_node *node) { + /* XXX still a leak here. + * Need to cast value ptr to original cso type, then free the + * driver-specific data hanging off of it. For example: + struct cso_sampler *csamp = (struct cso_sampler *) node->value; + free(csamp->data); + */ + free(node->value); free(node); } diff --git a/src/mesa/pipe/draw/draw_context.c b/src/mesa/pipe/draw/draw_context.c index 179f7ed0d6..a9ff54404f 100644 --- a/src/mesa/pipe/draw/draw_context.c +++ b/src/mesa/pipe/draw/draw_context.c @@ -102,6 +102,7 @@ void draw_destroy( struct draw_context *draw ) draw->pipeline.validate->destroy( draw->pipeline.validate ); if (draw->pipeline.rasterize) draw->pipeline.rasterize->destroy( draw->pipeline.rasterize ); + tgsi_exec_machine_free_data(&draw->machine); FREE( draw->vcache.vertex[0] ); /* Frees all the vertices. */ FREE( draw ); } diff --git a/src/mesa/pipe/i965simple/brw_context.h b/src/mesa/pipe/i965simple/brw_context.h index 139f13ad4e..c610a435e0 100644 --- a/src/mesa/pipe/i965simple/brw_context.h +++ b/src/mesa/pipe/i965simple/brw_context.h @@ -329,6 +329,7 @@ struct brw_vs_prog_data { float imm_buf[PIPE_MAX_CONSTANT][4]; unsigned num_imm; + unsigned num_consts; /* Used for calculating urb partitions: */ diff --git a/src/mesa/pipe/i965simple/brw_curbe.c b/src/mesa/pipe/i965simple/brw_curbe.c index 603116c863..4d79a7abe2 100644 --- a/src/mesa/pipe/i965simple/brw_curbe.c +++ b/src/mesa/pipe/i965simple/brw_curbe.c @@ -252,9 +252,14 @@ static void upload_constant_buffer(struct brw_context *brw) /*unsigned nr = vp->max_const;*/ const struct pipe_constant_buffer *cbuffer = brw->attribs.Constants[0]; struct pipe_winsys *ws = brw->pipe.winsys; - if (cbuffer->size) { + /* FIXME: buffer size is num_consts + num_immediates */ + if (brw->vs.prog_data->num_consts) { /* map the vertex constant buffer and copy to curbe: */ ws->buffer_map(ws, cbuffer->buffer, 0); + /* FIXME: this is wrong. the cbuffer->size currently + * represents size of consts + immediates. so if we'll + * have both we'll copy over the end of the buffer + * with the subsequent memcpy */ ws->buffer_get_subdata(ws, cbuffer->buffer, 0, cbuffer->size, @@ -263,12 +268,10 @@ static void upload_constant_buffer(struct brw_context *brw) offset += cbuffer->size; } /*immediates*/ -#if 0 if (brw->vs.prog_data->num_imm) { memcpy(&buf[offset], brw->vs.prog_data->imm_buf, brw->vs.prog_data->num_imm * 4 * sizeof(float)); } -#endif } if (1) { diff --git a/src/mesa/pipe/i965simple/brw_vs_emit.c b/src/mesa/pipe/i965simple/brw_vs_emit.c index f3507f60f7..0cc0a437b0 100644 --- a/src/mesa/pipe/i965simple/brw_vs_emit.c +++ b/src/mesa/pipe/i965simple/brw_vs_emit.c @@ -630,6 +630,8 @@ static struct brw_reg get_reg( struct brw_vs_compile *c, assert(c->regs[file][index].nr != 0); return c->regs[file][index]; case TGSI_FILE_CONSTANT: + assert(c->regs[TGSI_FILE_CONSTANT][index + c->prog_data.num_consts].nr != 0); + return c->regs[TGSI_FILE_CONSTANT][index + c->prog_data.num_consts]; case TGSI_FILE_IMMEDIATE: assert(c->regs[TGSI_FILE_CONSTANT][index].nr != 0); return c->regs[TGSI_FILE_CONSTANT][index]; @@ -1317,6 +1319,7 @@ void brw_vs_emit(struct brw_vs_compile *c) /* first instruction (declerations finished). * now that we know what vars are being used allocate * registers for them.*/ + c->prog_data.num_consts = prog_info.num_consts; c->prog_data.max_const = prog_info.num_consts + c->prog_data.num_imm; brw_vs_alloc_regs(c, &prog_info); diff --git a/src/mesa/pipe/softpipe/sp_context.c b/src/mesa/pipe/softpipe/sp_context.c index b6995b8a6c..c7af63cc2d 100644 --- a/src/mesa/pipe/softpipe/sp_context.c +++ b/src/mesa/pipe/softpipe/sp_context.c @@ -127,6 +127,8 @@ softpipe_unmap_surfaces(struct softpipe_context *sp) static void softpipe_destroy( struct pipe_context *pipe ) { struct softpipe_context *softpipe = softpipe_context( pipe ); + struct pipe_winsys *ws = pipe->winsys; + uint i; draw_destroy( softpipe->draw ); @@ -143,6 +145,20 @@ static void softpipe_destroy( struct pipe_context *pipe ) softpipe->quad.colormask->destroy( softpipe->quad.colormask ); softpipe->quad.output->destroy( softpipe->quad.output ); + for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) + sp_destroy_tile_cache(softpipe->cbuf_cache[i]); + sp_destroy_tile_cache(softpipe->zbuf_cache); + sp_destroy_tile_cache(softpipe->sbuf_cache_sep); + + for (i = 0; i < PIPE_MAX_SAMPLERS; i++) + sp_destroy_tile_cache(softpipe->tex_cache[i]); + + for (i = 0; i < Elements(softpipe->constants); i++) { + if (softpipe->constants[i].buffer) { + ws->buffer_reference(ws, &softpipe->constants[i].buffer, NULL); + } + } + FREE( softpipe ); } diff --git a/src/mesa/pipe/softpipe/sp_context.h b/src/mesa/pipe/softpipe/sp_context.h index 8f14dd11d1..394baf0109 100644 --- a/src/mesa/pipe/softpipe/sp_context.h +++ b/src/mesa/pipe/softpipe/sp_context.h @@ -43,29 +43,10 @@ struct softpipe_winsys; struct draw_context; struct draw_stage; struct softpipe_tile_cache; +struct sp_fragment_shader_state; +struct sp_vertex_shader_state; -#define SP_NEW_VIEWPORT 0x1 -#define SP_NEW_RASTERIZER 0x2 -#define SP_NEW_FS 0x4 -#define SP_NEW_BLEND 0x8 -#define SP_NEW_CLIP 0x10 -#define SP_NEW_SCISSOR 0x20 -#define SP_NEW_STIPPLE 0x40 -#define SP_NEW_FRAMEBUFFER 0x80 -#define SP_NEW_DEPTH_STENCIL_ALPHA 0x100 -#define SP_NEW_CONSTANTS 0x200 -#define SP_NEW_SAMPLER 0x400 -#define SP_NEW_TEXTURE 0x800 -#define SP_NEW_VERTEX 0x1000 -#define SP_NEW_VS 0x2000 -#define SP_NEW_QUERY 0x4000 - -struct sp_vertex_shader_state { - struct pipe_shader_state *state; - void *draw_data; -}; - struct softpipe_context { struct pipe_context pipe; /**< base class */ struct softpipe_winsys *winsys; /**< window system interface */ diff --git a/src/mesa/pipe/softpipe/sp_quad_fs.c b/src/mesa/pipe/softpipe/sp_quad_fs.c index 6e7e7eb074..921dfbaccb 100644 --- a/src/mesa/pipe/softpipe/sp_quad_fs.c +++ b/src/mesa/pipe/softpipe/sp_quad_fs.c @@ -335,6 +335,7 @@ static void shade_destroy(struct quad_stage *qs) { struct quad_shade_stage *qss = (struct quad_shade_stage *) qs; + tgsi_exec_machine_free_data(&qss->machine); FREE( qss->inputs ); FREE( qss->outputs ); FREE( qs ); diff --git a/src/mesa/pipe/softpipe/sp_quad_stencil.c b/src/mesa/pipe/softpipe/sp_quad_stencil.c index a688a06c74..33740883d3 100644 --- a/src/mesa/pipe/softpipe/sp_quad_stencil.c +++ b/src/mesa/pipe/softpipe/sp_quad_stencil.c @@ -208,16 +208,22 @@ stencil_test_quad(struct quad_stage *qs, struct quad_header *quad) struct softpipe_cached_tile *tile = sp_get_cached_tile(softpipe, softpipe->sbuf_cache, quad->x0, quad->y0); uint j; + uint face = quad->facing; + + if (!softpipe->depth_stencil->stencil[1].enabled) { + /* single-sided stencil test, use front (face=0) state */ + face = 0; + } /* choose front or back face function, operator, etc */ /* XXX we could do these initializations once per primitive */ - func = softpipe->depth_stencil->stencil[quad->facing].func; - failOp = softpipe->depth_stencil->stencil[quad->facing].fail_op; - zFailOp = softpipe->depth_stencil->stencil[quad->facing].zfail_op; - zPassOp = softpipe->depth_stencil->stencil[quad->facing].zpass_op; - ref = softpipe->depth_stencil->stencil[quad->facing].ref_value; - wrtMask = softpipe->depth_stencil->stencil[quad->facing].write_mask; - valMask = softpipe->depth_stencil->stencil[quad->facing].value_mask; + func = softpipe->depth_stencil->stencil[face].func; + failOp = softpipe->depth_stencil->stencil[face].fail_op; + zFailOp = softpipe->depth_stencil->stencil[face].zfail_op; + zPassOp = softpipe->depth_stencil->stencil[face].zpass_op; + ref = softpipe->depth_stencil->stencil[face].ref_value; + wrtMask = softpipe->depth_stencil->stencil[face].write_mask; + valMask = softpipe->depth_stencil->stencil[face].value_mask; assert(ps); /* shouldn't get here if there's no stencil buffer */ diff --git a/src/mesa/pipe/softpipe/sp_state.h b/src/mesa/pipe/softpipe/sp_state.h index 76b79b5280..c1f5555a86 100644 --- a/src/mesa/pipe/softpipe/sp_state.h +++ b/src/mesa/pipe/softpipe/sp_state.h @@ -35,13 +35,32 @@ #include "x86/rtasm/x86sse.h" + +#define SP_NEW_VIEWPORT 0x1 +#define SP_NEW_RASTERIZER 0x2 +#define SP_NEW_FS 0x4 +#define SP_NEW_BLEND 0x8 +#define SP_NEW_CLIP 0x10 +#define SP_NEW_SCISSOR 0x20 +#define SP_NEW_STIPPLE 0x40 +#define SP_NEW_FRAMEBUFFER 0x80 +#define SP_NEW_DEPTH_STENCIL_ALPHA 0x100 +#define SP_NEW_CONSTANTS 0x200 +#define SP_NEW_SAMPLER 0x400 +#define SP_NEW_TEXTURE 0x800 +#define SP_NEW_VERTEX 0x1000 +#define SP_NEW_VS 0x2000 +#define SP_NEW_QUERY 0x4000 + + + #ifdef MESA_LLVM struct gallivm_prog; #endif -/** - * Softpipe fs state is derived from pipe_shader_state. - */ + + +/** Subclass of pipe_shader_state */ struct sp_fragment_shader_state { struct pipe_shader_state shader; #if defined(__i386__) || defined(__386__) @@ -53,6 +72,14 @@ struct sp_fragment_shader_state { }; +/** Subclass of pipe_shader_state */ +struct sp_vertex_shader_state { + struct pipe_shader_state shader; + void *draw_data; +}; + + + void * softpipe_create_blend_state(struct pipe_context *, const struct pipe_blend_state *); diff --git a/src/mesa/pipe/softpipe/sp_state_derived.c b/src/mesa/pipe/softpipe/sp_state_derived.c index a5e766781f..630ae3163f 100644 --- a/src/mesa/pipe/softpipe/sp_state_derived.c +++ b/src/mesa/pipe/softpipe/sp_state_derived.c @@ -40,7 +40,7 @@ */ static void calculate_vertex_layout( struct softpipe_context *softpipe ) { - const struct pipe_shader_state *vs = softpipe->vs->state; + const struct pipe_shader_state *vs = &softpipe->vs->shader; const struct pipe_shader_state *fs = &softpipe->fs->shader; const enum interp_mode colorInterp = softpipe->rasterizer->flatshade ? INTERP_CONSTANT : INTERP_LINEAR; diff --git a/src/mesa/pipe/softpipe/sp_state_fs.c b/src/mesa/pipe/softpipe/sp_state_fs.c index a360b4f02b..f72a91485f 100644 --- a/src/mesa/pipe/softpipe/sp_state_fs.c +++ b/src/mesa/pipe/softpipe/sp_state_fs.c @@ -42,18 +42,20 @@ void * softpipe_create_fs_state(struct pipe_context *pipe, const struct pipe_shader_state *templ) { struct softpipe_context *softpipe = softpipe_context(pipe); + struct sp_fragment_shader_state *state; /* Decide whether we'll be codegenerating this shader and if so do * that now. */ - struct sp_fragment_shader_state *state = MALLOC( sizeof(struct sp_fragment_shader_state) ); + state = CALLOC_STRUCT(sp_fragment_shader_state); + if (!state) + return NULL; + state->shader = *templ; - if( softpipe->dump_fs ) { - tgsi_dump( - state->shader.tokens, - 0 ); + if (softpipe->dump_fs) { + tgsi_dump(state->shader.tokens, 0); } #if defined(__i386__) || defined(__386__) @@ -75,6 +77,7 @@ void * softpipe_create_fs_state(struct pipe_context *pipe, return state; } + void softpipe_bind_fs_state(struct pipe_context *pipe, void *fs) { struct softpipe_context *softpipe = softpipe_context(pipe); @@ -84,6 +87,7 @@ void softpipe_bind_fs_state(struct pipe_context *pipe, void *fs) softpipe->dirty |= SP_NEW_FS; } + void softpipe_delete_fs_state(struct pipe_context *pipe, void *shader) { @@ -103,22 +107,16 @@ void * softpipe_create_vs_state(struct pipe_context *pipe, struct softpipe_context *softpipe = softpipe_context(pipe); struct sp_vertex_shader_state *state; - state = MALLOC( sizeof(struct sp_vertex_shader_state) ); + state = CALLOC_STRUCT(sp_vertex_shader_state); if (state == NULL ) { return NULL; } - state->state = MALLOC( sizeof(struct pipe_shader_state) ); - if (state->state == NULL) { - FREE( state ); - return NULL; - } - memcpy( state->state, templ, sizeof(struct pipe_shader_state) ); + state->shader = *templ; state->draw_data = draw_create_vertex_shader(softpipe->draw, - state->state); + &state->shader); if (state->draw_data == NULL) { - FREE( state->state ); FREE( state ); return NULL; } @@ -126,6 +124,7 @@ void * softpipe_create_vs_state(struct pipe_context *pipe, return state; } + void softpipe_bind_vs_state(struct pipe_context *pipe, void *vs) { struct softpipe_context *softpipe = softpipe_context(pipe); @@ -137,8 +136,8 @@ void softpipe_bind_vs_state(struct pipe_context *pipe, void *vs) softpipe->dirty |= SP_NEW_VS; } -void softpipe_delete_vs_state(struct pipe_context *pipe, - void *vs) + +void softpipe_delete_vs_state(struct pipe_context *pipe, void *vs) { struct softpipe_context *softpipe = softpipe_context(pipe); @@ -146,12 +145,10 @@ void softpipe_delete_vs_state(struct pipe_context *pipe, (struct sp_vertex_shader_state *)vs; draw_delete_vertex_shader(softpipe->draw, state->draw_data); - FREE( state->state ); FREE( state ); } - void softpipe_set_constant_buffer(struct pipe_context *pipe, uint shader, uint index, const struct pipe_constant_buffer *buf) @@ -170,5 +167,3 @@ void softpipe_set_constant_buffer(struct pipe_context *pipe, softpipe->dirty |= SP_NEW_CONSTANTS; } - - diff --git a/src/mesa/pipe/softpipe/sp_tile_cache.c b/src/mesa/pipe/softpipe/sp_tile_cache.c index ba1f71b01e..1dbcc5aadd 100644 --- a/src/mesa/pipe/softpipe/sp_tile_cache.c +++ b/src/mesa/pipe/softpipe/sp_tile_cache.c @@ -126,9 +126,17 @@ void sp_destroy_tile_cache(struct softpipe_tile_cache *tc) { uint pos; + for (pos = 0; pos < NUM_ENTRIES; pos++) { - assert(tc->entries[pos].x < 0); + //assert(tc->entries[pos].x < 0); + } + if (tc->surface) { + pipe_surface_reference(&tc->surface, NULL); + } + if (tc->tex_surf) { + pipe_surface_reference(&tc->tex_surf, NULL); } + FREE( tc ); } @@ -466,15 +474,12 @@ sp_get_cached_tile_tex(struct pipe_context *pipe, tc->tex_level != level || tc->tex_z != z) { /* get new surface (view into texture) */ - struct pipe_surface *ps; if (tc->tex_surf && tc->tex_surf->map) pipe_surface_unmap(tc->tex_surf); - ps = pipe->get_tex_surface(pipe, tc->texture, face, level, z); - pipe_surface_reference(&tc->tex_surf, ps); - - pipe_surface_map(ps); + tc->tex_surf = pipe->get_tex_surface(pipe, tc->texture, face, level, z); + pipe_surface_map(tc->tex_surf); tc->tex_face = face; tc->tex_level = level; diff --git a/src/mesa/pipe/tgsi/exec/tgsi_exec.c b/src/mesa/pipe/tgsi/exec/tgsi_exec.c index e469281d22..49affc12f3 100644 --- a/src/mesa/pipe/tgsi/exec/tgsi_exec.c +++ b/src/mesa/pipe/tgsi/exec/tgsi_exec.c @@ -275,6 +275,22 @@ tgsi_exec_machine_init( } +void +tgsi_exec_machine_free_data(struct tgsi_exec_machine *mach) +{ + if (mach->Instructions) { + FREE(mach->Instructions); + mach->Instructions = NULL; + mach->NumInstructions = 0; + } + if (mach->Declarations) { + FREE(mach->Declarations); + mach->Declarations = NULL; + mach->NumDeclarations = 0; + } +} + + static void micro_abs( union tgsi_exec_channel *dst, diff --git a/src/mesa/pipe/tgsi/exec/tgsi_exec.h b/src/mesa/pipe/tgsi/exec/tgsi_exec.h index db92e282df..1fb66ee960 100644 --- a/src/mesa/pipe/tgsi/exec/tgsi_exec.h +++ b/src/mesa/pipe/tgsi/exec/tgsi_exec.h @@ -227,6 +227,11 @@ uint tgsi_exec_machine_run( struct tgsi_exec_machine *mach ); + +void +tgsi_exec_machine_free_data(struct tgsi_exec_machine *mach); + + #if defined __cplusplus } /* extern "C" */ #endif diff --git a/src/mesa/pipe/xlib/xm_api.c b/src/mesa/pipe/xlib/xm_api.c index ebf4c21eaf..168eba0784 100644 --- a/src/mesa/pipe/xlib/xm_api.c +++ b/src/mesa/pipe/xlib/xm_api.c @@ -447,6 +447,10 @@ xmesa_free_buffer(XMesaBuffer buffer) /* Unreference. If count = zero we'll really delete the buffer */ _mesa_unreference_framebuffer(&fb); + XFreeGC(b->xm_visual->display, b->gc); + + free(buffer); + return; } /* continue search */ diff --git a/src/mesa/shader/prog_cache.c b/src/mesa/shader/prog_cache.c index d97e27dd6b..dd0241ef24 100644 --- a/src/mesa/shader/prog_cache.c +++ b/src/mesa/shader/prog_cache.c @@ -143,6 +143,7 @@ _mesa_delete_program_cache(GLcontext *ctx, struct gl_program_cache *cache) { clear_cache(ctx, cache); _mesa_free(cache->items); + _mesa_free(cache); } diff --git a/src/mesa/shader/program.c b/src/mesa/shader/program.c index f13aa18e95..fc53b5737c 100644 --- a/src/mesa/shader/program.c +++ b/src/mesa/shader/program.c @@ -101,6 +101,7 @@ _mesa_free_program_data(GLcontext *ctx) if (ctx->VertexProgram.Current->Base.RefCount <= 0) ctx->Driver.DeleteProgram(ctx, &(ctx->VertexProgram.Current->Base)); } + _mesa_delete_program_cache(ctx, ctx->VertexProgram.Cache); #endif #if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program if (ctx->FragmentProgram.Current) { @@ -108,6 +109,7 @@ _mesa_free_program_data(GLcontext *ctx) if (ctx->FragmentProgram.Current->Base.RefCount <= 0) ctx->Driver.DeleteProgram(ctx, &(ctx->FragmentProgram.Current->Base)); } + _mesa_delete_program_cache(ctx, ctx->FragmentProgram.Cache); #endif /* XXX probably move this stuff */ #if FEATURE_ATI_fragment_shader diff --git a/src/mesa/state_tracker/st_context.c b/src/mesa/state_tracker/st_context.c index 1d26da474e..668ac139f7 100644 --- a/src/mesa/state_tracker/st_context.c +++ b/src/mesa/state_tracker/st_context.c @@ -51,6 +51,7 @@ #include "st_extensions.h" #include "st_program.h" #include "pipe/p_context.h" +#include "pipe/p_winsys.h" #include "pipe/draw/draw_context.h" #include "pipe/cso_cache/cso_cache.h" @@ -136,6 +137,9 @@ struct st_context *st_create_context(struct pipe_context *pipe, static void st_destroy_context_priv( struct st_context *st ) { + struct pipe_winsys *ws = st->pipe->winsys; + uint i; + draw_destroy(st->draw); st_destroy_atoms( st ); st_destroy_draw( st ); @@ -146,6 +150,12 @@ static void st_destroy_context_priv( struct st_context *st ) _mesa_delete_program_cache(st->ctx, st->pixel_xfer.cache); + for (i = 0; i < Elements(st->state.constants); i++) { + if (st->state.constants[i].buffer) { + ws->buffer_reference(ws, &st->state.constants[i].buffer, NULL); + } + } + st->pipe->destroy( st->pipe ); free( st ); } diff --git a/src/mesa/state_tracker/st_draw.c b/src/mesa/state_tracker/st_draw.c index b3d463043d..96db9e3c03 100644 --- a/src/mesa/state_tracker/st_draw.c +++ b/src/mesa/state_tracker/st_draw.c @@ -616,6 +616,7 @@ st_feedback_draw_vbo(GLcontext *ctx, if (draw->vertex_buffer[i].buffer) { pipe->winsys->buffer_unmap(pipe->winsys, draw->vertex_buffer[i].buffer); + winsys->buffer_reference(winsys, &draw->vertex_buffer[i].buffer, NULL); draw_set_mapped_vertex_buffer(draw, i, NULL); } } diff --git a/src/mesa/vbo/vbo_context.c b/src/mesa/vbo/vbo_context.c index 60d0b76ab6..235cee2429 100644 --- a/src/mesa/vbo/vbo_context.c +++ b/src/mesa/vbo/vbo_context.c @@ -246,6 +246,7 @@ void _vbo_DestroyContext( GLcontext *ctx ) } vbo_exec_destroy(ctx); + vbo_save_destroy(ctx); FREE(vbo_context(ctx)); ctx->swtnl_im = NULL; } diff --git a/src/mesa/vbo/vbo_save.c b/src/mesa/vbo/vbo_save.c index 87248e10f3..8dd87141c0 100644 --- a/src/mesa/vbo/vbo_save.c +++ b/src/mesa/vbo/vbo_save.c @@ -69,6 +69,21 @@ void vbo_save_init( GLcontext *ctx ) void vbo_save_destroy( GLcontext *ctx ) { + struct vbo_context *vbo = vbo_context(ctx); + struct vbo_save_context *save = &vbo->save; + if (save->prim_store) { + if ( --save->prim_store->refcount == 0 ) { + FREE( save->prim_store ); + save->prim_store = NULL; + } + if ( --save->vertex_store->refcount == 0 ) { + if (save->vertex_store->bufferobj) + ctx->Driver.DeleteBuffer( ctx, save->vertex_store->bufferobj ); + + FREE( save->vertex_store ); + save->vertex_store = NULL; + } + } } |