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_resource.h"

   struct nouveau_pushbuf *push;

   uint32_t packet_vertex_limit;

   boolean need_vertex_id;

   uint32_t prim;

   uint32_t restart_index;

   uint32_t instance_id;

      int buffer;

      float value;

      uint8_t *data;

      unsigned offset;

      unsigned stride;

   } edgeflag;

};

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

{

   struct pipe_vertex_element *ve;

   ctx->translate = nvc0->vertex->translate;

      ctx->need_vertex_id = nvc0->vertprog->vp.need_vertex_id;

   else

      ctx->need_vertex_id = FALSE;

   ctx->edgeflag.value = 0.5f;

      ve = &nvc0->vertex->element[nvc0->vertprog->vp.edgeflag].pipe;

      ctx->edgeflag.buffer = ve->vertex_buffer_index;

      ctx->edgeflag.offset = ve->src_offset;

      ctx->packet_vertex_limit = 1;

   } else {

      ctx->packet_vertex_limit = nvc0->vertex->vtx_per_packet_max;

      if (unlikely(ctx->need_vertex_id))

         ctx->packet_vertex_limit = 1;

   }

}

set_edgeflag(struct push_context *ctx, unsigned vtx_id)

{

   float f = *(float *)(ctx->edgeflag.data + vtx_id * ctx->edgeflag.stride);

      ctx->edgeflag.value = f;

      IMMED_NVC0(ctx->push, NVC0_3D(EDGEFLAG), f ? 1 : 0);

   }

}

set_vertexid(struct push_context *ctx, uint32_t vtx_id)

{

#if 0

   BEGIN_NVC0(ctx->push, NVC0_3D(VERTEX_ID), 1); /* broken on nvc0 */

#else

   BEGIN_NVC0(ctx->push, NVC0_3D(VERTEX_DATA), 1); /* as last attribute */

#endif

   PUSH_DATA (ctx->push, vtx_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 *restrict 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);

         set_edgeflag(ctx, elts[0]);

                                ctx->push->cur);

      ctx->push->cur += size;

         set_vertexid(ctx, elts[0]);

      elts += nr;

         count--;

         elts++;

         BEGIN_NVC0(ctx->push, NVC0_3D(VERTEX_END_GL), 2);

         PUSH_DATA (ctx->push, 0);

         PUSH_DATA (ctx->push, NVC0_3D_VERTEX_BEGIN_GL_INSTANCE_CONT |

                    (ctx->prim & ~NVC0_3D_VERTEX_BEGIN_GL_INSTANCE_NEXT));

      }

   }

}

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

{

   uint16_t *restrict 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);

         set_edgeflag(ctx, elts[0]);

                                 ctx->push->cur);

      ctx->push->cur += size;

         set_vertexid(ctx, elts[0]);

      elts += nr;

         count--;

         elts++;

         BEGIN_NVC0(ctx->push, NVC0_3D(VERTEX_END_GL), 2);

         PUSH_DATA (ctx->push, 0);

         PUSH_DATA (ctx->push, NVC0_3D_VERTEX_BEGIN_GL_INSTANCE_CONT |

                    (ctx->prim & ~NVC0_3D_VERTEX_BEGIN_GL_INSTANCE_NEXT));

      }

   }

}

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

{

   uint32_t *restrict 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);

         set_edgeflag(ctx, elts[0]);

                               ctx->push->cur);

      ctx->push->cur += size;

         set_vertexid(ctx, elts[0]);

      elts += nr;

         count--;

         elts++;

         BEGIN_NVC0(ctx->push, NVC0_3D(VERTEX_END_GL), 2);

         PUSH_DATA (ctx->push, 0);

         PUSH_DATA (ctx->push, NVC0_3D_VERTEX_BEGIN_GL_INSTANCE_CONT |

                    (ctx->prim & ~NVC0_3D_VERTEX_BEGIN_GL_INSTANCE_NEXT));

      }

   }

}

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;

         set_edgeflag(ctx, start);

                          ctx->push->cur);

      ctx->push->cur += size;

         set_vertexid(ctx, start);

      start += push;

   }

}

   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;

      break;

   }

}

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;

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

      uint8_t *data;

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

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

                                         vb->buffer_offset, NOUVEAU_BO_RD);

         data += info->index_bias * vb->stride;

         ctx.edgeflag.data = data + ctx.edgeflag.offset;

         ctx.edgeflag.stride = vb->stride;

      }

   }

      ctx.idxbuf =

         nouveau_resource_map_offset(&nvc0->base,

                                     nv04_resource(nvc0->idxbuf.buffer),

                                     nvc0->idxbuf.offset, NOUVEAU_BO_RD);

      if (!ctx.idxbuf)

         return;

      index_size = nvc0->idxbuf.index_size;

      ctx.primitive_restart = info->primitive_restart;

      ctx.restart_index = info->restart_index;

   } else {

      ctx.idxbuf = NULL;

      index_size = 0;

      ctx.primitive_restart = FALSE;

      ctx.restart_index = 0;

         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.prim = nvc0_prim_gl(info->mode);

      const unsigned a = nvc0->vertex->num_elements;

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

      PUSH_DATA (ctx.push, (a << NVC0_3D_VERTEX_ATTRIB_FORMAT_BUFFER__SHIFT) |

                 NVC0_3D_VERTEX_ATTRIB_FORMAT_TYPE_FLOAT |

                 NVC0_3D_VERTEX_ATTRIB_FORMAT_SIZE_32);

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

      PUSH_DATA (ctx.push, (((0x80 + a * 0x10) / 4) << 4) | 1);

   }

      BEGIN_NVC0(ctx.push, NVC0_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;

      }

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

      ctx.prim |= NVC0_3D_VERTEX_BEGIN_GL_INSTANCE_NEXT;

   }

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

      const unsigned a = nvc0->vertex->num_elements;

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

      BEGIN_NVC0(ctx.push, NVC0_3D(VERTEX_ATTRIB_FORMAT(a)), 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);

   }

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

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

}