Subversion Repositories Kolibri OS

#include "pipe/p_state.h"

#include "util/u_inlines.h"

#include "util/u_format.h"

#include "translate/translate.h"

#include "nvc0/nvc0_resource.h"

   struct nouveau_pushbuf *push;

   void *dest;

   const void *idxbuf;

   uint32_t restart_index;

   uint32_t instance_id;

   boolean need_vertex_id;

      boolean enabled;

      boolean value;

      unsigned stride;

      const uint8_t *data;

   } edgeflag;

};

                                        struct nvc0_context *,

                                        const struct pipe_draw_info *);

nvc0_push_context_init(struct nvc0_context *nvc0, struct push_context *ctx)

{

   ctx->push = nvc0->base.pushbuf;

   ctx->vertex_size = nvc0->vertex->size;

      nvc0->vertprog->vp.need_vertex_id && (nvc0->vertex->num_elements < 32);

   ctx->edgeflag.enabled = nvc0->vertprog->vp.edgeflag < PIPE_MAX_ATTRIBS;

   ctx->edgeflag.data = NULL;

   ctx->edgeflag.stride = 0;

}

nvc0_vertex_configure_translate(struct nvc0_context *nvc0, int32_t index_bias)

{

   struct translate *translate = nvc0->vertex->translate;

   unsigned i;

      const uint8_t *map;

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

         map = (const uint8_t *)vb->user_buffer;

      else

         map = nouveau_resource_map_offset(&nvc0->base,

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

         map += (intptr_t)index_bias * vb->stride;

   }

}

nvc0_push_map_idxbuf(struct push_context *ctx, struct nvc0_context *nvc0)

{

   if (nvc0->idxbuf.buffer) {

      struct nv04_resource *buf = nv04_resource(nvc0->idxbuf.buffer);

      ctx->idxbuf = nouveau_resource_map_offset(&nvc0->base,

         buf, nvc0->idxbuf.offset, NOUVEAU_BO_RD);

   } else {

      ctx->idxbuf = nvc0->idxbuf.user_buffer;

   }

}

nvc0_push_map_edgeflag(struct push_context *ctx, struct nvc0_context *nvc0,

                       int32_t index_bias)

{

   unsigned attr = nvc0->vertprog->vp.edgeflag;

   struct pipe_vertex_element *ve = &nvc0->vertex->element[attr].pipe;

   struct pipe_vertex_buffer *vb = &nvc0->vtxbuf[ve->vertex_buffer_index];

   struct nv04_resource *buf = nv04_resource(vb->buffer);

   if (buf) {

      unsigned offset = vb->buffer_offset + ve->src_offset;

      ctx->edgeflag.data = nouveau_resource_map_offset(&nvc0->base,

                           buf, offset, NOUVEAU_BO_RD);

   } else {

      ctx->edgeflag.data = (const uint8_t *)vb->user_buffer + ve->src_offset;

   }

      ctx->edgeflag.data += (intptr_t)index_bias * vb->stride;

}

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

{

   unsigned i;

   for (i = 0; i < push && elts[i] != index; ++i);

   return i;

}

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

{

   unsigned i;

   for (i = 0; i < push && elts[i] != index; ++i);

   return i;

}

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

{

   unsigned i;

   for (i = 0; i < push && elts[i] != index; ++i);

   return i;

}

ef_value(const struct push_context *ctx, uint32_t index)

{

   float *pf = (float *)&ctx->edgeflag.data[index * ctx->edgeflag.stride];

   return *pf ? TRUE : FALSE;

}

ef_toggle(struct push_context *ctx)

{

   ctx->edgeflag.value = !ctx->edgeflag.value;

   return ctx->edgeflag.value;

}

ef_toggle_search_i08(struct push_context *ctx, const uint8_t *elts, unsigned n)

{

   unsigned i;

   for (i = 0; i < n && ef_value(ctx, elts[i]) == ctx->edgeflag.value; ++i);

   return i;

}

ef_toggle_search_i16(struct push_context *ctx, const uint16_t *elts, unsigned n)

{

   unsigned i;

   for (i = 0; i < n && ef_value(ctx, elts[i]) == ctx->edgeflag.value; ++i);

   return i;

}

ef_toggle_search_i32(struct push_context *ctx, const uint32_t *elts, unsigned n)

{

   unsigned i;

   for (i = 0; i < n && ef_value(ctx, elts[i]) == ctx->edgeflag.value; ++i);

   return i;

}

ef_toggle_search_seq(struct push_context *ctx, unsigned start, unsigned n)

{

   unsigned i;

   for (i = 0; i < n && ef_value(ctx, start++) == ctx->edgeflag.value; ++i);

   return i;

}

nvc0_push_setup_vertex_array(struct nvc0_context *nvc0, const unsigned count)

{

   struct nouveau_pushbuf *push = nvc0->base.pushbuf;

   struct nouveau_bo *bo;

   uint64_t va;

   const unsigned size = count * nvc0->vertex->size;

   PUSH_DATAh(push, va);

   PUSH_DATA (push, va);

   BEGIN_NVC0(push, NVC0_3D(VERTEX_ARRAY_LIMIT_HIGH(0)), 2);

   PUSH_DATAh(push, va + size - 1);

   PUSH_DATA (push, va + size - 1);

                bo);

   nouveau_pushbuf_validate(push);

}

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

{

   struct nouveau_pushbuf *push = ctx->push;

   struct translate *translate = ctx->translate;

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

   unsigned pos = 0;

      unsigned nR = count;

         nR = prim_restart_search_i08(elts, nR, ctx->restart_index);

      count -= nR;

      ctx->dest += nR * ctx->vertex_size;

         unsigned nE = nR;

            nE = ef_toggle_search_i08(ctx, elts, nR);

         if (likely(nE >= 2)) {

            BEGIN_NVC0(push, NVC0_3D(VERTEX_BUFFER_FIRST), 2);

            PUSH_DATA (push, pos);

            PUSH_DATA (push, nE);

         } else

         if (nE) {

            if (pos <= 0xff) {

               IMMED_NVC0(push, NVC0_3D(VB_ELEMENT_U32), pos);

            } else {

               BEGIN_NVC0(push, NVC0_3D(VB_ELEMENT_U32), 1);

               PUSH_DATA (push, pos);

            }

         }

         if (unlikely(nE != nR))

            IMMED_NVC0(push, NVC0_3D(EDGEFLAG), ef_toggle(ctx));

         elts += nE;

         nR -= nE;

      }

      if (count) {

         BEGIN_NVC0(push, NVC0_3D(VB_ELEMENT_U32), 1);

         PUSH_DATA (push, 0xffffffff);

         ++elts;

         ctx->dest += ctx->vertex_size;

         ++pos;

         --count;

      }

   } while (count);

}

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

{

   struct nouveau_pushbuf *push = ctx->push;

   struct translate *translate = ctx->translate;

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

   unsigned pos = 0;

      unsigned nR = count;

         nR = prim_restart_search_i16(elts, nR, ctx->restart_index);

      count -= nR;

      ctx->dest += nR * ctx->vertex_size;

         unsigned nE = nR;

            nE = ef_toggle_search_i16(ctx, elts, nR);

         if (likely(nE >= 2)) {

            BEGIN_NVC0(push, NVC0_3D(VERTEX_BUFFER_FIRST), 2);

            PUSH_DATA (push, pos);

            PUSH_DATA (push, nE);

         } else

         if (nE) {

            if (pos <= 0xff) {

               IMMED_NVC0(push, NVC0_3D(VB_ELEMENT_U32), pos);

            } else {

               BEGIN_NVC0(push, NVC0_3D(VB_ELEMENT_U32), 1);

               PUSH_DATA (push, pos);

            }

         }

         if (unlikely(nE != nR))

            IMMED_NVC0(push, NVC0_3D(EDGEFLAG), ef_toggle(ctx));

         elts += nE;

         nR -= nE;

      }

      if (count) {

         BEGIN_NVC0(push, NVC0_3D(VB_ELEMENT_U32), 1);

         PUSH_DATA (push, 0xffffffff);

         ++elts;

         ctx->dest += ctx->vertex_size;

         ++pos;

         --count;

      }

   } while (count);

}

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

{

   struct nouveau_pushbuf *push = ctx->push;

   struct translate *translate = ctx->translate;

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

   unsigned pos = 0;

      unsigned nR = count;

         nR = prim_restart_search_i32(elts, nR, ctx->restart_index);

      count -= nR;

      ctx->dest += nR * ctx->vertex_size;

         unsigned nE = nR;

            nE = ef_toggle_search_i32(ctx, elts, nR);

         if (likely(nE >= 2)) {

            BEGIN_NVC0(push, NVC0_3D(VERTEX_BUFFER_FIRST), 2);

            PUSH_DATA (push, pos);

            PUSH_DATA (push, nE);

         } else

         if (nE) {

            if (pos <= 0xff) {

               IMMED_NVC0(push, NVC0_3D(VB_ELEMENT_U32), pos);

            } else {

               BEGIN_NVC0(push, NVC0_3D(VB_ELEMENT_U32), 1);

               PUSH_DATA (push, pos);

            }

         }

         if (unlikely(nE != nR))

            IMMED_NVC0(push, NVC0_3D(EDGEFLAG), ef_toggle(ctx));

         elts += nE;

         nR -= nE;

      }

      if (count) {

         BEGIN_NVC0(push, NVC0_3D(VB_ELEMENT_U32), 1);

         PUSH_DATA (push, 0xffffffff);

         ++elts;

         ctx->dest += ctx->vertex_size;

         ++pos;

         --count;

      }

   } while (count);

}

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

{

   struct nouveau_pushbuf *push = ctx->push;

   struct translate *translate = ctx->translate;

   unsigned pos = 0;

    *  maybe we should avoid that ?

    */

   translate->run(translate, start, count, 0, ctx->instance_id, ctx->dest);

   do {

      unsigned nr = count;

         nr = ef_toggle_search_seq(ctx, start + pos, nr);

      if (likely(nr)) {

         BEGIN_NVC0(push, NVC0_3D(VERTEX_BUFFER_FIRST), 2);

         PUSH_DATA (push, pos);

         PUSH_DATA (push, nr);

      }

      if (unlikely(nr != count))

         IMMED_NVC0(push, NVC0_3D(EDGEFLAG), ef_toggle(ctx));

      count -= nr;

   } while (count);

}

   case PIPE_PRIM_##n: return NVC0_3D_VERTEX_BEGIN_GL_PRIMITIVE_##n

nvc0_prim_gl(unsigned prim)

{

   switch (prim) {

   NVC0_PRIM_GL_CASE(POINTS);

   NVC0_PRIM_GL_CASE(LINES);

   NVC0_PRIM_GL_CASE(LINE_LOOP);

   NVC0_PRIM_GL_CASE(LINE_STRIP);

   NVC0_PRIM_GL_CASE(TRIANGLES);

   NVC0_PRIM_GL_CASE(TRIANGLE_STRIP);

   NVC0_PRIM_GL_CASE(TRIANGLE_FAN);

   NVC0_PRIM_GL_CASE(QUADS);

   NVC0_PRIM_GL_CASE(QUAD_STRIP);

   NVC0_PRIM_GL_CASE(POLYGON);

   NVC0_PRIM_GL_CASE(LINES_ADJACENCY);

   NVC0_PRIM_GL_CASE(LINE_STRIP_ADJACENCY);

   NVC0_PRIM_GL_CASE(TRIANGLES_ADJACENCY);

   NVC0_PRIM_GL_CASE(TRIANGLE_STRIP_ADJACENCY);

   /*

   NVC0_PRIM_GL_CASE(PATCHES); */

   default:

      return NVC0_3D_VERTEX_BEGIN_GL_PRIMITIVE_POINTS;

   }

}

nvc0_push_vbo(struct nvc0_context *nvc0, 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;

   unsigned prim;

      /* this is already taken care of by translate */

      IMMED_NVC0(ctx.push, NVC0_3D(VB_ELEMENT_BASE), 0);

      nvc0->state.index_bias = 0;

   }

      nvc0_push_map_edgeflag(&ctx, nvc0, info->index_bias);

   ctx.restart_index = info->restart_index;

      /* NOTE: I hope we won't ever need that last index (~0).

       * If we do, we have to disable primitive restart here always and

       * use END,BEGIN to restart. (XXX: would that affect PrimitiveID ?)

       * We could also deactive PRIM_RESTART_WITH_DRAW_ARRAYS temporarily,

       * and add manual restart to disp_vertices_seq.

       */

      BEGIN_NVC0(ctx.push, NVC0_3D(PRIM_RESTART_ENABLE), 2);

      PUSH_DATA (ctx.push, 1);

      PUSH_DATA (ctx.push, info->indexed ? 0xffffffff : info->restart_index);

   } else

   if (nvc0->state.prim_restart) {

      IMMED_NVC0(ctx.push, NVC0_3D(PRIM_RESTART_ENABLE), 0);

   }

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

      nvc0_push_map_idxbuf(&ctx, nvc0);

      index_size = nvc0->idxbuf.index_size;

   } else {

      if (unlikely(info->count_from_stream_output)) {

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

         struct nvc0_so_target *targ;

         targ = nvc0_so_target(info->count_from_stream_output);

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

         vert_count /= targ->stride;

      }

      ctx.idxbuf = NULL; /* shut up warnings */

      index_size = 0;

   }

   do {

      PUSH_SPACE(ctx.push, 9);

      if (unlikely(!ctx.dest))

         break;

         nvc0_push_upload_vertex_ids(&ctx, nvc0, info);

         IMMED_NVC0(ctx.push, NVC0_3D(VERTEX_ARRAY_FLUSH), 0);

      BEGIN_NVC0(ctx.push, NVC0_3D(VERTEX_BEGIN_GL), 1);

      PUSH_DATA (ctx.push, prim);

      switch (index_size) {

      case 1:

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

         break;

      case 2:

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

         break;

      case 4:

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

         break;

      default:

         assert(index_size == 0);

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

         break;

      }

      PUSH_SPACE(ctx.push, 1);

      IMMED_NVC0(ctx.push, NVC0_3D(VERTEX_END_GL), 0);

         prim |= NVC0_3D_VERTEX_BEGIN_GL_INSTANCE_NEXT;

         ++ctx.instance_id;

      }

      nouveau_bufctx_reset(nvc0->bufctx_3d, NVC0_BIND_VTX_TMP);

      nouveau_scratch_done(&nvc0->base);

   } while (inst_count);

      PUSH_SPACE(ctx.push, 1);

      IMMED_NVC0(ctx.push, NVC0_3D(EDGEFLAG), 1);

   }

      PUSH_SPACE(ctx.push, 4);

      IMMED_NVC0(ctx.push, NVC0_3D(VERTEX_ID_REPLACE), 0);

      BEGIN_NVC0(ctx.push, NVC0_3D(VERTEX_ATTRIB_FORMAT(1)), 1);

      PUSH_DATA (ctx.push,

                 NVC0_3D_VERTEX_ATTRIB_FORMAT_CONST |

                 NVC0_3D_VERTEX_ATTRIB_FORMAT_TYPE_FLOAT |

                 NVC0_3D_VERTEX_ATTRIB_FORMAT_SIZE_32);

      IMMED_NVC0(ctx.push, NVC0_3D(VERTEX_ARRAY_FETCH(1)), 0);

   }

      nouveau_resource_unmap(nv04_resource(nvc0->idxbuf.buffer));

   for (i = 0; i < nvc0->num_vtxbufs; ++i)

      nouveau_resource_unmap(nv04_resource(nvc0->vtxbuf[i].buffer));

}

copy_indices_u8(uint32_t *dst, const uint8_t *elts, uint32_t bias, unsigned n)

{

   unsigned i;

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

      dst[i] = elts[i] + bias;

}

copy_indices_u16(uint32_t *dst, const uint16_t *elts, uint32_t bias, unsigned n)

{

   unsigned i;

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

      dst[i] = elts[i] + bias;

}

copy_indices_u32(uint32_t *dst, const uint32_t *elts, uint32_t bias, unsigned n)

{

   unsigned i;

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

      dst[i] = elts[i] + bias;

}

nvc0_push_upload_vertex_ids(struct push_context *ctx,

                            struct nvc0_context *nvc0,

                            const struct pipe_draw_info *info)

   struct nouveau_pushbuf *push = ctx->push;

   struct nouveau_bo *bo;

   uint64_t va;

   uint32_t *data;

   uint32_t format;

   unsigned index_size = nvc0->idxbuf.index_size;

   unsigned i;

   unsigned a = nvc0->vertex->num_elements;

      index_size = 4;

   data = (uint32_t *)nouveau_scratch_get(&nvc0->base,

                                          info->count * index_size, &va, &bo);

                bo);

   nouveau_pushbuf_validate(push);

      if (!info->index_bias) {

         memcpy(data, ctx->idxbuf, info->count * index_size);

      } else {

         switch (nvc0->idxbuf.index_size) {

         case 1:

            copy_indices_u8(data, ctx->idxbuf, info->index_bias, info->count);

            break;

         case 2:

            copy_indices_u16(data, ctx->idxbuf, info->index_bias, info->count);

            break;

         default:

            copy_indices_u32(data, ctx->idxbuf, info->index_bias, info->count);

            break;

         }

      }

   } else {

      for (i = 0; i < info->count; ++i)

         data[i] = i + (info->start + info->index_bias);

   }

      NVC0_3D_VERTEX_ATTRIB_FORMAT_TYPE_UINT;

   case 1:

      format |= NVC0_3D_VERTEX_ATTRIB_FORMAT_SIZE_8;

      break;

   case 2:

      format |= NVC0_3D_VERTEX_ATTRIB_FORMAT_SIZE_16;

      break;

   default:

      format |= NVC0_3D_VERTEX_ATTRIB_FORMAT_SIZE_32;

      break;

   }

      nvc0->state.instance_elts &= ~2;

      IMMED_NVC0(push, NVC0_3D(VERTEX_ARRAY_PER_INSTANCE(1)), 0);

   }

   PUSH_DATA (push, format);

   PUSH_DATA (push, NVC0_3D_VERTEX_ARRAY_FETCH_ENABLE | index_size);

   PUSH_DATAh(push, va);

   PUSH_DATA (push, va);

   BEGIN_NVC0(push, NVC0_3D(VERTEX_ARRAY_LIMIT_HIGH(1)), 2);

   PUSH_DATAh(push, va + info->count * index_size - 1);

   PUSH_DATA (push, va + info->count * index_size - 1);

   (((0x80 + (a) * 0x10) / 4) << NVC0_3D_VERTEX_ID_REPLACE_SOURCE__SHIFT)

   PUSH_DATA (push, NVC0_3D_VERTEX_ID_REPLACE_SOURCE_ATTR_X(a) | 1);

}