From 84798668341b15890d625e3bffbbc2d19f434568 Mon Sep 17 00:00:00 2001 From: marha Date: Wed, 6 Mar 2013 08:37:36 +0100 Subject: fontconfig libfontenc mesa xserver git update 6 Mar 2013 xserver commit 103b77c59e3638a45179bf6d7908f5c738d2d872 libfontenc commit 624508365ec3279bc74ce523d024533e062629e1 fontconfig commit e96d7760886a3781a46b3271c76af99e15cb0146 mesa commit 88b20d58344ed336b146799c0bf1149a932dc2d7 --- mesalib/bin/get-pick-list.sh | 2 +- mesalib/configure.ac | 16 +- mesalib/scons/llvm.py | 2 +- mesalib/src/gallium/auxiliary/util/u_blitter.c | 5 + mesalib/src/glsl/glsl_parser_extras.cpp | 15 +- mesalib/src/glsl/standalone_scaffolding.cpp | 2 +- mesalib/src/glsl/standalone_scaffolding.h | 2 +- mesalib/src/mesa/main/errors.c | 551 +++++++++------------ mesalib/src/mesa/main/errors.h | 13 +- mesalib/src/mesa/main/get_hash_params.py | 2 +- mesalib/src/mesa/main/mtypes.h | 80 +-- mesalib/src/mesa/main/teximage.c | 1 + mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp | 20 +- 13 files changed, 332 insertions(+), 379 deletions(-) (limited to 'mesalib') diff --git a/mesalib/bin/get-pick-list.sh b/mesalib/bin/get-pick-list.sh index a141afe26..d3ac511c1 100644 --- a/mesalib/bin/get-pick-list.sh +++ b/mesalib/bin/get-pick-list.sh @@ -8,7 +8,7 @@ git log --reverse --grep="cherry picked from commit" origin/master..HEAD |\ sed -e 's/^[[:space:]]*(cherry picked from commit[[:space:]]*//' -e 's/)//' > already_picked # Grep for commits that were marked as a candidate for the stable tree. -git log --reverse --pretty=%H -i --grep='^[[:space:]]*NOTE: This is a candidate' HEAD..origin/master |\ +git log --reverse --pretty=%H -i --grep='^[[:space:]]*NOTE: .*[Cc]andidate' HEAD..origin/master |\ while read sha do # Check to see whether the patch is on the ignore list. diff --git a/mesalib/configure.ac b/mesalib/configure.ac index 5f95a78d2..ea56a044d 100644 --- a/mesalib/configure.ac +++ b/mesalib/configure.ac @@ -832,20 +832,6 @@ if test "x$enable_dri" = xyes; then fi fi -dnl Find out if X is available. -PKG_CHECK_MODULES([X11], [x11], [no_x=no], [no_x=yes]) - -dnl Try to tell the user that the --x-* options are only used when -dnl pkg-config is not available. This must be right after AC_PATH_XTRA. -m4_divert_once([HELP_BEGIN], -[These options are only used when the X libraries cannot be found by the -pkg-config utility.]) - -dnl We need X for xlib and dri, so bomb now if it's not found -if test "x$enable_glx" = xyes -a "x$no_x" = xyes; then - AC_MSG_ERROR([X11 development libraries needed for GLX]) -fi - dnl Direct rendering or just indirect rendering case "$host_os" in gnu*) @@ -1095,7 +1081,7 @@ if test "x$enable_dri" = xyes; then fi # if we are building any dri driver other than swrast or using the dri state tracker ... - if test -n "$DRI_DIRS" -a x"$DRI_DIRS" != xswrast || test "x$enable_dri" = xyes; then + if test -n "$DRI_DIRS" -a x"$DRI_DIRS" != xswrast -a "x$enable_dri" = xyes; then # ... libdrm is required if test "x$have_libdrm" != xyes; then AC_MSG_ERROR([DRI drivers requires libdrm >= $LIBDRM_REQUIRED]) diff --git a/mesalib/scons/llvm.py b/mesalib/scons/llvm.py index 7f00c6ce1..7cd609c20 100644 --- a/mesalib/scons/llvm.py +++ b/mesalib/scons/llvm.py @@ -174,7 +174,7 @@ def generate(env): env.Append(LINKFLAGS = ['/nodefaultlib:LIBCMT']) else: if not env.Detect('llvm-config'): - print 'scons: llvm-config script not found' % llvm_version + print 'scons: llvm-config script not found' return llvm_version = env.backtick('llvm-config --version').rstrip() diff --git a/mesalib/src/gallium/auxiliary/util/u_blitter.c b/mesalib/src/gallium/auxiliary/util/u_blitter.c index e37be4e0a..a85183644 100644 --- a/mesalib/src/gallium/auxiliary/util/u_blitter.c +++ b/mesalib/src/gallium/auxiliary/util/u_blitter.c @@ -924,6 +924,11 @@ void util_blitter_cache_all_shaders(struct blitter_context *blitter) (target == PIPE_TEXTURE_CUBE_ARRAY)) continue; + if (i > 1 && + (target != PIPE_TEXTURE_2D && + target != PIPE_TEXTURE_2D_ARRAY)) + continue; + blitter_get_fs_texfetch_col(ctx, target, i); blitter_get_fs_texfetch_depth(ctx, target, i); if (ctx->has_stencil_export) { diff --git a/mesalib/src/glsl/glsl_parser_extras.cpp b/mesalib/src/glsl/glsl_parser_extras.cpp index 9d7de3381..56082f761 100644 --- a/mesalib/src/glsl/glsl_parser_extras.cpp +++ b/mesalib/src/glsl/glsl_parser_extras.cpp @@ -308,9 +308,10 @@ _mesa_glsl_shader_target_name(enum _mesa_glsl_parser_targets target) 'id' is the implementation-defined ID of the given message. */ static void _mesa_glsl_msg(const YYLTYPE *locp, _mesa_glsl_parse_state *state, - GLenum type, GLuint id, const char *fmt, va_list ap) + GLenum type, const char *fmt, va_list ap) { - bool error = (type == GL_DEBUG_TYPE_ERROR_ARB); + bool error = (type == MESA_DEBUG_TYPE_ERROR); + GLuint msg_id = 0; assert(state->info_log != NULL); @@ -326,9 +327,9 @@ _mesa_glsl_msg(const YYLTYPE *locp, _mesa_glsl_parse_state *state, const char *const msg = &state->info_log[msg_offset]; struct gl_context *ctx = state->ctx; + /* Report the error via GL_ARB_debug_output. */ - if (error) - _mesa_shader_debug(ctx, type, id, msg, strlen(msg)); + _mesa_shader_debug(ctx, type, &msg_id, msg, strlen(msg)); ralloc_strcat(&state->info_log, "\n"); } @@ -338,12 +339,11 @@ _mesa_glsl_error(YYLTYPE *locp, _mesa_glsl_parse_state *state, const char *fmt, ...) { va_list ap; - GLenum type = GL_DEBUG_TYPE_ERROR_ARB; state->error = true; va_start(ap, fmt); - _mesa_glsl_msg(locp, state, type, SHADER_ERROR_UNKNOWN, fmt, ap); + _mesa_glsl_msg(locp, state, MESA_DEBUG_TYPE_ERROR, fmt, ap); va_end(ap); } @@ -353,10 +353,9 @@ _mesa_glsl_warning(const YYLTYPE *locp, _mesa_glsl_parse_state *state, const char *fmt, ...) { va_list ap; - GLenum type = GL_DEBUG_TYPE_OTHER_ARB; va_start(ap, fmt); - _mesa_glsl_msg(locp, state, type, 0, fmt, ap); + _mesa_glsl_msg(locp, state, MESA_DEBUG_TYPE_OTHER, fmt, ap); va_end(ap); } diff --git a/mesalib/src/glsl/standalone_scaffolding.cpp b/mesalib/src/glsl/standalone_scaffolding.cpp index 8c0091e84..b5ef768bd 100644 --- a/mesalib/src/glsl/standalone_scaffolding.cpp +++ b/mesalib/src/glsl/standalone_scaffolding.cpp @@ -60,7 +60,7 @@ _mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr, } void -_mesa_shader_debug(struct gl_context *, GLenum, GLuint, +_mesa_shader_debug(struct gl_context *, GLenum, GLuint *id, const char *, int) { } diff --git a/mesalib/src/glsl/standalone_scaffolding.h b/mesalib/src/glsl/standalone_scaffolding.h index 096b2f114..0a2cde8a3 100644 --- a/mesalib/src/glsl/standalone_scaffolding.h +++ b/mesalib/src/glsl/standalone_scaffolding.h @@ -44,7 +44,7 @@ extern "C" struct gl_shader * _mesa_new_shader(struct gl_context *ctx, GLuint name, GLenum type); extern "C" void -_mesa_shader_debug(struct gl_context *ctx, GLenum type, GLuint id, +_mesa_shader_debug(struct gl_context *ctx, GLenum type, GLuint *id, const char *msg, int len); /** diff --git a/mesalib/src/mesa/main/errors.c b/mesalib/src/mesa/main/errors.c index 0c5e36d5a..97f1b8a03 100644 --- a/mesalib/src/mesa/main/errors.c +++ b/mesalib/src/mesa/main/errors.c @@ -29,19 +29,20 @@ #include "errors.h" - +#include "enums.h" #include "imports.h" #include "context.h" #include "dispatch.h" #include "hash.h" #include "mtypes.h" #include "version.h" +#include "hash_table.h" +#include "glapi/glthread.h" +_glthread_DECLARE_STATIC_MUTEX(DynamicIDMutex); +static GLuint NextDynamicID = 1; -#define MAXSTRING MAX_DEBUG_MESSAGE_LENGTH - - -struct gl_client_severity +struct gl_debug_severity { struct simple_node link; GLuint ID; @@ -49,82 +50,89 @@ struct gl_client_severity static char out_of_memory[] = "Debugging error: out of memory"; -#define enum_is(e, kind1, kind2) \ - ((e) == GL_DEBUG_##kind1##_##kind2##_ARB || (e) == GL_DONT_CARE) -#define severity_is(sev, kind) enum_is(sev, SEVERITY, kind) -#define source_is(s, kind) enum_is(s, SOURCE, kind) -#define type_is(t, kind) enum_is(t, TYPE, kind) - -/* Prevent define collision on Windows */ -#undef ERROR - -enum { - SOURCE_APPLICATION, - SOURCE_THIRD_PARTY, - - SOURCE_COUNT, - SOURCE_ANY = -1 +static const GLenum debug_source_enums[] = { + GL_DEBUG_SOURCE_API, + GL_DEBUG_SOURCE_WINDOW_SYSTEM, + GL_DEBUG_SOURCE_SHADER_COMPILER, + GL_DEBUG_SOURCE_THIRD_PARTY, + GL_DEBUG_SOURCE_APPLICATION, + GL_DEBUG_SOURCE_OTHER, }; -enum { - TYPE_ERROR, - TYPE_DEPRECATED, - TYPE_UNDEFINED, - TYPE_PORTABILITY, - TYPE_PERFORMANCE, - TYPE_OTHER, - - TYPE_COUNT, - TYPE_ANY = -1 +static const GLenum debug_type_enums[] = { + GL_DEBUG_TYPE_ERROR, + GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR, + GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR, + GL_DEBUG_TYPE_PORTABILITY, + GL_DEBUG_TYPE_PERFORMANCE, + GL_DEBUG_TYPE_OTHER, }; -enum { - SEVERITY_LOW, - SEVERITY_MEDIUM, - SEVERITY_HIGH, - - SEVERITY_COUNT, - SEVERITY_ANY = -1 +static const GLenum debug_severity_enums[] = { + GL_DEBUG_SEVERITY_LOW, + GL_DEBUG_SEVERITY_MEDIUM, + GL_DEBUG_SEVERITY_HIGH, }; -static int -enum_to_index(GLenum e) +static enum mesa_debug_source +gl_enum_to_debug_source(GLenum e) { - switch (e) { - case GL_DEBUG_SOURCE_APPLICATION_ARB: - return (int)SOURCE_APPLICATION; - case GL_DEBUG_SOURCE_THIRD_PARTY_ARB: - return (int)SOURCE_THIRD_PARTY; + int i; - case GL_DEBUG_TYPE_ERROR_ARB: - return (int)TYPE_ERROR; - case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB: - return (int)TYPE_DEPRECATED; - case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB: - return (int)TYPE_UNDEFINED; - case GL_DEBUG_TYPE_PERFORMANCE_ARB: - return (int)TYPE_PERFORMANCE; - case GL_DEBUG_TYPE_PORTABILITY_ARB: - return (int)TYPE_PORTABILITY; - case GL_DEBUG_TYPE_OTHER_ARB: - return (int)TYPE_OTHER; + for (i = 0; i < Elements(debug_source_enums); i++) { + if (debug_source_enums[i] == e) + break; + } + return i; +} - case GL_DEBUG_SEVERITY_LOW_ARB: - return (int)SEVERITY_LOW; - case GL_DEBUG_SEVERITY_MEDIUM_ARB: - return (int)SEVERITY_MEDIUM; - case GL_DEBUG_SEVERITY_HIGH_ARB: - return (int)SEVERITY_HIGH; +static enum mesa_debug_type +gl_enum_to_debug_type(GLenum e) +{ + int i; - case GL_DONT_CARE: - return (int)TYPE_ANY; + for (i = 0; i < Elements(debug_type_enums); i++) { + if (debug_type_enums[i] == e) + break; + } + return i; +} - default: - assert(0 && "unreachable"); - return -2; - }; +static enum mesa_debug_severity +gl_enum_to_debug_severity(GLenum e) +{ + int i; + + for (i = 0; i < Elements(debug_severity_enums); i++) { + if (debug_severity_enums[i] == e) + break; + } + return i; } +/** + * Handles generating a GL_ARB_debug_output message ID generated by the GL or + * GLSL compiler. + * + * The GL API has this "ID" mechanism, where the intention is to allow a + * client to filter in/out messages based on source, type, and ID. Of course, + * building a giant enum list of all debug output messages that Mesa might + * generate is ridiculous, so instead we have our caller pass us a pointer to + * static storage where the ID should get stored. This ID will be shared + * across all contexts for that message (which seems like a desirable + * property, even if it's not expected by the spec), but note that it won't be + * the same between executions if messages aren't generated in the same order. + */ +static void +debug_get_id(GLuint *id) +{ + if (!(*id)) { + _glthread_LOCK_MUTEX(DynamicIDMutex); + if (!(*id)) + *id = NextDynamicID++; + _glthread_UNLOCK_MUTEX(DynamicIDMutex); + } +} /* * We store a bitfield in the hash table, with five possible values total. @@ -168,17 +176,17 @@ enum { }; /** - * Returns the state of the given message ID in a client-controlled - * namespace. - * 'source', 'type', and 'severity' are array indices like TYPE_ERROR, - * not GL enums. + * Returns the state of the given message source/type/ID tuple. */ static GLboolean -get_message_state(struct gl_context *ctx, int source, int type, - GLuint id, int severity) +should_log(struct gl_context *ctx, + enum mesa_debug_source source, + enum mesa_debug_type type, + GLuint id, + enum mesa_debug_severity severity) { - struct gl_client_namespace *nspace = - &ctx->Debug.ClientIDs.Namespaces[source][type]; + struct gl_debug_namespace *nspace = + &ctx->Debug.Namespaces[source][type]; uintptr_t state; /* In addition to not being able to store zero as a value, HashTable also @@ -191,10 +199,10 @@ get_message_state(struct gl_context *ctx, int source, int type, /* Only do this once for each ID. This makes sure the ID exists in, at most, one list, and does not pointlessly appear multiple times. */ if (!(state & KNOWN_SEVERITY)) { - struct gl_client_severity *entry; + struct gl_debug_severity *entry; if (state == NOT_FOUND) { - if (ctx->Debug.ClientIDs.Defaults[severity][source][type]) + if (ctx->Debug.Defaults[severity][source][type]) state = ENABLED; else state = DISABLED; @@ -220,16 +228,16 @@ out: } /** - * Sets the state of the given message ID in a client-controlled - * namespace. - * 'source' and 'type' are array indices like TYPE_ERROR, not GL enums. + * Sets the state of the given message source/type/ID tuple. */ static void -set_message_state(struct gl_context *ctx, int source, int type, +set_message_state(struct gl_context *ctx, + enum mesa_debug_source source, + enum mesa_debug_type type, GLuint id, GLboolean enabled) { - struct gl_client_namespace *nspace = - &ctx->Debug.ClientIDs.Namespaces[source][type]; + struct gl_debug_namespace *nspace = + &ctx->Debug.Namespaces[source][type]; uintptr_t state; /* In addition to not being able to store zero as a value, HashTable also @@ -254,41 +262,6 @@ set_message_state(struct gl_context *ctx, int source, int type, nspace->ZeroID = state; } -/** - * Whether a debugging message should be logged or not. - * For implementation-controlled namespaces, we keep an array - * of booleans per namespace, per context, recording whether - * each individual message is enabled or not. The message ID - * is an index into the namespace's array. - */ -static GLboolean -should_log(struct gl_context *ctx, GLenum source, GLenum type, - GLuint id, GLenum severity) -{ - if (source == GL_DEBUG_SOURCE_APPLICATION_ARB || - source == GL_DEBUG_SOURCE_THIRD_PARTY_ARB) { - int s, t, sev; - s = enum_to_index(source); - t = enum_to_index(type); - sev = enum_to_index(severity); - - return get_message_state(ctx, s, t, sev, id); - } - - if (type_is(type, ERROR)) { - if (source_is(source, API)) - return ctx->Debug.ApiErrors[id]; - if (source_is(source, WINDOW_SYSTEM)) - return ctx->Debug.WinsysErrors[id]; - if (source_is(source, SHADER_COMPILER)) - return ctx->Debug.ShaderErrors[id]; - if (source_is(source, OTHER)) - return ctx->Debug.OtherErrors[id]; - } - - return (severity != GL_DEBUG_SEVERITY_LOW_ARB); -} - /** * 'buf' is not necessarily a null-terminated string. When logging, copy * 'len' characters from it, store them in a new, null-terminated string, @@ -296,8 +269,9 @@ should_log(struct gl_context *ctx, GLenum source, GLenum type, * the null terminator this time. */ static void -_mesa_log_msg(struct gl_context *ctx, GLenum source, GLenum type, - GLuint id, GLenum severity, GLint len, const char *buf) +_mesa_log_msg(struct gl_context *ctx, enum mesa_debug_source source, + enum mesa_debug_type type, GLuint id, + enum mesa_debug_severity severity, GLint len, const char *buf) { GLint nextEmpty; struct gl_debug_msg *emptySlot; @@ -308,7 +282,10 @@ _mesa_log_msg(struct gl_context *ctx, GLenum source, GLenum type, return; if (ctx->Debug.Callback) { - ctx->Debug.Callback(source, type, id, severity, + ctx->Debug.Callback(debug_source_enums[source], + debug_type_enums[type], + id, + debug_severity_enums[severity], len, buf, ctx->Debug.CallbackData); return; } @@ -333,13 +310,16 @@ _mesa_log_msg(struct gl_context *ctx, GLenum source, GLenum type, emptySlot->id = id; emptySlot->severity = severity; } else { + static GLuint oom_msg_id = 0; + debug_get_id(&oom_msg_id); + /* malloc failed! */ emptySlot->message = out_of_memory; emptySlot->length = strlen(out_of_memory)+1; - emptySlot->source = GL_DEBUG_SOURCE_OTHER_ARB; - emptySlot->type = GL_DEBUG_TYPE_ERROR_ARB; - emptySlot->id = OTHER_ERROR_OUT_OF_MEMORY; - emptySlot->severity = GL_DEBUG_SEVERITY_HIGH_ARB; + emptySlot->source = MESA_DEBUG_SOURCE_OTHER; + emptySlot->type = MESA_DEBUG_TYPE_ERROR; + emptySlot->id = oom_msg_id; + emptySlot->severity = MESA_DEBUG_SEVERITY_HIGH; } if (ctx->Debug.NumMessages == 0) @@ -377,11 +357,11 @@ _mesa_get_msg(struct gl_context *ctx, GLenum *source, GLenum *type, return 0; if (severity) - *severity = msg->severity; + *severity = debug_severity_enums[msg->severity]; if (source) - *source = msg->source; + *source = debug_source_enums[msg->source]; if (type) - *type = msg->type; + *type = debug_type_enums[msg->type]; if (id) *id = msg->id; @@ -498,7 +478,10 @@ _mesa_DebugMessageInsertARB(GLenum source, GLenum type, GLuint id, return; } - _mesa_log_msg(ctx, source, type, id, severity, length, buf); + _mesa_log_msg(ctx, + gl_enum_to_debug_source(source), + gl_enum_to_debug_type(type), id, + gl_enum_to_debug_severity(severity), length, buf); } GLuint GLAPIENTRY @@ -547,42 +530,9 @@ _mesa_GetDebugMessageLogARB(GLuint count, GLsizei logSize, GLenum* sources, } /** - * 'array' is an array representing a particular debugging-message namespace. - * I.e., the set of all API errors, or the set of all Shader Compiler errors. - * 'size' is the size of 'array'. 'count' is the size of 'ids', an array - * of indices into 'array'. All the elements of 'array' at the indices - * listed in 'ids' will be overwritten with the value of 'enabled'. - * - * If 'count' is zero, all elements in 'array' are overwritten with the - * value of 'enabled'. - */ -static void -control_messages(GLboolean *array, GLuint size, - GLsizei count, const GLuint *ids, GLboolean enabled) -{ - GLsizei i; - - if (!count) { - GLuint id; - for (id = 0; id < size; id++) { - array[id] = enabled; - } - return; - } - - for (i = 0; i < count; i++) { - if (ids[i] >= size) { - /* XXX: The spec doesn't say what to do with a non-existent ID. */ - continue; - } - array[ids[i]] = enabled; - } -} - -/** - * Set the state of all message IDs found in the given intersection - * of 'source', 'type', and 'severity'. Note that all three of these - * parameters are array indices, not the corresponding GL enums. + * Set the state of all message IDs found in the given intersection of + * 'source', 'type', and 'severity'. The _COUNT enum can be used for + * GL_DONT_CARE (include all messages in the class). * * This requires both setting the state of all previously seen message * IDs in the hash table, and setting the default state for all @@ -591,29 +541,31 @@ control_messages(GLboolean *array, GLuint size, * impacted as if they were already known. */ static void -control_app_messages_by_group(struct gl_context *ctx, int source, int type, - int severity, GLboolean enabled) +control_messages(struct gl_context *ctx, + enum mesa_debug_source source, + enum mesa_debug_type type, + enum mesa_debug_severity severity, + GLboolean enabled) { - struct gl_client_debug *ClientIDs = &ctx->Debug.ClientIDs; int s, t, sev, smax, tmax, sevmax; - if (source == SOURCE_ANY) { + if (source == MESA_DEBUG_SOURCE_COUNT) { source = 0; - smax = SOURCE_COUNT; + smax = MESA_DEBUG_SOURCE_COUNT; } else { smax = source+1; } - if (type == TYPE_ANY) { + if (type == MESA_DEBUG_TYPE_COUNT) { type = 0; - tmax = TYPE_COUNT; + tmax = MESA_DEBUG_TYPE_COUNT; } else { tmax = type+1; } - if (severity == SEVERITY_ANY) { + if (severity == MESA_DEBUG_SEVERITY_COUNT) { severity = 0; - sevmax = SEVERITY_COUNT; + sevmax = MESA_DEBUG_SEVERITY_COUNT; } else { sevmax = severity+1; } @@ -622,14 +574,14 @@ control_app_messages_by_group(struct gl_context *ctx, int source, int type, for (s = source; s < smax; s++) for (t = type; t < tmax; t++) { struct simple_node *node; - struct gl_client_severity *entry; + struct gl_debug_severity *entry; /* change the default for IDs we've never seen before. */ - ClientIDs->Defaults[sev][s][t] = enabled; + ctx->Debug.Defaults[sev][s][t] = enabled; /* Now change the state of IDs we *have* seen... */ - foreach(node, &ClientIDs->Namespaces[s][t].Severity[sev]) { - entry = (struct gl_client_severity *)node; + foreach(node, &ctx->Debug.Namespaces[s][t].Severity[sev]) { + entry = (struct gl_debug_severity *)node; set_message_state(ctx, s, t, entry->ID, enabled); } } @@ -652,16 +604,15 @@ control_app_messages(struct gl_context *ctx, GLenum esource, GLenum etype, GLenum eseverity, GLsizei count, const GLuint *ids, GLboolean enabled) { - int source, type, severity; GLsizei i; - - source = enum_to_index(esource); - type = enum_to_index(etype); - severity = enum_to_index(eseverity); + enum mesa_debug_source source = gl_enum_to_debug_source(esource); + enum mesa_debug_type type = gl_enum_to_debug_type(etype); + enum mesa_debug_severity severity = gl_enum_to_debug_severity(eseverity); if (count) - assert(severity == SEVERITY_ANY && type != TYPE_ANY - && source != SOURCE_ANY); + assert(severity == MESA_DEBUG_SEVERITY_COUNT + && type != MESA_DEBUG_TYPE_COUNT + && source != MESA_DEBUG_SOURCE_COUNT); for (i = 0; i < count; i++) set_message_state(ctx, source, type, ids[i], enabled); @@ -669,14 +620,18 @@ control_app_messages(struct gl_context *ctx, GLenum esource, GLenum etype, if (count) return; - control_app_messages_by_group(ctx, source, type, severity, enabled); + control_messages(ctx, source, type, severity, enabled); } void GLAPIENTRY -_mesa_DebugMessageControlARB(GLenum source, GLenum type, GLenum severity, +_mesa_DebugMessageControlARB(GLenum gl_source, GLenum gl_type, + GLenum gl_severity, GLsizei count, const GLuint *ids, GLboolean enabled) { + enum mesa_debug_source source; + enum mesa_debug_type type; + enum mesa_debug_severity severity; GET_CURRENT_CONTEXT(ctx); if (count < 0) { @@ -685,36 +640,22 @@ _mesa_DebugMessageControlARB(GLenum source, GLenum type, GLenum severity, return; } - if (!validate_params(ctx, CONTROL, source, type, severity)) + if (!validate_params(ctx, CONTROL, gl_source, gl_type, gl_severity)) return; /* GL_INVALID_ENUM */ - if (count && (severity != GL_DONT_CARE || type == GL_DONT_CARE - || source == GL_DONT_CARE)) { + if (count && (gl_severity != GL_DONT_CARE || gl_type == GL_DONT_CARE + || gl_source == GL_DONT_CARE)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glDebugMessageControlARB" "(When passing an array of ids, severity must be" " GL_DONT_CARE, and source and type must not be GL_DONT_CARE."); return; } - if (source_is(source, APPLICATION) || source_is(source, THIRD_PARTY)) - control_app_messages(ctx, source, type, severity, count, ids, enabled); - - if (severity_is(severity, HIGH)) { - if (type_is(type, ERROR)) { - if (source_is(source, API)) - control_messages(ctx->Debug.ApiErrors, API_ERROR_COUNT, - count, ids, enabled); - if (source_is(source, WINDOW_SYSTEM)) - control_messages(ctx->Debug.WinsysErrors, WINSYS_ERROR_COUNT, - count, ids, enabled); - if (source_is(source, SHADER_COMPILER)) - control_messages(ctx->Debug.ShaderErrors, SHADER_ERROR_COUNT, - count, ids, enabled); - if (source_is(source, OTHER)) - control_messages(ctx->Debug.OtherErrors, OTHER_ERROR_COUNT, - count, ids, enabled); - } - } + source = gl_enum_to_debug_severity(gl_source); + type = gl_enum_to_debug_severity(gl_type); + severity = gl_enum_to_debug_severity(gl_severity); + + control_app_messages(ctx, source, type, severity, count, ids, enabled); } void GLAPIENTRY @@ -729,7 +670,6 @@ void _mesa_init_errors(struct gl_context *ctx) { int s, t, sev; - struct gl_client_debug *ClientIDs = &ctx->Debug.ClientIDs; ctx->Debug.Callback = NULL; ctx->Debug.SyncOutput = GL_FALSE; @@ -739,44 +679,47 @@ _mesa_init_errors(struct gl_context *ctx) ctx->Debug.NextMsgLength = 0; /* Enable all the messages with severity HIGH or MEDIUM by default. */ - memset(ctx->Debug.ApiErrors, GL_TRUE, sizeof ctx->Debug.ApiErrors); - memset(ctx->Debug.WinsysErrors, GL_TRUE, sizeof ctx->Debug.WinsysErrors); - memset(ctx->Debug.ShaderErrors, GL_TRUE, sizeof ctx->Debug.ShaderErrors); - memset(ctx->Debug.OtherErrors, GL_TRUE, sizeof ctx->Debug.OtherErrors); - memset(ClientIDs->Defaults[SEVERITY_HIGH], GL_TRUE, - sizeof ClientIDs->Defaults[SEVERITY_HIGH]); - memset(ClientIDs->Defaults[SEVERITY_MEDIUM], GL_TRUE, - sizeof ClientIDs->Defaults[SEVERITY_MEDIUM]); - memset(ClientIDs->Defaults[SEVERITY_LOW], GL_FALSE, - sizeof ClientIDs->Defaults[SEVERITY_LOW]); - - /* Initialize state for filtering client-provided debug messages. */ - for (s = 0; s < SOURCE_COUNT; s++) - for (t = 0; t < TYPE_COUNT; t++) { - ClientIDs->Namespaces[s][t].IDs = _mesa_NewHashTable(); - assert(ClientIDs->Namespaces[s][t].IDs); - - for (sev = 0; sev < SEVERITY_COUNT; sev++) - make_empty_list(&ClientIDs->Namespaces[s][t].Severity[sev]); + memset(ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_HIGH], GL_TRUE, + sizeof ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_HIGH]); + memset(ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_MEDIUM], GL_TRUE, + sizeof ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_MEDIUM]); + memset(ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_LOW], GL_FALSE, + sizeof ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_LOW]); + + /* Initialize state for filtering known debug messages. */ + for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++) + for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++) { + ctx->Debug.Namespaces[s][t].IDs = _mesa_NewHashTable(); + assert(ctx->Debug.Namespaces[s][t].IDs); + + for (sev = 0; sev < MESA_DEBUG_SEVERITY_COUNT; sev++) + make_empty_list(&ctx->Debug.Namespaces[s][t].Severity[sev]); } } +static void +do_nothing(GLuint key, void *data, void *userData) +{ +} + void _mesa_free_errors_data(struct gl_context *ctx) { - int s, t, sev; - struct gl_client_debug *ClientIDs = &ctx->Debug.ClientIDs; - - /* Tear down state for filtering client-provided debug messages. */ - for (s = 0; s < SOURCE_COUNT; s++) - for (t = 0; t < TYPE_COUNT; t++) { - _mesa_DeleteHashTable(ClientIDs->Namespaces[s][t].IDs); - for (sev = 0; sev < SEVERITY_COUNT; sev++) { + enum mesa_debug_type t; + enum mesa_debug_source s; + enum mesa_debug_severity sev; + + /* Tear down state for filtering debug messages. */ + for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++) + for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++) { + _mesa_HashDeleteAll(ctx->Debug.Namespaces[s][t].IDs, do_nothing, NULL); + _mesa_DeleteHashTable(ctx->Debug.Namespaces[s][t].IDs); + for (sev = 0; sev < MESA_DEBUG_SEVERITY_COUNT; sev++) { struct simple_node *node, *tmp; - struct gl_client_severity *entry; + struct gl_debug_severity *entry; - foreach_s(node, tmp, &ClientIDs->Namespaces[s][t].Severity[sev]) { - entry = (struct gl_client_severity *)node; + foreach_s(node, tmp, &ctx->Debug.Namespaces[s][t].Severity[sev]) { + entry = (struct gl_debug_severity *)node; free(entry); } } @@ -838,38 +781,6 @@ output_if_debug(const char *prefixString, const char *outputString, } } - -/** - * Return string version of GL error code. - */ -static const char * -error_string( GLenum error ) -{ - switch (error) { - case GL_NO_ERROR: - return "GL_NO_ERROR"; - case GL_INVALID_VALUE: - return "GL_INVALID_VALUE"; - case GL_INVALID_ENUM: - return "GL_INVALID_ENUM"; - case GL_INVALID_OPERATION: - return "GL_INVALID_OPERATION"; - case GL_STACK_OVERFLOW: - return "GL_STACK_OVERFLOW"; - case GL_STACK_UNDERFLOW: - return "GL_STACK_UNDERFLOW"; - case GL_OUT_OF_MEMORY: - return "GL_OUT_OF_MEMORY"; - case GL_TABLE_TOO_LARGE: - return "GL_TABLE_TOO_LARGE"; - case GL_INVALID_FRAMEBUFFER_OPERATION_EXT: - return "GL_INVALID_FRAMEBUFFER_OPERATION"; - default: - return "unknown"; - } -} - - /** * When a new type of error is recorded, print a message describing * previous errors which were accumulated. @@ -877,12 +788,12 @@ error_string( GLenum error ) static void flush_delayed_errors( struct gl_context *ctx ) { - char s[MAXSTRING]; + char s[MAX_DEBUG_MESSAGE_LENGTH]; if (ctx->ErrorDebugCount) { - _mesa_snprintf(s, MAXSTRING, "%d similar %s errors", + _mesa_snprintf(s, MAX_DEBUG_MESSAGE_LENGTH, "%d similar %s errors", ctx->ErrorDebugCount, - error_string(ctx->ErrorValue)); + _mesa_lookup_enum_by_nr(ctx->ErrorValue)); output_if_debug("Mesa", s, GL_TRUE); @@ -901,10 +812,10 @@ flush_delayed_errors( struct gl_context *ctx ) void _mesa_warning( struct gl_context *ctx, const char *fmtString, ... ) { - char str[MAXSTRING]; + char str[MAX_DEBUG_MESSAGE_LENGTH]; va_list args; va_start( args, fmtString ); - (void) _mesa_vsnprintf( str, MAXSTRING, fmtString, args ); + (void) _mesa_vsnprintf( str, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args ); va_end( args ); if (ctx) @@ -925,7 +836,7 @@ void _mesa_problem( const struct gl_context *ctx, const char *fmtString, ... ) { va_list args; - char str[MAXSTRING]; + char str[MAX_DEBUG_MESSAGE_LENGTH]; static int numCalls = 0; (void) ctx; @@ -934,7 +845,7 @@ _mesa_problem( const struct gl_context *ctx, const char *fmtString, ... ) numCalls++; va_start( args, fmtString ); - _mesa_vsnprintf( str, MAXSTRING, fmtString, args ); + _mesa_vsnprintf( str, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args ); va_end( args ); fprintf(stderr, "Mesa %s implementation error: %s\n", MESA_VERSION_STRING, str); @@ -978,6 +889,27 @@ should_output(struct gl_context *ctx, GLenum error, const char *fmtString) return GL_FALSE; } +void +_mesa_gl_debug(struct gl_context *ctx, + GLuint *id, + enum mesa_debug_type type, + enum mesa_debug_severity severity, + const char *fmtString, ...) +{ + char s[MAX_DEBUG_MESSAGE_LENGTH]; + int len; + va_list args; + + debug_get_id(id); + + va_start(args, fmtString); + len = _mesa_vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args); + va_end(args); + + _mesa_log_msg(ctx, MESA_DEBUG_SOURCE_API, type, + *id, severity, len, s); +} + /** * Record an OpenGL state error. These usually occur when the user @@ -995,29 +927,39 @@ void _mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... ) { GLboolean do_output, do_log; + /* Ideally this would be set up by the caller, so that we had proper IDs + * per different message. + */ + static GLuint error_msg_id = 0; + + debug_get_id(&error_msg_id); do_output = should_output(ctx, error, fmtString); - do_log = should_log(ctx, GL_DEBUG_SOURCE_API_ARB, GL_DEBUG_TYPE_ERROR_ARB, - API_ERROR_UNKNOWN, GL_DEBUG_SEVERITY_HIGH_ARB); + do_log = should_log(ctx, + MESA_DEBUG_SOURCE_API, + MESA_DEBUG_TYPE_ERROR, + error_msg_id, + MESA_DEBUG_SEVERITY_HIGH); if (do_output || do_log) { - char s[MAXSTRING], s2[MAXSTRING]; + char s[MAX_DEBUG_MESSAGE_LENGTH], s2[MAX_DEBUG_MESSAGE_LENGTH]; int len; va_list args; va_start(args, fmtString); - len = _mesa_vsnprintf(s, MAXSTRING, fmtString, args); + len = _mesa_vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args); va_end(args); - if (len >= MAXSTRING) { + if (len >= MAX_DEBUG_MESSAGE_LENGTH) { /* Too long error message. Whoever calls _mesa_error should use * shorter strings. */ ASSERT(0); return; } - len = _mesa_snprintf(s2, MAXSTRING, "%s in %s", error_string(error), s); - if (len >= MAXSTRING) { + len = _mesa_snprintf(s2, MAX_DEBUG_MESSAGE_LENGTH, "%s in %s", + _mesa_lookup_enum_by_nr(error), s); + if (len >= MAX_DEBUG_MESSAGE_LENGTH) { /* Same as above. */ ASSERT(0); return; @@ -1030,8 +972,11 @@ _mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... ) /* Log the error via ARB_debug_output if needed.*/ if (do_log) { - _mesa_log_msg(ctx, GL_DEBUG_SOURCE_API_ARB, GL_DEBUG_TYPE_ERROR_ARB, - API_ERROR_UNKNOWN, GL_DEBUG_SEVERITY_HIGH_ARB, len, s2); + _mesa_log_msg(ctx, + MESA_DEBUG_SOURCE_API, + MESA_DEBUG_TYPE_ERROR, + error_msg_id, + MESA_DEBUG_SEVERITY_HIGH, len, s2); } } @@ -1051,10 +996,10 @@ void _mesa_debug( const struct gl_context *ctx, const char *fmtString, ... ) { #ifdef DEBUG - char s[MAXSTRING]; + char s[MAX_DEBUG_MESSAGE_LENGTH]; va_list args; va_start(args, fmtString); - _mesa_vsnprintf(s, MAXSTRING, fmtString, args); + _mesa_vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args); va_end(args); output_if_debug("Mesa", s, GL_FALSE); #endif /* DEBUG */ @@ -1073,27 +1018,13 @@ _mesa_debug( const struct gl_context *ctx, const char *fmtString, ... ) * \param len The length of 'msg'. If negative, 'msg' must be null-terminated. */ void -_mesa_shader_debug( struct gl_context *ctx, GLenum type, GLuint id, +_mesa_shader_debug( struct gl_context *ctx, GLenum type, GLuint *id, const char *msg, int len ) { - GLenum source = GL_DEBUG_SOURCE_SHADER_COMPILER_ARB, - severity; + enum mesa_debug_source source = MESA_DEBUG_SOURCE_SHADER_COMPILER; + enum mesa_debug_severity severity = MESA_DEBUG_SEVERITY_HIGH; - switch (type) { - case GL_DEBUG_TYPE_ERROR_ARB: - assert(id < SHADER_ERROR_COUNT); - severity = GL_DEBUG_SEVERITY_HIGH_ARB; - break; - case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB: - case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB: - case GL_DEBUG_TYPE_PORTABILITY_ARB: - case GL_DEBUG_TYPE_PERFORMANCE_ARB: - case GL_DEBUG_TYPE_OTHER_ARB: - assert(0 && "other categories not implemented yet"); - default: - _mesa_problem(ctx, "bad enum in _mesa_shader_debug()"); - return; - } + debug_get_id(id); if (len < 0) len = strlen(msg); @@ -1102,7 +1033,7 @@ _mesa_shader_debug( struct gl_context *ctx, GLenum type, GLuint id, if (len >= MAX_DEBUG_MESSAGE_LENGTH) len = MAX_DEBUG_MESSAGE_LENGTH - 1; - _mesa_log_msg(ctx, source, type, id, severity, len, msg); + _mesa_log_msg(ctx, source, type, *id, severity, len, msg); } /*@}*/ diff --git a/mesalib/src/mesa/main/errors.h b/mesalib/src/mesa/main/errors.h index c92ee0a6e..7d8be5aca 100644 --- a/mesalib/src/mesa/main/errors.h +++ b/mesalib/src/mesa/main/errors.h @@ -44,8 +44,9 @@ extern "C" { #endif +#include "mtypes.h" + struct _glapi_table; -struct gl_context; extern void _mesa_init_errors( struct gl_context *ctx ); @@ -66,7 +67,15 @@ extern void _mesa_debug( const struct gl_context *ctx, const char *fmtString, ... ) PRINTFLIKE(2, 3); extern void -_mesa_shader_debug( struct gl_context *ctx, GLenum type, GLuint id, const char *msg, int len ); +_mesa_gl_debug(struct gl_context *ctx, + GLuint *id, + enum mesa_debug_type type, + enum mesa_debug_severity severity, + const char *fmtString, ...) PRINTFLIKE(5, 6); + +extern void +_mesa_shader_debug(struct gl_context *ctx, GLenum type, GLuint *id, + const char *msg, int len); void GLAPIENTRY _mesa_DebugMessageInsertARB(GLenum source, GLenum type, GLuint id, diff --git a/mesalib/src/mesa/main/get_hash_params.py b/mesalib/src/mesa/main/get_hash_params.py index 5022ddc40..7d4f7e2a4 100644 --- a/mesalib/src/mesa/main/get_hash_params.py +++ b/mesalib/src/mesa/main/get_hash_params.py @@ -412,7 +412,7 @@ descriptor=[ [ "DEPTH_SCALE", "CONTEXT_FLOAT(Pixel.DepthScale), NO_EXTRA" ], [ "DOUBLEBUFFER", "BUFFER_INT(Visual.doubleBufferMode), NO_EXTRA" ], [ "DRAW_BUFFER", "BUFFER_ENUM(ColorDrawBuffer[0]), NO_EXTRA" ], - [ "EDGE_FLAG", "LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA" ], + [ "EDGE_FLAG", "LOC_CUSTOM, TYPE_BOOLEAN, 0, extra_flush_current" ], [ "FEEDBACK_BUFFER_SIZE", "CONTEXT_INT(Feedback.BufferSize), NO_EXTRA" ], [ "FEEDBACK_BUFFER_TYPE", "CONTEXT_ENUM(Feedback.Type), NO_EXTRA" ], [ "FOG_INDEX", "CONTEXT_FLOAT(Fog.Index), NO_EXTRA" ], diff --git a/mesalib/src/mesa/main/mtypes.h b/mesalib/src/mesa/main/mtypes.h index a80944c81..4f0951339 100644 --- a/mesalib/src/mesa/main/mtypes.h +++ b/mesalib/src/mesa/main/mtypes.h @@ -3368,52 +3368,61 @@ struct gl_dlist_state } Current; }; +/** @{ + * + * These are a mapping of the GL_ARB_debug_output enums to small enums + * suitable for use as an array index. + */ + +enum mesa_debug_source { + MESA_DEBUG_SOURCE_API, + MESA_DEBUG_SOURCE_WINDOW_SYSTEM, + MESA_DEBUG_SOURCE_SHADER_COMPILER, + MESA_DEBUG_SOURCE_THIRD_PARTY, + MESA_DEBUG_SOURCE_APPLICATION, + MESA_DEBUG_SOURCE_OTHER, + MESA_DEBUG_SOURCE_COUNT, +}; + +enum mesa_debug_type { + MESA_DEBUG_TYPE_ERROR, + MESA_DEBUG_TYPE_DEPRECATED, + MESA_DEBUG_TYPE_UNDEFINED, + MESA_DEBUG_TYPE_PORTABILITY, + MESA_DEBUG_TYPE_PERFORMANCE, + MESA_DEBUG_TYPE_OTHER, + MESA_DEBUG_TYPE_COUNT, +}; + +enum mesa_debug_severity { + MESA_DEBUG_SEVERITY_LOW, + MESA_DEBUG_SEVERITY_MEDIUM, + MESA_DEBUG_SEVERITY_HIGH, + MESA_DEBUG_SEVERITY_COUNT, +}; + +/** @} */ + /** * An error, warning, or other piece of debug information for an application * to consume via GL_ARB_debug_output. */ struct gl_debug_msg { - GLenum source; - GLenum type; + enum mesa_debug_source source; + enum mesa_debug_type type; GLuint id; - GLenum severity; + enum mesa_debug_severity severity; GLsizei length; GLcharARB *message; }; -typedef enum { - API_ERROR_UNKNOWN, - API_ERROR_COUNT -} gl_api_error; - -typedef enum { - WINSYS_ERROR_UNKNOWN, - WINSYS_ERROR_COUNT -} gl_winsys_error; - -typedef enum { - SHADER_ERROR_UNKNOWN, - SHADER_ERROR_COUNT -} gl_shader_error; - -typedef enum { - OTHER_ERROR_UNKNOWN, - OTHER_ERROR_OUT_OF_MEMORY, - OTHER_ERROR_COUNT -} gl_other_error; - -struct gl_client_namespace +struct gl_debug_namespace { struct _mesa_HashTable *IDs; unsigned ZeroID; /* a HashTable won't take zero, so store its state here */ - struct simple_node Severity[3]; /* lists of IDs in the hash table */ -}; - -struct gl_client_debug -{ - GLboolean Defaults[3][2][6]; /* severity, source, type */ - struct gl_client_namespace Namespaces[2][6]; /* source, type */ + /** lists of IDs in the hash table at each severity */ + struct simple_node Severity[MESA_DEBUG_SEVERITY_COUNT]; }; struct gl_debug_state @@ -3421,11 +3430,8 @@ struct gl_debug_state GLDEBUGPROCARB Callback; GLvoid *CallbackData; GLboolean SyncOutput; - GLboolean ApiErrors[API_ERROR_COUNT]; - GLboolean WinsysErrors[WINSYS_ERROR_COUNT]; - GLboolean ShaderErrors[SHADER_ERROR_COUNT]; - GLboolean OtherErrors[OTHER_ERROR_COUNT]; - struct gl_client_debug ClientIDs; + GLboolean Defaults[MESA_DEBUG_SEVERITY_COUNT][MESA_DEBUG_SOURCE_COUNT][MESA_DEBUG_TYPE_COUNT]; + struct gl_debug_namespace Namespaces[MESA_DEBUG_SOURCE_COUNT][MESA_DEBUG_TYPE_COUNT]; struct gl_debug_msg Log[MAX_DEBUG_LOGGED_MESSAGES]; GLint NumMessages; GLint NextMsg; diff --git a/mesalib/src/mesa/main/teximage.c b/mesalib/src/mesa/main/teximage.c index 0dcf88ae4..9d4a17052 100644 --- a/mesalib/src/mesa/main/teximage.c +++ b/mesalib/src/mesa/main/teximage.c @@ -1416,6 +1416,7 @@ _mesa_legal_texture_dimensions(struct gl_context *ctx, GLenum target, return GL_FALSE; return GL_TRUE; + case GL_TEXTURE_CUBE_MAP: case GL_TEXTURE_CUBE_MAP_POSITIVE_X: case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: diff --git a/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp b/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp index c41b5833e..131ecb22a 100644 --- a/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp +++ b/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp @@ -2714,16 +2714,28 @@ glsl_to_tgsi_visitor::visit(ir_texture *ir) switch (ir->op) { case ir_tex: opcode = (is_cube_array && ir->shadow_comparitor) ? TGSI_OPCODE_TEX2 : TGSI_OPCODE_TEX; + if (ir->offset) { + ir->offset->accept(this); + offset = this->result; + } break; case ir_txb: opcode = is_cube_array ? TGSI_OPCODE_TXB2 : TGSI_OPCODE_TXB; ir->lod_info.bias->accept(this); lod_info = this->result; + if (ir->offset) { + ir->offset->accept(this); + offset = this->result; + } break; case ir_txl: opcode = is_cube_array ? TGSI_OPCODE_TXL2 : TGSI_OPCODE_TXL; ir->lod_info.lod->accept(this); lod_info = this->result; + if (ir->offset) { + ir->offset->accept(this); + offset = this->result; + } break; case ir_txd: opcode = TGSI_OPCODE_TXD; @@ -2731,6 +2743,10 @@ glsl_to_tgsi_visitor::visit(ir_texture *ir) dx = this->result; ir->lod_info.grad.dPdy->accept(this); dy = this->result; + if (ir->offset) { + ir->offset->accept(this); + offset = this->result; + } break; case ir_txs: opcode = TGSI_OPCODE_TXQ; @@ -2742,8 +2758,8 @@ glsl_to_tgsi_visitor::visit(ir_texture *ir) ir->lod_info.lod->accept(this); lod_info = this->result; if (ir->offset) { - ir->offset->accept(this); - offset = this->result; + ir->offset->accept(this); + offset = this->result; } break; case ir_txf_ms: -- cgit v1.2.3