X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fsoftpipe%2Fsp_quad_fs.c;h=26e7434edcbce6165fd78b3e3f0ca956bd9a3322;hb=76f9eae7bb2b503e46ebe2847619bba1cec393b6;hp=1e7533d0f9ec8cafd0d007fe38ceb2f95e19a165;hpb=898de4a9d5e47ed32c600e5907476fd9338aa7e9;p=mesa.git diff --git a/src/gallium/drivers/softpipe/sp_quad_fs.c b/src/gallium/drivers/softpipe/sp_quad_fs.c index 1e7533d0f9e..26e7434edcb 100644 --- a/src/gallium/drivers/softpipe/sp_quad_fs.c +++ b/src/gallium/drivers/softpipe/sp_quad_fs.c @@ -1,6 +1,6 @@ /************************************************************************** * - * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. + * Copyright 2007 VMware, Inc. * All Rights Reserved. * Copyright 2008 VMware, Inc. All rights reserved. * @@ -19,7 +19,7 @@ * 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 + * IN NO EVENT SHALL VMWARE 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. @@ -45,38 +45,34 @@ #include "sp_state.h" #include "sp_quad.h" #include "sp_quad_pipe.h" -#include "sp_texture.h" -#include "sp_tex_sample.h" struct quad_shade_stage { struct quad_stage stage; /**< base class */ - struct tgsi_exec_machine *machine; - struct tgsi_exec_vector *inputs, *outputs; -}; - -/** cast wrapper */ -static INLINE struct quad_shade_stage * -quad_shade_stage(struct quad_stage *qs) -{ - return (struct quad_shade_stage *) qs; -} + /* no other fields at this time */ +}; /** * Execute fragment shader for the four fragments in the quad. + * \return TRUE if quad is alive, FALSE if all four pixels are killed */ -static INLINE boolean +static inline boolean shade_quad(struct quad_stage *qs, struct quad_header *quad) { - struct quad_shade_stage *qss = quad_shade_stage( qs ); struct softpipe_context *softpipe = qs->softpipe; - struct tgsi_exec_machine *machine = qss->machine; + struct tgsi_exec_machine *machine = softpipe->fs_machine; + + if (softpipe->active_statistics_queries) { + softpipe->pipeline_statistics.ps_invocations += + util_bitcount(quad->inout.mask); + } /* run shader */ - return softpipe->fs->run( softpipe->fs, machine, quad ); + machine->flatshade_color = softpipe->rasterizer->flatshade ? TRUE : FALSE; + return softpipe->fs_variant->run( softpipe->fs_variant, machine, quad, softpipe->early_depth ); } @@ -91,7 +87,7 @@ coverage_quad(struct quad_stage *qs, struct quad_header *quad) for (cbuf = 0; cbuf < softpipe->framebuffer.nr_cbufs; cbuf++) { float (*quadColor)[4] = quad->output.color[cbuf]; unsigned j; - for (j = 0; j < QUAD_SIZE; j++) { + for (j = 0; j < TGSI_QUAD_SIZE; j++) { assert(quad->input.coverage[j] >= 0.0); assert(quad->input.coverage[j] <= 1.0); quadColor[3][j] *= quad->input.coverage[j]; @@ -100,53 +96,55 @@ coverage_quad(struct quad_stage *qs, struct quad_header *quad) } - +/** + * Shade/write an array of quads + * Called via quad_stage::run() + */ static void shade_quads(struct quad_stage *qs, - struct quad_header *quads[], - unsigned nr) + struct quad_header *quads[], + unsigned nr) { - struct quad_shade_stage *qss = quad_shade_stage( qs ); struct softpipe_context *softpipe = qs->softpipe; - struct tgsi_exec_machine *machine = qss->machine; + struct tgsi_exec_machine *machine = softpipe->fs_machine; + unsigned i, nr_quads = 0; + + tgsi_exec_set_constant_buffers(machine, PIPE_MAX_CONSTANT_BUFFERS, + softpipe->mapped_constants[PIPE_SHADER_FRAGMENT], + softpipe->const_buffer_size[PIPE_SHADER_FRAGMENT]); - unsigned i, pass = 0; - - machine->Consts = softpipe->mapped_constants[PIPE_SHADER_FRAGMENT]; machine->InterpCoefs = quads[0]->coef; for (i = 0; i < nr; i++) { - if (!shade_quad(qs, quads[i])) - continue; + /* Only omit this quad from the output list if all the fragments + * are killed _AND_ it's not the first quad in the list. + * The first quad is special in the (optimized) depth-testing code: + * the quads' Z coordinates are step-wise interpolated with respect + * to the first quad in the list. + * For multi-pass algorithms we need to produce exactly the same + * Z values in each pass. If interpolation starts with different quads + * we can get different Z values for the same (x,y). + */ + if (!shade_quad(qs, quads[i]) && i > 0) + continue; /* quad totally culled/killed */ if (/*do_coverage*/ 0) coverage_quad( qs, quads[i] ); - quads[pass++] = quads[i]; + quads[nr_quads++] = quads[i]; } - if (pass) - qs->next->run(qs->next, quads, pass); + if (nr_quads) + qs->next->run(qs->next, quads, nr_quads); } - - - /** * Per-primitive (or per-begin?) setup */ static void shade_begin(struct quad_stage *qs) { - struct quad_shade_stage *qss = quad_shade_stage(qs); - struct softpipe_context *softpipe = qs->softpipe; - - softpipe->fs->prepare( softpipe->fs, - qss->machine, - (struct tgsi_sampler **) - softpipe->tgsi.frag_samplers_list ); - qs->next->begin(qs->next); } @@ -154,10 +152,6 @@ shade_begin(struct quad_stage *qs) static void shade_destroy(struct quad_stage *qs) { - struct quad_shade_stage *qss = (struct quad_shade_stage *) qs; - - tgsi_exec_machine_destroy(qss->machine); - FREE( qs ); } @@ -174,16 +168,9 @@ sp_quad_shade_stage( struct softpipe_context *softpipe ) qss->stage.run = shade_quads; qss->stage.destroy = shade_destroy; - qss->machine = tgsi_exec_machine_create(); - if (!qss->machine) - goto fail; - return &qss->stage; fail: - if (qss && qss->machine) - tgsi_exec_machine_destroy(qss->machine); - FREE(qss); return NULL; }