diff --git a/src/compiler/glsl/builtin_variables.cpp b/src/compiler/glsl/builtin_variables.cpp index 869d4523f6c..79d5e5be514 100644 --- a/src/compiler/glsl/builtin_variables.cpp +++ b/src/compiler/glsl/builtin_variables.cpp @@ -192,56 +192,40 @@ static const struct gl_builtin_uniform_element gl_CurrentAttribFragMESA_elements {NULL, {STATE_INTERNAL, STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED, 0}, SWIZZLE_XYZW}, }; -#define MATRIX(name, statevar, modifier) \ +#define MATRIX(name, statevar) \ static const struct gl_builtin_uniform_element name ## _elements[] = { \ - { NULL, { statevar, 0, 0, 0, modifier}, SWIZZLE_XYZW }, \ - { NULL, { statevar, 0, 1, 1, modifier}, SWIZZLE_XYZW }, \ - { NULL, { statevar, 0, 2, 2, modifier}, SWIZZLE_XYZW }, \ - { NULL, { statevar, 0, 3, 3, modifier}, SWIZZLE_XYZW }, \ + { NULL, { statevar, 0, 0, 0, 0}, SWIZZLE_XYZW }, \ + { NULL, { statevar, 0, 1, 1, 0}, SWIZZLE_XYZW }, \ + { NULL, { statevar, 0, 2, 2, 0}, SWIZZLE_XYZW }, \ + { NULL, { statevar, 0, 3, 3, 0}, SWIZZLE_XYZW }, \ } -MATRIX(gl_ModelViewMatrix, - STATE_MODELVIEW_MATRIX, STATE_MATRIX_TRANSPOSE); -MATRIX(gl_ModelViewMatrixInverse, - STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVTRANS); -MATRIX(gl_ModelViewMatrixTranspose, - STATE_MODELVIEW_MATRIX, 0); -MATRIX(gl_ModelViewMatrixInverseTranspose, - STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVERSE); +MATRIX(gl_ModelViewMatrix, STATE_MODELVIEW_MATRIX_TRANSPOSE); +MATRIX(gl_ModelViewMatrixInverse, STATE_MODELVIEW_MATRIX_INVTRANS); +MATRIX(gl_ModelViewMatrixTranspose, STATE_MODELVIEW_MATRIX); +MATRIX(gl_ModelViewMatrixInverseTranspose, STATE_MODELVIEW_MATRIX_INVERSE); -MATRIX(gl_ProjectionMatrix, - STATE_PROJECTION_MATRIX, STATE_MATRIX_TRANSPOSE); -MATRIX(gl_ProjectionMatrixInverse, - STATE_PROJECTION_MATRIX, STATE_MATRIX_INVTRANS); -MATRIX(gl_ProjectionMatrixTranspose, - STATE_PROJECTION_MATRIX, 0); -MATRIX(gl_ProjectionMatrixInverseTranspose, - STATE_PROJECTION_MATRIX, STATE_MATRIX_INVERSE); +MATRIX(gl_ProjectionMatrix, STATE_PROJECTION_MATRIX_TRANSPOSE); +MATRIX(gl_ProjectionMatrixInverse, STATE_PROJECTION_MATRIX_INVTRANS); +MATRIX(gl_ProjectionMatrixTranspose, STATE_PROJECTION_MATRIX); +MATRIX(gl_ProjectionMatrixInverseTranspose, STATE_PROJECTION_MATRIX_INVERSE); -MATRIX(gl_ModelViewProjectionMatrix, - STATE_MVP_MATRIX, STATE_MATRIX_TRANSPOSE); -MATRIX(gl_ModelViewProjectionMatrixInverse, - STATE_MVP_MATRIX, STATE_MATRIX_INVTRANS); -MATRIX(gl_ModelViewProjectionMatrixTranspose, - STATE_MVP_MATRIX, 0); -MATRIX(gl_ModelViewProjectionMatrixInverseTranspose, - STATE_MVP_MATRIX, STATE_MATRIX_INVERSE); +MATRIX(gl_ModelViewProjectionMatrix, STATE_MVP_MATRIX_TRANSPOSE); +MATRIX(gl_ModelViewProjectionMatrixInverse, STATE_MVP_MATRIX_INVTRANS); +MATRIX(gl_ModelViewProjectionMatrixTranspose, STATE_MVP_MATRIX); +MATRIX(gl_ModelViewProjectionMatrixInverseTranspose, STATE_MVP_MATRIX_INVERSE); -MATRIX(gl_TextureMatrix, - STATE_TEXTURE_MATRIX, STATE_MATRIX_TRANSPOSE); -MATRIX(gl_TextureMatrixInverse, - STATE_TEXTURE_MATRIX, STATE_MATRIX_INVTRANS); -MATRIX(gl_TextureMatrixTranspose, - STATE_TEXTURE_MATRIX, 0); -MATRIX(gl_TextureMatrixInverseTranspose, - STATE_TEXTURE_MATRIX, STATE_MATRIX_INVERSE); +MATRIX(gl_TextureMatrix, STATE_TEXTURE_MATRIX_TRANSPOSE); +MATRIX(gl_TextureMatrixInverse, STATE_TEXTURE_MATRIX_INVTRANS); +MATRIX(gl_TextureMatrixTranspose, STATE_TEXTURE_MATRIX); +MATRIX(gl_TextureMatrixInverseTranspose, STATE_TEXTURE_MATRIX_INVERSE); static const struct gl_builtin_uniform_element gl_NormalMatrix_elements[] = { - { NULL, { STATE_MODELVIEW_MATRIX, 0, 0, 0, STATE_MATRIX_INVERSE}, + { NULL, { STATE_MODELVIEW_MATRIX_INVERSE, 0, 0, 0, 0}, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) }, - { NULL, { STATE_MODELVIEW_MATRIX, 0, 1, 1, STATE_MATRIX_INVERSE}, + { NULL, { STATE_MODELVIEW_MATRIX_INVERSE, 0, 1, 1, 0}, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) }, - { NULL, { STATE_MODELVIEW_MATRIX, 0, 2, 2, STATE_MATRIX_INVERSE}, + { NULL, { STATE_MODELVIEW_MATRIX_INVERSE, 0, 2, 2, 0}, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) }, }; diff --git a/src/mesa/main/ffvertex_prog.c b/src/mesa/main/ffvertex_prog.c index 57026793ea1..86b556238d4 100644 --- a/src/mesa/main/ffvertex_prog.c +++ b/src/mesa/main/ffvertex_prog.c @@ -722,8 +722,8 @@ static struct ureg get_eye_position( struct tnl_program *p ) emit_matrix_transform_vec4(p, p->eye_position, modelview, pos); } else { - register_matrix_param5( p, STATE_MODELVIEW_MATRIX, 0, 0, 3, - STATE_MATRIX_TRANSPOSE, modelview ); + register_matrix_param5( p, STATE_MODELVIEW_MATRIX_TRANSPOSE, 0, 0, 3, + 0, modelview ); emit_transpose_matrix_transform_vec4(p, p->eye_position, modelview, pos); } @@ -782,8 +782,8 @@ static struct ureg get_transformed_normal( struct tnl_program *p ) struct ureg transformed_normal = reserve_temp(p); if (p->state->need_eye_coords) { - register_matrix_param5( p, STATE_MODELVIEW_MATRIX, 0, 0, 2, - STATE_MATRIX_INVTRANS, mvinv ); + register_matrix_param5( p, STATE_MODELVIEW_MATRIX_INVTRANS, 0, 0, 2, + 0, mvinv ); /* Transform to eye space: */ @@ -827,8 +827,8 @@ static void build_hpos( struct tnl_program *p ) emit_matrix_transform_vec4( p, hpos, mvp, pos ); } else { - register_matrix_param5( p, STATE_MVP_MATRIX, 0, 0, 3, - STATE_MATRIX_TRANSPOSE, mvp ); + register_matrix_param5( p, STATE_MVP_MATRIX_TRANSPOSE, 0, 0, 3, + 0, mvp ); emit_transpose_matrix_transform_vec4( p, hpos, mvp, pos ); } } @@ -1490,8 +1490,8 @@ static void build_texture_transform( struct tnl_program *p ) emit_matrix_transform_vec4( p, out, texmat, in ); } else { - register_matrix_param5( p, STATE_TEXTURE_MATRIX, i, 0, 3, - STATE_MATRIX_TRANSPOSE, texmat ); + register_matrix_param5( p, STATE_TEXTURE_MATRIX_TRANSPOSE, i, 0, 3, + 0, texmat ); emit_transpose_matrix_transform_vec4( p, out, texmat, in ); } } diff --git a/src/mesa/program/prog_statevars.c b/src/mesa/program/prog_statevars.c index d638d8038a2..bfe2bb9269f 100644 --- a/src/mesa/program/prog_statevars.c +++ b/src/mesa/program/prog_statevars.c @@ -45,6 +45,31 @@ #define ONE_DIV_SQRT_LN2 (1.201122408786449815) +static ALWAYS_INLINE void +copy_matrix(float *value, const float *m, unsigned firstRow, unsigned lastRow) +{ + unsigned i, row; + + assert(firstRow < 4); + assert(lastRow < 4); + + for (i = 0, row = firstRow; row <= lastRow; row++) { + value[i++] = m[row + 0]; + value[i++] = m[row + 4]; + value[i++] = m[row + 8]; + value[i++] = m[row + 12]; + } +} + +static ALWAYS_INLINE void +copy_matrix_transposed(float *value, const float *m, unsigned firstRow, unsigned lastRow) +{ + assert(firstRow < 4); + assert(lastRow < 4); + + memcpy(value, &m[firstRow * 4], + (lastRow - firstRow + 1) * 4 * sizeof(GLfloat)); +} /** * Use the list of tokens in the state[] array to find global GL state @@ -284,77 +309,136 @@ fetch_state(struct gl_context *ctx, const gl_state_index16 state[], value[2] = ctx->Point.Params[2]; value[3] = 1.0F; return; - case STATE_MODELVIEW_MATRIX: - case STATE_PROJECTION_MATRIX: - case STATE_MVP_MATRIX: - case STATE_TEXTURE_MATRIX: - case STATE_PROGRAM_MATRIX: - { - /* state[0] = modelview, projection, texture, etc. */ - /* state[1] = which texture matrix or program matrix */ - /* state[2] = first row to fetch */ - /* state[3] = last row to fetch */ - /* state[4] = transpose, inverse or invtrans */ - const GLmatrix *matrix; - const gl_state_index mat = state[0]; - const GLuint index = (GLuint) state[1]; - const GLuint firstRow = (GLuint) state[2]; - const GLuint lastRow = (GLuint) state[3]; - const gl_state_index modifier = state[4]; - const GLfloat *m; - GLuint row, i; - assert(firstRow < 4); - assert(lastRow < 4); - if (mat == STATE_MODELVIEW_MATRIX) { - matrix = ctx->ModelviewMatrixStack.Top; - } - else if (mat == STATE_PROJECTION_MATRIX) { - matrix = ctx->ProjectionMatrixStack.Top; - } - else if (mat == STATE_MVP_MATRIX) { - matrix = &ctx->_ModelProjectMatrix; - } - else if (mat == STATE_TEXTURE_MATRIX) { - assert(index < ARRAY_SIZE(ctx->TextureMatrixStack)); - matrix = ctx->TextureMatrixStack[index].Top; - } - else if (mat == STATE_PROGRAM_MATRIX) { - assert(index < ARRAY_SIZE(ctx->ProgramMatrixStack)); - matrix = ctx->ProgramMatrixStack[index].Top; - } - else { - unreachable("Bad matrix name in fetch_state()"); - return; - } - if (modifier == STATE_MATRIX_INVERSE || - modifier == STATE_MATRIX_INVTRANS) { - /* Be sure inverse is up to date: - */ - _math_matrix_analyse( (GLmatrix*) matrix ); - m = matrix->inv; - } - else { - m = matrix->m; - } - if (modifier == STATE_MATRIX_TRANSPOSE || - modifier == STATE_MATRIX_INVTRANS) { - for (i = 0, row = firstRow; row <= lastRow; row++) { - value[i++] = m[row * 4 + 0]; - value[i++] = m[row * 4 + 1]; - value[i++] = m[row * 4 + 2]; - value[i++] = m[row * 4 + 3]; - } - } - else { - for (i = 0, row = firstRow; row <= lastRow; row++) { - value[i++] = m[row + 0]; - value[i++] = m[row + 4]; - value[i++] = m[row + 8]; - value[i++] = m[row + 12]; - } - } - } + /* state[0] = modelview, projection, texture, etc. */ + /* state[1] = which texture matrix or program matrix */ + /* state[2] = first row to fetch */ + /* state[3] = last row to fetch */ + case STATE_MODELVIEW_MATRIX: { + const GLmatrix *matrix = ctx->ModelviewMatrixStack.Top; + copy_matrix(value, matrix->m, state[2], state[3]); return; + } + case STATE_MODELVIEW_MATRIX_INVERSE: { + const GLmatrix *matrix = ctx->ModelviewMatrixStack.Top; + _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */ + copy_matrix(value, matrix->inv, state[2], state[3]); + return; + } + case STATE_MODELVIEW_MATRIX_TRANSPOSE: { + const GLmatrix *matrix = ctx->ModelviewMatrixStack.Top; + copy_matrix_transposed(value, matrix->m, state[2], state[3]); + return; + } + case STATE_MODELVIEW_MATRIX_INVTRANS: { + const GLmatrix *matrix = ctx->ModelviewMatrixStack.Top; + _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */ + copy_matrix_transposed(value, matrix->inv, state[2], state[3]); + return; + } + case STATE_PROJECTION_MATRIX: { + const GLmatrix *matrix = ctx->ProjectionMatrixStack.Top; + copy_matrix(value, matrix->m, state[2], state[3]); + return; + } + case STATE_PROJECTION_MATRIX_INVERSE: { + const GLmatrix *matrix = ctx->ProjectionMatrixStack.Top; + _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */ + copy_matrix(value, matrix->inv, state[2], state[3]); + return; + } + case STATE_PROJECTION_MATRIX_TRANSPOSE: { + const GLmatrix *matrix = ctx->ProjectionMatrixStack.Top; + copy_matrix_transposed(value, matrix->m, state[2], state[3]); + return; + } + case STATE_PROJECTION_MATRIX_INVTRANS: { + const GLmatrix *matrix = ctx->ProjectionMatrixStack.Top; + _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */ + copy_matrix_transposed(value, matrix->inv, state[2], state[3]); + return; + } + case STATE_MVP_MATRIX: { + const GLmatrix *matrix = &ctx->_ModelProjectMatrix; + copy_matrix(value, matrix->m, state[2], state[3]); + return; + } + case STATE_MVP_MATRIX_INVERSE: { + const GLmatrix *matrix = &ctx->_ModelProjectMatrix; + _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */ + copy_matrix(value, matrix->inv, state[2], state[3]); + return; + } + case STATE_MVP_MATRIX_TRANSPOSE: { + const GLmatrix *matrix = &ctx->_ModelProjectMatrix; + copy_matrix_transposed(value, matrix->m, state[2], state[3]); + return; + } + case STATE_MVP_MATRIX_INVTRANS: { + const GLmatrix *matrix = &ctx->_ModelProjectMatrix; + _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */ + copy_matrix_transposed(value, matrix->inv, state[2], state[3]); + return; + } + case STATE_TEXTURE_MATRIX: { + const GLuint index = (GLuint) state[1]; + assert(index < ARRAY_SIZE(ctx->TextureMatrixStack)); + const GLmatrix *matrix = ctx->TextureMatrixStack[index].Top; + copy_matrix(value, matrix->m, state[2], state[3]); + return; + } + case STATE_TEXTURE_MATRIX_INVERSE: { + const GLuint index = (GLuint) state[1]; + assert(index < ARRAY_SIZE(ctx->TextureMatrixStack)); + const GLmatrix *matrix = ctx->TextureMatrixStack[index].Top; + _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */ + copy_matrix(value, matrix->inv, state[2], state[3]); + return; + } + case STATE_TEXTURE_MATRIX_TRANSPOSE: { + const GLuint index = (GLuint) state[1]; + assert(index < ARRAY_SIZE(ctx->TextureMatrixStack)); + const GLmatrix *matrix = ctx->TextureMatrixStack[index].Top; + copy_matrix_transposed(value, matrix->m, state[2], state[3]); + return; + } + case STATE_TEXTURE_MATRIX_INVTRANS: { + const GLuint index = (GLuint) state[1]; + assert(index < ARRAY_SIZE(ctx->TextureMatrixStack)); + const GLmatrix *matrix = ctx->TextureMatrixStack[index].Top; + _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */ + copy_matrix_transposed(value, matrix->inv, state[2], state[3]); + return; + } + case STATE_PROGRAM_MATRIX: { + const GLuint index = (GLuint) state[1]; + assert(index < ARRAY_SIZE(ctx->ProgramMatrixStack)); + const GLmatrix *matrix = ctx->ProgramMatrixStack[index].Top; + copy_matrix(value, matrix->m, state[2], state[3]); + return; + } + case STATE_PROGRAM_MATRIX_INVERSE: { + const GLuint index = (GLuint) state[1]; + assert(index < ARRAY_SIZE(ctx->ProgramMatrixStack)); + const GLmatrix *matrix = ctx->ProgramMatrixStack[index].Top; + _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */ + copy_matrix(value, matrix->inv, state[2], state[3]); + return; + } + case STATE_PROGRAM_MATRIX_TRANSPOSE: { + const GLuint index = (GLuint) state[1]; + assert(index < ARRAY_SIZE(ctx->ProgramMatrixStack)); + const GLmatrix *matrix = ctx->ProgramMatrixStack[index].Top; + copy_matrix_transposed(value, matrix->m, state[2], state[3]); + return; + } + case STATE_PROGRAM_MATRIX_INVTRANS: { + const GLuint index = (GLuint) state[1]; + assert(index < ARRAY_SIZE(ctx->ProgramMatrixStack)); + const GLmatrix *matrix = ctx->ProgramMatrixStack[index].Top; + _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */ + copy_matrix_transposed(value, matrix->inv, state[2], state[3]); + return; + } case STATE_NUM_SAMPLES: val[0].i = MAX2(1, _mesa_geometric_samples(ctx->DrawBuffer)); return; @@ -685,14 +769,29 @@ _mesa_program_state_flags(const gl_state_index16 state[STATE_LENGTH]) return _NEW_POINT; case STATE_MODELVIEW_MATRIX: + case STATE_MODELVIEW_MATRIX_INVERSE: + case STATE_MODELVIEW_MATRIX_TRANSPOSE: + case STATE_MODELVIEW_MATRIX_INVTRANS: return _NEW_MODELVIEW; case STATE_PROJECTION_MATRIX: + case STATE_PROJECTION_MATRIX_INVERSE: + case STATE_PROJECTION_MATRIX_TRANSPOSE: + case STATE_PROJECTION_MATRIX_INVTRANS: return _NEW_PROJECTION; case STATE_MVP_MATRIX: + case STATE_MVP_MATRIX_INVERSE: + case STATE_MVP_MATRIX_TRANSPOSE: + case STATE_MVP_MATRIX_INVTRANS: return _NEW_MODELVIEW | _NEW_PROJECTION; case STATE_TEXTURE_MATRIX: + case STATE_TEXTURE_MATRIX_INVERSE: + case STATE_TEXTURE_MATRIX_TRANSPOSE: + case STATE_TEXTURE_MATRIX_INVTRANS: return _NEW_TEXTURE_MATRIX; case STATE_PROGRAM_MATRIX: + case STATE_PROGRAM_MATRIX_INVERSE: + case STATE_PROGRAM_MATRIX_TRANSPOSE: + case STATE_PROGRAM_MATRIX_INVTRANS: return _NEW_TRACK_MATRIX; case STATE_NUM_SAMPLES: @@ -812,26 +911,63 @@ append_token(char *dst, gl_state_index k) case STATE_MODELVIEW_MATRIX: append(dst, "matrix.modelview"); break; + case STATE_MODELVIEW_MATRIX_INVERSE: + append(dst, "matrix.modelview.inverse"); + break; + case STATE_MODELVIEW_MATRIX_TRANSPOSE: + append(dst, "matrix.modelview.transpose"); + break; + case STATE_MODELVIEW_MATRIX_INVTRANS: + append(dst, "matrix.modelview.invtrans"); + break; case STATE_PROJECTION_MATRIX: append(dst, "matrix.projection"); break; + case STATE_PROJECTION_MATRIX_INVERSE: + append(dst, "matrix.projection.inverse"); + break; + case STATE_PROJECTION_MATRIX_TRANSPOSE: + append(dst, "matrix.projection.transpose"); + break; + case STATE_PROJECTION_MATRIX_INVTRANS: + append(dst, "matrix.projection.invtrans"); + break; case STATE_MVP_MATRIX: append(dst, "matrix.mvp"); break; + case STATE_MVP_MATRIX_INVERSE: + append(dst, "matrix.mvp.inverse"); + break; + case STATE_MVP_MATRIX_TRANSPOSE: + append(dst, "matrix.mvp.transpose"); + break; + case STATE_MVP_MATRIX_INVTRANS: + append(dst, "matrix.mvp.invtrans"); + break; case STATE_TEXTURE_MATRIX: append(dst, "matrix.texture"); break; + case STATE_TEXTURE_MATRIX_INVERSE: + append(dst, "matrix.texture.inverse"); + break; + case STATE_TEXTURE_MATRIX_TRANSPOSE: + append(dst, "matrix.texture.transpose"); + break; + case STATE_TEXTURE_MATRIX_INVTRANS: + append(dst, "matrix.texture.invtrans"); + break; case STATE_PROGRAM_MATRIX: append(dst, "matrix.program"); break; - case STATE_MATRIX_INVERSE: - append(dst, ".inverse"); + case STATE_PROGRAM_MATRIX_INVERSE: + append(dst, "matrix.program.inverse"); break; - case STATE_MATRIX_TRANSPOSE: - append(dst, ".transpose"); + case STATE_PROGRAM_MATRIX_TRANSPOSE: + append(dst, "matrix.program.transpose"); + break; + case STATE_PROGRAM_MATRIX_INVTRANS: + append(dst, "matrix.program.invtrans"); break; - case STATE_MATRIX_INVTRANS: - append(dst, ".invtrans"); break; case STATE_AMBIENT: append(dst, ".ambient"); @@ -1032,10 +1168,25 @@ _mesa_program_state_string(const gl_state_index16 state[STATE_LENGTH]) append(str, ".plane"); break; case STATE_MODELVIEW_MATRIX: + case STATE_MODELVIEW_MATRIX_INVERSE: + case STATE_MODELVIEW_MATRIX_TRANSPOSE: + case STATE_MODELVIEW_MATRIX_INVTRANS: case STATE_PROJECTION_MATRIX: + case STATE_PROJECTION_MATRIX_INVERSE: + case STATE_PROJECTION_MATRIX_TRANSPOSE: + case STATE_PROJECTION_MATRIX_INVTRANS: case STATE_MVP_MATRIX: + case STATE_MVP_MATRIX_INVERSE: + case STATE_MVP_MATRIX_TRANSPOSE: + case STATE_MVP_MATRIX_INVTRANS: case STATE_TEXTURE_MATRIX: + case STATE_TEXTURE_MATRIX_INVERSE: + case STATE_TEXTURE_MATRIX_TRANSPOSE: + case STATE_TEXTURE_MATRIX_INVTRANS: case STATE_PROGRAM_MATRIX: + case STATE_PROGRAM_MATRIX_INVERSE: + case STATE_PROGRAM_MATRIX_TRANSPOSE: + case STATE_PROGRAM_MATRIX_INVTRANS: { /* state[0] = modelview, projection, texture, etc. */ /* state[1] = which texture matrix or program matrix */ @@ -1046,13 +1197,10 @@ _mesa_program_state_string(const gl_state_index16 state[STATE_LENGTH]) const GLuint index = (GLuint) state[1]; const GLuint firstRow = (GLuint) state[2]; const GLuint lastRow = (GLuint) state[3]; - const gl_state_index modifier = state[4]; if (index || - mat == STATE_TEXTURE_MATRIX || - mat == STATE_PROGRAM_MATRIX) + (mat >= STATE_TEXTURE_MATRIX && + mat <= STATE_PROGRAM_MATRIX_INVTRANS)) append_index(str, index); - if (modifier) - append_token(str, modifier); if (firstRow == lastRow) sprintf(tmp, ".row[%d]", firstRow); else diff --git a/src/mesa/program/prog_statevars.h b/src/mesa/program/prog_statevars.h index 4dc0123776f..269ee8966a6 100644 --- a/src/mesa/program/prog_statevars.h +++ b/src/mesa/program/prog_statevars.h @@ -67,13 +67,29 @@ typedef enum gl_state_index_ { STATE_POINT_ATTENUATION, STATE_MODELVIEW_MATRIX, + STATE_MODELVIEW_MATRIX_INVERSE, + STATE_MODELVIEW_MATRIX_TRANSPOSE, + STATE_MODELVIEW_MATRIX_INVTRANS, + STATE_PROJECTION_MATRIX, + STATE_PROJECTION_MATRIX_INVERSE, + STATE_PROJECTION_MATRIX_TRANSPOSE, + STATE_PROJECTION_MATRIX_INVTRANS, + STATE_MVP_MATRIX, + STATE_MVP_MATRIX_INVERSE, + STATE_MVP_MATRIX_TRANSPOSE, + STATE_MVP_MATRIX_INVTRANS, + STATE_TEXTURE_MATRIX, + STATE_TEXTURE_MATRIX_INVERSE, + STATE_TEXTURE_MATRIX_TRANSPOSE, + STATE_TEXTURE_MATRIX_INVTRANS, + STATE_PROGRAM_MATRIX, - STATE_MATRIX_INVERSE, - STATE_MATRIX_TRANSPOSE, - STATE_MATRIX_INVTRANS, + STATE_PROGRAM_MATRIX_INVERSE, + STATE_PROGRAM_MATRIX_TRANSPOSE, + STATE_PROGRAM_MATRIX_INVTRANS, STATE_AMBIENT, STATE_DIFFUSE, diff --git a/src/mesa/program/program_parse.y b/src/mesa/program/program_parse.y index 577537dd7ab..47bbf9e531e 100644 --- a/src/mesa/program/program_parse.y +++ b/src/mesa/program/program_parse.y @@ -42,6 +42,13 @@ #include "util/u_math.h" #include "util/u_memory.h" +enum { + STATE_MATRIX_NO_MODIFIER, + STATE_MATRIX_INVERSE, + STATE_MATRIX_TRANSPOSE, + STATE_MATRIX_INVTRANS, +}; + extern void *yy_scan_string(char *); extern void yy_delete_buffer(void *); @@ -1456,21 +1463,19 @@ statePointProperty: SIZE_TOK stateMatrixRow: stateMatrixItem ROW '[' stateMatrixRowNum ']' { - $$[0] = $1[0]; + $$[0] = $1[0] + $1[2]; $$[1] = $1[1]; $$[2] = $4; $$[3] = $4; - $$[4] = $1[2]; } ; stateMatrixRows: stateMatrixItem optMatrixRows { - $$[0] = $1[0]; + $$[0] = $1[0] + $1[2]; $$[1] = $1[1]; $$[2] = $2[2]; $$[3] = $2[3]; - $$[4] = $1[2]; } ; @@ -1507,7 +1512,7 @@ stateMatrixItem: MATRIX stateMatrixName stateOptMatModifier stateOptMatModifier: { - $$ = 0; + $$ = STATE_MATRIX_NO_MODIFIER; } | stateMatModifier { @@ -2338,11 +2343,8 @@ initialize_symbol_from_state(struct gl_program *prog, /* If we are adding a STATE_MATRIX that has multiple rows, we need to * unroll it and call add_state_reference() for each row */ - if ((state_tokens[0] == STATE_MODELVIEW_MATRIX || - state_tokens[0] == STATE_PROJECTION_MATRIX || - state_tokens[0] == STATE_MVP_MATRIX || - state_tokens[0] == STATE_TEXTURE_MATRIX || - state_tokens[0] == STATE_PROGRAM_MATRIX) + if (state_tokens[0] >= STATE_MODELVIEW_MATRIX && + state_tokens[0] <= STATE_PROGRAM_MATRIX_INVTRANS && (state_tokens[2] != state_tokens[3])) { int row; const int first_row = state_tokens[2]; diff --git a/src/mesa/program/programopt.c b/src/mesa/program/programopt.c index a9c0beb31bc..42750cc8cfb 100644 --- a/src/mesa/program/programopt.c +++ b/src/mesa/program/programopt.c @@ -126,10 +126,10 @@ insert_mvp_mad_code(struct gl_context *ctx, struct gl_program *vprog) * XXX we should check if these state vars are already declared. */ static const gl_state_index16 mvpState[4][STATE_LENGTH] = { - { STATE_MVP_MATRIX, 0, 0, 0, STATE_MATRIX_TRANSPOSE }, - { STATE_MVP_MATRIX, 0, 1, 1, STATE_MATRIX_TRANSPOSE }, - { STATE_MVP_MATRIX, 0, 2, 2, STATE_MATRIX_TRANSPOSE }, - { STATE_MVP_MATRIX, 0, 3, 3, STATE_MATRIX_TRANSPOSE }, + { STATE_MVP_MATRIX_TRANSPOSE, 0, 0, 0, 0 }, + { STATE_MVP_MATRIX_TRANSPOSE, 0, 1, 1, 0 }, + { STATE_MVP_MATRIX_TRANSPOSE, 0, 2, 2, 0 }, + { STATE_MVP_MATRIX_TRANSPOSE, 0, 3, 3, 0 }, }; GLint mvpRef[4]; diff --git a/src/mesa/state_tracker/st_nir_lower_builtin.c b/src/mesa/state_tracker/st_nir_lower_builtin.c index dd4a30c518d..339e25446b8 100644 --- a/src/mesa/state_tracker/st_nir_lower_builtin.c +++ b/src/mesa/state_tracker/st_nir_lower_builtin.c @@ -110,10 +110,25 @@ get_variable(lower_builtin_state *state, nir_deref_path *path, /* we need to fixup the array index slot: */ switch (tokens[0]) { case STATE_MODELVIEW_MATRIX: + case STATE_MODELVIEW_MATRIX_INVERSE: + case STATE_MODELVIEW_MATRIX_TRANSPOSE: + case STATE_MODELVIEW_MATRIX_INVTRANS: case STATE_PROJECTION_MATRIX: + case STATE_PROJECTION_MATRIX_INVERSE: + case STATE_PROJECTION_MATRIX_TRANSPOSE: + case STATE_PROJECTION_MATRIX_INVTRANS: case STATE_MVP_MATRIX: + case STATE_MVP_MATRIX_INVERSE: + case STATE_MVP_MATRIX_TRANSPOSE: + case STATE_MVP_MATRIX_INVTRANS: case STATE_TEXTURE_MATRIX: + case STATE_TEXTURE_MATRIX_INVERSE: + case STATE_TEXTURE_MATRIX_TRANSPOSE: + case STATE_TEXTURE_MATRIX_INVTRANS: case STATE_PROGRAM_MATRIX: + case STATE_PROGRAM_MATRIX_INVERSE: + case STATE_PROGRAM_MATRIX_TRANSPOSE: + case STATE_PROGRAM_MATRIX_INVTRANS: case STATE_LIGHT: case STATE_LIGHTPROD: case STATE_TEXGEN: