OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

gallium: remove semantic info from pipe_shader_state

Browse Source 
Brian's patch to clean up the shader interfaces.
This commit is contained in:
Brian Paul
2008-03-13 18:08:18 +00:00
committed by Keith Whitwell
parent b0d5519b44
commit fa9e7e9a8d
8 changed files with 104 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/gallium/auxiliary/draw/draw_aaline.c
View File

@@ -340,7 +340,7 @@ generate_aaline_fs(struct aaline_stage *aaline)
tgsi_dump(aaline_fs.tokens, 0); tgsi_dump(aaline_fs.tokens, 0);
#endif #endif
#if 1 /* XXX remove */ #if 0 /* XXX remove */
aaline_fs.input_semantic_name[aaline_fs.num_inputs] = TGSI_SEMANTIC_GENERIC; aaline_fs.input_semantic_name[aaline_fs.num_inputs] = TGSI_SEMANTIC_GENERIC;
aaline_fs.input_semantic_index[aaline_fs.num_inputs] = transform.maxGeneric + 1; aaline_fs.input_semantic_index[aaline_fs.num_inputs] = transform.maxGeneric + 1;
aaline_fs.num_inputs++; aaline_fs.num_inputs++;

2
src/gallium/auxiliary/draw/draw_aapoint.c
View File

@@ -514,7 +514,7 @@ generate_aapoint_fs(struct aapoint_stage *aapoint)
tgsi_dump(aapoint_fs.tokens, 0); tgsi_dump(aapoint_fs.tokens, 0);
#endif #endif
#if 1 /* XXX remove */ #if 0 /* XXX remove */
aapoint_fs.input_semantic_name[aapoint_fs.num_inputs] = TGSI_SEMANTIC_GENERIC; aapoint_fs.input_semantic_name[aapoint_fs.num_inputs] = TGSI_SEMANTIC_GENERIC;
aapoint_fs.input_semantic_index[aapoint_fs.num_inputs] = transform.maxGeneric + 1; aapoint_fs.input_semantic_index[aapoint_fs.num_inputs] = transform.maxGeneric + 1;
aapoint_fs.num_inputs++; aapoint_fs.num_inputs++;

2
src/gallium/auxiliary/draw/draw_pstipple.c
View File

@@ -331,7 +331,7 @@ generate_pstip_fs(struct pstip_stage *pstip)
pstip->sampler_unit = transform.maxSampler + 1; pstip->sampler_unit = transform.maxSampler + 1;
#if 1 /* XXX remove */ #if 0 /* XXX remove */
if (transform.wincoordInput < 0) { if (transform.wincoordInput < 0) {
pstip_fs.input_semantic_name[pstip_fs.num_inputs] = TGSI_SEMANTIC_POSITION; pstip_fs.input_semantic_name[pstip_fs.num_inputs] = TGSI_SEMANTIC_POSITION;
pstip_fs.input_semantic_index[pstip_fs.num_inputs] = (ubyte)transform.maxInput; pstip_fs.input_semantic_index[pstip_fs.num_inputs] = (ubyte)transform.maxInput;

2
src/gallium/include/pipe/p_state.h
View File

@@ -162,6 +162,7 @@ struct pipe_constant_buffer
struct pipe_shader_state struct pipe_shader_state
{ {
const struct tgsi_token *tokens; const struct tgsi_token *tokens;
#if 0
/* XXX these are going away */ /* XXX these are going away */
ubyte num_inputs; ubyte num_inputs;
ubyte num_outputs; ubyte num_outputs;
@@ -169,6 +170,7 @@ struct pipe_shader_state
ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS]; ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
ubyte output_semantic_name[PIPE_MAX_SHADER_OUTPUTS]; /**< TGSI_SEMANTIC_x */ ubyte output_semantic_name[PIPE_MAX_SHADER_OUTPUTS]; /**< TGSI_SEMANTIC_x */
ubyte output_semantic_index[PIPE_MAX_SHADER_OUTPUTS]; ubyte output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
#endif
}; };

2
src/mesa/state_tracker/st_debug.c
View File

@@ -52,10 +52,12 @@ st_print_current(void)
struct st_context *st = ctx->st; struct st_context *st = ctx->st;
int i; int i;
#if 0
printf("Vertex Transform Inputs:\n"); printf("Vertex Transform Inputs:\n");
for (i = 0; i < st->vp->state.num_inputs; i++) { for (i = 0; i < st->vp->state.num_inputs; i++) {
printf(" Slot %d: VERT_ATTRIB_%d\n", i, st->vp->index_to_input[i]); printf(" Slot %d: VERT_ATTRIB_%d\n", i, st->vp->index_to_input[i]);
} }
#endif
tgsi_dump( st->vp->state.tokens, 0 ); tgsi_dump( st->vp->state.tokens, 0 );
if (st->vp->Base.Base.Parameters) if (st->vp->Base.Base.Parameters)

6
src/mesa/state_tracker/st_draw.c
View File

@@ -223,7 +223,7 @@ st_draw_vbo(GLcontext *ctx,
/* loop over TGSI shader inputs to determine vertex buffer /* loop over TGSI shader inputs to determine vertex buffer
* and attribute info * and attribute info
*/ */
for (attr = 0; attr < vs->num_inputs; attr++) { for (attr = 0; attr < /*vs*/vp->num_inputs; attr++) {
const GLuint mesaAttr = vp->index_to_input[attr]; const GLuint mesaAttr = vp->index_to_input[attr];
struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj; struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;
struct pipe_vertex_element velement; struct pipe_vertex_element velement;
@@ -333,7 +333,7 @@ st_draw_vbo(GLcontext *ctx,
} }
/* unreference buffers (frees wrapped user-space buffer objects) */ /* unreference buffers (frees wrapped user-space buffer objects) */
for (attr = 0; attr < vs->num_inputs; attr++) { for (attr = 0; attr < /*vs*/vp->num_inputs; attr++) {
pipe_buffer_reference(winsys, &vbuffer[attr].buffer, NULL); pipe_buffer_reference(winsys, &vbuffer[attr].buffer, NULL);
assert(!vbuffer[attr].buffer); assert(!vbuffer[attr].buffer);
pipe->set_vertex_buffer(pipe, attr, &vbuffer[attr]); pipe->set_vertex_buffer(pipe, attr, &vbuffer[attr]);
@@ -502,7 +502,7 @@ st_feedback_draw_vbo(GLcontext *ctx,
/* loop over TGSI shader inputs to determine vertex buffer /* loop over TGSI shader inputs to determine vertex buffer
* and attribute info * and attribute info
*/ */
for (attr = 0; attr < vs->num_inputs; attr++) { for (attr = 0; attr < /*vs*/vp->num_inputs; attr++) {
const GLuint mesaAttr = vp->index_to_input[attr]; const GLuint mesaAttr = vp->index_to_input[attr];
struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj; struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;
struct pipe_vertex_element velement; struct pipe_vertex_element velement;

167
src/mesa/state_tracker/st_program.c
View File

@@ -85,6 +85,14 @@ st_translate_vertex_program(struct st_context *st,
GLuint num_generic = 0; GLuint num_generic = 0;
GLuint num_tokens; GLuint num_tokens;
ubyte vs_input_semantic_name[PIPE_MAX_SHADER_INPUTS];
ubyte vs_input_semantic_index[PIPE_MAX_SHADER_INPUTS];
uint vs_num_inputs = 0;
ubyte vs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
ubyte vs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
uint vs_num_outputs = 0;
memset(&vs, 0, sizeof(vs)); memset(&vs, 0, sizeof(vs));
/* /*
@@ -93,36 +101,36 @@ st_translate_vertex_program(struct st_context *st,
*/ */
for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) { for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
if (stvp->Base.Base.InputsRead & (1 << attr)) { if (stvp->Base.Base.InputsRead & (1 << attr)) {
const GLuint slot = vs.num_inputs; const GLuint slot = vs_num_inputs;
vs.num_inputs++; vs_num_inputs++;
stvp->input_to_index[attr] = slot; stvp->input_to_index[attr] = slot;
stvp->index_to_input[slot] = attr; stvp->index_to_input[slot] = attr;
switch (attr) { switch (attr) {
case VERT_ATTRIB_POS: case VERT_ATTRIB_POS:
vs.input_semantic_name[slot] = TGSI_SEMANTIC_POSITION; vs_input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
vs.input_semantic_index[slot] = 0; vs_input_semantic_index[slot] = 0;
break; break;
case VERT_ATTRIB_WEIGHT: case VERT_ATTRIB_WEIGHT:
/* fall-through */ /* fall-through */
case VERT_ATTRIB_NORMAL: case VERT_ATTRIB_NORMAL:
/* just label as a generic */ /* just label as a generic */
vs.input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC; vs_input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
vs.input_semantic_index[slot] = 0; vs_input_semantic_index[slot] = 0;
break; break;
case VERT_ATTRIB_COLOR0: case VERT_ATTRIB_COLOR0:
vs.input_semantic_name[slot] = TGSI_SEMANTIC_COLOR; vs_input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
vs.input_semantic_index[slot] = 0; vs_input_semantic_index[slot] = 0;
break; break;
case VERT_ATTRIB_COLOR1: case VERT_ATTRIB_COLOR1:
vs.input_semantic_name[slot] = TGSI_SEMANTIC_COLOR; vs_input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
vs.input_semantic_index[slot] = 1; vs_input_semantic_index[slot] = 1;
break; break;
case VERT_ATTRIB_FOG: case VERT_ATTRIB_FOG:
vs.input_semantic_name[slot] = TGSI_SEMANTIC_FOG; vs_input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
vs.input_semantic_index[slot] = 0; vs_input_semantic_index[slot] = 0;
break; break;
case VERT_ATTRIB_TEX0: case VERT_ATTRIB_TEX0:
case VERT_ATTRIB_TEX1: case VERT_ATTRIB_TEX1:
@@ -132,8 +140,8 @@ st_translate_vertex_program(struct st_context *st,
case VERT_ATTRIB_TEX5: case VERT_ATTRIB_TEX5:
case VERT_ATTRIB_TEX6: case VERT_ATTRIB_TEX6:
case VERT_ATTRIB_TEX7: case VERT_ATTRIB_TEX7:
vs.input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC; vs_input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
vs.input_semantic_index[slot] = num_generic++; vs_input_semantic_index[slot] = num_generic++;
break; break;
case VERT_ATTRIB_GENERIC0: case VERT_ATTRIB_GENERIC0:
case VERT_ATTRIB_GENERIC1: case VERT_ATTRIB_GENERIC1:
@@ -144,8 +152,8 @@ st_translate_vertex_program(struct st_context *st,
case VERT_ATTRIB_GENERIC6: case VERT_ATTRIB_GENERIC6:
case VERT_ATTRIB_GENERIC7: case VERT_ATTRIB_GENERIC7:
assert(attr < VERT_ATTRIB_MAX); assert(attr < VERT_ATTRIB_MAX);
vs.input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC; vs_input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
vs.input_semantic_index[slot] = num_generic++; vs_input_semantic_index[slot] = num_generic++;
break; break;
default: default:
assert(0); assert(0);
@@ -155,8 +163,8 @@ st_translate_vertex_program(struct st_context *st,
/* initialize output semantics to defaults */ /* initialize output semantics to defaults */
for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) { for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
vs.output_semantic_name[i] = TGSI_SEMANTIC_GENERIC; vs_output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;
vs.output_semantic_index[i] = 0; vs_output_semantic_index[i] = 0;
} }
num_generic = 0; num_generic = 0;
@@ -173,8 +181,8 @@ st_translate_vertex_program(struct st_context *st,
assert(slot != ~0); assert(slot != ~0);
} }
else { else {
slot = vs.num_outputs; slot = vs_num_outputs;
vs.num_outputs++; vs_num_outputs++;
defaultOutputMapping[attr] = slot; defaultOutputMapping[attr] = slot;
} }
@@ -185,32 +193,32 @@ st_translate_vertex_program(struct st_context *st,
switch (attr) { switch (attr) {
case VERT_RESULT_HPOS: case VERT_RESULT_HPOS:
assert(slot == 0); assert(slot == 0);
vs.output_semantic_name[slot] = TGSI_SEMANTIC_POSITION; vs_output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
vs.output_semantic_index[slot] = 0; vs_output_semantic_index[slot] = 0;
break; break;
case VERT_RESULT_COL0: case VERT_RESULT_COL0:
vs.output_semantic_name[slot] = TGSI_SEMANTIC_COLOR; vs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
vs.output_semantic_index[slot] = 0; vs_output_semantic_index[slot] = 0;
break; break;
case VERT_RESULT_COL1: case VERT_RESULT_COL1:
vs.output_semantic_name[slot] = TGSI_SEMANTIC_COLOR; vs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
vs.output_semantic_index[slot] = 1; vs_output_semantic_index[slot] = 1;
break; break;
case VERT_RESULT_BFC0: case VERT_RESULT_BFC0:
vs.output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR; vs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
vs.output_semantic_index[slot] = 0; vs_output_semantic_index[slot] = 0;
break; break;
case VERT_RESULT_BFC1: case VERT_RESULT_BFC1:
vs.output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR; vs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
vs.output_semantic_index[slot] = 1; vs_output_semantic_index[slot] = 1;
break; break;
case VERT_RESULT_FOGC: case VERT_RESULT_FOGC:
vs.output_semantic_name[slot] = TGSI_SEMANTIC_FOG; vs_output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
vs.output_semantic_index[slot] = 0; vs_output_semantic_index[slot] = 0;
break; break;
case VERT_RESULT_PSIZ: case VERT_RESULT_PSIZ:
vs.output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE; vs_output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
vs.output_semantic_index[slot] = 0; vs_output_semantic_index[slot] = 0;
break; break;
case VERT_RESULT_EDGE: case VERT_RESULT_EDGE:
assert(0); assert(0);
@@ -223,30 +231,30 @@ st_translate_vertex_program(struct st_context *st,
case VERT_RESULT_TEX5: case VERT_RESULT_TEX5:
case VERT_RESULT_TEX6: case VERT_RESULT_TEX6:
case VERT_RESULT_TEX7: case VERT_RESULT_TEX7:
vs.output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC; vs_output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
vs.output_semantic_index[slot] = num_generic++; vs_output_semantic_index[slot] = num_generic++;
break; break;
case VERT_RESULT_VAR0: case VERT_RESULT_VAR0:
/* fall-through */ /* fall-through */
default: default:
assert(attr - VERT_RESULT_VAR0 < MAX_VARYING); assert(attr - VERT_RESULT_VAR0 < MAX_VARYING);
vs.output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC; vs_output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
vs.output_semantic_index[slot] = num_generic++; vs_output_semantic_index[slot] = num_generic++;
} }
} }
} }
assert(vs.output_semantic_name[0] == TGSI_SEMANTIC_POSITION); assert(vs_output_semantic_name[0] == TGSI_SEMANTIC_POSITION);
if (outputMapping) { if (outputMapping) {
/* find max output slot referenced to compute vs.num_outputs */ /* find max output slot referenced to compute vs_num_outputs */
GLuint maxSlot = 0; GLuint maxSlot = 0;
for (attr = 0; attr < VERT_RESULT_MAX; attr++) { for (attr = 0; attr < VERT_RESULT_MAX; attr++) {
if (outputMapping[attr] != ~0 && outputMapping[attr] > maxSlot) if (outputMapping[attr] != ~0 && outputMapping[attr] > maxSlot)
maxSlot = outputMapping[attr]; maxSlot = outputMapping[attr];
} }
vs.num_outputs = maxSlot + 1; vs_num_outputs = maxSlot + 1;
} }
else { else {
outputMapping = defaultOutputMapping; outputMapping = defaultOutputMapping;
@@ -257,22 +265,23 @@ st_translate_vertex_program(struct st_context *st,
num_tokens = tgsi_translate_mesa_program( TGSI_PROCESSOR_VERTEX, num_tokens = tgsi_translate_mesa_program( TGSI_PROCESSOR_VERTEX,
&stvp->Base.Base, &stvp->Base.Base,
/* inputs */ /* inputs */
vs.num_inputs, vs_num_inputs,
stvp->input_to_index, stvp->input_to_index,
vs.input_semantic_name, vs_input_semantic_name,
vs.input_semantic_index, vs_input_semantic_index,
NULL, NULL,
/* outputs */ /* outputs */
vs.num_outputs, vs_num_outputs,
outputMapping, outputMapping,
vs.output_semantic_name, vs_output_semantic_name,
vs.output_semantic_index, vs_output_semantic_index,
/* tokenized result */ /* tokenized result */
tokens, ST_MAX_SHADER_TOKENS); tokens, ST_MAX_SHADER_TOKENS);
vs.tokens = (struct tgsi_token *) vs.tokens = (struct tgsi_token *)
mem_dup(tokens, num_tokens * sizeof(tokens[0])); mem_dup(tokens, num_tokens * sizeof(tokens[0]));
stvp->num_inputs = vs_num_inputs;
stvp->state = vs; /* struct copy */ stvp->state = vs; /* struct copy */
stvp->driver_shader = pipe->create_vs_state(pipe, &vs); stvp->driver_shader = pipe->create_vs_state(pipe, &vs);
@@ -310,6 +319,14 @@ st_translate_fragment_program(struct st_context *st,
GLuint num_generic = 0; GLuint num_generic = 0;
GLuint num_tokens; GLuint num_tokens;
ubyte fs_input_semantic_name[PIPE_MAX_SHADER_INPUTS];
ubyte fs_input_semantic_index[PIPE_MAX_SHADER_INPUTS];
uint fs_num_inputs = 0;
ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
uint fs_num_outputs = 0;
memset(&fs, 0, sizeof(fs)); memset(&fs, 0, sizeof(fs));
/* which vertex output goes to the first fragment input: */ /* which vertex output goes to the first fragment input: */
@@ -323,33 +340,33 @@ st_translate_fragment_program(struct st_context *st,
*/ */
for (attr = 0; attr < FRAG_ATTRIB_MAX; attr++) { for (attr = 0; attr < FRAG_ATTRIB_MAX; attr++) {
if (inputsRead & (1 << attr)) { if (inputsRead & (1 << attr)) {
const GLuint slot = fs.num_inputs; const GLuint slot = fs_num_inputs;
defaultInputMapping[attr] = slot; defaultInputMapping[attr] = slot;
stfp->input_map[slot] = vslot++; stfp->input_map[slot] = vslot++;
fs.num_inputs++; fs_num_inputs++;
switch (attr) { switch (attr) {
case FRAG_ATTRIB_WPOS: case FRAG_ATTRIB_WPOS:
fs.input_semantic_name[slot] = TGSI_SEMANTIC_POSITION; fs_input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
fs.input_semantic_index[slot] = 0; fs_input_semantic_index[slot] = 0;
interpMode[slot] = TGSI_INTERPOLATE_LINEAR; interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
break; break;
case FRAG_ATTRIB_COL0: case FRAG_ATTRIB_COL0:
fs.input_semantic_name[slot] = TGSI_SEMANTIC_COLOR; fs_input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
fs.input_semantic_index[slot] = 0; fs_input_semantic_index[slot] = 0;
interpMode[slot] = TGSI_INTERPOLATE_LINEAR; interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
break; break;
case FRAG_ATTRIB_COL1: case FRAG_ATTRIB_COL1:
fs.input_semantic_name[slot] = TGSI_SEMANTIC_COLOR; fs_input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
fs.input_semantic_index[slot] = 1; fs_input_semantic_index[slot] = 1;
interpMode[slot] = TGSI_INTERPOLATE_LINEAR; interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
break; break;
case FRAG_ATTRIB_FOGC: case FRAG_ATTRIB_FOGC:
fs.input_semantic_name[slot] = TGSI_SEMANTIC_FOG; fs_input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
fs.input_semantic_index[slot] = 0; fs_input_semantic_index[slot] = 0;
interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE; interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
break; break;
case FRAG_ATTRIB_TEX0: case FRAG_ATTRIB_TEX0:
@@ -360,15 +377,15 @@ st_translate_fragment_program(struct st_context *st,
case FRAG_ATTRIB_TEX5: case FRAG_ATTRIB_TEX5:
case FRAG_ATTRIB_TEX6: case FRAG_ATTRIB_TEX6:
case FRAG_ATTRIB_TEX7: case FRAG_ATTRIB_TEX7:
fs.input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC; fs_input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
fs.input_semantic_index[slot] = num_generic++; fs_input_semantic_index[slot] = num_generic++;
interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE; interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
break; break;
case FRAG_ATTRIB_VAR0: case FRAG_ATTRIB_VAR0:
/* fall-through */ /* fall-through */
default: default:
fs.input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC; fs_input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
fs.input_semantic_index[slot] = num_generic++; fs_input_semantic_index[slot] = num_generic++;
interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE; interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
} }
} }
@@ -383,10 +400,10 @@ st_translate_fragment_program(struct st_context *st,
/* if z is written, emit that first */ /* if z is written, emit that first */
if (outputsWritten & (1 << FRAG_RESULT_DEPR)) { if (outputsWritten & (1 << FRAG_RESULT_DEPR)) {
fs.output_semantic_name[fs.num_outputs] = TGSI_SEMANTIC_POSITION; fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
fs.output_semantic_index[fs.num_outputs] = 0; fs_output_semantic_index[fs_num_outputs] = 0;
outputMapping[FRAG_RESULT_DEPR] = fs.num_outputs; outputMapping[FRAG_RESULT_DEPR] = fs_num_outputs;
fs.num_outputs++; fs_num_outputs++;
outputsWritten &= ~(1 << FRAG_RESULT_DEPR); outputsWritten &= ~(1 << FRAG_RESULT_DEPR);
} }
@@ -399,15 +416,15 @@ st_translate_fragment_program(struct st_context *st,
assert(0); assert(0);
break; break;
case FRAG_RESULT_COLR: case FRAG_RESULT_COLR:
fs.output_semantic_name[fs.num_outputs] = TGSI_SEMANTIC_COLOR; fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
fs.output_semantic_index[fs.num_outputs] = numColors; fs_output_semantic_index[fs_num_outputs] = numColors;
outputMapping[attr] = fs.num_outputs; outputMapping[attr] = fs_num_outputs;
numColors++; numColors++;
break; break;
default: default:
assert(0); assert(0);
} }
fs.num_outputs++; fs_num_outputs++;
} }
} }
} }
@@ -420,16 +437,16 @@ st_translate_fragment_program(struct st_context *st,
num_tokens = tgsi_translate_mesa_program( TGSI_PROCESSOR_FRAGMENT, num_tokens = tgsi_translate_mesa_program( TGSI_PROCESSOR_FRAGMENT,
&stfp->Base.Base, &stfp->Base.Base,
/* inputs */ /* inputs */
fs.num_inputs, fs_num_inputs,
inputMapping, inputMapping,
fs.input_semantic_name, fs_input_semantic_name,
fs.input_semantic_index, fs_input_semantic_index,
interpMode, interpMode,
/* outputs */ /* outputs */
fs.num_outputs, fs_num_outputs,
outputMapping, outputMapping,
fs.output_semantic_name, fs_output_semantic_name,
fs.output_semantic_index, fs_output_semantic_index,
/* tokenized result */ /* tokenized result */
tokens, ST_MAX_SHADER_TOKENS); tokens, ST_MAX_SHADER_TOKENS);

2
src/mesa/state_tracker/st_program.h
View File

@@ -85,6 +85,8 @@ struct st_vertex_program
/** maps a TGSI input index back to a Mesa VERT_ATTRIB_x */ /** maps a TGSI input index back to a Mesa VERT_ATTRIB_x */
GLuint index_to_input[PIPE_MAX_SHADER_INPUTS]; GLuint index_to_input[PIPE_MAX_SHADER_INPUTS];
GLuint num_inputs;
struct pipe_shader_state state; struct pipe_shader_state state;
struct pipe_shader_state *driver_shader; struct pipe_shader_state *driver_shader;