gallivm: replace `0x` version print with actual version string

[mesa.git] / src / gallium / auxiliary / draw / draw_pt_so_emit.c

diff --git a/src/gallium/auxiliary/draw/draw_pt_so_emit.c b/src/gallium/auxiliary/draw/draw_pt_so_emit.c
index d624a990bc6d55a376883134d13d0fd01fcf1d95..ea3169f32b1b3023bbbfa0ad20a59904b0e3ca31 100644 (file)
--- a/src/gallium/auxiliary/draw/draw_pt_so_emit.c
+++ b/src/gallium/auxiliary/draw/draw_pt_so_emit.c
@@ -48,8 +48,8 @@ struct pt_so_emit {
    boolean use_pre_clip_pos;
    int pos_idx;
    unsigned emitted_primitives;
-   unsigned emitted_vertices;
    unsigned generated_primitives;
+   unsigned stream;
 };
 
 static const struct pipe_stream_output_info *
@@ -66,7 +66,7 @@ draw_so_info(const struct draw_context *draw)
    return state;
 }
 
-static INLINE boolean
+static inline boolean
 draw_has_so(const struct draw_context *draw)
 {
    const struct pipe_stream_output_info *state = draw_so_info(draw);
@@ -145,6 +145,9 @@ static void so_emit_prim(struct pt_so_emit *so,
          int ob = state->output[slot].output_buffer;
          unsigned dst_offset = state->output[slot].dst_offset * sizeof(float);
          unsigned write_size = num_comps * sizeof(float);
+
+         if (state->output[slot].stream != so->stream)
+            continue;
          /* If a buffer is missing then that's equivalent to
           * an overflow */
          if (!draw->so.targets[ob]) {
@@ -163,7 +166,7 @@ static void so_emit_prim(struct pt_so_emit *so,
    for (i = 0; i < num_vertices; ++i) {
       const float (*input)[4];
       const float *pre_clip_pos = NULL;
-      int ob;
+      unsigned  ob;
 
       input = (const float (*)[4])(
          (const char *)input_ptr + (indices[i] * input_vertex_stride));
@@ -176,28 +179,46 @@ static void so_emit_prim(struct pt_so_emit *so,
          unsigned idx = state->output[slot].register_index;
          unsigned start_comp = state->output[slot].start_component;
          unsigned num_comps = state->output[slot].num_components;
+         unsigned stream = state->output[slot].stream;
 
+         if (stream != so->stream)
+            continue;
          ob = state->output[slot].output_buffer;
          buffer_written[ob] = TRUE;
 
          buffer = (float *)((char *)draw->so.targets[ob]->mapping +
                             draw->so.targets[ob]->target.buffer_offset +
-                            draw->so.targets[ob]->internal_offset) + state->output[slot].dst_offset;
+                            draw->so.targets[ob]->internal_offset) +
+            state->output[slot].dst_offset;
          
-         if (idx == so->pos_idx && pcp_ptr)
-            memcpy(buffer, &pre_clip_pos[start_comp], num_comps * sizeof(float));
+         if (idx == so->pos_idx && pcp_ptr && so->stream == 0)
+            memcpy(buffer, &pre_clip_pos[start_comp],
+                   num_comps * sizeof(float));
          else
-            memcpy(buffer, &input[idx][start_comp], num_comps * sizeof(float));
+            memcpy(buffer, &input[idx][start_comp],
+                   num_comps * sizeof(float));
+#if 0
+         {
+            int j;
+            debug_printf("VERT[%d], stream = %d, offset = %d, slot[%d] sc = %d, num_c = %d, idx = %d = [",
+                         i, stream,
+                         draw->so.targets[ob]->internal_offset,
+                         slot, start_comp, num_comps, idx);
+            for (j = 0; j < num_comps; ++j) {
+               unsigned *ubuffer = (unsigned*)buffer;
+               debug_printf("%d (0x%x), ", ubuffer[j], ubuffer[j]);
+            }
+            debug_printf("]\n");
+         }
+#endif
       }
       for (ob = 0; ob < draw->so.num_targets; ++ob) {
          struct draw_so_target *target = draw->so.targets[ob];
          if (target && buffer_written[ob]) {
             target->internal_offset += state->stride[ob] * sizeof(float);
-            target->emitted_vertices += 1;
          }
       }
    }
-   so->emitted_vertices += num_vertices;
    ++so->emitted_primitives;
 }
 
@@ -244,12 +265,13 @@ static void so_tri(struct pt_so_emit *so, int i0, int i1, int i2)
 
 
 void draw_pt_so_emit( struct pt_so_emit *emit,
+                      int num_vertex_streams,
                       const struct draw_vertex_info *input_verts,
                       const struct draw_prim_info *input_prims )
 {
    struct draw_context *draw = emit->draw;
    struct vbuf_render *render = draw->render;
-   unsigned start, i;
+   unsigned start, i, stream;
 
    if (!emit->has_so)
       return;
@@ -257,36 +279,36 @@ void draw_pt_so_emit( struct pt_so_emit *emit,
    if (!draw->so.num_targets)
       return;
 
-   emit->emitted_vertices = 0;
-   emit->emitted_primitives = 0;
-   emit->generated_primitives = 0;
-   emit->input_vertex_stride = input_verts->stride;
-   if (emit->use_pre_clip_pos)
-      emit->pre_clip_pos = input_verts->verts->pre_clip_pos;
-
-   emit->inputs = (const float (*)[4])input_verts->verts->data;
-
    /* XXX: need to flush to get prim_vbuf.c to release its allocation??*/
    draw_do_flush( draw, DRAW_FLUSH_BACKEND );
 
-   for (start = i = 0; i < input_prims->primitive_count;
-        start += input_prims->primitive_lengths[i], i++)
-   {
-      unsigned count = input_prims->primitive_lengths[i];
-
-      if (input_prims->linear) {
-         so_run_linear(emit, input_prims, input_verts,
-                       start, count);
-      } else {
-         so_run_elts(emit, input_prims, input_verts,
-                     start, count);
+   for (stream = 0; stream < num_vertex_streams; stream++) {
+      emit->emitted_primitives = 0;
+      emit->generated_primitives = 0;
+      if (emit->use_pre_clip_pos)
+         emit->pre_clip_pos = input_verts[stream].verts->clip_pos;
+
+      emit->input_vertex_stride = input_verts[stream].stride;
+      emit->inputs = (const float (*)[4])input_verts[stream].verts->data;
+      emit->stream = stream;
+      for (start = i = 0; i < input_prims[stream].primitive_count;
+           start += input_prims[stream].primitive_lengths[i], i++)
+      {
+         unsigned count = input_prims[stream].primitive_lengths[i];
+
+         if (input_prims->linear) {
+            so_run_linear(emit, &input_prims[stream], &input_verts[stream],
+                          start, count);
+         } else {
+            so_run_elts(emit, &input_prims[stream], &input_verts[stream],
+                        start, count);
+         }
       }
+      render->set_stream_output_info(render,
+                                     stream,
+                                     emit->emitted_primitives,
+                                     emit->generated_primitives);
    }
-
-   render->set_stream_output_info(render,
-                                  emit->emitted_primitives,
-                                  emit->emitted_vertices,
-                                  emit->generated_primitives);
 }