src/gallium/auxiliary/draw/draw_vs_varient.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28  /*
  29   * Authors:
  30   *   Keith Whitwell <keith@tungstengraphics.com>
  31   */
  32
  33 #include "pipe/p_util.h"
  34 #include "draw/draw_context.h"
  35 #include "draw/draw_private.h"
  36 #include "draw/draw_vbuf.h"
  37 #include "draw/draw_vertex.h"
  38 #include "draw/draw_vs.h"
  39 #include "translate/translate.h"
  40 #include "translate/translate_cache.h"
  41
  42 /* A first pass at incorporating vertex fetch/emit functionality into
  43  */
  44 struct draw_vs_varient_generic {
  45    struct draw_vs_varient base;
  46
  47    struct draw_vertex_shader *shader;
  48    struct draw_context *draw;
  49
  50    /* Basic plan is to run these two translate functions before/after
  51     * the vertex shader's existing run_linear() routine to simulate
  52     * the inclusion of this functionality into the shader...
  53     *
  54     * Next will look at actually including it.
  55     */
  56    struct translate *fetch;
  57    struct translate *emit;
  58 };
  59
  60
  61
  62
  63
  64 static void vsvg_set_input( struct draw_vs_varient *varient,
  65                             unsigned buffer,
  66                             const void *ptr,
  67                             unsigned stride )
  68 {
  69    struct draw_vs_varient_generic *vsvg = (struct draw_vs_varient_generic *)varient;
  70
  71    vsvg->fetch->set_buffer(vsvg->fetch,
  72                            buffer,
  73                            ptr,
  74                            stride);
  75 }
  76
  77
  78 /* Mainly for debug at this stage:
  79  */
  80 static void do_rhw_viewport( struct draw_vs_varient_generic *vsvg,
  81                              unsigned count,
  82                              void *output_buffer )
  83 {
  84    char *ptr = (char *)output_buffer;
  85    const float *scale = vsvg->base.vs->draw->viewport.scale;
  86    const float *trans = vsvg->base.vs->draw->viewport.translate;
  87    unsigned stride = vsvg->base.key.output_stride;
  88    unsigned j;
  89
  90    for (j = 0; j < count; j++, ptr += stride) {
  91       float *data = (float *)ptr;
  92       float w = 1.0f / data[3];
  93
  94       data[0] = data[0] * w * scale[0] + trans[0];
  95       data[1] = data[1] * w * scale[1] + trans[1];
  96       data[2] = data[2] * w * scale[2] + trans[2];
  97       data[3] = w;
  98    }
  99 }
 100
 101 static void do_viewport( struct draw_vs_varient_generic *vsvg,
 102                              unsigned count,
 103                              void *output_buffer )
 104 {
 105    char *ptr = (char *)output_buffer;
 106    const float *scale = vsvg->base.vs->draw->viewport.scale;
 107    const float *trans = vsvg->base.vs->draw->viewport.translate;
 108    unsigned stride = vsvg->base.key.output_stride;
 109    unsigned j;
 110
 111    for (j = 0; j < count; j++, ptr += stride) {
 112       float *data = (float *)ptr;
 113
 114       data[0] = data[0] * scale[0] + trans[0];
 115       data[1] = data[1] * scale[1] + trans[1];
 116       data[2] = data[2] * scale[2] + trans[2];
 117    }
 118 }
 119
 120
 121 static void PIPE_CDECL vsvg_run_elts( struct draw_vs_varient *varient,
 122                                       const unsigned *elts,
 123                                       unsigned count,
 124                                       void *output_buffer)
 125 {
 126    struct draw_vs_varient_generic *vsvg = (struct draw_vs_varient_generic *)varient;
 127
 128    /* Want to do this in small batches for cache locality?
 129     */
 130
 131    vsvg->fetch->run_elts( vsvg->fetch,
 132                           elts,
 133                           count,
 134                           output_buffer );
 135
 136    //if (!vsvg->base.vs->is_passthrough)
 137    {
 138       vsvg->base.vs->run_linear( vsvg->base.vs,
 139                                  output_buffer,
 140                                  output_buffer,
 141                                  (const float (*)[4])vsvg->base.vs->draw->pt.user.constants,
 142                                  count,
 143                                  vsvg->base.key.output_stride,
 144                                  vsvg->base.key.output_stride);
 145
 146
 147       if (vsvg->base.key.clip) {
 148          /* not really handling clipping, just do the rhw so we can
 149           * see the results...
 150           */
 151          do_rhw_viewport( vsvg,
 152                           count,
 153                           output_buffer );
 154       }
 155       else if (vsvg->base.key.viewport) {
 156          do_viewport( vsvg,
 157                       count,
 158                       output_buffer );
 159       }
 160
 161
 162       //if (!vsvg->already_in_emit_format)
 163
 164       vsvg->emit->set_buffer( vsvg->emit,
 165                               0,
 166                               output_buffer,
 167                               vsvg->base.key.output_stride );
 168
 169
 170       vsvg->emit->run( vsvg->emit,
 171                        0, count,
 172                        output_buffer );
 173    }
 174 }
 175
 176
 177 static void PIPE_CDECL vsvg_run_linear( struct draw_vs_varient *varient,
 178                                         unsigned start,
 179                                         unsigned count,
 180                                         void *output_buffer )
 181 {
 182    struct draw_vs_varient_generic *vsvg = (struct draw_vs_varient_generic *)varient;
 183
 184    //debug_printf("%s %d %d\n", __FUNCTION__, start, count);
 185
 186
 187    vsvg->fetch->run( vsvg->fetch,
 188                      start,
 189                      count,
 190                      output_buffer );
 191
 192    //if (!vsvg->base.vs->is_passthrough)
 193    {
 194       vsvg->base.vs->run_linear( vsvg->base.vs,
 195                                  output_buffer,
 196                                  output_buffer,
 197                                  (const float (*)[4])vsvg->base.vs->draw->pt.user.constants,
 198                                  count,
 199                                  vsvg->base.key.output_stride,
 200                                  vsvg->base.key.output_stride);
 201
 202       if (vsvg->base.key.clip) {
 203          /* not really handling clipping, just do the rhw so we can
 204           * see the results...
 205           */
 206          do_rhw_viewport( vsvg,
 207                           count,
 208                           output_buffer );
 209       }
 210       else if (vsvg->base.key.viewport) {
 211          do_viewport( vsvg,
 212                       count,
 213                       output_buffer );
 214       }
 215
 216       //if (!vsvg->already_in_emit_format)
 217       vsvg->emit->set_buffer( vsvg->emit,
 218                               0,
 219                               output_buffer,
 220                               vsvg->base.key.output_stride );
 221
 222       vsvg->emit->set_buffer( vsvg->emit,
 223                               1,
 224                               &vsvg->draw->rasterizer->point_size,
 225                               0);
 226
 227       vsvg->emit->run( vsvg->emit,
 228                        0, count,
 229                        output_buffer );
 230    }
 231 }
 232
 233
 234
 235
 236
 237 static void vsvg_destroy( struct draw_vs_varient *varient )
 238 {
 239    FREE(varient);
 240 }
 241
 242
 243 struct draw_vs_varient *draw_vs_varient_generic( struct draw_vertex_shader *vs,
 244                                                  const struct draw_vs_varient_key *key )
 245 {
 246    unsigned i;
 247    struct translate_key fetch, emit;
 248
 249    struct draw_vs_varient_generic *vsvg = CALLOC_STRUCT( draw_vs_varient_generic );
 250    if (vsvg == NULL)
 251       return NULL;
 252
 253    vsvg->base.key = *key;
 254    vsvg->base.vs = vs;
 255    vsvg->base.set_input     = vsvg_set_input;
 256    vsvg->base.run_elts      = vsvg_run_elts;
 257    vsvg->base.run_linear    = vsvg_run_linear;
 258    vsvg->base.destroy       = vsvg_destroy;
 259
 260
 261
 262    /* Build free-standing fetch and emit functions:
 263     */
 264    fetch.nr_elements = key->nr_inputs;
 265    fetch.output_stride = 0;
 266    for (i = 0; i < key->nr_inputs; i++) {
 267       fetch.element[i].input_format = key->element[i].in.format;
 268       fetch.element[i].input_buffer = key->element[i].in.buffer;
 269       fetch.element[i].input_offset = key->element[i].in.offset;
 270       fetch.element[i].output_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
 271       fetch.element[i].output_offset = fetch.output_stride;
 272       fetch.output_stride += 4 * sizeof(float);
 273    }
 274
 275
 276    emit.nr_elements = key->nr_outputs;
 277    emit.output_stride = key->output_stride;
 278    for (i = 0; i < key->nr_outputs; i++) {
 279       if (key->element[i].out.format != EMIT_1F_PSIZE)
 280       {
 281          emit.element[i].input_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
 282          emit.element[i].input_buffer = 0;
 283          emit.element[i].input_offset = key->element[i].out.vs_output * 4 * sizeof(float);
 284          emit.element[i].output_format = draw_translate_vinfo_format(key->element[i].out.format);
 285          emit.element[i].output_offset = key->element[i].out.offset;
 286       }
 287       else {
 288          emit.element[i].input_format = PIPE_FORMAT_R32_FLOAT;
 289          emit.element[i].input_buffer = 1;
 290          emit.element[i].input_offset = 0;
 291          emit.element[i].output_format = PIPE_FORMAT_R32_FLOAT;
 292          emit.element[i].output_offset = key->element[i].out.offset;
 293       }
 294    }
 295
 296    vsvg->fetch = draw_vs_get_fetch( vs->draw, &fetch );
 297    vsvg->emit = draw_vs_get_emit( vs->draw, &emit );
 298
 299    return &vsvg->base;
 300 }
 301
 302
 303
 304
 305