src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline.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 #include "pipe/p_util.h"
  29 #include "draw/draw_context.h"
  30 #include "draw/draw_private.h"
  31 #include "draw/draw_vbuf.h"
  32 #include "draw/draw_vertex.h"
  33 #include "draw/draw_pt.h"
  34 #include "translate/translate.h"
  35
  36
  37 struct fetch_pipeline_middle_end {
  38    struct draw_pt_middle_end base;
  39    struct draw_context *draw;
  40
  41    struct translate *translate;
  42
  43    unsigned pipeline_vertex_size;
  44    unsigned prim;
  45    unsigned opt;
  46 };
  47
  48
  49 static void fetch_pipeline_prepare( struct draw_pt_middle_end *middle,
  50                                     unsigned prim,
  51                                     unsigned opt )
  52 {
  53    struct fetch_pipeline_middle_end *fpme = (struct fetch_pipeline_middle_end *)middle;
  54    struct draw_context *draw = fpme->draw;
  55    unsigned i;
  56    boolean ok;
  57    const struct vertex_info *vinfo;
  58    unsigned dst_offset;
  59    struct translate_key hw_key;
  60
  61    fpme->prim = prim;
  62    fpme->opt = opt;
  63
  64    ok = draw->render->set_primitive(draw->render, prim);
  65    if (!ok) {
  66       assert(0);
  67       return;
  68    }
  69
  70    /* Must do this after set_primitive() above:
  71     */
  72    vinfo = draw->render->get_vertex_info(draw->render);
  73
  74
  75    /* In passthrough mode, need to translate from vertex shader
  76     * outputs to hw vertices.
  77     */
  78    dst_offset = 0;
  79    for (i = 0; i < vinfo->num_attribs; i++) {
  80       unsigned emit_sz = 0;
  81       unsigned src_buffer = 0;
  82       unsigned output_format;
  83       unsigned src_offset = (sizeof(struct vertex_header) +
  84                              vinfo->src_index[i] * 4 * sizeof(float) );
  85
  86
  87
  88       switch (vinfo->emit[i]) {
  89       case EMIT_4F:
  90          output_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
  91          emit_sz = 4 * sizeof(float);
  92          break;
  93       case EMIT_3F:
  94          output_format = PIPE_FORMAT_R32G32B32_FLOAT;
  95          emit_sz = 3 * sizeof(float);
  96          break;
  97       case EMIT_2F:
  98          output_format = PIPE_FORMAT_R32G32_FLOAT;
  99          emit_sz = 2 * sizeof(float);
 100          break;
 101       case EMIT_1F:
 102          output_format = PIPE_FORMAT_R32_FLOAT;
 103          emit_sz = 1 * sizeof(float);
 104          break;
 105       case EMIT_1F_PSIZE:
 106          output_format = PIPE_FORMAT_R32_FLOAT;
 107          emit_sz = 1 * sizeof(float);
 108          src_buffer = 1;
 109          src_offset = 0;
 110          break;
 111       case EMIT_4UB:
 112          output_format = PIPE_FORMAT_B8G8R8A8_UNORM;
 113          emit_sz = 4 * sizeof(ubyte);
 114       default:
 115          assert(0);
 116          output_format = PIPE_FORMAT_NONE;
 117          emit_sz = 0;
 118          break;
 119       }
 120
 121       hw_key.element[i].input_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
 122       hw_key.element[i].input_buffer = src_buffer;
 123       hw_key.element[i].input_offset = src_offset;
 124       hw_key.element[i].output_format = output_format;
 125       hw_key.element[i].output_offset = dst_offset;
 126
 127       dst_offset += emit_sz;
 128    }
 129
 130    hw_key.nr_elements = vinfo->num_attribs;
 131    hw_key.output_stride = vinfo->size * 4;
 132
 133    /* Don't bother with caching at this stage:
 134     */
 135    if (!fpme->translate ||
 136        memcmp(&fpme->translate->key, &hw_key, sizeof(hw_key)) != 0)
 137    {
 138       if (fpme->translate)
 139          fpme->translate->release(fpme->translate);
 140
 141       fpme->translate = translate_generic_create( &hw_key );
 142    }
 143
 144
 145
 146    //fpme->pipeline_vertex_size = sizeof(struct vertex_header) + nr * 4 * sizeof(float);
 147    fpme->pipeline_vertex_size = MAX_VERTEX_ALLOCATION;
 148 }
 149
 150
 151
 152
 153 static void fetch_pipeline_run( struct draw_pt_middle_end *middle,
 154                                 const unsigned *fetch_elts,
 155                                 unsigned fetch_count,
 156                                 const ushort *draw_elts,
 157                                 unsigned draw_count )
 158 {
 159    struct fetch_pipeline_middle_end *fpme = (struct fetch_pipeline_middle_end *)middle;
 160    struct draw_context *draw = fpme->draw;
 161    struct draw_vertex_shader *shader = draw->vertex_shader;
 162    char *pipeline_verts;
 163    unsigned pipeline = PT_PIPELINE;
 164
 165    pipeline_verts = MALLOC(fpme->pipeline_vertex_size *
 166                            fetch_count);
 167
 168    if (!pipeline_verts) {
 169       assert(0);
 170       return;
 171    }
 172
 173
 174    /* Shade
 175     */
 176    shader->prepare(shader, draw);
 177
 178    if (shader->run(shader, draw, fetch_elts, fetch_count, pipeline_verts,
 179                    fpme->pipeline_vertex_size))
 180    {
 181       pipeline |= PT_CLIPTEST;
 182    }
 183
 184
 185    /* Do we need to run the pipeline?
 186     */
 187    if (fpme->opt & pipeline) {
 188       draw_pt_run_pipeline( fpme->draw,
 189                             fpme->prim,
 190                             pipeline_verts,
 191                             fpme->pipeline_vertex_size,
 192                             fetch_count,
 193                             draw_elts,
 194                             draw_count );
 195    } else {
 196       struct translate *translate = fpme->translate;
 197       void *hw_verts;
 198
 199       /* XXX: need to flush to get prim_vbuf.c to release its allocation??
 200        */
 201       draw_do_flush( draw, DRAW_FLUSH_BACKEND );
 202
 203       hw_verts = draw->render->allocate_vertices(draw->render,
 204                                                  (ushort)fpme->translate->key.output_stride,
 205                                                  (ushort)fetch_count);
 206       if (!hw_verts) {
 207          assert(0);
 208          return;
 209       }
 210
 211       translate->set_buffer(translate,
 212                             0,
 213                             pipeline_verts,
 214                             fpme->pipeline_vertex_size );
 215
 216       translate->set_buffer(translate,
 217                             1,
 218                             &fpme->draw->rasterizer->point_size,
 219                             0);
 220
 221       translate->run( translate,
 222                       0, fetch_count,
 223                       hw_verts );
 224
 225       draw->render->draw(draw->render,
 226                          draw_elts,
 227                          draw_count);
 228
 229       draw->render->release_vertices(draw->render,
 230                                      hw_verts,
 231                                      fpme->translate->key.output_stride,
 232                                      fetch_count);
 233    }
 234
 235
 236    FREE(pipeline_verts);
 237 }
 238
 239
 240
 241 static void fetch_pipeline_finish( struct draw_pt_middle_end *middle )
 242 {
 243    /* nothing to do */
 244 }
 245
 246 static void fetch_pipeline_destroy( struct draw_pt_middle_end *middle )
 247 {
 248    FREE(middle);
 249 }
 250
 251
 252 struct draw_pt_middle_end *draw_pt_fetch_pipeline_or_emit( struct draw_context *draw )
 253 {
 254    struct fetch_pipeline_middle_end *fetch_pipeline = CALLOC_STRUCT( fetch_pipeline_middle_end );
 255
 256    fetch_pipeline->base.prepare = fetch_pipeline_prepare;
 257    fetch_pipeline->base.run     = fetch_pipeline_run;
 258    fetch_pipeline->base.finish  = fetch_pipeline_finish;
 259    fetch_pipeline->base.destroy = fetch_pipeline_destroy;
 260
 261    fetch_pipeline->draw = draw;
 262
 263    return &fetch_pipeline->base;
 264 }