draw_pt.h File Reference

Include dependency graph for draw_pt.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	draw_pt_front_end
struct	draw_pt_middle_end
Defines
#define	PT_SHADE   0x1
#define	PT_CLIPTEST   0x2
#define	PT_PIPELINE   0x4
#define	PT_MAX_MIDDLE   0x8
Typedefs
typedef unsigned(*	pt_elt_func )(const void *elts, unsigned idx)
Functions
pt_elt_func	draw_pt_elt_func (struct draw_context *draw)
const void *	draw_pt_elt_ptr (struct draw_context *draw, unsigned start)
struct draw_pt_front_end *	draw_pt_vcache (struct draw_context *draw)
struct draw_pt_front_end *	draw_pt_varray (struct draw_context *draw)
struct draw_pt_middle_end *	draw_pt_fetch_emit (struct draw_context *draw)
struct draw_pt_middle_end *	draw_pt_middle_fse (struct draw_context *draw)
struct draw_pt_middle_end *	draw_pt_fetch_pipeline_or_emit (struct draw_context *draw)
boolean	draw_pt_get_edgeflag (struct draw_context *draw, unsigned idx)
void	draw_pt_emit_prepare (struct pt_emit *emit, unsigned prim, unsigned *max_vertices)
void	draw_pt_emit (struct pt_emit *emit, const float(*vertex_data)[4], unsigned vertex_count, unsigned stride, const ushort *elts, unsigned count)
void	draw_pt_emit_linear (struct pt_emit *emit, const float(*vertex_data)[4], unsigned vertex_count, unsigned stride, unsigned start, unsigned count)
void	draw_pt_emit_destroy (struct pt_emit *emit)
struct pt_emit *	draw_pt_emit_create (struct draw_context *draw)
void	draw_pt_fetch_prepare (struct pt_fetch *fetch, unsigned vertex_size)
void	draw_pt_fetch_run (struct pt_fetch *fetch, const unsigned *elts, unsigned count, char *verts)
void	draw_pt_fetch_run_linear (struct pt_fetch *fetch, unsigned start, unsigned count, char *verts)
void	draw_pt_fetch_destroy (struct pt_fetch *fetch)
struct pt_fetch *	draw_pt_fetch_create (struct draw_context *draw)
boolean	draw_pt_post_vs_run (struct pt_post_vs *pvs, struct vertex_header *pipeline_verts, unsigned stride, unsigned count)
void	draw_pt_post_vs_prepare (struct pt_post_vs *pvs, boolean bypass_clipping, boolean identity_viewport, boolean opengl)
struct pt_post_vs *	draw_pt_post_vs_create (struct draw_context *draw)
void	draw_pt_post_vs_destroy (struct pt_post_vs *pvs)
void	draw_pt_split_prim (unsigned prim, unsigned *first, unsigned *incr)
unsigned	draw_pt_reduced_prim (unsigned prim)

---

Define Documentation

#define PT_CLIPTEST   0x2

Definition at line 45 of file draw_pt.h.

#define PT_MAX_MIDDLE   0x8

Definition at line 47 of file draw_pt.h.

#define PT_PIPELINE   0x4

Definition at line 46 of file draw_pt.h.

#define PT_SHADE   0x1

Definition at line 44 of file draw_pt.h.

---

Typedef Documentation

typedef unsigned(* pt_elt_func)(const void *elts, unsigned idx)

Definition at line 38 of file draw_pt.h.

---

Function Documentation

pt_elt_func draw_pt_elt_func

(

struct draw_context *

draw

)

Definition at line 60 of file draw_pt_elts.c.

References elt_ubyte(), elt_uint(), elt_ushort(), elt_vert(), draw_context::pt, and draw_context::user.

{
   switch (draw->pt.user.eltSize) {
   case 0: return &elt_vert;
   case 1: return &elt_ubyte;
   case 2: return &elt_ushort; 
   case 4: return &elt_uint;
   default: return NULL;
   }
}     

const void* draw_pt_elt_ptr	(	struct draw_context *	draw,
		unsigned	start
	)

Definition at line 71 of file draw_pt_elts.c.

References draw_context::pt, and draw_context::user.

{
   const char *elts = draw->pt.user.elts;

   switch (draw->pt.user.eltSize) {
   case 0: 
      return (const void *)(((const ubyte *)NULL) + start);
   case 1: 
      return (const void *)(((const ubyte *)elts) + start);
   case 2: 
      return (const void *)(((const ushort *)elts) + start);
   case 4: 
      return (const void *)(((const uint *)elts) + start);
   default:
      return NULL;
   }
}

void draw_pt_emit	(	struct pt_emit *	emit,
		const float *	vertex_data[4],
		unsigned	vertex_count,
		unsigned	stride,
		const ushort *	elts,
		unsigned	count
	)

Definition at line 152 of file draw_pt_emit.c.

References vbuf_render::allocate_vertices, assert, vbuf_render::draw, pt_emit::draw, draw, draw_do_flush(), DRAW_FLUSH_BACKEND, translate::key, translate_key::output_stride, pipe_rasterizer_state::point_size, pt_emit::prim, draw_context::rasterizer, vbuf_render::release_vertices, draw_context::render, translate::set_buffer, vbuf_render::set_primitive, and pt_emit::translate.

{
   struct draw_context *draw = emit->draw;
   struct translate *translate = emit->translate;
   struct vbuf_render *render = draw->render;
   void *hw_verts;

   /* XXX: need to flush to get prim_vbuf.c to release its allocation?? 
    */
   draw_do_flush( draw, DRAW_FLUSH_BACKEND );

   /* 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;
   }

   hw_verts = render->allocate_vertices(render,
                                        (ushort)translate->key.output_stride,
                                        (ushort)vertex_count);
   if (!hw_verts) {
      assert(0);
      return;
   }

   translate->set_buffer(translate, 
                         0, 
                         vertex_data,
                         stride );

   translate->set_buffer(translate, 
                         1, 
                         &draw->rasterizer->point_size,
                         0);

   translate->run( translate,
                   0, 
                   vertex_count,
                   hw_verts );

   render->draw(render,
                elts,
                count);

   render->release_vertices(render,
                            hw_verts,
                            translate->key.output_stride,
                            vertex_count);
}

struct pt_emit* draw_pt_emit_create

(

struct draw_context *

draw

)

[read]

Definition at line 276 of file draw_pt_emit.c.

References pt_emit::cache, CALLOC_STRUCT, pt_emit::draw, FREE, and translate_cache_create().

{
   struct pt_emit *emit = CALLOC_STRUCT(pt_emit);
   if (!emit)
      return NULL;

   emit->draw = draw;
   emit->cache = translate_cache_create();
   if (!emit->cache) {
      FREE(emit);
      return NULL;
   }

   return emit;
}

void draw_pt_emit_destroy

(

struct pt_emit *

emit

)

Definition at line 292 of file draw_pt_emit.c.

References pt_emit::cache, FREE, and translate_cache_destroy().

{
   if (emit->cache)
      translate_cache_destroy(emit->cache);

   FREE(emit);
}

void draw_pt_emit_linear	(	struct pt_emit *	emit,
		const float *	vertex_data[4],
		unsigned	vertex_count,
		unsigned	stride,
		unsigned	start,
		unsigned	count
	)

Definition at line 210 of file draw_pt_emit.c.

References vbuf_render::allocate_vertices, assert, debug_printf(), pt_emit::draw, draw, vbuf_render::draw_arrays, draw_do_flush(), draw_dump_emitted_vertex(), DRAW_FLUSH_BACKEND, translate::key, translate_key::output_stride, pipe_rasterizer_state::point_size, pt_emit::prim, draw_context::rasterizer, vbuf_render::release_vertices, draw_context::render, translate::set_buffer, vbuf_render::set_primitive, pt_emit::translate, and pt_emit::vinfo.

{
   struct draw_context *draw = emit->draw;
   struct translate *translate = emit->translate;
   struct vbuf_render *render = draw->render;
   void *hw_verts;

#if 0
   debug_printf("Linear emit\n");
#endif
   /* XXX: need to flush to get prim_vbuf.c to release its allocation?? 
    */
   draw_do_flush( draw, DRAW_FLUSH_BACKEND );

   /* 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;
   }

   hw_verts = render->allocate_vertices(render,
                                        (ushort)translate->key.output_stride,
                                        (ushort)count);
   if (!hw_verts) {
      assert(0);
      return;
   }

   translate->set_buffer(translate, 0,
                         vertex_data, stride);

   translate->set_buffer(translate, 1,
                         &draw->rasterizer->point_size,
                         0);

   translate->run(translate,
                  0,
                  vertex_count,
                  hw_verts);

   if (0) {
      unsigned i;
      for (i = 0; i < vertex_count; i++) {
         debug_printf("\n\n%s vertex %d:\n", __FUNCTION__, i);
         draw_dump_emitted_vertex( emit->vinfo, 
                                   (const uint8_t *)hw_verts + 
                                   translate->key.output_stride * i );
      }
   }


   render->draw_arrays(render, start, count);

   render->release_vertices(render,
                            hw_verts,
                            translate->key.output_stride,
                            vertex_count);
}

void draw_pt_emit_prepare	(	struct pt_emit *	emit,
		unsigned	prim,
		unsigned *	max_vertices
	)

Definition at line 48 of file draw_pt_emit.c.

References assert, vertex_info::attrib, pt_emit::cache, pt_emit::draw, draw, draw_do_flush(), DRAW_FLUSH_BACKEND, translate_key::element, vertex_info::emit, EMIT_1F, EMIT_1F_PSIZE, EMIT_2F, EMIT_3F, EMIT_4F, EMIT_4UB, vbuf_render::get_vertex_info, translate_element::input_buffer, translate_element::input_format, translate_element::input_offset, translate::key, vbuf_render::max_vertex_buffer_bytes, translate_key::nr_elements, vertex_info::num_attribs, translate_element::output_format, translate_element::output_offset, translate_key::output_stride, PIPE_FORMAT_B8G8R8A8_UNORM, PIPE_FORMAT_NONE, PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, pt_emit::prim, draw_context::render, vbuf_render::set_primitive, vertex_info::size, vertex_info::src_index, pt_emit::translate, translate_cache_find(), translate_key_compare(), translate_key_sanitize(), and pt_emit::vinfo.

{
   struct draw_context *draw = emit->draw;
   const struct vertex_info *vinfo;
   unsigned dst_offset;
   struct translate_key hw_key;
   unsigned i;
   boolean ok;
   
   /* XXX: need to flush to get prim_vbuf.c to release its allocation?? 
    */
   draw_do_flush( draw, DRAW_FLUSH_BACKEND );


   /* XXX: may need to defensively reset this later on as clipping can
    * clobber this state in the render backend.
    */
   emit->prim = prim;

   ok = draw->render->set_primitive(draw->render, emit->prim);
   if (!ok) {
      assert(0);
      return;
   }

   /* Must do this after set_primitive() above:
    */
   emit->vinfo = vinfo = draw->render->get_vertex_info(draw->render);


   /* Translate from pipeline vertices to hw vertices.
    */
   dst_offset = 0;
   for (i = 0; i < vinfo->num_attribs; i++) {
      unsigned emit_sz = 0;
      unsigned src_buffer = 0;
      unsigned output_format;
      unsigned src_offset = (vinfo->attrib[i].src_index * 4 * sizeof(float) );


         
      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);
         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].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].output_format = output_format;
      hw_key.element[i].output_offset = dst_offset;

      dst_offset += emit_sz;
   }

   hw_key.nr_elements = vinfo->num_attribs;
   hw_key.output_stride = vinfo->size * 4;

   if (!emit->translate ||
       translate_key_compare(&emit->translate->key, &hw_key) != 0)
   {
      translate_key_sanitize(&hw_key);
      emit->translate = translate_cache_find(emit->cache, &hw_key);
   }

   *max_vertices = (draw->render->max_vertex_buffer_bytes / 
                    (vinfo->size * 4));

   /* even number */
   *max_vertices = *max_vertices & ~1;
}

struct pt_fetch* draw_pt_fetch_create

(

struct draw_context *

draw

)

[read]

Definition at line 205 of file draw_pt_fetch.c.

References pt_fetch::cache, CALLOC_STRUCT, pt_fetch::draw, FREE, and translate_cache_create().

{
   struct pt_fetch *fetch = CALLOC_STRUCT(pt_fetch);
   if (!fetch)
      return NULL;

   fetch->draw = draw;
   fetch->cache = translate_cache_create();
   if (!fetch->cache) {
      FREE(fetch);
      return NULL;
   }

   return fetch;
}

void draw_pt_fetch_destroy

(

struct pt_fetch *

fetch

)

Definition at line 221 of file draw_pt_fetch.c.

References pt_fetch::cache, FREE, and translate_cache_destroy().

{
   if (fetch->cache)
      translate_cache_destroy(fetch->cache);

   FREE(fetch);
}

struct draw_pt_middle_end* draw_pt_fetch_emit

(

struct draw_context *

draw

)

[read]

Definition at line 390 of file draw_pt_fetch_emit.c.

References fetch_emit_middle_end::base, fetch_emit_middle_end::cache, CALLOC_STRUCT, draw_pt_middle_end::destroy, fetch_emit_middle_end::draw, fetch_emit_destroy(), fetch_emit_finish(), fetch_emit_prepare(), fetch_emit_run(), fetch_emit_run_linear(), fetch_emit_run_linear_elts(), draw_pt_middle_end::finish, FREE, draw_pt_middle_end::prepare, draw_pt_middle_end::run, draw_pt_middle_end::run_linear, draw_pt_middle_end::run_linear_elts, and translate_cache_create().

{
   struct fetch_emit_middle_end *fetch_emit = CALLOC_STRUCT( fetch_emit_middle_end );
   if (fetch_emit == NULL)
      return NULL;

   fetch_emit->cache = translate_cache_create();
   if (!fetch_emit->cache) {
      FREE(fetch_emit);
      return NULL;
   }

   fetch_emit->base.prepare    = fetch_emit_prepare;
   fetch_emit->base.run        = fetch_emit_run;
   fetch_emit->base.run_linear = fetch_emit_run_linear;
   fetch_emit->base.run_linear_elts = fetch_emit_run_linear_elts;
   fetch_emit->base.finish     = fetch_emit_finish;
   fetch_emit->base.destroy    = fetch_emit_destroy;

   fetch_emit->draw = draw;
     
   return &fetch_emit->base;
}

struct draw_pt_middle_end* draw_pt_fetch_pipeline_or_emit

(

struct draw_context *

draw

)

[read]

Definition at line 362 of file draw_pt_fetch_shade_pipeline.c.

References fetch_pipeline_middle_end::base, CALLOC_STRUCT, draw_pt_middle_end::destroy, fetch_pipeline_middle_end::draw, draw_pt_emit_create(), draw_pt_fetch_create(), draw_pt_post_vs_create(), fetch_pipeline_middle_end::emit, fetch_pipeline_middle_end::fetch, fetch_pipeline_destroy(), fetch_pipeline_finish(), fetch_pipeline_linear_run(), fetch_pipeline_linear_run_elts(), fetch_pipeline_prepare(), fetch_pipeline_run(), draw_pt_middle_end::finish, fetch_pipeline_middle_end::post_vs, draw_pt_middle_end::prepare, draw_pt_middle_end::run, draw_pt_middle_end::run_linear, and draw_pt_middle_end::run_linear_elts.

{
   struct fetch_pipeline_middle_end *fpme = CALLOC_STRUCT( fetch_pipeline_middle_end );
   if (!fpme)
      goto fail;

   fpme->base.prepare        = fetch_pipeline_prepare;
   fpme->base.run            = fetch_pipeline_run;
   fpme->base.run_linear     = fetch_pipeline_linear_run;
   fpme->base.run_linear_elts = fetch_pipeline_linear_run_elts;
   fpme->base.finish         = fetch_pipeline_finish;
   fpme->base.destroy        = fetch_pipeline_destroy;

   fpme->draw = draw;

   fpme->fetch = draw_pt_fetch_create( draw );
   if (!fpme->fetch)
      goto fail;

   fpme->post_vs = draw_pt_post_vs_create( draw );
   if (!fpme->post_vs)
      goto fail;

   fpme->emit = draw_pt_emit_create( draw );
   if (!fpme->emit) 
      goto fail;

   return &fpme->base;

 fail:
   if (fpme)
      fetch_pipeline_destroy( &fpme->base );

   return NULL;
}

void draw_pt_fetch_prepare	(	struct pt_fetch *	fetch,
		unsigned	vertex_size
	)

Definition at line 58 of file draw_pt_fetch.c.

References assert, pt_fetch::cache, pt_fetch::draw, draw, translate_key::element, pipe_rasterizer_state::fill_ccw, pipe_rasterizer_state::fill_cw, translate_element::input_buffer, translate_element::input_format, translate_element::input_offset, translate::key, pt_fetch::need_edgeflags, translate_key::nr_elements, draw_context::nr_vertex_buffers, draw_context::nr_vertex_elements, translate_element::output_format, translate_element::output_offset, translate_key::output_stride, PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, PIPE_POLYGON_MODE_FILL, draw_context::pt, draw_context::rasterizer, translate::set_buffer, pipe_vertex_element::src_format, pipe_vertex_element::src_offset, pt_fetch::translate, translate_cache_find(), translate_key_compare(), translate_key_sanitize(), UNDEFINED_VERTEX_ID, draw_context::user, pipe_vertex_element::vertex_buffer_index, draw_context::vertex_element, and pt_fetch::vertex_size.

{
   struct draw_context *draw = fetch->draw;
   unsigned i, nr = 0;
   unsigned dst_offset = 0;
   struct translate_key key;

   fetch->vertex_size = vertex_size;

   /* Always emit/leave space for a vertex header.
    *
    * It's worth considering whether the vertex headers should contain
    * a pointer to the 'data', rather than having it inline.
    * Something to look at after we've fully switched over to the pt
    * paths.
    */
   {
      /* Need to set header->vertex_id = 0xffff somehow.
       */
      key.element[nr].input_format = PIPE_FORMAT_R32_FLOAT;
      key.element[nr].input_buffer = draw->pt.nr_vertex_buffers;
      key.element[nr].input_offset = 0;
      key.element[nr].output_format = PIPE_FORMAT_R32_FLOAT;
      key.element[nr].output_offset = dst_offset;
      dst_offset += 1 * sizeof(float);
      nr++;


      /* Just leave the clip[] array untouched.
       */
      dst_offset += 4 * sizeof(float);
   }
      

   for (i = 0; i < draw->pt.nr_vertex_elements; i++) {
      key.element[nr].input_format = draw->pt.vertex_element[i].src_format;
      key.element[nr].input_buffer = draw->pt.vertex_element[i].vertex_buffer_index;
      key.element[nr].input_offset = draw->pt.vertex_element[i].src_offset;
      key.element[nr].output_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
      key.element[nr].output_offset = dst_offset;

      dst_offset += 4 * sizeof(float);
      nr++;
   }

   assert(dst_offset <= vertex_size);

   key.nr_elements = nr;
   key.output_stride = vertex_size;


   if (!fetch->translate ||
       translate_key_compare(&fetch->translate->key, &key) != 0)
   {
      translate_key_sanitize(&key);
      fetch->translate = translate_cache_find(fetch->cache, &key);

      {
         static struct vertex_header vh = { 0, 1, 0, UNDEFINED_VERTEX_ID, { .0f, .0f, .0f, .0f } };
         fetch->translate->set_buffer(fetch->translate,
                                      draw->pt.nr_vertex_buffers,
                                      &vh,
                                      0);
      }
   }

   fetch->need_edgeflags = ((draw->rasterizer->fill_cw != PIPE_POLYGON_MODE_FILL ||
                             draw->rasterizer->fill_ccw != PIPE_POLYGON_MODE_FILL) &&
                            draw->pt.user.edgeflag);
}

void draw_pt_fetch_run	(	struct pt_fetch *	fetch,
		const unsigned *	elts,
		unsigned	count,
		char *	verts
	)

Definition at line 133 of file draw_pt_fetch.c.

References pipe_vertex_buffer::buffer_offset, pt_fetch::draw, draw, draw_pt_get_edgeflag(), vertex_header::edgeflag, pt_fetch::need_edgeflags, draw_context::nr_vertex_buffers, pipe_vertex_buffer::pitch, draw_context::pt, translate::set_buffer, pt_fetch::translate, draw_context::user, draw_context::vertex_buffer, and pt_fetch::vertex_size.

{
   struct draw_context *draw = fetch->draw;
   struct translate *translate = fetch->translate;
   unsigned i;

   for (i = 0; i < draw->pt.nr_vertex_buffers; i++) {
      translate->set_buffer(translate, 
                            i, 
                            ((char *)draw->pt.user.vbuffer[i] + 
                             draw->pt.vertex_buffer[i].buffer_offset),
                            draw->pt.vertex_buffer[i].pitch );
   }

   translate->run_elts( translate,
                        elts, 
                        count,
                        verts );

   /* Edgeflags are hard to fit into a translate program, populate
    * them separately if required.  In the setup above they are
    * defaulted to one, so only need this if there is reason to change
    * that default:
    */
   if (fetch->need_edgeflags) {
      for (i = 0; i < count; i++) {
         struct vertex_header *vh = (struct vertex_header *)(verts + i * fetch->vertex_size);
         vh->edgeflag = draw_pt_get_edgeflag( draw, elts[i] );
      }
   }
}

void draw_pt_fetch_run_linear	(	struct pt_fetch *	fetch,
		unsigned	start,
		unsigned	count,
		char *	verts
	)

Definition at line 169 of file draw_pt_fetch.c.

References pipe_vertex_buffer::buffer_offset, pt_fetch::draw, draw, draw_pt_get_edgeflag(), vertex_header::edgeflag, pt_fetch::need_edgeflags, draw_context::nr_vertex_buffers, pipe_vertex_buffer::pitch, draw_context::pt, translate::set_buffer, pt_fetch::translate, draw_context::user, draw_context::vertex_buffer, and pt_fetch::vertex_size.

{
   struct draw_context *draw = fetch->draw;
   struct translate *translate = fetch->translate;
   unsigned i;

   for (i = 0; i < draw->pt.nr_vertex_buffers; i++) {
      translate->set_buffer(translate,
                            i,
                            ((char *)draw->pt.user.vbuffer[i] +
                             draw->pt.vertex_buffer[i].buffer_offset),
                            draw->pt.vertex_buffer[i].pitch );
   }

   translate->run( translate,
                   start,
                   count,
                   verts );

   /* Edgeflags are hard to fit into a translate program, populate
    * them separately if required.  In the setup above they are
    * defaulted to one, so only need this if there is reason to change
    * that default:
    */
   if (fetch->need_edgeflags) {
      for (i = 0; i < count; i++) {
         struct vertex_header *vh = (struct vertex_header *)(verts + i * fetch->vertex_size);
         vh->edgeflag = draw_pt_get_edgeflag( draw, start + i );
      }
   }
}

boolean draw_pt_get_edgeflag	(	struct draw_context *	draw,
		unsigned	idx
	)

Definition at line 316 of file draw_pt.c.

References draw_context::pt, and draw_context::user.

{
   if (draw->pt.user.edgeflag)
      return (draw->pt.user.edgeflag[idx/32] & (1 << (idx%32))) != 0;
   else
      return 1;
}

struct draw_pt_middle_end* draw_pt_middle_fse

(

struct draw_context *

draw

)

[read]

Definition at line 394 of file draw_pt_fetch_shade_emit.c.

References fetch_shade_emit::base, CALLOC_STRUCT, draw_pt_middle_end::destroy, fetch_shade_emit::draw, draw_pt_middle_end::finish, fse_destroy(), fse_finish(), fse_prepare(), fse_run(), fse_run_linear(), fse_run_linear_elts(), draw_pt_middle_end::prepare, draw_pt_middle_end::run, draw_pt_middle_end::run_linear, and draw_pt_middle_end::run_linear_elts.

{
   struct fetch_shade_emit *fse = CALLOC_STRUCT(fetch_shade_emit);
   if (!fse)
      return NULL;

   fse->base.prepare = fse_prepare;
   fse->base.run = fse_run;
   fse->base.run_linear = fse_run_linear;
   fse->base.run_linear_elts = fse_run_linear_elts;
   fse->base.finish = fse_finish;
   fse->base.destroy = fse_destroy;
   fse->draw = draw;

   return &fse->base;
}

struct pt_post_vs* draw_pt_post_vs_create

(

struct draw_context *

draw

)

[read]

Definition at line 219 of file draw_pt_post_vs.c.

References CALLOC_STRUCT, and pt_post_vs::draw.

{
   struct pt_post_vs *pvs = CALLOC_STRUCT( pt_post_vs );
   if (!pvs)
      return NULL;

   pvs->draw = draw;
   
   return pvs;
}

void draw_pt_post_vs_destroy

(

struct pt_post_vs *

pvs

)

Definition at line 230 of file draw_pt_post_vs.c.

References FREE.

{
   FREE(pvs);
}

void draw_pt_post_vs_prepare	(	struct pt_post_vs *	pvs,
		boolean	bypass_clipping,
		boolean	identity_viewport,
		boolean	opengl
	)

Definition at line 201 of file draw_pt_post_vs.c.

References post_vs_cliptest_viewport_gl(), post_vs_none(), post_vs_viewport(), and pt_post_vs::run.

{
   if (bypass_clipping) {
      if (identity_viewport)
         pvs->run = post_vs_none;
      else
         pvs->run = post_vs_viewport;
   }
   else {
      //if (opengl) 
      pvs->run = post_vs_cliptest_viewport_gl;
   }
}

boolean draw_pt_post_vs_run	(	struct pt_post_vs *	pvs,
		struct vertex_header *	pipeline_verts,
		unsigned	stride,
		unsigned	count
	)

Definition at line 192 of file draw_pt_post_vs.c.

References pt_post_vs::run.

{
   return pvs->run( pvs, pipeline_verts, count, stride );
}

unsigned draw_pt_reduced_prim

(

unsigned

prim

)

Definition at line 80 of file draw_pt_util.c.

References assert, PIPE_PRIM_LINE_LOOP, PIPE_PRIM_LINE_STRIP, PIPE_PRIM_LINES, PIPE_PRIM_POINTS, PIPE_PRIM_POLYGON, PIPE_PRIM_QUAD_STRIP, PIPE_PRIM_QUADS, PIPE_PRIM_TRIANGLE_FAN, PIPE_PRIM_TRIANGLE_STRIP, and PIPE_PRIM_TRIANGLES.

{
   switch (prim) {
   case PIPE_PRIM_POINTS:
      return PIPE_PRIM_POINTS;
   case PIPE_PRIM_LINES:
   case PIPE_PRIM_LINE_STRIP:
   case PIPE_PRIM_LINE_LOOP:
      return PIPE_PRIM_LINES;
   case PIPE_PRIM_TRIANGLES:
   case PIPE_PRIM_TRIANGLE_STRIP:
   case PIPE_PRIM_TRIANGLE_FAN:
   case PIPE_PRIM_POLYGON:
   case PIPE_PRIM_QUADS:
   case PIPE_PRIM_QUAD_STRIP:
      return PIPE_PRIM_TRIANGLES;
   default:
      assert(0);
      return PIPE_PRIM_POINTS;
   }
}

void draw_pt_split_prim	(	unsigned	prim,
		unsigned *	first,
		unsigned *	incr
	)

Definition at line 37 of file draw_pt_util.c.

References assert, PIPE_PRIM_LINE_LOOP, PIPE_PRIM_LINE_STRIP, PIPE_PRIM_LINES, PIPE_PRIM_POINTS, PIPE_PRIM_POLYGON, PIPE_PRIM_QUAD_STRIP, PIPE_PRIM_QUADS, PIPE_PRIM_TRIANGLE_FAN, PIPE_PRIM_TRIANGLE_STRIP, and PIPE_PRIM_TRIANGLES.

{
   switch (prim) {
   case PIPE_PRIM_POINTS:
      *first = 1;
      *incr = 1;
      break;
   case PIPE_PRIM_LINES:
      *first = 2;
      *incr = 2;
      break;
   case PIPE_PRIM_LINE_STRIP:
   case PIPE_PRIM_LINE_LOOP:
      *first = 2;
      *incr = 1;
      break;
   case PIPE_PRIM_TRIANGLES:
      *first = 3;
      *incr = 3;
      break;
   case PIPE_PRIM_TRIANGLE_STRIP:
   case PIPE_PRIM_TRIANGLE_FAN:
   case PIPE_PRIM_POLYGON:
      *first = 3;
      *incr = 1;
      break;
   case PIPE_PRIM_QUADS:
      *first = 4;
      *incr = 4;
      break;
   case PIPE_PRIM_QUAD_STRIP:
      *first = 4;
      *incr = 2;
      break;
   default:
      assert(0);
      *first = 0;
      *incr = 1;                /* set to one so that count % incr works */
      break;
   }
}

struct draw_pt_front_end* draw_pt_varray

(

struct draw_context *

draw

)

[read]

Definition at line 175 of file draw_pt_varray.c.

References varray_frontend::base, CALLOC_STRUCT, draw_pt_front_end::destroy, varray_frontend::draw, varray_frontend::draw_elts, DRAW_MAX, draw_pt_front_end::finish, draw_pt_front_end::prepare, draw_pt_front_end::run, varray_destroy(), varray_finish(), and varray_prepare().

{
   ushort i;
   struct varray_frontend *varray = CALLOC_STRUCT(varray_frontend);
   if (varray == NULL)
      return NULL;

   varray->base.prepare = varray_prepare;
   varray->base.run     = NULL;
   varray->base.finish  = varray_finish;
   varray->base.destroy = varray_destroy;
   varray->draw = draw;

   for (i = 0; i < DRAW_MAX; i++) {
      varray->draw_elts[i] = i;
   }

   return &varray->base;
}

struct draw_pt_front_end* draw_pt_vcache

(

struct draw_context *

draw

)

[read]

Definition at line 485 of file draw_pt_vcache.c.

References vcache_frontend::base, CALLOC_STRUCT, draw_pt_front_end::destroy, vcache_frontend::draw, draw_pt_front_end::finish, vcache_frontend::in, draw_pt_front_end::prepare, draw_pt_front_end::run, vcache_destroy(), vcache_finish(), and vcache_prepare().

{
   struct vcache_frontend *vcache = CALLOC_STRUCT( vcache_frontend );
   if (vcache == NULL)
      return NULL;
 
   vcache->base.prepare = vcache_prepare;
   vcache->base.run     = NULL;
   vcache->base.finish  = vcache_finish;
   vcache->base.destroy = vcache_destroy;
   vcache->draw = draw;
   
   memset(vcache->in, ~0, sizeof(vcache->in));
  
   return &vcache->base;
}

---