fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-05 13:58:04 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

draw: asst. clean-ups in draw_gs.[ch]

Browse source 
Signed-off-by: Brian Paul <brianp@vmware.com>
Acked-by: Dave Airlie <airlied@redhat.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/19024>
This commit is contained in:
Brian Paul 2022-10-05 21:38:57 -06:00 • committed by Marge Bot
parent 490f7a14f6
commit 8613316a31
2 changed files with 181 additions and 147 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

302
src/gallium/auxiliary/draw/draw_gs.c
View file

@ -46,14 +46,14 @@
/* fixme: move it from here */
#define MAX_PRIMITIVES 64
static inline int
draw_gs_get_input_index(int semantic, int index,
const struct tgsi_shader_info *input_info)
{
int i;
const ubyte *input_semantic_names = input_info->output_semantic_name;
const ubyte *input_semantic_indices = input_info->output_semantic_index;
for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
for (int i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
if (input_semantic_names[i] == semantic &&
input_semantic_indices[i] == index)
return i;
@ -61,6 +61,7 @@ draw_gs_get_input_index(int semantic, int index,
return -1;
}
/**
* We execute geometry shaders in the SOA mode, so ideally we want to
* flush when the number of currently fetched primitives is equal to
@ -73,6 +74,7 @@ draw_gs_should_flush(struct draw_geometry_shader *shader)
return (shader->fetched_prim_count == shader->vector_length || shader->num_invocations > 1);
}
/*#define DEBUG_OUTPUTS 1*/
static void
tgsi_fetch_gs_outputs(struct draw_geometry_shader *shader,
@ -81,7 +83,6 @@ tgsi_fetch_gs_outputs(struct draw_geometry_shader *shader,
float (**p_output)[4])
{
struct tgsi_exec_machine *machine = shader->machine;
unsigned prim_idx, j, slot;
float (*output)[4];
output = *p_output;
@ -89,19 +90,19 @@ tgsi_fetch_gs_outputs(struct draw_geometry_shader *shader,
/* Unswizzle all output results.
*/
for (prim_idx = 0; prim_idx < num_primitives; ++prim_idx) {
for (unsigned prim_idx = 0; prim_idx < num_primitives; ++prim_idx) {
unsigned num_verts_per_prim = machine->Primitives[stream][prim_idx];
unsigned prim_offset = machine->PrimitiveOffsets[stream][prim_idx];
shader->stream[stream].primitive_lengths[prim_idx + shader->stream[stream].emitted_primitives] =
machine->Primitives[stream][prim_idx];
shader->stream[stream].emitted_vertices += num_verts_per_prim;
for (j = 0; j < num_verts_per_prim; j++) {
for (unsigned j = 0; j < num_verts_per_prim; j++) {
int idx = prim_offset + j * shader->info.num_outputs;
#ifdef DEBUG_OUTPUTS
debug_printf("%d/%d) Output vert:\n", stream, idx / shader->info.num_outputs);
#endif
for (slot = 0; slot < shader->info.num_outputs; slot++) {
for (unsigned slot = 0; slot < shader->info.num_outputs; slot++) {
output[slot][0] = machine->Outputs[idx + slot].xyzw[0].f[0];
output[slot][1] = machine->Outputs[idx + slot].xyzw[1].f[0];
output[slot][2] = machine->Outputs[idx + slot].xyzw[2].f[0];
@ -121,17 +122,16 @@ tgsi_fetch_gs_outputs(struct draw_geometry_shader *shader,
shader->stream[stream].emitted_primitives += num_primitives;
}
/*#define DEBUG_INPUTS 1*/
static void tgsi_fetch_gs_input(struct draw_geometry_shader *shader,
unsigned *indices,
unsigned num_vertices,
unsigned prim_idx)
static void
tgsi_fetch_gs_input(struct draw_geometry_shader *shader,
unsigned *indices,
unsigned num_vertices,
unsigned prim_idx)
{
struct tgsi_exec_machine *machine = shader->machine;
unsigned slot, i;
int vs_slot;
unsigned input_vertex_stride = shader->input_vertex_stride;
const float (*input_ptr)[4];
const unsigned input_vertex_stride = shader->input_vertex_stride;
int primid_sv = machine->SysSemanticToIndex[TGSI_SEMANTIC_PRIMID];
if (primid_sv != -1) {
@ -139,17 +139,17 @@ static void tgsi_fetch_gs_input(struct draw_geometry_shader *shader,
machine->SystemValue[primid_sv].xyzw[0].i[j] = shader->in_prim_idx;
}
input_ptr = shader->input;
const float (*input_ptr)[4] = shader->input;
for (i = 0; i < num_vertices; ++i) {
const float (*input)[4];
for (unsigned i = 0; i < num_vertices; ++i) {
#if DEBUG_INPUTS
debug_printf("%d) vertex index = %d (prim idx = %d)\n",
i, indices[i], prim_idx);
#endif
input = (const float (*)[4])(
(const char *)input_ptr + (indices[i] * input_vertex_stride));
for (slot = 0, vs_slot = 0; slot < shader->info.num_inputs; ++slot) {
const float (*input)[4] = (const float (*)[4])
((const char *)input_ptr + (indices[i] * input_vertex_stride));
int vs_slot = 0;
for (unsigned slot = 0; slot < shader->info.num_inputs; ++slot) {
unsigned idx = i * TGSI_EXEC_MAX_INPUT_ATTRIBS + slot;
if (shader->info.input_semantic_name[slot] == TGSI_SEMANTIC_PRIMID) {
machine->Inputs[idx].xyzw[0].u[prim_idx] = shader->in_prim_idx;
@ -157,6 +157,7 @@ static void tgsi_fetch_gs_input(struct draw_geometry_shader *shader,
machine->Inputs[idx].xyzw[2].u[prim_idx] = shader->in_prim_idx;
machine->Inputs[idx].xyzw[3].u[prim_idx] = shader->in_prim_idx;
} else {
/* TODO: Move this call out of the for(i) loop */
vs_slot = draw_gs_get_input_index(
shader->info.input_semantic_name[slot],
shader->info.input_semantic_index[slot],
@ -194,21 +195,24 @@ static void tgsi_fetch_gs_input(struct draw_geometry_shader *shader,
}
}
static void tgsi_gs_prepare(struct draw_geometry_shader *shader,
const void *constants[PIPE_MAX_CONSTANT_BUFFERS],
const unsigned constants_size[PIPE_MAX_CONSTANT_BUFFERS])
static void
tgsi_gs_prepare(struct draw_geometry_shader *shader,
const void *constants[PIPE_MAX_CONSTANT_BUFFERS],
const unsigned constants_size[PIPE_MAX_CONSTANT_BUFFERS])
{
struct tgsi_exec_machine *machine = shader->machine;
tgsi_exec_set_constant_buffers(machine, PIPE_MAX_CONSTANT_BUFFERS,
constants, constants_size);
}
static void tgsi_gs_run(struct draw_geometry_shader *shader,
unsigned input_primitives,
unsigned *out_prims)
static void
tgsi_gs_run(struct draw_geometry_shader *shader,
unsigned input_primitives,
unsigned *out_prims)
{
struct tgsi_exec_machine *machine = shader->machine;
int i;
if (shader->info.uses_invocationid) {
unsigned i = machine->SysSemanticToIndex[TGSI_SEMANTIC_INVOCATIONID];
@ -219,37 +223,39 @@ static void tgsi_gs_run(struct draw_geometry_shader *shader,
/* run interpreter */
tgsi_exec_machine_run(machine, 0);
for (i = 0; i < 4; i++)
for (int i = 0; i < 4; i++)
out_prims[i] = machine->OutputPrimCount[i];
}
#ifdef DRAW_LLVM_AVAILABLE
/*
* Fetch the vertex attribute values for one primitive.
* num_vertices is vertices/prim (1 for points, 2 for lines, 3 for tris)
*/
static void
llvm_fetch_gs_input(struct draw_geometry_shader *shader,
unsigned *indices,
unsigned num_vertices,
unsigned prim_idx)
{
unsigned slot, i;
int vs_slot;
unsigned input_vertex_stride = shader->input_vertex_stride;
const float (*input_ptr)[4];
const unsigned input_vertex_stride = shader->input_vertex_stride;
float (*input_data)[6][PIPE_MAX_SHADER_INPUTS][TGSI_NUM_CHANNELS][TGSI_NUM_CHANNELS] = &shader->gs_input->data;
shader->llvm_prim_ids[shader->fetched_prim_count] = shader->in_prim_idx;
input_ptr = shader->input;
const float (*input_ptr)[4] = shader->input;
for (i = 0; i < num_vertices; ++i) {
const float (*input)[4];
for (unsigned i = 0; i < num_vertices; ++i) {
#if DEBUG_INPUTS
debug_printf("%d) vertex index = %d (prim idx = %d)\n",
i, indices[i], prim_idx);
#endif
input = (const float (*)[4])(
(const char *)input_ptr + (indices[i] * input_vertex_stride));
for (slot = 0, vs_slot = 0; slot < shader->info.num_inputs; ++slot) {
const float (*input)[4] = (const float (*)[4])
((const char *)input_ptr + (indices[i] * input_vertex_stride));
int vs_slot = 0;
for (unsigned slot = 0; slot < shader->info.num_inputs; ++slot) {
if (shader->info.input_semantic_name[slot] == TGSI_SEMANTIC_PRIMID) {
/* skip. we handle system values through gallivm */
/* NOTE: If we hit this case here it's an ordinary input not a sv,
@ -295,6 +301,7 @@ llvm_fetch_gs_input(struct draw_geometry_shader *shader,
}
}
static void
llvm_fetch_gs_outputs(struct draw_geometry_shader *shader,
unsigned stream,
@ -306,20 +313,20 @@ llvm_fetch_gs_outputs(struct draw_geometry_shader *shader,
int total_prims = 0;
int max_prims_per_invocation = 0;
char *output_ptr = (char*)shader->gs_output[stream];
int i, j, prim_idx;
int prim_idx;
unsigned next_prim_boundary = shader->primitive_boundary;
for (i = 0; i < shader->vector_length; ++i) {
for (int i = 0; i < shader->vector_length; ++i) {
int prims = shader->llvm_emitted_primitives[i + (stream * shader->vector_length)];
total_prims += prims;
max_prims_per_invocation = MAX2(max_prims_per_invocation, prims);
}
for (i = 0; i < shader->vector_length; ++i) {
for (int i = 0; i < shader->vector_length; ++i) {
total_verts += shader->llvm_emitted_vertices[i + (stream * shader->vector_length)];
}
output_ptr += shader->stream[stream].emitted_vertices * shader->vertex_size;
for (i = 0; i < shader->vector_length - 1; ++i) {
for (int i = 0; i < shader->vector_length - 1; ++i) {
int current_verts = shader->llvm_emitted_vertices[i + (stream * shader->vector_length)];
int next_verts = shader->llvm_emitted_vertices[i + 1 + (stream * shader->vector_length)];
#if 0
@ -344,8 +351,7 @@ llvm_fetch_gs_outputs(struct draw_geometry_shader *shader,
#if 0
{
int i;
for (i = 0; i < total_verts; ++i) {
for (int i = 0; i < total_verts; ++i) {
struct vertex_header *vh = (struct vertex_header *)(output_ptr + shader->vertex_size * i);
debug_printf("%d) Vertex:\n", i);
for (j = 0; j < shader->info.num_outputs; ++j) {
@ -360,9 +366,9 @@ llvm_fetch_gs_outputs(struct draw_geometry_shader *shader,
#endif
prim_idx = 0;
for (i = 0; i < shader->vector_length; ++i) {
for (int i = 0; i < shader->vector_length; ++i) {
int num_prims = shader->llvm_emitted_primitives[i + (stream * shader->vector_length)];
for (j = 0; j < num_prims; ++j) {
for (int j = 0; j < num_prims; ++j) {
int prim_length =
shader->llvm_prim_lengths[j * shader->num_vertex_streams + stream][i];
shader->stream[stream].primitive_lengths[shader->stream[stream].emitted_primitives + prim_idx] =
@ -375,6 +381,7 @@ llvm_fetch_gs_outputs(struct draw_geometry_shader *shader,
shader->stream[stream].emitted_vertices += total_verts;
}
static void
llvm_gs_prepare(struct draw_geometry_shader *shader,
const void *constants[PIPE_MAX_CONSTANT_BUFFERS],
@ -382,6 +389,7 @@ llvm_gs_prepare(struct draw_geometry_shader *shader,
{
}
static void
llvm_gs_run(struct draw_geometry_shader *shader,
unsigned input_primitives, unsigned *out_prims)
@ -393,14 +401,14 @@ llvm_gs_run(struct draw_geometry_shader *shader,
input[i] = (struct vertex_header *)tmp;
}
shader->current_variant->jit_func(
shader->jit_context, shader->gs_input->data,
input,
input_primitives,
shader->draw->instance_id,
shader->llvm_prim_ids,
shader->invocation_id,
shader->draw->pt.user.viewid);
shader->current_variant->jit_func(shader->jit_context,
shader->gs_input->data,
input,
input_primitives,
shader->draw->instance_id,
shader->llvm_prim_ids,
shader->invocation_id,
shader->draw->pt.user.viewid);
for (unsigned i = 0; i < shader->num_vertex_streams; i++) {
out_prims[i] = shader->jit_context->emitted_prims[i];
@ -409,7 +417,9 @@ llvm_gs_run(struct draw_geometry_shader *shader,
#endif
static void gs_flush(struct draw_geometry_shader *shader)
static void
gs_flush(struct draw_geometry_shader *shader)
{
unsigned out_prim_count[TGSI_MAX_VERTEX_STREAMS];
unsigned i;
@ -443,8 +453,9 @@ static void gs_flush(struct draw_geometry_shader *shader)
shader->fetched_prim_count = 0;
}
static void gs_point(struct draw_geometry_shader *shader,
int idx)
static void
gs_point(struct draw_geometry_shader *shader, int idx)
{
unsigned indices[1];
@ -459,8 +470,9 @@ static void gs_point(struct draw_geometry_shader *shader,
gs_flush(shader);
}
static void gs_line(struct draw_geometry_shader *shader,
int i0, int i1)
static void
gs_line(struct draw_geometry_shader *shader, int i0, int i1)
{
unsigned indices[2];
@ -476,8 +488,10 @@ static void gs_line(struct draw_geometry_shader *shader,
gs_flush(shader);
}
static void gs_line_adj(struct draw_geometry_shader *shader,
int i0, int i1, int i2, int i3)
static void
gs_line_adj(struct draw_geometry_shader *shader,
int i0, int i1, int i2, int i3)
{
unsigned indices[4];
@ -495,8 +509,10 @@ static void gs_line_adj(struct draw_geometry_shader *shader,
gs_flush(shader);
}
static void gs_tri(struct draw_geometry_shader *shader,
int i0, int i1, int i2)
static void
gs_tri(struct draw_geometry_shader *shader,
int i0, int i1, int i2)
{
unsigned indices[3];
@ -513,9 +529,11 @@ static void gs_tri(struct draw_geometry_shader *shader,
gs_flush(shader);
}
static void gs_tri_adj(struct draw_geometry_shader *shader,
int i0, int i1, int i2,
int i3, int i4, int i5)
static void
gs_tri_adj(struct draw_geometry_shader *shader,
int i0, int i1, int i2,
int i3, int i4, int i5)
{
unsigned indices[6];
@ -549,49 +567,50 @@ static void gs_tri_adj(struct draw_geometry_shader *shader,
/**
* Execute geometry shader.
*/
int draw_geometry_shader_run(struct draw_geometry_shader *shader,
const void *constants[PIPE_MAX_CONSTANT_BUFFERS],
const unsigned constants_size[PIPE_MAX_CONSTANT_BUFFERS],
const struct draw_vertex_info *input_verts,
const struct draw_prim_info *input_prim,
const struct tgsi_shader_info *input_info,
struct draw_vertex_info *output_verts,
struct draw_prim_info *output_prims )
int
draw_geometry_shader_run(struct draw_geometry_shader *shader,
const void *constants[PIPE_MAX_CONSTANT_BUFFERS],
const unsigned constants_size[PIPE_MAX_CONSTANT_BUFFERS],
const struct draw_vertex_info *input_verts,
const struct draw_prim_info *input_prim,
const struct tgsi_shader_info *input_info,
struct draw_vertex_info *output_verts,
struct draw_prim_info *output_prims)
{
const float (*input)[4] = (const float (*)[4])input_verts->verts->data;
unsigned input_stride = input_verts->vertex_size;
unsigned num_outputs = draw_total_gs_outputs(shader->draw);
unsigned vertex_size = sizeof(struct vertex_header) + num_outputs * 4 * sizeof(float);
unsigned num_input_verts = input_prim->linear ?
input_verts->count :
input_prim->count;
unsigned num_in_primitives =
align(
MAX2(u_decomposed_prims_for_vertices(input_prim->prim,
num_input_verts),
u_decomposed_prims_for_vertices(shader->input_primitive,
num_input_verts)),
shader->vector_length);
unsigned max_out_prims =
u_decomposed_prims_for_vertices(shader->output_primitive,
shader->max_output_vertices)
* num_in_primitives;
/* we allocate exactly one extra vertex per primitive to allow the GS to emit
* overflown vertices into some area where they won't harm anyone */
unsigned total_verts_per_buffer = shader->primitive_boundary *
num_in_primitives;
int i;
const unsigned input_stride = input_verts->vertex_size;
const unsigned num_outputs = draw_total_gs_outputs(shader->draw);
const unsigned vertex_size =
sizeof(struct vertex_header) + num_outputs * 4 * sizeof(float);
const unsigned num_input_verts =
input_prim->linear ? input_verts->count : input_prim->count;
const unsigned num_in_primitives =
align(MAX2(u_decomposed_prims_for_vertices(input_prim->prim,
num_input_verts),
u_decomposed_prims_for_vertices(shader->input_primitive,
num_input_verts)),
shader->vector_length);
//Assume at least one primitive
max_out_prims = MAX2(max_out_prims, 1);
const unsigned max_out_prims =
MAX2(1, u_decomposed_prims_for_vertices(shader->output_primitive,
shader->max_output_vertices)
* num_in_primitives);
for (i = 0; i < shader->num_vertex_streams; i++) {
/* we allocate exactly one extra vertex per primitive to allow the GS to
* emit overflown vertices into some area where they won't harm anyone */
const unsigned total_verts_per_buffer =
shader->primitive_boundary * num_in_primitives;
for (int i = 0; i < shader->num_vertex_streams; i++) {
/* write all the vertex data into all the streams */
output_verts[i].vertex_size = vertex_size;
output_verts[i].stride = output_verts[i].vertex_size;
output_verts[i].verts =
(struct vertex_header *)MALLOC(output_verts[i].vertex_size *
total_verts_per_buffer * shader->num_invocations +
DRAW_EXTRA_VERTICES_PADDING);
(struct vertex_header *) MALLOC(output_verts[i].vertex_size *
total_verts_per_buffer *
shader->num_invocations +
DRAW_EXTRA_VERTICES_PADDING);
assert(output_verts[i].verts);
}
@ -612,11 +631,12 @@ int draw_geometry_shader_run(struct draw_geometry_shader *shader,
total_verts_per_buffer);
#endif
for (i = 0; i < shader->num_vertex_streams; i++) {
for (int i = 0; i < shader->num_vertex_streams; i++) {
shader->stream[i].emitted_vertices = 0;
shader->stream[i].emitted_primitives = 0;
FREE(shader->stream[i].primitive_lengths);
shader->stream[i].primitive_lengths = MALLOC(max_out_prims * sizeof(unsigned) * shader->num_invocations);
shader->stream[i].primitive_lengths =
MALLOC(max_out_prims * sizeof(unsigned) * shader->num_invocations);
shader->stream[i].tmp_output = (float (*)[4])output_verts[i].verts->data;
}
shader->vertex_size = vertex_size;
@ -627,20 +647,19 @@ int draw_geometry_shader_run(struct draw_geometry_shader *shader,
#ifdef DRAW_LLVM_AVAILABLE
if (shader->draw->llvm) {
for (i = 0; i < shader->num_vertex_streams; i++) {
for (int i = 0; i < shader->num_vertex_streams; i++) {
shader->gs_output[i] = output_verts[i].verts;
}
if (max_out_prims > shader->max_out_prims) {
unsigned i;
if (shader->llvm_prim_lengths) {
for (i = 0; i < shader->num_vertex_streams * shader->max_out_prims; ++i) {
for (unsigned i = 0; i < shader->num_vertex_streams * shader->max_out_prims; ++i) {
align_free(shader->llvm_prim_lengths[i]);
}
FREE(shader->llvm_prim_lengths);
}
shader->llvm_prim_lengths = MALLOC(shader->num_vertex_streams * max_out_prims * sizeof(unsigned*));
for (i = 0; i < shader->num_vertex_streams * max_out_prims; ++i) {
for (unsigned i = 0; i < shader->num_vertex_streams * max_out_prims; ++i) {
int vector_size = shader->vector_length * sizeof(unsigned);
shader->llvm_prim_lengths[i] =
align_malloc(vector_size, vector_size);
@ -673,7 +692,7 @@ int draw_geometry_shader_run(struct draw_geometry_shader *shader,
/* Update prim_info:
*/
for (i = 0; i < shader->num_vertex_streams; i++) {
for (int i = 0; i < shader->num_vertex_streams; i++) {
output_prims[i].linear = TRUE;
output_prims[i].elts = NULL;
output_prims[i].start = 0;
@ -685,29 +704,32 @@ int draw_geometry_shader_run(struct draw_geometry_shader *shader,
output_verts[i].count = shader->stream[i].emitted_vertices;
if (shader->draw->collect_statistics) {
unsigned j;
for (j = 0; j < shader->stream[i].emitted_primitives; ++j) {
for (unsigned j = 0; j < shader->stream[i].emitted_primitives; ++j) {
shader->draw->statistics.gs_primitives +=
u_decomposed_prims_for_vertices(shader->output_primitive,
shader->stream[i].primitive_lengths[j]);
shader->stream[i].primitive_lengths[j]);
}
}
}
#if 0
debug_printf("GS finished\n");
for (i = 0; i < 4; i++)
debug_printf("stream %d: prims = %d verts = %d\n", i, output_prims[i].primitive_count, output_verts[i].count);
for (int i = 0; i < 4; i++)
debug_printf("stream %d: prims = %d verts = %d\n", i,
output_prims[i].primitive_count, output_verts[i].count);
#endif
return 0;
}
void draw_geometry_shader_prepare(struct draw_geometry_shader *shader,
struct draw_context *draw)
void
draw_geometry_shader_prepare(struct draw_geometry_shader *shader,
struct draw_context *draw)
{
boolean use_llvm = draw->llvm != NULL;
if (!use_llvm && shader && shader->machine->Tokens != shader->state.tokens) {
if (!use_llvm &&
shader && shader->machine->Tokens != shader->state.tokens) {
tgsi_exec_machine_bind_shader(shader->machine,
shader->state.tokens,
draw->gs.tgsi.sampler,
@ -718,7 +740,7 @@ void draw_geometry_shader_prepare(struct draw_geometry_shader *shader,
boolean
draw_gs_init( struct draw_context *draw )
draw_gs_init(struct draw_context *draw)
{
if (!draw->llvm) {
draw->gs.tgsi.machine = tgsi_exec_machine_create(PIPE_SHADER_GEOMETRY);
@ -728,7 +750,8 @@ draw_gs_init( struct draw_context *draw )
MAX_PRIMITIVES * sizeof(struct tgsi_exec_vector), 16);
draw->gs.tgsi.machine->PrimitiveOffsets[i] = align_malloc(
MAX_PRIMITIVES * sizeof(struct tgsi_exec_vector), 16);
if (!draw->gs.tgsi.machine->Primitives[i] || !draw->gs.tgsi.machine->PrimitiveOffsets[i])
if (!draw->gs.tgsi.machine->Primitives[i] ||
!draw->gs.tgsi.machine->PrimitiveOffsets[i])
return FALSE;
memset(draw->gs.tgsi.machine->Primitives[i], 0,
MAX_PRIMITIVES * sizeof(struct tgsi_exec_vector));
@ -740,11 +763,12 @@ draw_gs_init( struct draw_context *draw )
return TRUE;
}
void draw_gs_destroy( struct draw_context *draw )
void
draw_gs_destroy(struct draw_context *draw)
{
int i;
if (draw->gs.tgsi.machine) {
for (i = 0; i < TGSI_MAX_VERTEX_STREAMS; i++) {
for (int i = 0; i < TGSI_MAX_VERTEX_STREAMS; i++) {
align_free(draw->gs.tgsi.machine->Primitives[i]);
align_free(draw->gs.tgsi.machine->PrimitiveOffsets[i]);
}
@ -752,6 +776,10 @@ void draw_gs_destroy( struct draw_context *draw )
}
}
/*
* num_vertices is vertices/prim (1 for points, 2 for lines, 3 for tris)
*/
struct draw_geometry_shader *
draw_create_geometry_shader(struct draw_context *draw,
const struct pipe_shader_state *state)
@ -761,7 +789,6 @@ draw_create_geometry_shader(struct draw_context *draw,
struct llvm_geometry_shader *llvm_gs = NULL;
#endif
struct draw_geometry_shader *gs;
unsigned i;
#ifdef DRAW_LLVM_AVAILABLE
if (use_llvm) {
@ -794,7 +821,7 @@ draw_create_geometry_shader(struct draw_context *draw,
tgsi_scan_shader(state->tokens, &gs->info);
gs->num_vertex_streams = 1;
for (i = 0; i < gs->state.stream_output.num_outputs; i++) {
for (unsigned i = 0; i < gs->state.stream_output.num_outputs; i++) {
if (gs->state.stream_output.output[i].stream >= gs->num_vertex_streams)
gs->num_vertex_streams = gs->state.stream_output.output[i].stream + 1;
}
@ -844,7 +871,7 @@ draw_create_geometry_shader(struct draw_context *draw,
gs->position_output = -1;
bool found_clipvertex = false;
for (i = 0; i < gs->info.num_outputs; i++) {
for (unsigned i = 0; i < gs->info.num_outputs; i++) {
if (gs->info.output_semantic_name[i] == TGSI_SEMANTIC_POSITION &&
gs->info.output_semantic_index[i] == 0)
gs->position_output = i;
@ -885,7 +912,6 @@ draw_create_geometry_shader(struct draw_context *draw,
gs->jit_context = &draw->llvm->gs_jit_context;
llvm_gs->variant_key_size =
draw_gs_llvm_variant_key_size(
gs->info.file_max[TGSI_FILE_SAMPLER]+1,
@ -903,8 +929,10 @@ draw_create_geometry_shader(struct draw_context *draw,
return gs;
}
void draw_bind_geometry_shader(struct draw_context *draw,
struct draw_geometry_shader *dgs)
void
draw_bind_geometry_shader(struct draw_context *draw,
struct draw_geometry_shader *dgs)
{
draw_do_flush(draw, DRAW_FLUSH_STATE_CHANGE);
@ -914,17 +942,17 @@ void draw_bind_geometry_shader(struct draw_context *draw,
draw->gs.position_output = dgs->position_output;
draw->gs.clipvertex_output = dgs->clipvertex_output;
draw_geometry_shader_prepare(dgs, draw);
}
else {
} else {
draw->gs.geometry_shader = NULL;
draw->gs.num_gs_outputs = 0;
}
}
void draw_delete_geometry_shader(struct draw_context *draw,
struct draw_geometry_shader *dgs)
void
draw_delete_geometry_shader(struct draw_context *draw,
struct draw_geometry_shader *dgs)
{
int i;
if (!dgs) {
return;
}
@ -940,8 +968,7 @@ void draw_delete_geometry_shader(struct draw_context *draw,
assert(shader->variants_cached == 0);
if (dgs->llvm_prim_lengths) {
unsigned i;
for (i = 0; i < dgs->num_vertex_streams * dgs->max_out_prims; ++i) {
for (unsigned i = 0; i < dgs->num_vertex_streams * dgs->max_out_prims; ++i) {
align_free(dgs->llvm_prim_lengths[i]);
}
FREE(dgs->llvm_prim_lengths);
@ -957,7 +984,7 @@ void draw_delete_geometry_shader(struct draw_context *draw,
if (draw->gs.tgsi.machine && draw->gs.tgsi.machine->Tokens == dgs->state.tokens)
draw->gs.tgsi.machine->Tokens = NULL;
for (i = 0; i < TGSI_MAX_VERTEX_STREAMS; i++)
for (unsigned i = 0; i < TGSI_MAX_VERTEX_STREAMS; i++)
FREE(dgs->stream[i].primitive_lengths);
if (dgs->state.type == PIPE_SHADER_IR_NIR && dgs->state.ir.nir)
@ -968,8 +995,9 @@ void draw_delete_geometry_shader(struct draw_context *draw,
#ifdef DRAW_LLVM_AVAILABLE
void draw_gs_set_current_variant(struct draw_geometry_shader *shader,
struct draw_gs_llvm_variant *variant)
void
draw_gs_set_current_variant(struct draw_geometry_shader *shader,
struct draw_gs_llvm_variant *variant)
{
shader->current_variant = variant;
}

26
src/gallium/auxiliary/draw/draw_gs.h
View file

@ -118,14 +118,17 @@ struct draw_geometry_shader {
unsigned num_primitives,
float (**p_output)[4]);
void (*prepare)(struct draw_geometry_shader *shader,
const void *constants[PIPE_MAX_CONSTANT_BUFFERS],
const unsigned constants_size[PIPE_MAX_CONSTANT_BUFFERS]);
void (*prepare)(struct draw_geometry_shader *shader,
const void *constants[PIPE_MAX_CONSTANT_BUFFERS],
const unsigned constants_size[PIPE_MAX_CONSTANT_BUFFERS]);
void (*run)(struct draw_geometry_shader *shader,
unsigned input_primitives, unsigned *out_prims);
};
void draw_geometry_shader_new_instance(struct draw_geometry_shader *gs);
void
draw_geometry_shader_new_instance(struct draw_geometry_shader *gs);
/*
* Returns the number of vertices emitted.
@ -141,15 +144,18 @@ int draw_geometry_shader_run(struct draw_geometry_shader *shader,
struct draw_vertex_info *output_verts,
struct draw_prim_info *output_prims );
void draw_geometry_shader_prepare(struct draw_geometry_shader *shader,
struct draw_context *draw);
void
draw_geometry_shader_prepare(struct draw_geometry_shader *shader,
struct draw_context *draw);
int draw_gs_max_output_vertices(struct draw_geometry_shader *shader,
unsigned pipe_prim);
int
draw_gs_max_output_vertices(struct draw_geometry_shader *shader,
unsigned pipe_prim);
#ifdef DRAW_LLVM_AVAILABLE
void draw_gs_set_current_variant(struct draw_geometry_shader *shader,
struct draw_gs_llvm_variant *variant);
void
draw_gs_set_current_variant(struct draw_geometry_shader *shader,
struct draw_gs_llvm_variant *variant);
#endif
#endif