draw: Pass-through pipe_buffer::max_index to translate.

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

diff --git a/src/gallium/auxiliary/draw/draw_pt_emit.c b/src/gallium/auxiliary/draw/draw_pt_emit.c
index d520b05869b6f7ccd8de53d998615c70ade3fc09..ad48fa39a4f0ad751058b9b91f07e50bc07cb080 100644 (file)
--- a/src/gallium/auxiliary/draw/draw_pt_emit.c
+++ b/src/gallium/auxiliary/draw/draw_pt_emit.c
@@ -86,45 +86,22 @@ void draw_pt_emit_prepare( struct pt_emit *emit,
       unsigned output_format;
       unsigned src_offset = (vinfo->attrib[i].src_index * 4 * sizeof(float) );
 
+      output_format = draw_translate_vinfo_format(vinfo->attrib[i].emit);
+      emit_sz = draw_translate_vinfo_size(vinfo->attrib[i].emit);
 
-         
-      switch (vinfo->attrib[i].emit) {
-      case EMIT_4F:
-        output_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
-        emit_sz = 4 * sizeof(float);
-        break;
-      case EMIT_3F:
-        output_format = PIPE_FORMAT_R32G32B32_FLOAT;
-        emit_sz = 3 * sizeof(float);
-        break;
-      case EMIT_2F:
-        output_format = PIPE_FORMAT_R32G32_FLOAT;
-        emit_sz = 2 * sizeof(float);
-        break;
-      case EMIT_1F:
-        output_format = PIPE_FORMAT_R32_FLOAT;
-        emit_sz = 1 * sizeof(float);
-        break;
-      case EMIT_1F_PSIZE:
-        output_format = PIPE_FORMAT_R32_FLOAT;
-        emit_sz = 1 * sizeof(float);
+      /* doesn't handle EMIT_OMIT */
+      assert(emit_sz != 0);
+
+      if (vinfo->attrib[i].emit == EMIT_1F_PSIZE) {
         src_buffer = 1;
         src_offset = 0;
-        break;
-      case EMIT_4UB:
-        output_format = PIPE_FORMAT_B8G8R8A8_UNORM;
-        emit_sz = 4 * sizeof(ubyte);
-         break;
-      default:
-        assert(0);
-        output_format = PIPE_FORMAT_NONE;
-        emit_sz = 0;
-        break;
       }
-      
+
+      hw_key.element[i].type = TRANSLATE_ELEMENT_NORMAL;
       hw_key.element[i].input_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
       hw_key.element[i].input_buffer = src_buffer;
       hw_key.element[i].input_offset = src_offset;
+      hw_key.element[i].instance_divisor = 0;
       hw_key.element[i].output_format = output_format;
       hw_key.element[i].output_offset = dst_offset;
 
@@ -165,6 +142,14 @@ void draw_pt_emit( struct pt_emit *emit,
     */
    draw_do_flush( draw, DRAW_FLUSH_BACKEND );
 
+   if (vertex_count == 0)
+      return;
+
+   if (vertex_count >= UNDEFINED_VERTEX_ID) {
+      assert(0);
+      return;
+   }
+
    /* XXX: and work out some way to coordinate the render primitive
     * between vbuf.c and here...
     */
@@ -173,9 +158,11 @@ void draw_pt_emit( struct pt_emit *emit,
       return;
    }
 
-   hw_verts = render->allocate_vertices(render,
-                                       (ushort)translate->key.output_stride,
-                                       (ushort)vertex_count);
+   render->allocate_vertices(render,
+                             (ushort)translate->key.output_stride,
+                             (ushort)vertex_count);
+
+   hw_verts = render->map_vertices( render );
    if (!hw_verts) {
       assert(0);
       return;
@@ -184,34 +171,36 @@ void draw_pt_emit( struct pt_emit *emit,
    translate->set_buffer(translate, 
                         0, 
                         vertex_data,
-                        stride );
+                        stride,
+                        ~0);
 
    translate->set_buffer(translate, 
                         1, 
                         &draw->rasterizer->point_size,
-                        0);
+                        0,
+                        ~0);
 
    translate->run( translate,
                   0, 
                   vertex_count,
+                   draw->instance_id,
                   hw_verts );
 
+   render->unmap_vertices( render, 
+                           0, 
+                           vertex_count - 1 );
+
    render->draw(render,
                elts,
                count);
 
-   render->release_vertices(render,
-                           hw_verts,
-                           translate->key.output_stride,
-                           vertex_count);
+   render->release_vertices(render);
 }
 
 
 void draw_pt_emit_linear(struct pt_emit *emit,
                          const float (*vertex_data)[4],
-                         unsigned vertex_count,
                          unsigned stride,
-                         unsigned start,
                          unsigned count)
 {
    struct draw_context *draw = emit->draw;
@@ -226,37 +215,40 @@ void draw_pt_emit_linear(struct pt_emit *emit,
     */
    draw_do_flush( draw, DRAW_FLUSH_BACKEND );
 
+   if (count >= UNDEFINED_VERTEX_ID)
+      goto fail;
+
    /* XXX: and work out some way to coordinate the render primitive
     * between vbuf.c and here...
     */
-   if (!draw->render->set_primitive(draw->render, emit->prim)) {
-      assert(0);
-      return;
-   }
+   if (!draw->render->set_primitive(draw->render, emit->prim)) 
+      goto fail;
 
-   hw_verts = render->allocate_vertices(render,
-                                       (ushort)translate->key.output_stride,
-                                       (ushort)count);
-   if (!hw_verts) {
-      assert(0);
-      return;
-   }
+   if (!render->allocate_vertices(render,
+                                  (ushort)translate->key.output_stride,
+                                  (ushort)count))
+      goto fail;
+
+   hw_verts = render->map_vertices( render );
+   if (!hw_verts)
+      goto fail;
 
    translate->set_buffer(translate, 0,
-                        vertex_data, stride);
+                        vertex_data, stride, count - 1);
 
    translate->set_buffer(translate, 1,
                         &draw->rasterizer->point_size,
-                        0);
+                        0, ~0);
 
    translate->run(translate,
                   0,
-                  vertex_count,
+                  count,
+                  draw->instance_id,
                   hw_verts);
 
    if (0) {
       unsigned i;
-      for (i = 0; i < vertex_count; i++) {
+      for (i = 0; i < count; i++) {
          debug_printf("\n\n%s vertex %d:\n", __FUNCTION__, i);
          draw_dump_emitted_vertex( emit->vinfo, 
                                    (const uint8_t *)hw_verts + 
@@ -264,13 +256,17 @@ void draw_pt_emit_linear(struct pt_emit *emit,
       }
    }
 
+   render->unmap_vertices( render, 0, count - 1 );
+
+   render->draw_arrays(render, 0, count);
+
+   render->release_vertices(render);
 
-   render->draw_arrays(render, start, count);
+   return;
 
-   render->release_vertices(render,
-                           hw_verts,
-                           translate->key.output_stride,
-                           vertex_count);
+fail:
+   assert(0);
+   return;
 }
 
 struct pt_emit *draw_pt_emit_create( struct draw_context *draw )