src/gallium/drivers/nvc0/nvc0_push.c

   1
   2 #include "pipe/p_context.h"
   3 #include "pipe/p_state.h"
   4 #include "util/u_inlines.h"
   5 #include "util/u_format.h"
   6 #include "translate/translate.h"
   7
   8 #include "nvc0_context.h"
   9 #include "nvc0_resource.h"
  10
  11 #include "nvc0_3d.xml.h"
  12
  13 struct push_context {
  14    struct nouveau_channel *chan;
  15
  16    void *idxbuf;
  17
  18    float edgeflag;
  19    int edgeflag_attr;
  20
  21    uint32_t vertex_words;
  22    uint32_t packet_vertex_limit;
  23
  24    struct translate *translate;
  25
  26    boolean primitive_restart;
  27    uint32_t prim;
  28    uint32_t restart_index;
  29 };
  30
  31 static INLINE unsigned
  32 prim_restart_search_i08(uint8_t *elts, unsigned push, uint8_t index)
  33 {
  34    unsigned i;
  35    for (i = 0; i < push; ++i)
  36       if (elts[i] == index)
  37          break;
  38    return i;
  39 }
  40
  41 static INLINE unsigned
  42 prim_restart_search_i16(uint16_t *elts, unsigned push, uint16_t index)
  43 {
  44    unsigned i;
  45    for (i = 0; i < push; ++i)
  46       if (elts[i] == index)
  47          break;
  48    return i;
  49 }
  50
  51 static INLINE unsigned
  52 prim_restart_search_i32(uint32_t *elts, unsigned push, uint32_t index)
  53 {
  54    unsigned i;
  55    for (i = 0; i < push; ++i)
  56       if (elts[i] == index)
  57          break;
  58    return i;
  59 }
  60
  61 static void
  62 emit_vertices_i08(struct push_context *ctx, unsigned start, unsigned count)
  63 {
  64    uint8_t *elts = (uint8_t *)ctx->idxbuf + start;
  65
  66    while (count) {
  67       unsigned push = MIN2(count, ctx->packet_vertex_limit);
  68       unsigned size, nr;
  69
  70       nr = push;
  71       if (ctx->primitive_restart)
  72          nr = prim_restart_search_i08(elts, push, ctx->restart_index);
  73
  74       size = ctx->vertex_words * nr;
  75
  76       BEGIN_RING_NI(ctx->chan, RING_3D(VERTEX_DATA), size);
  77
  78       ctx->translate->run_elts8(ctx->translate, elts, nr, 0, ctx->chan->cur);
  79
  80       ctx->chan->cur += size;
  81       count -= nr;
  82       elts += nr;
  83
  84       if (nr != push) {
  85          count--;
  86          elts++;
  87          BEGIN_RING(ctx->chan, RING_3D(VERTEX_END_GL), 2);
  88          OUT_RING  (ctx->chan, 0);
  89          OUT_RING  (ctx->chan, ctx->prim);
  90       }
  91    }
  92 }
  93
  94 static void
  95 emit_vertices_i16(struct push_context *ctx, unsigned start, unsigned count)
  96 {
  97    uint16_t *elts = (uint16_t *)ctx->idxbuf + start;
  98
  99    while (count) {
 100       unsigned push = MIN2(count, ctx->packet_vertex_limit);
 101       unsigned size, nr;
 102
 103       nr = push;
 104       if (ctx->primitive_restart)
 105          nr = prim_restart_search_i16(elts, push, ctx->restart_index);
 106
 107       size = ctx->vertex_words * nr;
 108
 109       BEGIN_RING_NI(ctx->chan, RING_3D(VERTEX_DATA), size);
 110
 111       ctx->translate->run_elts16(ctx->translate, elts, nr, 0, ctx->chan->cur);
 112
 113       ctx->chan->cur += size;
 114       count -= nr;
 115       elts += nr;
 116
 117       if (nr != push) {
 118          count--;
 119          elts++;
 120          BEGIN_RING(ctx->chan, RING_3D(VERTEX_END_GL), 2);
 121          OUT_RING  (ctx->chan, 0);
 122          OUT_RING  (ctx->chan, ctx->prim);
 123       }
 124    }
 125 }
 126
 127 static void
 128 emit_vertices_i32(struct push_context *ctx, unsigned start, unsigned count)
 129 {
 130    uint32_t *elts = (uint32_t *)ctx->idxbuf + start;
 131
 132    while (count) {
 133       unsigned push = MIN2(count, ctx->packet_vertex_limit);
 134       unsigned size, nr;
 135
 136       nr = push;
 137       if (ctx->primitive_restart)
 138          nr = prim_restart_search_i32(elts, push, ctx->restart_index);
 139
 140       size = ctx->vertex_words * nr;
 141
 142       BEGIN_RING_NI(ctx->chan, RING_3D(VERTEX_DATA), size);
 143
 144       ctx->translate->run_elts(ctx->translate, elts, nr, 0, ctx->chan->cur);
 145
 146       ctx->chan->cur += size;
 147       count -= nr;
 148       elts += nr;
 149
 150       if (nr != push) {
 151          count--;
 152          elts++;
 153          BEGIN_RING(ctx->chan, RING_3D(VERTEX_END_GL), 2);
 154          OUT_RING  (ctx->chan, 0);
 155          OUT_RING  (ctx->chan, ctx->prim);
 156       }
 157    }
 158 }
 159
 160 static void
 161 emit_vertices_seq(struct push_context *ctx, unsigned start, unsigned count)
 162 {
 163    while (count) {
 164       unsigned push = MIN2(count, ctx->packet_vertex_limit);
 165       unsigned size = ctx->vertex_words * push;
 166
 167       BEGIN_RING_NI(ctx->chan, RING_3D(VERTEX_DATA), size);
 168
 169       ctx->translate->run(ctx->translate, start, push, 0, ctx->chan->cur);
 170       ctx->chan->cur += size;
 171       count -= push;
 172       start += push;
 173    }
 174 }
 175
 176
 177 #define NVC0_PRIM_GL_CASE(n) \
 178    case PIPE_PRIM_##n: return NVC0_3D_VERTEX_BEGIN_GL_PRIMITIVE_##n
 179
 180 static INLINE unsigned
 181 nvc0_prim_gl(unsigned prim)
 182 {
 183    switch (prim) {
 184    NVC0_PRIM_GL_CASE(POINTS);
 185    NVC0_PRIM_GL_CASE(LINES);
 186    NVC0_PRIM_GL_CASE(LINE_LOOP);
 187    NVC0_PRIM_GL_CASE(LINE_STRIP);
 188    NVC0_PRIM_GL_CASE(TRIANGLES);
 189    NVC0_PRIM_GL_CASE(TRIANGLE_STRIP);
 190    NVC0_PRIM_GL_CASE(TRIANGLE_FAN);
 191    NVC0_PRIM_GL_CASE(QUADS);
 192    NVC0_PRIM_GL_CASE(QUAD_STRIP);
 193    NVC0_PRIM_GL_CASE(POLYGON);
 194    NVC0_PRIM_GL_CASE(LINES_ADJACENCY);
 195    NVC0_PRIM_GL_CASE(LINE_STRIP_ADJACENCY);
 196    NVC0_PRIM_GL_CASE(TRIANGLES_ADJACENCY);
 197    NVC0_PRIM_GL_CASE(TRIANGLE_STRIP_ADJACENCY);
 198    /*
 199    NVC0_PRIM_GL_CASE(PATCHES); */
 200    default:
 201       return NVC0_3D_VERTEX_BEGIN_GL_PRIMITIVE_POINTS;
 202       break;
 203    }
 204 }
 205
 206 void
 207 nvc0_push_vbo(struct nvc0_context *nvc0, const struct pipe_draw_info *info)
 208 {
 209    struct push_context ctx;
 210    unsigned i, index_size;
 211    unsigned inst = info->instance_count;
 212
 213    ctx.chan = nvc0->screen->base.channel;
 214    ctx.translate = nvc0->vertex->translate;
 215    ctx.packet_vertex_limit = nvc0->vertex->vtx_per_packet_max;
 216    ctx.vertex_words = nvc0->vertex->vtx_size;
 217
 218    for (i = 0; i < nvc0->num_vtxbufs; ++i) {
 219       uint8_t *data;
 220       struct pipe_vertex_buffer *vb = &nvc0->vtxbuf[i];
 221       struct nvc0_resource *res = nvc0_resource(vb->buffer);
 222
 223       data = nvc0_resource_map_offset(nvc0, res,
 224                                       vb->buffer_offset, NOUVEAU_BO_RD);
 225       if (info->indexed)
 226          data += info->index_bias * vb->stride;
 227
 228       ctx.translate->set_buffer(ctx.translate, i, data, vb->stride, ~0);
 229    }
 230
 231    if (info->indexed) {
 232       ctx.idxbuf = nvc0_resource_map_offset(nvc0,
 233                                             nvc0_resource(nvc0->idxbuf.buffer),
 234                                             nvc0->idxbuf.offset, NOUVEAU_BO_RD);
 235       if (!ctx.idxbuf)
 236          return;
 237       index_size = nvc0->idxbuf.index_size;
 238       ctx.primitive_restart = info->primitive_restart;
 239       ctx.restart_index = info->restart_index;
 240    } else {
 241       ctx.idxbuf = NULL;
 242       index_size = 0;
 243       ctx.primitive_restart = FALSE;
 244       ctx.restart_index = 0;
 245    }
 246
 247    ctx.prim = nvc0_prim_gl(info->mode);
 248
 249    while (inst--) {
 250       BEGIN_RING(ctx.chan, RING_3D(VERTEX_BEGIN_GL), 1);
 251       OUT_RING  (ctx.chan, ctx.prim);
 252       switch (index_size) {
 253       case 0:
 254          emit_vertices_seq(&ctx, info->start, info->count);
 255          break;
 256       case 1:
 257          emit_vertices_i08(&ctx, info->start, info->count);
 258          break;
 259       case 2:
 260          emit_vertices_i16(&ctx, info->start, info->count);
 261          break;
 262       case 4:
 263          emit_vertices_i32(&ctx, info->start, info->count);
 264          break;
 265       default:
 266          assert(0);
 267          break;
 268       }
 269       IMMED_RING(ctx.chan, RING_3D(VERTEX_END_GL), 0);
 270
 271       ctx.prim |= NVC0_3D_VERTEX_BEGIN_GL_INSTANCE_NEXT;
 272    }
 273
 274    if (info->indexed)
 275       nvc0_resource_unmap(nvc0_resource(nvc0->idxbuf.buffer));
 276
 277    for (i = 0; i < nvc0->num_vtxbufs; ++i)
 278       nvc0_resource_unmap(nvc0_resource(nvc0->vtxbuf[i].buffer));
 279 }