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

mesa: rework matrix statevar enums to remove excessive branching in fetch_state

Browse Source 
Instead of having $matrix and $modifier as separate enums, combine them
to 1 enum $matrix_$modifier.

Reviewed-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/6946>
This commit is contained in:
Marek Olšák
2020-09-28 09:30:51 -04:00
committed by Marge Bot
parent 3175b63a0d
commit 2ca6c99604
7 changed files with 311 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
src/compiler/glsl/builtin_variables.cpp
View File

@@ -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) },
};

16
src/mesa/main/ffvertex_prog.c
View File

@@ -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 );
}
}

310
src/mesa/program/prog_statevars.c
View File

@@ -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

22
src/mesa/program/prog_statevars.h
View File

@@ -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,

22
src/mesa/program/program_parse.y
View File

@@ -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];

8
src/mesa/program/programopt.c
View File

@@ -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];

15
src/mesa/state_tracker/st_nir_lower_builtin.c
View File

@@ -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: