From: José Fonseca <jfonseca@vmware.com>
Date: Sat, 16 Jan 2010 23:21:06 +0000 (+0000)
Subject: Merge remote branch 'origin/master' into lp-binning
X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=ba5d600c90f7075cf2c33a0c5c679ef822e8746e;p=mesa.git

Merge remote branch 'origin/master' into lp-binning

Conflicts:
	src/gallium/drivers/llvmpipe/lp_quad.h
	src/gallium/drivers/llvmpipe/lp_setup.c
---

ba5d600c90f7075cf2c33a0c5c679ef822e8746e
diff --cc src/gallium/drivers/llvmpipe/lp_context.h
index 5390a713699,426d6eb4a12..3af7b62a53b
--- a/src/gallium/drivers/llvmpipe/lp_context.h
+++ b/src/gallium/drivers/llvmpipe/lp_context.h
@@@ -60,9 -62,9 +60,9 @@@ struct llvmpipe_context 
     const struct lp_vertex_shader *vs;
  
     /** Other rendering state */
 -   struct pipe_blend_color blend_color[4][16];
 +   struct pipe_blend_color blend_color;
     struct pipe_clip_state clip;
-    struct pipe_constant_buffer constants[PIPE_SHADER_TYPES];
+    struct pipe_buffer *constants[PIPE_SHADER_TYPES];
     struct pipe_framebuffer_state framebuffer;
     struct pipe_poly_stipple poly_stipple;
     struct pipe_scissor_state scissor;
diff --cc src/gallium/drivers/llvmpipe/lp_rast.h
index 21ebfa7ca91,00000000000..e4c56f153fc
mode 100644,000000..100644
--- a/src/gallium/drivers/llvmpipe/lp_rast.h
+++ b/src/gallium/drivers/llvmpipe/lp_rast.h
@@@ -1,236 -1,0 +1,236 @@@
 +/**************************************************************************
 + *
 + * Copyright 2009 VMware, Inc.
 + * 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 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.
 + *
 + **************************************************************************/
 +
 +/**
 + * The rast code is concerned with rasterization of command bins.
 + * Each screen tile has a bin associated with it.  To render the
 + * scene we iterate over the tile bins and execute the commands
 + * in each bin.
 + * We'll do that with multiple threads...
 + */
 +
 +
 +#ifndef LP_RAST_H
 +#define LP_RAST_H
 +
 +#include "pipe/p_compiler.h"
 +#include "lp_jit.h"
 +
 +
 +struct lp_rasterizer;
 +struct lp_scene;
 +struct lp_scene_queue;
 +struct lp_fence;
 +struct cmd_bin;
 +struct pipe_screen;
 +
 +/** For sub-pixel positioning */
 +#define FIXED_ORDER 4
 +#define FIXED_ONE (1<<FIXED_ORDER)
 +
 +
 +/**
 + * Rasterization state.
 + * Objects of this type are put into the shared data bin and pointed
 + * to by commands in the per-tile bins.
 + */
 +struct lp_rast_state {
 +   /* State for the shader.  This also contains state which feeds into
 +    * the fragment shader, such as blend color and alpha ref value.
 +    */
 +   struct lp_jit_context jit_context;
 +   
 +   /* The shader itself.  Probably we also need to pass a pointer to
 +    * the tile color/z/stencil data somehow:
 +    * jit_function[0] skips the triangle in/out test code
 +    * jit_function[1] does triangle in/out testing
 +     */
 +   lp_jit_frag_func jit_function[2];
 +
 +   boolean opaque;
 +};
 +
 +
 +/**
 + * Coefficients necessary to run the shader at a given location.
 + * First coefficient is position.
 + * These pointers point into the bin data buffer.
 + */
 +struct lp_rast_shader_inputs {
 +   float (*a0)[4];
 +   float (*dadx)[4];
 +   float (*dady)[4];
 +
 +   /* edge/step info for 3 edges and 4x4 block of pixels */
-    int ALIGN16_ATTRIB step[3][16];
++   PIPE_ALIGN_VAR(16) int step[3][16];
 +};
 +
 +
 +/**
 + * Rasterization information for a triangle known to be in this bin,
 + * plus inputs to run the shader:
 + * These fields are tile- and bin-independent.
 + * Objects of this type are put into the setup_context::data buffer.
 + */
 +struct lp_rast_triangle {
 +   /* one-pixel sized trivial accept offsets for each plane */
 +   int ei1;                   
 +   int ei2;
 +   int ei3;
 +
 +   /* one-pixel sized trivial reject offsets for each plane */
 +   int eo1;                   
 +   int eo2;
 +   int eo3;
 +
 +   /* y deltas for vertex pairs (in fixed pt) */
 +   int dy12;
 +   int dy23;
 +   int dy31;
 +
 +   /* x deltas for vertex pairs (in fixed pt) */
 +   int dx12;
 +   int dx23;
 +   int dx31;
 +
 +   /* edge function values at minx,miny ?? */
 +   int c1, c2, c3;
 +
 +   /* inputs for the shader */
-    struct lp_rast_shader_inputs ALIGN16_ATTRIB inputs;
++   PIPE_ALIGN_VAR(16) struct lp_rast_shader_inputs inputs;
 +};
 +
 +
 +
 +struct lp_rasterizer *lp_rast_create( struct pipe_screen *screen,
 +                                      struct lp_scene_queue *empty );
 +
 +void lp_rast_destroy( struct lp_rasterizer * );
 +
 +unsigned lp_rast_get_num_threads( struct lp_rasterizer * );
 +
 +void lp_rasterize_scene( struct lp_rasterizer *rast,
 +			 struct lp_scene *scene,
 +			 const struct pipe_framebuffer_state *fb,
 +			 bool write_depth );
 +
 +
 +
 +union lp_rast_cmd_arg {
 +   const struct lp_rast_shader_inputs *shade_tile;
 +   const struct lp_rast_triangle *triangle;
 +   const struct lp_rast_state *set_state;
 +   uint8_t clear_color[4];
 +   unsigned clear_zstencil;
 +   struct lp_fence *fence;
 +};
 +
 +
 +/* Cast wrappers.  Hopefully these compile to noops!
 + */
 +static INLINE const union lp_rast_cmd_arg
 +lp_rast_arg_inputs( const struct lp_rast_shader_inputs *shade_tile )
 +{
 +   union lp_rast_cmd_arg arg;
 +   arg.shade_tile = shade_tile;
 +   return arg;
 +}
 +
 +static INLINE const union lp_rast_cmd_arg
 +lp_rast_arg_triangle( const struct lp_rast_triangle *triangle )
 +{
 +   union lp_rast_cmd_arg arg;
 +   arg.triangle = triangle;
 +   return arg;
 +}
 +
 +static INLINE const union lp_rast_cmd_arg
 +lp_rast_arg_state( const struct lp_rast_state *state )
 +{
 +   union lp_rast_cmd_arg arg;
 +   arg.set_state = state;
 +   return arg;
 +}
 +
 +static INLINE const union lp_rast_cmd_arg
 +lp_rast_arg_fence( struct lp_fence *fence )
 +{
 +   union lp_rast_cmd_arg arg;
 +   arg.fence = fence;
 +   return arg;
 +}
 +
 +
 +static INLINE const union lp_rast_cmd_arg
 +lp_rast_arg_null( void )
 +{
 +   union lp_rast_cmd_arg arg;
 +   arg.set_state = NULL;
 +   return arg;
 +}
 +
 +
 +
 +/**
 + * Binnable Commands.
 + * These get put into bins by the setup code and are called when
 + * the bins are executed.
 + */
 +
 +void lp_rast_clear_color( struct lp_rasterizer *, 
 +                          unsigned thread_index,
 +                          const union lp_rast_cmd_arg );
 +
 +void lp_rast_clear_zstencil( struct lp_rasterizer *, 
 +                             unsigned thread_index,
 +                             const union lp_rast_cmd_arg );
 +
 +void lp_rast_load_color( struct lp_rasterizer *, 
 +                         unsigned thread_index,
 +                         const union lp_rast_cmd_arg );
 +
 +void lp_rast_load_zstencil( struct lp_rasterizer *, 
 +                            unsigned thread_index,
 +                            const union lp_rast_cmd_arg );
 +
 +void lp_rast_set_state( struct lp_rasterizer *, 
 +                        unsigned thread_index,
 +                        const union lp_rast_cmd_arg );
 +
 +void lp_rast_triangle( struct lp_rasterizer *, 
 +                       unsigned thread_index,
 +                       const union lp_rast_cmd_arg );
 +
 +void lp_rast_shade_tile( struct lp_rasterizer *,
 +                         unsigned thread_index,
 +                         const union lp_rast_cmd_arg );
 +
 +void lp_rast_fence( struct lp_rasterizer *,
 +                    unsigned thread_index,
 +                    const union lp_rast_cmd_arg );
 +
 +#endif
diff --cc src/gallium/drivers/llvmpipe/lp_state_derived.c
index 28af477914c,6c1ef6bc42d..bdd906e1a73
--- a/src/gallium/drivers/llvmpipe/lp_state_derived.c
+++ b/src/gallium/drivers/llvmpipe/lp_state_derived.c
@@@ -167,25 -228,6 +167,25 @@@ void llvmpipe_update_derived( struct ll
                            LP_NEW_TEXTURE))
        llvmpipe_update_fs( llvmpipe );
  
 +   if (llvmpipe->dirty & LP_NEW_BLEND_COLOR)
 +      lp_setup_set_blend_color(llvmpipe->setup,
 +                               &llvmpipe->blend_color);
 +
 +   if (llvmpipe->dirty & LP_NEW_SCISSOR)
 +      lp_setup_set_scissor(llvmpipe->setup, &llvmpipe->scissor);
 +
 +   if (llvmpipe->dirty & LP_NEW_DEPTH_STENCIL_ALPHA)
 +      lp_setup_set_alpha_ref_value(llvmpipe->setup, 
 +                                   llvmpipe->depth_stencil->alpha.ref_value);
 +
 +   if (llvmpipe->dirty & LP_NEW_CONSTANTS)
 +      lp_setup_set_fs_constants(llvmpipe->setup, 
-                                 llvmpipe->constants[PIPE_SHADER_FRAGMENT].buffer);
++                                llvmpipe->constants[PIPE_SHADER_FRAGMENT]);
 +
 +   if (llvmpipe->dirty & LP_NEW_TEXTURE)
 +      lp_setup_set_sampler_textures(llvmpipe->setup, 
 +                                    llvmpipe->num_textures,
 +                                    llvmpipe->texture);
  
     llvmpipe->dirty = 0;
  }
diff --cc src/gallium/drivers/llvmpipe/lp_state_fs.c
index a8f4a4ed463,9f4bbef73fb..4b51d6b964f
--- a/src/gallium/drivers/llvmpipe/lp_state_fs.c
+++ b/src/gallium/drivers/llvmpipe/lp_state_fs.c
@@@ -1008,14 -723,15 +1007,14 @@@ llvmpipe_set_constant_buffer(struct pip
     assert(shader < PIPE_SHADER_TYPES);
     assert(index == 0);
  
-    if(llvmpipe->constants[shader].buffer == buffer)
++   if(llvmpipe->constants[shader] == constants)
 +      return;
 +
     draw_flush(llvmpipe->draw);
  
     /* note: reference counting */
-    pipe_buffer_reference(&llvmpipe->constants[shader].buffer, buffer);
+    pipe_buffer_reference(&llvmpipe->constants[shader], constants);
  
 -   if(shader == PIPE_SHADER_FRAGMENT) {
 -      llvmpipe->jit_context.constants = data;
 -   }
 -
     if(shader == PIPE_SHADER_VERTEX) {
        draw_set_mapped_constant_buffer(llvmpipe->draw, PIPE_SHADER_VERTEX,
                                        data, size);