static void
append_index(char *dst, GLint index)
{
char s[20];
_mesa_sprintf(s, "[%d]", index);
append(dst, s);
}
void _math_test_all_transform_functions( char *description )
{
int psize, mtype;
unsigned long benchmark_tab[4][7];
static int first_time = 1;
if ( first_time ) {
first_time = 0;
mesa_profile = _mesa_getenv( "MESA_PROFILE" );
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile ) {
if ( !counter_overhead ) {
INIT_COUNTER();
_mesa_printf("counter overhead: %lu cycles\n\n", counter_overhead );
}
_mesa_printf("transform results after hooking in %s functions:\n", description );
}
#endif
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile ) {
_mesa_printf("\n" );
for ( psize = 1 ; psize <= 4 ; psize++ ) {
_mesa_printf(" p%d\t", psize );
}
_mesa_printf("\n--------------------------------------------------------\n" );
}
#endif
for ( mtype = 0 ; mtype < 7 ; mtype++ ) {
for ( psize = 1 ; psize <= 4 ; psize++ ) {
transform_func func = _mesa_transform_tab[psize][mtypes[mtype]];
unsigned long *cycles = &(benchmark_tab[psize-1][mtype]);
if ( test_transform_function( func, psize, mtype, cycles ) == 0 ) {
char buf[100];
_mesa_sprintf(buf, "_mesa_transform_tab[0][%d][%s] failed test (%s)",
psize, mstrings[mtype], description );
_mesa_problem( NULL, buf );
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile )
_mesa_printf(" %li\t", benchmark_tab[psize-1][mtype] );
#endif
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile )
_mesa_printf(" | [%s]\n", mstrings[mtype] );
#endif
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile )
_mesa_printf( "\n" );
#endif
}
/**
* Add a new unnamed constant to the parameter list.
* \param paramList - the parameter list
* \param values - four float values
* \return index of the new parameter.
*/
GLint
_mesa_add_unnamed_constant(struct program_parameter_list *paramList,
const GLfloat values[4])
{
/* generate a new dummy name */
static GLuint n = 0;
char name[20];
_mesa_sprintf(name, "constant%d", n);
n++;
/* store it */
return add_parameter(paramList, name, values, CONSTANT);
}
void _math_test_all_normal_transform_functions( char *description )
{
int mtype;
long benchmark_tab[0xf];
static int first_time = 1;
if ( first_time ) {
first_time = 0;
mesa_profile = _mesa_getenv( "MESA_PROFILE" );
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile ) {
if ( !counter_overhead ) {
INIT_COUNTER();
_mesa_printf( "counter overhead: %ld cycles\n\n", counter_overhead );
}
_mesa_printf( "normal transform results after hooking in %s functions:\n",
description );
_mesa_printf( "\n-------------------------------------------------------\n" );
}
#endif
for ( mtype = 0 ; mtype < 8 ; mtype++ ) {
normal_func func = _mesa_normal_tab[norm_types[mtype]];
long *cycles = &benchmark_tab[mtype];
if ( test_norm_function( func, mtype, cycles ) == 0 ) {
char buf[100];
_mesa_sprintf( buf, "_mesa_normal_tab[0][%s] failed test (%s)",
norm_strings[mtype], description );
_mesa_problem( NULL, buf );
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile ) {
_mesa_printf( " %li\t", benchmark_tab[mtype] );
_mesa_printf( " | [%s]\n", norm_strings[mtype] );
}
#endif
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile ) {
_mesa_printf( "\n" );
}
#endif
}
static GLboolean insert_binding (slang_uniform_bindings *bind, slang_export_data_quant *q,
char *name, slang_atom_pool *atoms, GLuint index, GLuint addr)
{
GLuint count, i;
slang_string_concat (name, slang_atom_pool_id (atoms, q->name));
if (q->array_len == 0)
count = 1;
else
count = q->array_len;
for (i = 0; i < count; i++)
{
GLuint save;
save = slang_string_length (name);
if (q->array_len != 0)
_mesa_sprintf (name + slang_string_length (name), "[%d]", i);
if (q->structure != NULL)
{
GLuint save, i;
slang_string_concat (name, ".");
save = slang_string_length (name);
for (i = 0; i < q->u.field_count; i++)
{
if (!insert_binding (bind, &q->structure[i], name, atoms, index, addr))
return GL_FALSE;
name[save] = '\0';
addr += q->structure[i].size;
}
}
else
{
if (!slang_uniform_bindings_add (bind, q, name, index, addr))
return GL_FALSE;
addr += q->size;
}
name[save] = '\0';
}
return GL_TRUE;
}
const char *_mesa_lookup_enum_by_nr( int nr )
{
enum_elt tmp, *e, **f;
if (!sorted)
sort_enums();
tmp.n = nr;
e = &tmp;
f = (enum_elt **)bsearch( &e, index1, Elements(all_enums),
sizeof(*index1), (cfunc) compar_nr );
if (f) {
return (*f)->c;
}
else {
/* this isn't re-entrant safe, no big deal here */
_mesa_sprintf(token_tmp, "0x%x", nr);
return token_tmp;
}
}
/**
* Return string representation of the given register.
* Note that some types of registers (like PROGRAM_UNIFORM) aren't defined
* by the ARB/NV program languages so we've taken some liberties here.
* \param f the register file (PROGRAM_INPUT, PROGRAM_TEMPORARY, etc)
* \param index number of the register in the register file
* \param mode the output format/mode/style
* \param prog pointer to containing program
*/
static const char *
reg_string(gl_register_file f, GLint index, gl_prog_print_mode mode,
GLboolean relAddr, const struct gl_program *prog)
{
static char str[100];
const char *addr = relAddr ? "ADDR+" : "";
str[0] = 0;
switch (mode) {
case PROG_PRINT_DEBUG:
_mesa_sprintf(str, "%s[%s%d]", file_string(f, mode), addr, index);
break;
case PROG_PRINT_ARB:
switch (f) {
case PROGRAM_INPUT:
_mesa_sprintf(str, "%s", arb_input_attrib_string(index, prog->Target));
break;
case PROGRAM_OUTPUT:
_mesa_sprintf(str, "%s", arb_output_attrib_string(index, prog->Target));
break;
case PROGRAM_TEMPORARY:
_mesa_sprintf(str, "temp%d", index);
break;
case PROGRAM_ENV_PARAM:
_mesa_sprintf(str, "program.env[%s%d]", addr, index);
break;
case PROGRAM_LOCAL_PARAM:
_mesa_sprintf(str, "program.local[%s%d]", addr, index);
break;
case PROGRAM_VARYING: /* extension */
_mesa_sprintf(str, "varying[%s%d]", addr, index);
break;
case PROGRAM_CONSTANT: /* extension */
_mesa_sprintf(str, "constant[%s%d]", addr, index);
break;
case PROGRAM_UNIFORM: /* extension */
_mesa_sprintf(str, "uniform[%s%d]", addr, index);
break;
case PROGRAM_STATE_VAR:
{
struct gl_program_parameter *param
= prog->Parameters->Parameters + index;
char *state = _mesa_program_state_string(param->StateIndexes);
_mesa_sprintf(str, state);
_mesa_free(state);
}
break;
case PROGRAM_ADDRESS:
_mesa_sprintf(str, "A%d", index);
break;
default:
_mesa_problem(NULL, "bad file in reg_string()");
}
break;
case PROG_PRINT_NV:
switch (f) {
case PROGRAM_INPUT:
if (prog->Target == GL_VERTEX_PROGRAM_ARB)
_mesa_sprintf(str, "v[%d]", index);
else
_mesa_sprintf(str, "f[%d]", index);
break;
case PROGRAM_OUTPUT:
_mesa_sprintf(str, "o[%d]", index);
break;
case PROGRAM_TEMPORARY:
_mesa_sprintf(str, "R%d", index);
break;
case PROGRAM_ENV_PARAM:
_mesa_sprintf(str, "c[%d]", index);
break;
case PROGRAM_VARYING: /* extension */
_mesa_sprintf(str, "varying[%s%d]", addr, index);
break;
case PROGRAM_UNIFORM: /* extension */
_mesa_sprintf(str, "uniform[%s%d]", addr, index);
break;
case PROGRAM_CONSTANT: /* extension */
_mesa_sprintf(str, "constant[%s%d]", addr, index);
break;
case PROGRAM_STATE_VAR: /* extension */
_mesa_sprintf(str, "state[%s%d]", addr, index);
break;
default:
_mesa_problem(NULL, "bad file in reg_string()");
}
break;
default:
_mesa_problem(NULL, "bad mode in reg_string()");
}
return str;
}
/**
* Make a string from the given state vector.
* For example, return "state.matrix.texture[2].inverse".
* Use _mesa_free() to deallocate the string.
*/
const char *
_mesa_program_state_string(const gl_state_index state[STATE_LENGTH])
{
char str[1000] = "";
char tmp[30];
append(str, "state.");
append_token(str, (gl_state_index) state[0]);
switch (state[0]) {
case STATE_MATERIAL:
append_face(str, state[1]);
append_token(str, (gl_state_index) state[2]);
break;
case STATE_LIGHT:
append_index(str, state[1]); /* light number [i]. */
append_token(str, (gl_state_index) state[2]); /* coefficients */
break;
case STATE_LIGHTMODEL_AMBIENT:
append(str, "lightmodel.ambient");
break;
case STATE_LIGHTMODEL_SCENECOLOR:
if (state[1] == 0) {
append(str, "lightmodel.front.scenecolor");
}
else {
append(str, "lightmodel.back.scenecolor");
}
break;
case STATE_LIGHTPROD:
append_index(str, state[1]); /* light number [i]. */
append_face(str, state[2]);
append_token(str, (gl_state_index) state[3]);
break;
case STATE_TEXGEN:
append_index(str, state[1]); /* tex unit [i] */
append_token(str, (gl_state_index) state[2]); /* plane coef */
break;
case STATE_TEXENV_COLOR:
append_index(str, state[1]); /* tex unit [i] */
append(str, "color");
break;
case STATE_CLIPPLANE:
append_index(str, state[1]); /* plane [i] */
append(str, ".plane");
break;
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 gl_state_index mat = (gl_state_index) 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 = (gl_state_index) state[4];
if (index ||
mat == STATE_TEXTURE_MATRIX ||
mat == STATE_PROGRAM_MATRIX)
append_index(str, index);
if (modifier)
append_token(str, modifier);
if (firstRow == lastRow)
_mesa_sprintf(tmp, ".row[%d]", firstRow);
else
_mesa_sprintf(tmp, ".row[%d..%d]", firstRow, lastRow);
append(str, tmp);
}
break;
case STATE_POINT_SIZE:
break;
case STATE_POINT_ATTENUATION:
break;
case STATE_FOG_PARAMS:
break;
case STATE_FOG_COLOR:
break;
case STATE_DEPTH_RANGE:
break;
case STATE_FRAGMENT_PROGRAM:
case STATE_VERTEX_PROGRAM:
/* state[1] = {STATE_ENV, STATE_LOCAL} */
/* state[2] = parameter index */
append_token(str, (gl_state_index) state[1]);
append_index(str, state[2]);
break;
case STATE_INTERNAL:
break;
default:
_mesa_problem(NULL, "Invalid state in _mesa_program_state_string");
break;
}
return _mesa_strdup(str);
}
