Subversion Repositories Kolibri OS

#include "pipe/p_state.h"

#include "util/u_inlines.h"

#include "util/u_format.h"

#include "translate/translate.h"

#include "nv50_resource.h"

   struct nouveau_pushbuf *push;

   int edgeflag_attr;

   uint32_t packet_vertex_limit;

   uint32_t prim;

   uint32_t restart_index;

   uint32_t instance_id;

};

prim_restart_search_i08(uint8_t *elts, unsigned push, uint8_t index)

{

   unsigned i;

   for (i = 0; i < push; ++i)

      if (elts[i] == index)

         break;

   return i;

}

prim_restart_search_i16(uint16_t *elts, unsigned push, uint16_t index)

{

   unsigned i;

   for (i = 0; i < push; ++i)

      if (elts[i] == index)

         break;

   return i;

}

prim_restart_search_i32(uint32_t *elts, unsigned push, uint32_t index)

{

   unsigned i;

   for (i = 0; i < push; ++i)

      if (elts[i] == index)

         break;

   return i;

}

emit_vertices_i08(struct push_context *ctx, unsigned start, unsigned count)

{

   uint8_t *elts = (uint8_t *)ctx->idxbuf + start;

      unsigned push = MIN2(count, ctx->packet_vertex_limit);

      unsigned size, nr;

      if (ctx->primitive_restart)

         nr = prim_restart_search_i08(elts, push, ctx->restart_index);

                                ctx->push->cur);

      count -= nr;

      elts += nr;

         count--;

         elts++;

         BEGIN_NV04(ctx->push, NV50_3D(VB_ELEMENT_U32), 1);

         PUSH_DATA (ctx->push, ctx->restart_index);

      }

   }

}

emit_vertices_i16(struct push_context *ctx, unsigned start, unsigned count)

{

   uint16_t *elts = (uint16_t *)ctx->idxbuf + start;

      unsigned push = MIN2(count, ctx->packet_vertex_limit);

      unsigned size, nr;

      if (ctx->primitive_restart)

         nr = prim_restart_search_i16(elts, push, ctx->restart_index);

                                 ctx->push->cur);

      count -= nr;

      elts += nr;

         count--;

         elts++;

         BEGIN_NV04(ctx->push, NV50_3D(VB_ELEMENT_U32), 1);

         PUSH_DATA (ctx->push, ctx->restart_index);

      }

   }

}

emit_vertices_i32(struct push_context *ctx, unsigned start, unsigned count)

{

   uint32_t *elts = (uint32_t *)ctx->idxbuf + start;

      unsigned push = MIN2(count, ctx->packet_vertex_limit);

      unsigned size, nr;

      if (ctx->primitive_restart)

         nr = prim_restart_search_i32(elts, push, ctx->restart_index);

                               ctx->push->cur);

      count -= nr;

      elts += nr;

         count--;

         elts++;

         BEGIN_NV04(ctx->push, NV50_3D(VB_ELEMENT_U32), 1);

         PUSH_DATA (ctx->push, ctx->restart_index);

      }

   }

}

emit_vertices_seq(struct push_context *ctx, unsigned start, unsigned count)

{

   while (count) {

      unsigned push = MIN2(count, ctx->packet_vertex_limit);

      unsigned size = ctx->vertex_words * push;

                          ctx->push->cur);

      ctx->push->cur += size;

      count -= push;

      start += push;

   }

}

   case PIPE_PRIM_##n: return NV50_3D_VERTEX_BEGIN_GL_PRIMITIVE_##n

nv50_prim_gl(unsigned prim)

{

   switch (prim) {

   NV50_PRIM_GL_CASE(POINTS);

   NV50_PRIM_GL_CASE(LINES);

   NV50_PRIM_GL_CASE(LINE_LOOP);

   NV50_PRIM_GL_CASE(LINE_STRIP);

   NV50_PRIM_GL_CASE(TRIANGLES);

   NV50_PRIM_GL_CASE(TRIANGLE_STRIP);

   NV50_PRIM_GL_CASE(TRIANGLE_FAN);

   NV50_PRIM_GL_CASE(QUADS);

   NV50_PRIM_GL_CASE(QUAD_STRIP);

   NV50_PRIM_GL_CASE(POLYGON);

   NV50_PRIM_GL_CASE(LINES_ADJACENCY);

   NV50_PRIM_GL_CASE(LINE_STRIP_ADJACENCY);

   NV50_PRIM_GL_CASE(TRIANGLES_ADJACENCY);

   NV50_PRIM_GL_CASE(TRIANGLE_STRIP_ADJACENCY);

   /*

   NV50_PRIM_GL_CASE(PATCHES); */

   default:

      return NV50_3D_VERTEX_BEGIN_GL_PRIMITIVE_POINTS;

      break;

   }

}

nv50_push_vbo(struct nv50_context *nv50, const struct pipe_draw_info *info)

{

   struct push_context ctx;

   unsigned i, index_size;

   unsigned inst_count = info->instance_count;

   unsigned vert_count = info->count;

   boolean apply_bias = info->indexed && info->index_bias;

   ctx.translate = nv50->vertex->translate;

   ctx.packet_vertex_limit = nv50->vertex->packet_vertex_limit;

   ctx.vertex_words = nv50->vertex->vertex_size;

      const struct pipe_vertex_buffer *vb = &nv50->vtxbuf[i];

      const uint8_t *data;

         data = nouveau_resource_map_offset(&nv50->base,

            nv04_resource(vb->buffer), vb->buffer_offset, NOUVEAU_BO_RD);

      else

         data = vb->user_buffer;

         data += (ptrdiff_t)info->index_bias * vb->stride;

   }

      if (nv50->idxbuf.buffer) {

         ctx.idxbuf = nouveau_resource_map_offset(&nv50->base,

            nv04_resource(nv50->idxbuf.buffer), nv50->idxbuf.offset,

            NOUVEAU_BO_RD);

      } else {

         ctx.idxbuf = nv50->idxbuf.user_buffer;

      }

      if (!ctx.idxbuf)

         return;

      index_size = nv50->idxbuf.index_size;

      ctx.primitive_restart = info->primitive_restart;

      ctx.restart_index = info->restart_index;

   } else {

      if (unlikely(info->count_from_stream_output)) {

         struct pipe_context *pipe = &nv50->base.pipe;

         struct nv50_so_target *targ;

         targ = nv50_so_target(info->count_from_stream_output);

         if (!targ->pq) {

            NOUVEAU_ERR("draw_stream_output not supported on pre-NVA0 cards\n");

            return;

         }

         pipe->get_query_result(pipe, targ->pq, TRUE, (void *)&vert_count);

         vert_count /= targ->stride;

      }

      ctx.idxbuf = NULL;

      index_size = 0;

      ctx.primitive_restart = FALSE;

      ctx.restart_index = 0;

   }

   ctx.prim = nv50_prim_gl(info->mode);

      BEGIN_NV04(ctx.push, NV50_3D(PRIM_RESTART_ENABLE), 2);

      PUSH_DATA (ctx.push, 1);

      PUSH_DATA (ctx.push, info->restart_index);

   } else

   if (nv50->state.prim_restart) {

      BEGIN_NV04(ctx.push, NV50_3D(PRIM_RESTART_ENABLE), 1);

      PUSH_DATA (ctx.push, 0);

   }

   nv50->state.prim_restart = info->primitive_restart;

      BEGIN_NV04(ctx.push, NV50_3D(VERTEX_BEGIN_GL), 1);

      PUSH_DATA (ctx.push, ctx.prim);

      switch (index_size) {

      case 0:

         emit_vertices_seq(&ctx, info->start, vert_count);

         break;

      case 1:

         emit_vertices_i08(&ctx, info->start, vert_count);

         break;

      case 2:

         emit_vertices_i16(&ctx, info->start, vert_count);

         break;

      case 4:

         emit_vertices_i32(&ctx, info->start, vert_count);

         break;

      default:

         assert(0);

         break;

      }

      BEGIN_NV04(ctx.push, NV50_3D(VERTEX_END_GL), 1);

      PUSH_DATA (ctx.push, 0);

      ctx.prim |= NV50_3D_VERTEX_BEGIN_GL_INSTANCE_NEXT;

   }

}