src/gallium/auxiliary/draw/draw_pt_so_emit.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2010 VMware, Inc.
   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 VMWARE 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 "draw/draw_private.h"
  29 #include "draw/draw_vs.h"
  30 #include "draw/draw_gs.h"
  31 #include "draw/draw_context.h"
  32 #include "draw/draw_vbuf.h"
  33 #include "draw/draw_vertex.h"
  34 #include "draw/draw_pt.h"
  35
  36 #include "pipe/p_state.h"
  37
  38 #include "util/u_math.h"
  39 #include "util/u_memory.h"
  40
  41 struct pt_so_emit {
  42    struct draw_context *draw;
  43
  44    unsigned input_vertex_stride;
  45    const float (*inputs)[4];
  46    const float (*pre_clip_pos)[4];
  47    boolean has_so;
  48    boolean use_pre_clip_pos;
  49    int pos_idx;
  50    unsigned emitted_primitives;
  51    unsigned emitted_vertices;
  52    unsigned generated_primitives;
  53 };
  54
  55 static const struct pipe_stream_output_info *
  56 draw_so_info(const struct draw_context *draw)
  57 {
  58    const struct pipe_stream_output_info *state = NULL;
  59
  60    if (draw->gs.geometry_shader) {
  61       state = &draw->gs.geometry_shader->state.stream_output;
  62    } else {
  63       state = &draw->vs.vertex_shader->state.stream_output;
  64    }
  65
  66    return state;
  67 }
  68
  69 static INLINE boolean
  70 draw_has_so(const struct draw_context *draw)
  71 {
  72    const struct pipe_stream_output_info *state = draw_so_info(draw);
  73
  74    if (state && state->num_outputs > 0)
  75       return TRUE;
  76
  77    return FALSE;
  78 }
  79
  80 void draw_pt_so_emit_prepare(struct pt_so_emit *emit, boolean use_pre_clip_pos)
  81 {
  82    struct draw_context *draw = emit->draw;
  83
  84    emit->use_pre_clip_pos = use_pre_clip_pos;
  85    emit->has_so = draw_has_so(draw);
  86    if (use_pre_clip_pos)
  87       emit->pos_idx = draw_current_shader_position_output(draw);
  88
  89    /* if we have a state with outputs make sure we have
  90     * buffers to output to */
  91    if (emit->has_so) {
  92       boolean has_valid_buffer = FALSE;
  93       unsigned i;
  94       for (i = 0; i < draw->so.num_targets; ++i) {
  95          if (draw->so.targets[i]) {
  96             has_valid_buffer = TRUE;
  97             break;
  98          }
  99       }
 100       emit->has_so = has_valid_buffer;
 101    }
 102
 103    if (!emit->has_so)
 104       return;
 105
 106    /* XXX: need to flush to get prim_vbuf.c to release its allocation??
 107     */
 108    draw_do_flush( draw, DRAW_FLUSH_BACKEND );
 109 }
 110
 111 static void so_emit_prim(struct pt_so_emit *so,
 112                          unsigned *indices,
 113                          unsigned num_vertices)
 114 {
 115    unsigned slot, i;
 116    unsigned input_vertex_stride = so->input_vertex_stride;
 117    struct draw_context *draw = so->draw;
 118    const float (*input_ptr)[4];
 119    const float (*pcp_ptr)[4] = NULL;
 120    const struct pipe_stream_output_info *state = draw_so_info(draw);
 121    float *buffer;
 122    int buffer_total_bytes[PIPE_MAX_SO_BUFFERS];
 123
 124    input_ptr = so->inputs;
 125    if (so->use_pre_clip_pos)
 126       pcp_ptr = so->pre_clip_pos;
 127
 128    ++so->generated_primitives;
 129
 130    for (i = 0; i < draw->so.num_targets; i++) {
 131       struct draw_so_target *target = draw->so.targets[i];
 132       buffer_total_bytes[i] = target->internal_offset;
 133    }
 134
 135    /* check have we space to emit prim first - if not don't do anything */
 136    for (i = 0; i < num_vertices; ++i) {
 137       for (slot = 0; slot < state->num_outputs; ++slot) {
 138          unsigned num_comps = state->output[slot].num_components;
 139          int ob = state->output[slot].output_buffer;
 140
 141          if ((buffer_total_bytes[ob] + num_comps * sizeof(float)) >
 142              draw->so.targets[ob]->target.buffer_size) {
 143             return;
 144          }
 145          buffer_total_bytes[ob] += num_comps * sizeof(float);
 146       }
 147    }
 148
 149    for (i = 0; i < num_vertices; ++i) {
 150       const float (*input)[4];
 151       const float (*pre_clip_pos)[4] = NULL;
 152       int ob;
 153
 154       input = (const float (*)[4])(
 155          (const char *)input_ptr + (indices[i] * input_vertex_stride));
 156
 157       if (pcp_ptr)
 158          pre_clip_pos = (const float (*)[4])(
 159          (const char *)pcp_ptr + (indices[i] * input_vertex_stride));
 160
 161       for (slot = 0; slot < state->num_outputs; ++slot) {
 162          unsigned idx = state->output[slot].register_index;
 163          unsigned start_comp = state->output[slot].start_component;
 164          unsigned num_comps = state->output[slot].num_components;
 165
 166          ob = state->output[slot].output_buffer;
 167
 168          buffer = (float *)((char *)draw->so.targets[ob]->mapping +
 169                             draw->so.targets[ob]->target.buffer_offset +
 170                             draw->so.targets[ob]->internal_offset) + state->output[slot].dst_offset;
 171
 172          if (idx == so->pos_idx && pcp_ptr)
 173             memcpy(buffer, &pre_clip_pos[idx][start_comp], num_comps * sizeof(float));
 174          else
 175             memcpy(buffer, &input[idx][start_comp], num_comps * sizeof(float));
 176       }
 177       for (ob = 0; ob < draw->so.num_targets; ++ob) {
 178          draw->so.targets[ob]->internal_offset += state->stride[ob] * sizeof(float);
 179          draw->so.targets[ob]->emitted_vertices += 1;
 180       }
 181    }
 182    so->emitted_vertices += num_vertices;
 183    ++so->emitted_primitives;
 184 }
 185
 186 static void so_point(struct pt_so_emit *so, int idx)
 187 {
 188    unsigned indices[1];
 189
 190    indices[0] = idx;
 191
 192    so_emit_prim(so, indices, 1);
 193 }
 194
 195 static void so_line(struct pt_so_emit *so, int i0, int i1)
 196 {
 197    unsigned indices[2];
 198
 199    indices[0] = i0;
 200    indices[1] = i1;
 201
 202    so_emit_prim(so, indices, 2);
 203 }
 204
 205 static void so_tri(struct pt_so_emit *so, int i0, int i1, int i2)
 206 {
 207    unsigned indices[3];
 208
 209    indices[0] = i0;
 210    indices[1] = i1;
 211    indices[2] = i2;
 212
 213    so_emit_prim(so, indices, 3);
 214 }
 215
 216
 217 #define FUNC         so_run_linear
 218 #define GET_ELT(idx) (start + (idx))
 219 #include "draw_so_emit_tmp.h"
 220
 221
 222 #define FUNC         so_run_elts
 223 #define LOCAL_VARS   const ushort *elts = input_prims->elts;
 224 #define GET_ELT(idx) (elts[start + (idx)])
 225 #include "draw_so_emit_tmp.h"
 226
 227
 228 void draw_pt_so_emit( struct pt_so_emit *emit,
 229                       const struct draw_vertex_info *input_verts,
 230                       const struct draw_prim_info *input_prims )
 231 {
 232    struct draw_context *draw = emit->draw;
 233    struct vbuf_render *render = draw->render;
 234    unsigned start, i;
 235
 236    if (!emit->has_so)
 237       return;
 238
 239    if (!draw->so.num_targets)
 240       return;
 241
 242    emit->emitted_vertices = 0;
 243    emit->emitted_primitives = 0;
 244    emit->generated_primitives = 0;
 245    emit->input_vertex_stride = input_verts->stride;
 246    if (emit->use_pre_clip_pos)
 247      emit->pre_clip_pos = (const float (*)[4])input_verts->verts->pre_clip_pos;
 248
 249    emit->inputs = (const float (*)[4])input_verts->verts->data;
 250
 251    /* XXX: need to flush to get prim_vbuf.c to release its allocation??*/
 252    draw_do_flush( draw, DRAW_FLUSH_BACKEND );
 253
 254    for (start = i = 0; i < input_prims->primitive_count;
 255         start += input_prims->primitive_lengths[i], i++)
 256    {
 257       unsigned count = input_prims->primitive_lengths[i];
 258
 259       if (input_prims->linear) {
 260          so_run_linear(emit, input_prims, input_verts,
 261                        start, count);
 262       } else {
 263          so_run_elts(emit, input_prims, input_verts,
 264                      start, count);
 265       }
 266    }
 267
 268    render->set_stream_output_info(render,
 269                                   emit->emitted_primitives,
 270                                   emit->emitted_vertices,
 271                                   emit->generated_primitives);
 272 }
 273
 274
 275 struct pt_so_emit *draw_pt_so_emit_create( struct draw_context *draw )
 276 {
 277    struct pt_so_emit *emit = CALLOC_STRUCT(pt_so_emit);
 278    if (!emit)
 279       return NULL;
 280
 281    emit->draw = draw;
 282
 283    return emit;
 284 }
 285
 286 void draw_pt_so_emit_destroy( struct pt_so_emit *emit )
 287 {
 288    FREE(emit);
 289 }