draw_vs.h File Reference

Include dependency graph for draw_vs.h:

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

Go to the source code of this file.

Data Structures
struct	draw_varient_input
struct	draw_varient_output
struct	draw_varient_element
struct	draw_vs_varient_key
struct	draw_vs_varient
struct	draw_vertex_shader
	Private version of the compiled vertex_shader. More...
Defines
#define	MAX_TGSI_VERTICES   4
Functions
struct draw_vs_varient *	draw_vs_lookup_varient (struct draw_vertex_shader *base, const struct draw_vs_varient_key *key)
struct draw_vertex_shader *	draw_create_vs_exec (struct draw_context *draw, const struct pipe_shader_state *templ)
struct draw_vertex_shader *	draw_create_vs_sse (struct draw_context *draw, const struct pipe_shader_state *templ)
struct draw_vertex_shader *	draw_create_vs_llvm (struct draw_context *draw, const struct pipe_shader_state *templ)
struct draw_vs_varient *	draw_vs_varient_aos_sse (struct draw_vertex_shader *vs, const struct draw_vs_varient_key *key)
struct translate *	draw_vs_get_fetch (struct draw_context *draw, struct translate_key *key)
struct translate *	draw_vs_get_emit (struct draw_context *draw, struct translate_key *key)
struct draw_vs_varient *	draw_vs_varient_generic (struct draw_vertex_shader *vs, const struct draw_vs_varient_key *key)
static int	draw_vs_varient_keysize (const struct draw_vs_varient_key *key)
static int	draw_vs_varient_key_compare (const struct draw_vs_varient_key *a, const struct draw_vs_varient_key *b)
struct aos_machine *	draw_vs_aos_machine (void)
void	draw_vs_aos_machine_destroy (struct aos_machine *machine)
void	draw_vs_aos_machine_constants (struct aos_machine *machine, const float(*constants)[4])
void	draw_vs_aos_machine_viewport (struct aos_machine *machine, const struct pipe_viewport_state *viewport)

---

Define Documentation

#define MAX_TGSI_VERTICES   4

Definition at line 216 of file draw_vs.h.

---

Function Documentation

struct draw_vertex_shader* draw_create_vs_exec	(	struct draw_context *	draw,
		const struct pipe_shader_state *	templ
	)			[read]

Definition at line 172 of file draw_vs_exec.c.

References exec_vertex_shader::base, CALLOC_STRUCT, draw_vertex_shader::create_varient, draw_vertex_shader::delete, draw_vertex_shader::draw, FREE, draw_vertex_shader::info, draw_context::machine, exec_vertex_shader::machine, draw_vertex_shader::prepare, draw_vertex_shader::run_linear, draw_vertex_shader::state, tgsi_dup_tokens(), tgsi_scan_shader(), pipe_shader_state::tokens, draw_context::vs, vs_exec_delete(), vs_exec_prepare(), and vs_exec_run_linear().

{
   struct exec_vertex_shader *vs = CALLOC_STRUCT( exec_vertex_shader );

   if (vs == NULL) 
      return NULL;

   /* we make a private copy of the tokens */
   vs->base.state.tokens = tgsi_dup_tokens(state->tokens);
   if (!vs->base.state.tokens) {
      FREE(vs);
      return NULL;
   }

   tgsi_scan_shader(state->tokens, &vs->base.info);

   vs->base.draw = draw;
   vs->base.prepare = vs_exec_prepare;
   vs->base.run_linear = vs_exec_run_linear;
   vs->base.delete = vs_exec_delete;
   vs->base.create_varient = draw_vs_varient_generic;
   vs->machine = &draw->vs.machine;

   return &vs->base;
}

struct draw_vertex_shader* draw_create_vs_llvm	(	struct draw_context *	draw,
		const struct pipe_shader_state *	templ
	)			[read]

Definition at line 99 of file draw_vs_llvm.c.

References draw_llvm_vertex_shader::base, CALLOC_STRUCT, draw_vertex_shader::create_varient, draw_vertex_shader::delete, draw_vertex_shader::draw, draw_context::engine, FREE, gallivm_cpu_engine_create(), gallivm_cpu_jit_compile(), gallivm_global_cpu_engine(), gallivm_ir_compile(), gallivm_ir_delete(), gallivm_ir_fill_from_tgsi(), gallivm_ir_new(), gallivm_ir_set_components(), gallivm_ir_set_layout(), GALLIVM_SOA, GALLIVM_VS, draw_vertex_shader::info, draw_llvm_vertex_shader::llvm_prog, draw_context::machine, draw_llvm_vertex_shader::machine, draw_vertex_shader::prepare, draw_vertex_shader::run_linear, draw_vertex_shader::state, tgsi_dup_tokens(), tgsi_scan_shader(), pipe_shader_state::tokens, draw_context::vs, vs_llvm_delete(), vs_llvm_prepare(), and vs_llvm_run_linear().

{
   struct draw_llvm_vertex_shader *vs;

   vs = CALLOC_STRUCT( draw_llvm_vertex_shader );
   if (vs == NULL)
      return NULL;

   /* we make a private copy of the tokens */
   vs->base.state.tokens = tgsi_dup_tokens(templ->tokens);
   if (!vs->base.state.tokens) {
      FREE(vs);
      return NULL;
   }

   tgsi_scan_shader(vs->base.state.tokens, &vs->base.info);

   vs->base.draw = draw;
   vs->base.prepare = vs_llvm_prepare;
   vs->base.create_varient = draw_vs_varient_generic;
   vs->base.run_linear = vs_llvm_run_linear;
   vs->base.delete = vs_llvm_delete;
   vs->machine = &draw->vs.machine;

   {
      struct gallivm_ir *ir = gallivm_ir_new(GALLIVM_VS);
      gallivm_ir_set_layout(ir, GALLIVM_SOA);
      gallivm_ir_set_components(ir, 4);
      gallivm_ir_fill_from_tgsi(ir, vs->base.state.tokens);
      vs->llvm_prog = gallivm_ir_compile(ir);
      gallivm_ir_delete(ir);
   }

   draw->vs.engine = gallivm_global_cpu_engine();

   /* XXX: Why are there two versions of this?  Shouldn't creating the
    *      engine be a separate operation to compiling a shader?
    */
   if (!draw->vs.engine) {
      draw->vs.engine = gallivm_cpu_engine_create(vs->llvm_prog);
   }
   else {
      gallivm_cpu_jit_compile(draw->vs.engine, vs->llvm_prog);
   }

   return &vs->base;
}

struct draw_vertex_shader* draw_create_vs_sse	(	struct draw_context *	draw,
		const struct pipe_shader_state *	templ
	)			[read]

Definition at line 217 of file draw_vs_sse.c.

{
   return (void *) 0;

struct aos_machine* draw_vs_aos_machine

(

void

)

[read]

Definition at line 319 of file draw_vs_aos_machine.c.

{
   return NULL;
}

void draw_vs_aos_machine_constants	(	struct aos_machine *	machine,
		const float *	constants[4]
	)

Definition at line 310 of file draw_vs_aos_machine.c.

{
}

void draw_vs_aos_machine_destroy

(

struct aos_machine *

machine

)

Definition at line 315 of file draw_vs_aos_machine.c.

{
}

void draw_vs_aos_machine_viewport	(	struct aos_machine *	machine,
		const struct pipe_viewport_state *	viewport
	)

Definition at line 305 of file draw_vs_aos_machine.c.

{
}

struct translate* draw_vs_get_emit	(	struct draw_context *	draw,
		struct translate_key *	key
	)			[read]

Definition at line 253 of file draw_vs.c.

References draw_context::emit, draw_context::emit_cache, translate::key, translate_cache_find(), translate_key_compare(), translate_key_sanitize(), and draw_context::vs.

{
   if (!draw->vs.emit ||
       translate_key_compare(&draw->vs.emit->key, key) != 0) 
   {
      translate_key_sanitize(key);
      draw->vs.emit = translate_cache_find(draw->vs.emit_cache, key);
   }
   
   return draw->vs.emit;
}

struct translate* draw_vs_get_fetch	(	struct draw_context *	draw,
		struct translate_key *	key
	)			[read]

Definition at line 239 of file draw_vs.c.

References draw_context::fetch, draw_context::fetch_cache, translate::key, translate_cache_find(), translate_key_compare(), translate_key_sanitize(), and draw_context::vs.

{
   if (!draw->vs.fetch ||
       translate_key_compare(&draw->vs.fetch->key, key) != 0) 
   {
      translate_key_sanitize(key);
      draw->vs.fetch = translate_cache_find(draw->vs.fetch_cache, key);
   }
   
   return draw->vs.fetch;
}

struct draw_vs_varient* draw_vs_lookup_varient	(	struct draw_vertex_shader *	base,
		const struct draw_vs_varient_key *	key
	)			[read]

Definition at line 202 of file draw_vs.c.

References draw_vertex_shader::create_varient, draw_vs_varient::destroy, draw_vs_varient_key_compare(), Elements, draw_vs_varient::key, draw_vertex_shader::last_varient, draw_vertex_shader::nr_varients, and draw_vertex_shader::varient.

{
   struct draw_vs_varient *varient;
   unsigned i;

   /* Lookup existing varient: 
    */
   for (i = 0; i < vs->nr_varients; i++)
      if (draw_vs_varient_key_compare(key, &vs->varient[i]->key) == 0)
         return vs->varient[i];
   
   /* Else have to create a new one: 
    */
   varient = vs->create_varient( vs, key );
   if (varient == NULL)
      return NULL;

   /* Add it to our list, could be smarter: 
    */
   if (vs->nr_varients < Elements(vs->varient)) {
      vs->varient[vs->nr_varients++] = varient;
   }
   else {
      vs->last_varient++;
      vs->last_varient %= Elements(vs->varient);
      vs->varient[vs->last_varient]->destroy(vs->varient[vs->last_varient]);
      vs->varient[vs->last_varient] = varient;
   }

   /* Done 
    */
   return varient;
}

struct draw_vs_varient* draw_vs_varient_aos_sse	(	struct draw_vertex_shader *	vs,
		const struct draw_vs_varient_key *	key
	)			[read]

struct draw_vs_varient* draw_vs_varient_generic	(	struct draw_vertex_shader *	vs,
		const struct draw_vs_varient_key *	key
	)			[read]

Definition at line 256 of file draw_vs_varient.c.

References assert, draw_vs_varient_generic::base, draw_varient_input::buffer, CALLOC_STRUCT, draw_vs_varient::destroy, draw_vertex_shader::draw, draw_vs_varient_generic::draw, draw_translate_vinfo_format(), draw_vs_get_emit(), draw_vs_get_fetch(), draw_vs_varient_key::element, translate_key::element, draw_vs_varient_generic::emit, EMIT_1F_PSIZE, draw_vs_varient_generic::fetch, draw_varient_output::format, draw_varient_input::format, draw_varient_element::in, draw_vertex_shader::info, translate_element::input_buffer, translate_element::input_format, translate_element::input_offset, draw_vs_varient::key, MAX2, translate_key::nr_elements, draw_vs_varient_key::nr_inputs, draw_vs_varient_key::nr_outputs, tgsi_shader_info::num_outputs, draw_varient_output::offset, draw_varient_input::offset, draw_varient_element::out, translate_element::output_format, translate_element::output_offset, draw_vs_varient_key::output_stride, translate_key::output_stride, PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, draw_vs_varient::set_buffer, draw_vs_varient_generic::temp_vertex_stride, draw_vs_varient::vs, draw_varient_output::vs_output, vsvg_destroy(), vsvg_run_elts(), vsvg_run_linear(), and vsvg_set_buffer().

{
   unsigned i;
   struct translate_key fetch, emit;

   struct draw_vs_varient_generic *vsvg = CALLOC_STRUCT( draw_vs_varient_generic );
   if (vsvg == NULL)
      return NULL;

   vsvg->base.key = *key;
   vsvg->base.vs = vs;
   vsvg->base.set_buffer    = vsvg_set_buffer;
   vsvg->base.run_elts      = vsvg_run_elts;
   vsvg->base.run_linear    = vsvg_run_linear;
   vsvg->base.destroy       = vsvg_destroy;

   vsvg->draw = vs->draw;

   vsvg->temp_vertex_stride = MAX2(key->nr_inputs,
                                   vsvg->base.vs->info.num_outputs) * 4 * sizeof(float);

   /* Build free-standing fetch and emit functions:
    */
   fetch.nr_elements = key->nr_inputs;
   fetch.output_stride = vsvg->temp_vertex_stride;
   for (i = 0; i < key->nr_inputs; i++) {
      fetch.element[i].input_format = key->element[i].in.format;
      fetch.element[i].input_buffer = key->element[i].in.buffer;
      fetch.element[i].input_offset = key->element[i].in.offset;
      fetch.element[i].output_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
      fetch.element[i].output_offset = i * 4 * sizeof(float);
      assert(fetch.element[i].output_offset < fetch.output_stride);
   }


   emit.nr_elements = key->nr_outputs;
   emit.output_stride = key->output_stride;
   for (i = 0; i < key->nr_outputs; i++) {
      if (key->element[i].out.format != EMIT_1F_PSIZE)
      {      
         emit.element[i].input_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
         emit.element[i].input_buffer = 0;
         emit.element[i].input_offset = key->element[i].out.vs_output * 4 * sizeof(float);
         emit.element[i].output_format = draw_translate_vinfo_format(key->element[i].out.format);
         emit.element[i].output_offset = key->element[i].out.offset;
         assert(emit.element[i].input_offset <= fetch.output_stride);
      }
      else {
         emit.element[i].input_format = PIPE_FORMAT_R32_FLOAT;
         emit.element[i].input_buffer = 1;
         emit.element[i].input_offset = 0;
         emit.element[i].output_format = PIPE_FORMAT_R32_FLOAT;
         emit.element[i].output_offset = key->element[i].out.offset;
      }
   }

   vsvg->fetch = draw_vs_get_fetch( vs->draw, &fetch );
   vsvg->emit = draw_vs_get_emit( vs->draw, &emit );

   return &vsvg->base;
}

static int draw_vs_varient_key_compare	(	const struct draw_vs_varient_key *	a,
		const struct draw_vs_varient_key *	b
	)			[static]

Definition at line 198 of file draw_vs.h.

References draw_vs_varient_keysize().

{
   int keysize = draw_vs_varient_keysize(a);
   return memcmp(a, b, keysize);
}

static int draw_vs_varient_keysize

(

const struct draw_vs_varient_key *

key

)

[static]

Definition at line 193 of file draw_vs.h.

References draw_vs_varient_key::nr_elements.

{
   return 2 * sizeof(int) + key->nr_elements * sizeof(struct draw_varient_element);
}

---