From ea0cd87ecbe9fc3c5503ccad7f87a895a458d6d4 Mon Sep 17 00:00:00 2001 From: marha Date: Thu, 1 May 2014 16:56:41 +0200 Subject: xkeyboard-config libxcb xserver mesa git update 1 May 2014 xserver commit 2535b76c0d32bc1dd0ddaca06a419a68a4757df1 libxcb commit d978a4f69b30b630f28d07f1003cf290284d24d8 xkeyboard-config commit 5274a69ee85fb6c425c33c631fa8ea1310a8f097 mesa commit a773fdc64da8ba88d8c7f8e383c45248b0c3aa19 --- mesalib/src/mesa/drivers/common/meta.c | 4 +- mesalib/src/mesa/drivers/dri/common/SConscript | 1 + mesalib/src/mesa/drivers/dri/common/dri_util.c | 7 +- mesalib/src/mesa/drivers/dri/common/dri_util.h | 8 +- .../src/mesa/drivers/dri/common/megadriver_stub.c | 7 +- mesalib/src/mesa/drivers/dri/swrast/swrast.c | 8 +- mesalib/src/mesa/main/enable.c | 35 +- mesalib/src/mesa/main/errors.c | 1175 +++++++++++--------- mesalib/src/mesa/main/errors.h | 10 +- mesalib/src/mesa/main/ff_fragment_shader.cpp | 19 +- mesalib/src/mesa/main/ffvertex_prog.c | 4 +- mesalib/src/mesa/main/get.c | 16 +- mesalib/src/mesa/main/getstring.c | 17 +- mesalib/src/mesa/main/mtypes.h | 50 +- mesalib/src/mesa/main/texobj.c | 4 +- mesalib/src/mesa/main/texparam.c | 4 +- mesalib/src/mesa/main/texstate.c | 297 +++-- mesalib/src/mesa/state_tracker/st_atom.c | 1 + mesalib/src/mesa/state_tracker/st_atom.h | 1 + .../src/mesa/state_tracker/st_atom_framebuffer.c | 15 +- mesalib/src/mesa/state_tracker/st_atom_msaa.c | 23 + .../src/mesa/state_tracker/st_atom_pixeltransfer.c | 2 +- mesalib/src/mesa/state_tracker/st_cb_clear.c | 3 + mesalib/src/mesa/state_tracker/st_cb_drawtex.c | 6 +- mesalib/src/mesa/state_tracker/st_extensions.c | 3 +- mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp | 91 +- mesalib/src/mesa/state_tracker/st_manager.c | 11 +- mesalib/src/mesa/state_tracker/st_program.c | 21 +- mesalib/src/mesa/swrast/s_context.c | 8 +- mesalib/src/mesa/swrast/s_texcombine.c | 10 +- mesalib/src/mesa/swrast/s_texture.c | 66 +- mesalib/src/mesa/swrast/s_triangle.c | 4 +- mesalib/src/mesa/swrast_setup/ss_context.c | 3 +- 33 files changed, 1106 insertions(+), 828 deletions(-) (limited to 'mesalib/src/mesa') diff --git a/mesalib/src/mesa/drivers/common/meta.c b/mesalib/src/mesa/drivers/common/meta.c index ac27abba6..ab86f9c96 100644 --- a/mesalib/src/mesa/drivers/common/meta.c +++ b/mesalib/src/mesa/drivers/common/meta.c @@ -2328,7 +2328,7 @@ _mesa_meta_Bitmap(struct gl_context *ctx, if (ctx->_ImageTransferState || ctx->FragmentProgram._Enabled || ctx->Fog.Enabled || - ctx->Texture._EnabledUnits || + ctx->Texture._MaxEnabledTexImageUnit != -1 || width > tex->MaxSize || height > tex->MaxSize) { _swrast_Bitmap(ctx, x, y, width, height, unpack, bitmap1); @@ -3265,7 +3265,7 @@ _mesa_meta_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z, GLfloat s, t, s1, t1; GLuint tw, th; - if (!ctx->Texture.Unit[i]._ReallyEnabled) { + if (!ctx->Texture.Unit[i]._Current) { GLuint j; for (j = 0; j < 4; j++) { verts[j].st[i][0] = 0.0f; diff --git a/mesalib/src/mesa/drivers/dri/common/SConscript b/mesalib/src/mesa/drivers/dri/common/SConscript index 8b15532e3..41f6356c3 100644 --- a/mesalib/src/mesa/drivers/dri/common/SConscript +++ b/mesalib/src/mesa/drivers/dri/common/SConscript @@ -30,6 +30,7 @@ drienv.Replace(CPPPATH = [ driswenv = drienv.Clone() driswenv.Append(CPPDEFINES = [ '__NOT_HAVE_DRM_H', + 'HAVE_DLADDR', ]) drienv.PkgUseModules('DRM') diff --git a/mesalib/src/mesa/drivers/dri/common/dri_util.c b/mesalib/src/mesa/drivers/dri/common/dri_util.c index aed73c73f..248c36165 100644 --- a/mesalib/src/mesa/drivers/dri/common/dri_util.c +++ b/mesalib/src/mesa/drivers/dri/common/dri_util.c @@ -449,10 +449,7 @@ driContextSetFlags(struct gl_context *ctx, uint32_t flags) if ((flags & __DRI_CTX_FLAG_FORWARD_COMPATIBLE) != 0) ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT; if ((flags & __DRI_CTX_FLAG_DEBUG) != 0) { - struct gl_debug_state *debug = _mesa_get_debug_state(ctx); - if (debug) { - debug->DebugOutput = GL_TRUE; - } + _mesa_set_debug_state_int(ctx, GL_DEBUG_OUTPUT, GL_TRUE); ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_DEBUG_BIT; } } @@ -778,7 +775,7 @@ const __DRIswrastExtension driSWRastExtension = { }; const __DRI2configQueryExtension dri2ConfigQueryExtension = { - .base = { __DRI2_CONFIG_QUERY, __DRI2_CONFIG_QUERY_VERSION }, + .base = { __DRI2_CONFIG_QUERY, 1 }, .configQueryb = dri2ConfigQueryb, .configQueryi = dri2ConfigQueryi, diff --git a/mesalib/src/mesa/drivers/dri/common/dri_util.h b/mesalib/src/mesa/drivers/dri/common/dri_util.h index a37a0bbbc..1138bf106 100644 --- a/mesalib/src/mesa/drivers/dri/common/dri_util.h +++ b/mesalib/src/mesa/drivers/dri/common/dri_util.h @@ -174,13 +174,13 @@ struct __DRIscreenRec { struct { /* Flag to indicate that this is a DRI2 screen. Many of the above * fields will not be valid or initializaed in that case. */ - __DRIdri2LoaderExtension *loader; - __DRIimageLookupExtension *image; - __DRIuseInvalidateExtension *useInvalidate; + const __DRIdri2LoaderExtension *loader; + const __DRIimageLookupExtension *image; + const __DRIuseInvalidateExtension *useInvalidate; } dri2; struct { - __DRIimageLoaderExtension *loader; + const __DRIimageLoaderExtension *loader; } image; driOptionCache optionInfo; diff --git a/mesalib/src/mesa/drivers/dri/common/megadriver_stub.c b/mesalib/src/mesa/drivers/dri/common/megadriver_stub.c index 7b6d13450..d085080a1 100644 --- a/mesalib/src/mesa/drivers/dri/common/megadriver_stub.c +++ b/mesalib/src/mesa/drivers/dri/common/megadriver_stub.c @@ -28,10 +28,9 @@ /* We need GNU extensions to dlfcn.h in order to provide backward * compatibility for the older DRI driver loader mechanism. (dladdr, - * Dl_info, and RTLD_DEFAULT are only defined when _GNU_SOURCE is - * defined.) + * Dl_info, and RTLD_DEFAULT) */ -#ifdef RTLD_DEFAULT +#if defined(RTLD_DEFAULT) && defined(HAVE_DLADDR) #define MEGADRIVER_STUB_MAX_EXTENSIONS 10 #define LIB_PATH_SUFFIX "_dri.so" @@ -148,7 +147,7 @@ megadriver_stub_init(void) } } -#endif /* RTLD_DEFAULT */ +#endif /* RTLD_DEFAULT && HAVE_DLADDR */ static const __DRIconfig **stub_error_init_screen(__DRIscreen *psp) diff --git a/mesalib/src/mesa/drivers/dri/swrast/swrast.c b/mesalib/src/mesa/drivers/dri/swrast/swrast.c index 071192c6f..888138115 100644 --- a/mesalib/src/mesa/drivers/dri/swrast/swrast.c +++ b/mesalib/src/mesa/drivers/dri/swrast/swrast.c @@ -110,9 +110,11 @@ static void swrastSetTexBuffer(__DRIcontext *pDRICtx, GLint target, } static const __DRItexBufferExtension swrastTexBufferExtension = { - { __DRI_TEX_BUFFER, __DRI_TEX_BUFFER_VERSION }, - swrastSetTexBuffer, - swrastSetTexBuffer2, + .base = { __DRI_TEX_BUFFER, 3 }, + + .setTexBuffer = swrastSetTexBuffer, + .setTexBuffer2 = swrastSetTexBuffer2, + .releaseTexBuffer = NULL, }; static const __DRIextension *dri_screen_extensions[] = { diff --git a/mesalib/src/mesa/main/enable.c b/mesalib/src/mesa/main/enable.c index edd4751e1..0f3bcf0a9 100644 --- a/mesalib/src/mesa/main/enable.c +++ b/mesalib/src/mesa/main/enable.c @@ -368,26 +368,11 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) ctx->Depth.Test = state; break; case GL_DEBUG_OUTPUT: - if (!_mesa_is_desktop_gl(ctx)) { - goto invalid_enum_error; - } - else { - struct gl_debug_state *debug = _mesa_get_debug_state(ctx); - if (debug) { - debug->DebugOutput = state; - } - } - break; case GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB: - if (!_mesa_is_desktop_gl(ctx)) { + if (!_mesa_is_desktop_gl(ctx)) goto invalid_enum_error; - } - else { - struct gl_debug_state *debug = _mesa_get_debug_state(ctx); - if (debug) { - debug->SyncOutput = state; - } - } + else + _mesa_set_debug_state_int(ctx, cap, state); break; case GL_DITHER: if (ctx->Color.DitherFlag == state) @@ -1239,21 +1224,11 @@ _mesa_IsEnabled( GLenum cap ) case GL_CULL_FACE: return ctx->Polygon.CullFlag; case GL_DEBUG_OUTPUT: - if (!_mesa_is_desktop_gl(ctx)) - goto invalid_enum_error; - if (ctx->Debug) { - return ctx->Debug->DebugOutput; - } else { - return GL_FALSE; - } case GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB: if (!_mesa_is_desktop_gl(ctx)) goto invalid_enum_error; - if (ctx->Debug) { - return ctx->Debug->SyncOutput; - } else { - return GL_FALSE; - } + else + return (GLboolean) _mesa_get_debug_state_int(ctx, cap); case GL_DEPTH_TEST: return ctx->Depth.Test; case GL_DITHER: diff --git a/mesalib/src/mesa/main/errors.c b/mesalib/src/mesa/main/errors.c index d80fda0db..30a867298 100644 --- a/mesalib/src/mesa/main/errors.c +++ b/mesalib/src/mesa/main/errors.c @@ -41,10 +41,63 @@ static mtx_t DynamicIDMutex = _MTX_INITIALIZER_NP; static GLuint NextDynamicID = 1; -struct gl_debug_severity +/** + * A namespace element. + */ +struct gl_debug_element { struct simple_node link; + GLuint ID; + /* at which severity levels (mesa_debug_severity) is the message enabled */ + GLbitfield State; +}; + +struct gl_debug_namespace +{ + struct simple_node Elements; + GLbitfield DefaultState; +}; + +struct gl_debug_group { + struct gl_debug_namespace Namespaces[MESA_DEBUG_SOURCE_COUNT][MESA_DEBUG_TYPE_COUNT]; +}; + +/** + * An error, warning, or other piece of debug information for an application + * to consume via GL_ARB_debug_output/GL_KHR_debug. + */ +struct gl_debug_message +{ + enum mesa_debug_source source; + enum mesa_debug_type type; + GLuint id; + enum mesa_debug_severity severity; + GLsizei length; + GLcharARB *message; +}; + +/** + * Debug message log. It works like a ring buffer. + */ +struct gl_debug_log { + struct gl_debug_message Messages[MAX_DEBUG_LOGGED_MESSAGES]; + GLint NextMessage; + GLint NumMessages; +}; + +struct gl_debug_state +{ + GLDEBUGPROC Callback; + const void *CallbackData; + GLboolean SyncOutput; + GLboolean DebugOutput; + + struct gl_debug_group *Groups[MAX_DEBUG_GROUP_STACK_DEPTH]; + struct gl_debug_message GroupMessages[MAX_DEBUG_GROUP_STACK_DEPTH]; + GLint GroupStackDepth; + + struct gl_debug_log Log; }; static char out_of_memory[] = "Debugging error: out of memory"; @@ -139,235 +192,399 @@ debug_get_id(GLuint *id) } } +static void +debug_message_clear(struct gl_debug_message *msg) +{ + if (msg->message != (char*)out_of_memory) + free(msg->message); + msg->message = NULL; + msg->length = 0; +} + +static void +debug_message_store(struct gl_debug_message *msg, + enum mesa_debug_source source, + enum mesa_debug_type type, GLuint id, + enum mesa_debug_severity severity, + GLsizei len, const char *buf) +{ + assert(!msg->message && !msg->length); + + msg->message = malloc(len+1); + if (msg->message) { + (void) strncpy(msg->message, buf, (size_t)len); + msg->message[len] = '\0'; + + msg->length = len+1; + msg->source = source; + msg->type = type; + msg->id = id; + msg->severity = severity; + } else { + static GLuint oom_msg_id = 0; + debug_get_id(&oom_msg_id); + + /* malloc failed! */ + msg->message = out_of_memory; + msg->length = strlen(out_of_memory)+1; + msg->source = MESA_DEBUG_SOURCE_OTHER; + msg->type = MESA_DEBUG_TYPE_ERROR; + msg->id = oom_msg_id; + msg->severity = MESA_DEBUG_SEVERITY_HIGH; + } +} + +static void +debug_namespace_init(struct gl_debug_namespace *ns) +{ + make_empty_list(&ns->Elements); -/* - * We store a bitfield in the hash table, with five possible values total. - * - * The ENABLED_BIT's purpose is self-explanatory. - * - * The FOUND_BIT is needed to differentiate the value of DISABLED from - * the value returned by HashTableLookup() when it can't find the given key. - * - * The KNOWN_SEVERITY bit is a bit complicated: - * - * A client may call Control() with an array of IDs, then call Control() - * on all message IDs of a certain severity, then Insert() one of the - * previously specified IDs, giving us a known severity level, then call - * Control() on all message IDs of a certain severity level again. - * - * After the first call, those IDs will have a FOUND_BIT, but will not - * exist in any severity-specific list, so the second call will not - * impact them. This is undesirable but unavoidable given the API: - * The only entrypoint that gives a severity for a client-defined ID - * is the Insert() call. - * - * For the sake of Control(), we want to maintain the invariant - * that an ID will either appear in none of the three severity lists, - * or appear once, to minimize pointless duplication and potential surprises. - * - * Because Insert() is the only place that will learn an ID's severity, - * it should insert an ID into the appropriate list, but only if the ID - * doesn't exist in it or any other list yet. Because searching all three - * lists at O(n) is needlessly expensive, we store KNOWN_SEVERITY. - */ -enum { - FOUND_BIT = 1 << 0, - ENABLED_BIT = 1 << 1, - KNOWN_SEVERITY = 1 << 2, - - /* HashTable reserves zero as a return value meaning 'not found' */ - NOT_FOUND = 0, - DISABLED = FOUND_BIT, - ENABLED = ENABLED_BIT | FOUND_BIT -}; + /* Enable all the messages with severity HIGH or MEDIUM by default */ + ns->DefaultState = (1 << MESA_DEBUG_SEVERITY_HIGH) | + (1 << MESA_DEBUG_SEVERITY_MEDIUM); +} + +static void +debug_namespace_clear(struct gl_debug_namespace *ns) +{ + struct simple_node *node, *tmp; + + foreach_s(node, tmp, &ns->Elements) + free(node); +} + +static bool +debug_namespace_copy(struct gl_debug_namespace *dst, + const struct gl_debug_namespace *src) +{ + struct simple_node *node; + + dst->DefaultState = src->DefaultState; + make_empty_list(&dst->Elements); + foreach(node, &src->Elements) { + const struct gl_debug_element *elem = + (const struct gl_debug_element *) node; + struct gl_debug_element *copy; + + copy = malloc(sizeof(*copy)); + if (!copy) { + debug_namespace_clear(dst); + return false; + } + + copy->ID = elem->ID; + copy->State = elem->State; + insert_at_tail(&dst->Elements, ©->link); + } + + return true; +} /** - * Return debug state for the context. The debug state will be allocated - * and initialized upon the first call. + * Set the state of \p id in the namespace. */ -struct gl_debug_state * -_mesa_get_debug_state(struct gl_context *ctx) +static bool +debug_namespace_set(struct gl_debug_namespace *ns, + GLuint id, bool enabled) { - if (!ctx->Debug) { - ctx->Debug = CALLOC_STRUCT(gl_debug_state); - if (!ctx->Debug) { - _mesa_error(ctx, GL_OUT_OF_MEMORY, "allocating debug state"); + const uint32_t state = (enabled) ? + ((1 << MESA_DEBUG_SEVERITY_COUNT) - 1) : 0; + struct gl_debug_element *elem = NULL; + struct simple_node *node; + + /* find the element */ + foreach(node, &ns->Elements) { + struct gl_debug_element *tmp = (struct gl_debug_element *) node; + if (tmp->ID == id) { + elem = tmp; + break; } - else { - struct gl_debug_state *debug = ctx->Debug; - int s, t, sev; - - /* Enable all the messages with severity HIGH or MEDIUM by default. */ - memset(debug->Defaults[0][MESA_DEBUG_SEVERITY_HIGH], GL_TRUE, - sizeof debug->Defaults[0][MESA_DEBUG_SEVERITY_HIGH]); - memset(debug->Defaults[0][MESA_DEBUG_SEVERITY_MEDIUM], GL_TRUE, - sizeof debug->Defaults[0][MESA_DEBUG_SEVERITY_MEDIUM]); - memset(debug->Defaults[0][MESA_DEBUG_SEVERITY_LOW], GL_FALSE, - sizeof debug->Defaults[0][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++) { - debug->Namespaces[0][s][t].IDs = _mesa_NewHashTable(); - assert(debug->Namespaces[0][s][t].IDs); - - for (sev = 0; sev < MESA_DEBUG_SEVERITY_COUNT; sev++) { - make_empty_list(&debug->Namespaces[0][s][t].Severity[sev]); - } - } - } + } + + /* we do not need the element if it has the default state */ + if (ns->DefaultState == state) { + if (elem) { + remove_from_list(&elem->link); + free(elem); } + return true; } - return ctx->Debug; + if (!elem) { + elem = malloc(sizeof(*elem)); + if (!elem) + return false; + + elem->ID = id; + insert_at_tail(&ns->Elements, &elem->link); + } + + elem->State = state; + + return true; } +/** + * Set the default state of the namespace for \p severity. When \p severity + * is MESA_DEBUG_SEVERITY_COUNT, the default values for all severities are + * updated. + */ +static void +debug_namespace_set_all(struct gl_debug_namespace *ns, + enum mesa_debug_severity severity, + bool enabled) +{ + struct simple_node *node, *tmp; + uint32_t mask, val; + + /* set all elements to the same state */ + if (severity == MESA_DEBUG_SEVERITY_COUNT) { + ns->DefaultState = (enabled) ? ((1 << severity) - 1) : 0; + debug_namespace_clear(ns); + make_empty_list(&ns->Elements); + return; + } + + mask = 1 << severity; + val = (enabled) ? mask : 0; + ns->DefaultState = (ns->DefaultState & ~mask) | val; + + foreach_s(node, tmp, &ns->Elements) { + struct gl_debug_element *elem = (struct gl_debug_element *) node; + + elem->State = (elem->State & ~mask) | val; + if (elem->State == ns->DefaultState) { + remove_from_list(node); + free(node); + } + } +} /** - * Returns the state of the given message source/type/ID tuple. + * Get the state of \p id in the namespace. */ -static GLboolean -should_log(struct gl_context *ctx, - enum mesa_debug_source source, - enum mesa_debug_type type, - GLuint id, - enum mesa_debug_severity severity) +static bool +debug_namespace_get(const struct gl_debug_namespace *ns, GLuint id, + enum mesa_debug_severity severity) { - struct gl_debug_state *debug; - uintptr_t state = 0; + struct simple_node *node; + uint32_t state; - if (!ctx->Debug) { - /* no debug state set so far */ - return GL_FALSE; + state = ns->DefaultState; + foreach(node, &ns->Elements) { + struct gl_debug_element *elem = (struct gl_debug_element *) node; + + if (elem->ID == id) { + state = elem->State; + break; + } } - debug = _mesa_get_debug_state(ctx); - if (debug) { - const GLint gstack = debug->GroupStackDepth; - struct gl_debug_namespace *nspace = - &debug->Namespaces[gstack][source][type]; + return (state & (1 << severity)); +} - if (!debug->DebugOutput) - return GL_FALSE; +/** + * Allocate and initialize context debug state. + */ +static struct gl_debug_state * +debug_create(void) +{ + struct gl_debug_state *debug; + int s, t; - /* In addition to not being able to store zero as a value, HashTable also - * can't use zero as a key. - */ - if (id) - state = (uintptr_t)_mesa_HashLookup(nspace->IDs, id); - else - state = nspace->ZeroID; + debug = CALLOC_STRUCT(gl_debug_state); + if (!debug) + return NULL; - /* 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_debug_severity *entry; - - if (state == NOT_FOUND) { - if (debug->Defaults[gstack][severity][source][type]) - state = ENABLED; - else - state = DISABLED; - } + debug->Groups[0] = malloc(sizeof(*debug->Groups[0])); + if (!debug->Groups[0]) { + free(debug); + return NULL; + } + + /* 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++) + debug_namespace_init(&debug->Groups[0]->Namespaces[s][t]); + } + + return debug; +} - entry = malloc(sizeof *entry); - if (!entry) - goto out; +/** + * Return true if the top debug group points to the group below it. + */ +static bool +debug_is_group_read_only(const struct gl_debug_state *debug) +{ + const GLint gstack = debug->GroupStackDepth; + return (gstack > 0 && debug->Groups[gstack] == debug->Groups[gstack - 1]); +} + +/** + * Make the top debug group writable. + */ +static bool +debug_make_group_writable(struct gl_debug_state *debug) +{ + const GLint gstack = debug->GroupStackDepth; + const struct gl_debug_group *src = debug->Groups[gstack]; + struct gl_debug_group *dst; + int s, t; - state |= KNOWN_SEVERITY; + if (!debug_is_group_read_only(debug)) + return true; - if (id) - _mesa_HashInsert(nspace->IDs, id, (void*)state); - else - nspace->ZeroID = state; + dst = malloc(sizeof(*dst)); + if (!dst) + return false; - entry->ID = id; - insert_at_tail(&nspace->Severity[severity], &entry->link); + for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++) { + for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++) { + if (!debug_namespace_copy(&dst->Namespaces[s][t], + &src->Namespaces[s][t])) { + /* error path! */ + for (t = t - 1; t >= 0; t--) + debug_namespace_clear(&dst->Namespaces[s][t]); + for (s = s - 1; s >= 0; s--) { + for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++) + debug_namespace_clear(&dst->Namespaces[s][t]); + } + free(dst); + return false; + } } } -out: - return !!(state & ENABLED_BIT); -} + debug->Groups[gstack] = dst; + + return true; +} /** - * Sets the state of the given message source/type/ID tuple. + * Free the top debug group. */ static void -set_message_state(struct gl_context *ctx, - enum mesa_debug_source source, - enum mesa_debug_type type, - GLuint id, GLboolean enabled) +debug_clear_group(struct gl_debug_state *debug) { - struct gl_debug_state *debug = _mesa_get_debug_state(ctx); + const GLint gstack = debug->GroupStackDepth; - if (debug) { - GLint gstack = debug->GroupStackDepth; - struct gl_debug_namespace *nspace = - &debug->Namespaces[gstack][source][type]; - uintptr_t state; + if (!debug_is_group_read_only(debug)) { + struct gl_debug_group *grp = debug->Groups[gstack]; + int s, t; - /* In addition to not being able to store zero as a value, HashTable also - * can't use zero as a key. - */ - if (id) - state = (uintptr_t)_mesa_HashLookup(nspace->IDs, id); - else - state = nspace->ZeroID; - - if (state == NOT_FOUND) - state = enabled ? ENABLED : DISABLED; - else { - if (enabled) - state |= ENABLED_BIT; - else - state &= ~ENABLED_BIT; + for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++) { + for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++) + debug_namespace_clear(&grp->Namespaces[s][t]); } - if (id) - _mesa_HashInsert(nspace->IDs, id, (void*)state); - else - nspace->ZeroID = state; + free(grp); } + + debug->Groups[gstack] = NULL; } +/** + * Loop through debug group stack tearing down states for + * filtering debug messages. Then free debug output state. + */ +static void +debug_destroy(struct gl_debug_state *debug) +{ + while (debug->GroupStackDepth > 0) { + debug_clear_group(debug); + debug->GroupStackDepth--; + } + debug_clear_group(debug); + free(debug); +} + +/** + * Sets the state of the given message source/type/ID tuple. + */ static void -store_message_details(struct gl_debug_msg *emptySlot, - enum mesa_debug_source source, - enum mesa_debug_type type, GLuint id, - enum mesa_debug_severity severity, GLint len, - const char *buf) +debug_set_message_enable(struct gl_debug_state *debug, + enum mesa_debug_source source, + enum mesa_debug_type type, + GLuint id, GLboolean enabled) { - assert(!emptySlot->message && !emptySlot->length); - - emptySlot->message = malloc(len+1); - if (emptySlot->message) { - (void) strncpy(emptySlot->message, buf, (size_t)len); - emptySlot->message[len] = '\0'; - - emptySlot->length = len+1; - emptySlot->source = source; - emptySlot->type = type; - emptySlot->id = id; - emptySlot->severity = severity; + const GLint gstack = debug->GroupStackDepth; + struct gl_debug_namespace *ns; + + debug_make_group_writable(debug); + ns = &debug->Groups[gstack]->Namespaces[source][type]; + + debug_namespace_set(ns, id, enabled); +} + +/* + * 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 + * applicable combinations of source/type/severity, so that all the + * yet-unknown message IDs that may be used in the future will be + * impacted as if they were already known. + */ +static void +debug_set_message_enable_all(struct gl_debug_state *debug, + enum mesa_debug_source source, + enum mesa_debug_type type, + enum mesa_debug_severity severity, + GLboolean enabled) +{ + const GLint gstack = debug->GroupStackDepth; + int s, t, smax, tmax; + + if (source == MESA_DEBUG_SOURCE_COUNT) { + source = 0; + smax = MESA_DEBUG_SOURCE_COUNT; } else { - static GLuint oom_msg_id = 0; - debug_get_id(&oom_msg_id); + smax = source+1; + } - /* malloc failed! */ - emptySlot->message = out_of_memory; - emptySlot->length = strlen(out_of_memory)+1; - emptySlot->source = MESA_DEBUG_SOURCE_OTHER; - emptySlot->type = MESA_DEBUG_TYPE_ERROR; - emptySlot->id = oom_msg_id; - emptySlot->severity = MESA_DEBUG_SEVERITY_HIGH; + if (type == MESA_DEBUG_TYPE_COUNT) { + type = 0; + tmax = MESA_DEBUG_TYPE_COUNT; + } else { + tmax = type+1; + } + + debug_make_group_writable(debug); + + for (s = source; s < smax; s++) { + for (t = type; t < tmax; t++) { + struct gl_debug_namespace *nspace = + &debug->Groups[gstack]->Namespaces[s][t]; + debug_namespace_set_all(nspace, severity, enabled); + } } } +/** + * Returns if the given message source/type/ID tuple is enabled. + */ +static bool +debug_is_message_enabled(const struct gl_debug_state *debug, + enum mesa_debug_source source, + enum mesa_debug_type type, + GLuint id, + enum mesa_debug_severity severity) +{ + const GLint gstack = debug->GroupStackDepth; + struct gl_debug_group *grp = debug->Groups[gstack]; + struct gl_debug_namespace *nspace = &grp->Namespaces[source][type]; + + if (!debug->DebugOutput) + return false; + + return debug_namespace_get(nspace, id, severity); +} /** * 'buf' is not necessarily a null-terminated string. When logging, copy @@ -376,108 +593,229 @@ store_message_details(struct gl_debug_msg *emptySlot, * the null terminator this time. */ static void -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) +debug_log_message(struct gl_debug_state *debug, + enum mesa_debug_source source, + enum mesa_debug_type type, GLuint id, + enum mesa_debug_severity severity, + GLsizei len, const char *buf) { - struct gl_debug_state *debug = _mesa_get_debug_state(ctx); + struct gl_debug_log *log = &debug->Log; GLint nextEmpty; - struct gl_debug_msg *emptySlot; - - if (!debug) - return; + struct gl_debug_message *emptySlot; assert(len >= 0 && len < MAX_DEBUG_MESSAGE_LENGTH); - if (!should_log(ctx, source, type, id, severity)) + if (log->NumMessages == MAX_DEBUG_LOGGED_MESSAGES) return; - if (debug->Callback) { - GLenum gl_type = debug_type_enums[type]; - GLenum gl_severity = debug_severity_enums[severity]; + nextEmpty = (log->NextMessage + log->NumMessages) + % MAX_DEBUG_LOGGED_MESSAGES; + emptySlot = &log->Messages[nextEmpty]; - debug->Callback(debug_source_enums[source], gl_type, id, gl_severity, - len, buf, debug->CallbackData); - return; - } + debug_message_store(emptySlot, source, type, + id, severity, len, buf); - if (debug->NumMessages == MAX_DEBUG_LOGGED_MESSAGES) - return; + log->NumMessages++; +} + +/** + * Return the oldest debug message out of the log. + */ +static const struct gl_debug_message * +debug_fetch_message(const struct gl_debug_state *debug) +{ + const struct gl_debug_log *log = &debug->Log; + + return (log->NumMessages) ? &log->Messages[log->NextMessage] : NULL; +} + +/** + * Delete the oldest debug messages out of the log. + */ +static void +debug_delete_messages(struct gl_debug_state *debug, unsigned count) +{ + struct gl_debug_log *log = &debug->Log; - nextEmpty = (debug->NextMsg + debug->NumMessages) - % MAX_DEBUG_LOGGED_MESSAGES; - emptySlot = &debug->Log[nextEmpty]; + if (count > log->NumMessages) + count = log->NumMessages; - store_message_details(emptySlot, source, type, id, severity, len, buf); + while (count--) { + struct gl_debug_message *msg = &log->Messages[log->NextMessage]; - if (debug->NumMessages == 0) - debug->NextMsgLength = debug->Log[debug->NextMsg].length; + debug_message_clear(msg); - debug->NumMessages++; + log->NumMessages--; + log->NextMessage++; + log->NextMessage %= MAX_DEBUG_LOGGED_MESSAGES; + } +} + +static struct gl_debug_message * +debug_get_group_message(struct gl_debug_state *debug) +{ + return &debug->GroupMessages[debug->GroupStackDepth]; +} + +static void +debug_push_group(struct gl_debug_state *debug) +{ + const GLint gstack = debug->GroupStackDepth; + + /* just point to the previous stack */ + debug->Groups[gstack + 1] = debug->Groups[gstack]; + debug->GroupStackDepth++; +} + +static void +debug_pop_group(struct gl_debug_state *debug) +{ + debug_clear_group(debug); + debug->GroupStackDepth--; } /** - * Pop the oldest debug message out of the log. - * Writes the message string, including the null terminator, into 'buf', - * using up to 'bufSize' bytes. If 'bufSize' is too small, or - * if 'buf' is NULL, nothing is written. - * - * Returns the number of bytes written on success, or when 'buf' is NULL, - * the number that would have been written. A return value of 0 - * indicates failure. + * Return debug state for the context. The debug state will be allocated + * and initialized upon the first call. */ -static GLsizei -get_msg(struct gl_context *ctx, GLenum *source, GLenum *type, - GLuint *id, GLenum *severity, GLsizei bufSize, char *buf) +static struct gl_debug_state * +_mesa_get_debug_state(struct gl_context *ctx) +{ + if (!ctx->Debug) { + ctx->Debug = debug_create(); + if (!ctx->Debug) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "allocating debug state"); + } + } + + return ctx->Debug; +} + +/** + * Set the integer debug state specified by \p pname. This can be called from + * _mesa_set_enable for example. + */ +bool +_mesa_set_debug_state_int(struct gl_context *ctx, GLenum pname, GLint val) { struct gl_debug_state *debug = _mesa_get_debug_state(ctx); - struct gl_debug_msg *msg; - GLsizei length; - if (!debug || debug->NumMessages == 0) - return 0; + if (!debug) + return false; - msg = &debug->Log[debug->NextMsg]; - length = msg->length; + switch (pname) { + case GL_DEBUG_OUTPUT: + debug->DebugOutput = (val != 0); + break; + case GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB: + debug->SyncOutput = (val != 0); + break; + default: + assert(!"unknown debug output param"); + break; + } - assert(length > 0 && length == debug->NextMsgLength); + return true; +} - if (bufSize < length && buf != NULL) +/** + * Query the integer debug state specified by \p pname. This can be called + * _mesa_GetIntegerv for example. + */ +GLint +_mesa_get_debug_state_int(struct gl_context *ctx, GLenum pname) +{ + struct gl_debug_state *debug; + GLint val; + + debug = ctx->Debug; + if (!debug) return 0; - if (severity) { - *severity = debug_severity_enums[msg->severity]; + switch (pname) { + case GL_DEBUG_OUTPUT: + val = debug->DebugOutput; + break; + case GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB: + val = debug->SyncOutput; + break; + case GL_DEBUG_LOGGED_MESSAGES: + val = debug->Log.NumMessages; + break; + case GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH: + val = (debug->Log.NumMessages) ? + debug->Log.Messages[debug->Log.NextMessage].length : 0; + break; + case GL_DEBUG_GROUP_STACK_DEPTH: + val = debug->GroupStackDepth; + break; + default: + assert(!"unknown debug output param"); + val = 0; + break; } - if (source) { - *source = debug_source_enums[msg->source]; - } + return val; +} - if (type) { - *type = debug_type_enums[msg->type]; - } +/** + * Query the pointer debug state specified by \p pname. This can be called + * _mesa_GetPointerv for example. + */ +void * +_mesa_get_debug_state_ptr(struct gl_context *ctx, GLenum pname) +{ + struct gl_debug_state *debug; + void *val; - if (id) { - *id = msg->id; - } + debug = ctx->Debug; + if (!debug) + return NULL; - if (buf) { - assert(msg->message[length-1] == '\0'); - (void) strncpy(buf, msg->message, (size_t)length); + switch (pname) { + case GL_DEBUG_CALLBACK_FUNCTION_ARB: + val = (void *) debug->Callback; + break; + case GL_DEBUG_CALLBACK_USER_PARAM_ARB: + val = (void *) debug->CallbackData; + break; + default: + assert(!"unknown debug output param"); + val = NULL; + break; } - if (msg->message != (char*)out_of_memory) - free(msg->message); - msg->message = NULL; - msg->length = 0; + return val; +} - debug->NumMessages--; - debug->NextMsg++; - debug->NextMsg %= MAX_DEBUG_LOGGED_MESSAGES; - debug->NextMsgLength = debug->Log[debug->NextMsg].length; - return length; +/** + * Log a client or driver debug message. + */ +static void +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) +{ + struct gl_debug_state *debug = _mesa_get_debug_state(ctx); + + if (!debug) + return; + + if (!debug_is_message_enabled(debug, source, type, id, severity)) + return; + + if (debug->Callback) { + GLenum gl_type = debug_type_enums[type]; + GLenum gl_severity = debug_severity_enums[severity]; + + debug->Callback(debug_source_enums[source], gl_type, id, gl_severity, + len, buf, debug->CallbackData); + return; + } + + debug_log_message(debug, source, type, id, severity, len, buf); } @@ -560,172 +898,18 @@ error: } -/** - * 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 - * applicable combinations of source/type/severity, so that all the - * yet-unknown message IDs that may be used in the future will be - * impacted as if they were already known. - */ -static void -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_debug_state *debug = _mesa_get_debug_state(ctx); - int s, t, sev, smax, tmax, sevmax; - const GLint gstack = debug ? debug->GroupStackDepth : 0; - - if (!debug) - return; - - if (source == MESA_DEBUG_SOURCE_COUNT) { - source = 0; - smax = MESA_DEBUG_SOURCE_COUNT; - } else { - smax = source+1; - } - - if (type == MESA_DEBUG_TYPE_COUNT) { - type = 0; - tmax = MESA_DEBUG_TYPE_COUNT; - } else { - tmax = type+1; - } - - if (severity == MESA_DEBUG_SEVERITY_COUNT) { - severity = 0; - sevmax = MESA_DEBUG_SEVERITY_COUNT; - } else { - sevmax = severity+1; - } - - for (sev = severity; sev < sevmax; sev++) { - for (s = source; s < smax; s++) { - for (t = type; t < tmax; t++) { - struct simple_node *node; - struct gl_debug_severity *entry; - - /* change the default for IDs we've never seen before. */ - debug->Defaults[gstack][sev][s][t] = enabled; - - /* Now change the state of IDs we *have* seen... */ - foreach(node, &debug->Namespaces[gstack][s][t].Severity[sev]) { - entry = (struct gl_debug_severity *)node; - set_message_state(ctx, s, t, entry->ID, enabled); - } - } - } - } -} - - -/** - * Debugging-message namespaces with the source APPLICATION or THIRD_PARTY - * require special handling, since the IDs in them are controlled by clients, - * not the OpenGL implementation. - * - * 'count' is the length of the array 'ids'. If 'count' is nonzero, all - * the given IDs in the namespace defined by 'esource' and 'etype' - * will be affected. - * - * If 'count' is zero, this sets the state of all IDs that match - * the combination of 'esource', 'etype', and 'eseverity'. - */ -static void -control_app_messages(struct gl_context *ctx, GLenum esource, GLenum etype, - GLenum eseverity, GLsizei count, const GLuint *ids, - GLboolean enabled) -{ - GLsizei i; - 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); - - for (i = 0; i < count; i++) - set_message_state(ctx, source, type, ids[i], enabled); - - if (count) - return; - - control_messages(ctx, source, type, severity, enabled); -} - - -/** - * This is a generic message insert function. - * Validation of source, type and severity parameters should be done - * before calling this funtion. - */ -static void -message_insert(GLenum source, GLenum type, GLuint id, - GLenum severity, GLint length, const GLchar *buf, - const char *callerstr) +static GLboolean +validate_length(struct gl_context *ctx, const char *callerstr, GLsizei length) { - GET_CURRENT_CONTEXT(ctx); - - if (length < 0) - length = strlen(buf); - if (length >= MAX_DEBUG_MESSAGE_LENGTH) { _mesa_error(ctx, GL_INVALID_VALUE, "%s(length=%d, which is not less than " "GL_MAX_DEBUG_MESSAGE_LENGTH=%d)", callerstr, length, MAX_DEBUG_MESSAGE_LENGTH); - return; + return GL_FALSE; } - log_msg(ctx, - gl_enum_to_debug_source(source), - gl_enum_to_debug_type(type), id, - gl_enum_to_debug_severity(severity), length, buf); -} - - -static void -do_nothing(GLuint key, void *data, void *userData) -{ -} - - -/** - * Free context state pertaining to error/debug state for the given stack - * depth. - */ -static void -free_errors_data(struct gl_context *ctx, GLint gstack) -{ - struct gl_debug_state *debug = ctx->Debug; - enum mesa_debug_type t; - enum mesa_debug_source s; - enum mesa_debug_severity sev; - - assert(debug); - - /* 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(debug->Namespaces[gstack][s][t].IDs, - do_nothing, NULL); - _mesa_DeleteHashTable(debug->Namespaces[gstack][s][t].IDs); - for (sev = 0; sev < MESA_DEBUG_SEVERITY_COUNT; sev++) { - struct simple_node *node, *tmp; - struct gl_debug_severity *entry; - - foreach_s(node, tmp, - &debug->Namespaces[gstack][s][t].Severity[sev]) { - entry = (struct gl_debug_severity *)node; - free(entry); - } - } - } - } + return GL_TRUE; } @@ -741,7 +925,15 @@ _mesa_DebugMessageInsert(GLenum source, GLenum type, GLuint id, if (!validate_params(ctx, INSERT, callerstr, source, type, severity)) return; /* GL_INVALID_ENUM */ - message_insert(source, type, id, severity, length, buf, callerstr); + if (length < 0) + length = strlen(buf); + if (!validate_length(ctx, callerstr, length)) + return; /* GL_INVALID_VALUE */ + + log_msg(ctx, gl_enum_to_debug_source(source), + gl_enum_to_debug_type(type), id, + gl_enum_to_debug_severity(severity), + length, buf); } @@ -751,6 +943,7 @@ _mesa_GetDebugMessageLog(GLuint count, GLsizei logSize, GLenum *sources, GLsizei *lengths, GLchar *messageLog) { GET_CURRENT_CONTEXT(ctx); + struct gl_debug_state *debug; GLuint ret; if (!messageLog) @@ -763,29 +956,39 @@ _mesa_GetDebugMessageLog(GLuint count, GLsizei logSize, GLenum *sources, return 0; } + debug = _mesa_get_debug_state(ctx); + if (!debug) + return 0; + for (ret = 0; ret < count; ret++) { - GLsizei written = get_msg(ctx, sources, types, ids, severities, - logSize, messageLog); - if (!written) + const struct gl_debug_message *msg = debug_fetch_message(debug); + + if (!msg) + break; + + if (logSize < msg->length && messageLog != NULL) break; if (messageLog) { - messageLog += written; - logSize -= written; - } - if (lengths) { - *lengths = written; - lengths++; + assert(msg->message[msg->length-1] == '\0'); + (void) strncpy(messageLog, msg->message, (size_t)msg->length); + + messageLog += msg->length; + logSize -= msg->length; } + if (lengths) + *lengths++ = msg->length; if (severities) - severities++; + *severities++ = debug_severity_enums[msg->severity]; if (sources) - sources++; + *sources++ = debug_source_enums[msg->source]; if (types) - types++; + *types++ = debug_type_enums[msg->type]; if (ids) - ids++; + *ids++ = msg->id; + + debug_delete_messages(debug, 1); } return ret; @@ -797,9 +1000,12 @@ _mesa_DebugMessageControl(GLenum gl_source, GLenum gl_type, GLenum gl_severity, GLsizei count, const GLuint *ids, GLboolean enabled) { - const char *callerstr = "glDebugMessageControl"; - GET_CURRENT_CONTEXT(ctx); + enum mesa_debug_source source = gl_enum_to_debug_source(gl_source); + enum mesa_debug_type type = gl_enum_to_debug_type(gl_type); + enum mesa_debug_severity severity = gl_enum_to_debug_severity(gl_severity); + const char *callerstr = "glDebugMessageControl"; + struct gl_debug_state *debug; if (count < 0) { _mesa_error(ctx, GL_INVALID_VALUE, @@ -821,8 +1027,18 @@ _mesa_DebugMessageControl(GLenum gl_source, GLenum gl_type, return; } - control_app_messages(ctx, gl_source, gl_type, gl_severity, - count, ids, enabled); + debug = _mesa_get_debug_state(ctx); + if (!debug) + return; + + if (count) { + GLsizei i; + for (i = 0; i < count; i++) + debug_set_message_enable(debug, source, type, ids[i], enabled); + } + else { + debug_set_message_enable_all(debug, source, type, severity, enabled); + } } @@ -845,10 +1061,7 @@ _mesa_PushDebugGroup(GLenum source, GLuint id, GLsizei length, GET_CURRENT_CONTEXT(ctx); struct gl_debug_state *debug = _mesa_get_debug_state(ctx); const char *callerstr = "glPushDebugGroup"; - int s, t, sev; - GLint prevStackDepth; - GLint currStackDepth; - struct gl_debug_msg *emptySlot; + struct gl_debug_message *emptySlot; if (!debug) return; @@ -868,55 +1081,26 @@ _mesa_PushDebugGroup(GLenum source, GLuint id, GLsizei length, return; } - message_insert(source, GL_DEBUG_TYPE_PUSH_GROUP, id, - GL_DEBUG_SEVERITY_NOTIFICATION, length, - message, callerstr); + if (length < 0) + length = strlen(message); + if (!validate_length(ctx, callerstr, length)) + return; /* GL_INVALID_VALUE */ - prevStackDepth = debug->GroupStackDepth; - debug->GroupStackDepth++; - currStackDepth = debug->GroupStackDepth; + log_msg(ctx, gl_enum_to_debug_source(source), + MESA_DEBUG_TYPE_PUSH_GROUP, id, + MESA_DEBUG_SEVERITY_NOTIFICATION, length, + message); /* pop reuses the message details from push so we store this */ - if (length < 0) - length = strlen(message); - emptySlot = &debug->DebugGroupMsgs[debug->GroupStackDepth]; - store_message_details(emptySlot, gl_enum_to_debug_source(source), - gl_enum_to_debug_type(GL_DEBUG_TYPE_PUSH_GROUP), - id, - gl_enum_to_debug_severity(GL_DEBUG_SEVERITY_NOTIFICATION), - length, message); - - /* inherit the control volume of the debug group previously residing on - * the top of the debug group stack - */ - for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++) { - for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++) { - /* copy id settings */ - debug->Namespaces[currStackDepth][s][t].IDs = - _mesa_HashClone(debug->Namespaces[prevStackDepth][s][t].IDs); - - for (sev = 0; sev < MESA_DEBUG_SEVERITY_COUNT; sev++) { - struct gl_debug_severity *entry, *prevEntry; - struct simple_node *node; - - /* copy default settings for unknown ids */ - debug->Defaults[currStackDepth][sev][s][t] = - debug->Defaults[prevStackDepth][sev][s][t]; - - /* copy known id severity settings */ - make_empty_list(&debug->Namespaces[currStackDepth][s][t].Severity[sev]); - foreach(node, &debug->Namespaces[prevStackDepth][s][t].Severity[sev]) { - prevEntry = (struct gl_debug_severity *)node; - entry = malloc(sizeof *entry); - if (!entry) - return; - - entry->ID = prevEntry->ID; - insert_at_tail(&debug->Namespaces[currStackDepth][s][t].Severity[sev], &entry->link); - } - } - } - } + emptySlot = debug_get_group_message(debug); + debug_message_store(emptySlot, + gl_enum_to_debug_source(source), + gl_enum_to_debug_type(GL_DEBUG_TYPE_PUSH_GROUP), + id, + gl_enum_to_debug_severity(GL_DEBUG_SEVERITY_NOTIFICATION), + length, message); + + debug_push_group(debug); } @@ -926,8 +1110,7 @@ _mesa_PopDebugGroup(void) GET_CURRENT_CONTEXT(ctx); struct gl_debug_state *debug = _mesa_get_debug_state(ctx); const char *callerstr = "glPopDebugGroup"; - struct gl_debug_msg *gdmessage; - GLint prevStackDepth; + struct gl_debug_message *gdmessage; if (!debug) return; @@ -937,26 +1120,16 @@ _mesa_PopDebugGroup(void) return; } - prevStackDepth = debug->GroupStackDepth; - debug->GroupStackDepth--; + debug_pop_group(debug); - gdmessage = &debug->DebugGroupMsgs[prevStackDepth]; - /* using log_msg() directly here as verification of parameters - * already done in push - */ + gdmessage = debug_get_group_message(debug); log_msg(ctx, gdmessage->source, gl_enum_to_debug_type(GL_DEBUG_TYPE_POP_GROUP), gdmessage->id, gl_enum_to_debug_severity(GL_DEBUG_SEVERITY_NOTIFICATION), gdmessage->length, gdmessage->message); - if (gdmessage->message != (char*)out_of_memory) - free(gdmessage->message); - gdmessage->message = NULL; - gdmessage->length = 0; - - /* free popped debug group data */ - free_errors_data(ctx, prevStackDepth); + debug_message_clear(gdmessage); } @@ -967,20 +1140,11 @@ _mesa_init_errors(struct gl_context *ctx) } -/** - * Loop through debug group stack tearing down states for - * filtering debug messages. Then free debug output state. - */ void _mesa_free_errors_data(struct gl_context *ctx) { if (ctx->Debug) { - GLint i; - - for (i = 0; i <= ctx->Debug->GroupStackDepth; i++) { - free_errors_data(ctx, i); - } - free(ctx->Debug); + debug_destroy(ctx->Debug); /* set to NULL just in case it is used before context is completely gone. */ ctx->Debug = NULL; } @@ -1198,11 +1362,16 @@ _mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... ) debug_get_id(&error_msg_id); do_output = should_output(ctx, error, fmtString); - do_log = should_log(ctx, - MESA_DEBUG_SOURCE_API, - MESA_DEBUG_TYPE_ERROR, - error_msg_id, - MESA_DEBUG_SEVERITY_HIGH); + if (ctx->Debug) { + do_log = debug_is_message_enabled(ctx->Debug, + MESA_DEBUG_SOURCE_API, + MESA_DEBUG_TYPE_ERROR, + error_msg_id, + MESA_DEBUG_SEVERITY_HIGH); + } + else { + do_log = GL_FALSE; + } if (do_output || do_log) { char s[MAX_DEBUG_MESSAGE_LENGTH], s2[MAX_DEBUG_MESSAGE_LENGTH]; diff --git a/mesalib/src/mesa/main/errors.h b/mesalib/src/mesa/main/errors.h index e0706e5b9..06d0b21fc 100644 --- a/mesalib/src/mesa/main/errors.h +++ b/mesalib/src/mesa/main/errors.h @@ -83,8 +83,14 @@ _mesa_gl_debug(struct gl_context *ctx, } \ } while (0) -struct gl_debug_state * -_mesa_get_debug_state(struct gl_context *ctx); +bool +_mesa_set_debug_state_int(struct gl_context *ctx, GLenum pname, GLint val); + +GLint +_mesa_get_debug_state_int(struct gl_context *ctx, GLenum pname); + +void * +_mesa_get_debug_state_ptr(struct gl_context *ctx, GLenum pname); extern void _mesa_shader_debug(struct gl_context *ctx, GLenum type, GLuint *id, diff --git a/mesalib/src/mesa/main/ff_fragment_shader.cpp b/mesalib/src/mesa/main/ff_fragment_shader.cpp index 66c18fa16..605f3713e 100644 --- a/mesalib/src/mesa/main/ff_fragment_shader.cpp +++ b/mesalib/src/mesa/main/ff_fragment_shader.cpp @@ -42,6 +42,7 @@ extern "C" { #include "program/prog_statevars.h" #include "program/programopt.h" #include "texenvprogram.h" +#include "texobj.h" } #include "main/uniforms.h" #include "../glsl/glsl_types.h" @@ -290,18 +291,6 @@ need_saturate( GLuint mode ) } } - - -/** - * Translate TEXTURE_x_BIT to TEXTURE_x_INDEX. - */ -static GLuint translate_tex_src_bit( GLbitfield bit ) -{ - ASSERT(bit); - return ffs(bit) - 1; -} - - #define VERT_BIT_TEX_ANY (0xff << VERT_ATTRIB_TEX0) /** @@ -430,7 +419,7 @@ static GLuint make_state_key( struct gl_context *ctx, struct state_key *key ) const struct gl_sampler_object *samp; GLenum format; - if (!texUnit->_ReallyEnabled || !texUnit->Enabled) + if (!texUnit->_Current || !texUnit->Enabled) continue; samp = _mesa_get_samplerobj(ctx, i); @@ -441,8 +430,8 @@ static GLuint make_state_key( struct gl_context *ctx, struct state_key *key ) key->nr_enabled_units = i + 1; inputs_referenced |= VARYING_BIT_TEX(i); - key->unit[i].source_index = - translate_tex_src_bit(texUnit->_ReallyEnabled); + key->unit[i].source_index = _mesa_tex_target_to_index(ctx, + texObj->Target); key->unit[i].shadow = ((samp->CompareMode == GL_COMPARE_R_TO_TEXTURE) && diff --git a/mesalib/src/mesa/main/ffvertex_prog.c b/mesalib/src/mesa/main/ffvertex_prog.c index c5583c965..728cf968b 100644 --- a/mesalib/src/mesa/main/ffvertex_prog.c +++ b/mesalib/src/mesa/main/ffvertex_prog.c @@ -233,13 +233,13 @@ static void make_state_key( struct gl_context *ctx, struct state_key *key ) if (ctx->Texture._TexGenEnabled || ctx->Texture._TexMatEnabled || - ctx->Texture._EnabledUnits) + ctx->Texture._MaxEnabledTexImageUnit != -1) key->texture_enabled_global = 1; for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) { struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i]; - if (texUnit->_ReallyEnabled) + if (texUnit->_Current) key->unit[i].texunit_really_enabled = 1; if (ctx->Point.PointSprite) diff --git a/mesalib/src/mesa/main/get.c b/mesalib/src/mesa/main/get.c index 6d9579008..fe35ff3ef 100644 --- a/mesalib/src/mesa/main/get.c +++ b/mesalib/src/mesa/main/get.c @@ -989,24 +989,10 @@ find_custom_value(struct gl_context *ctx, const struct value_desc *d, union valu break; /* GL_KHR_DEBUG */ case GL_DEBUG_LOGGED_MESSAGES: - { - struct gl_debug_state *debug = _mesa_get_debug_state(ctx); - v->value_int = debug ? debug->NumMessages : 0; - } - break; case GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH: - { - struct gl_debug_state *debug = _mesa_get_debug_state(ctx); - v->value_int = debug ? debug->NextMsgLength : 0; - } - break; case GL_DEBUG_GROUP_STACK_DEPTH: - { - struct gl_debug_state *debug = _mesa_get_debug_state(ctx); - v->value_int = debug ? debug->GroupStackDepth : 0; - } + v->value_int = _mesa_get_debug_state_int(ctx, d->pname); break; - /* GL_ARB_shader_atomic_counters */ case GL_ATOMIC_COUNTER_BUFFER_BINDING: v->value_int = ctx->AtomicBuffer->Name; diff --git a/mesalib/src/mesa/main/getstring.c b/mesalib/src/mesa/main/getstring.c index b0bd3190b..431d60b03 100644 --- a/mesalib/src/mesa/main/getstring.c +++ b/mesalib/src/mesa/main/getstring.c @@ -253,22 +253,11 @@ _mesa_GetPointerv( GLenum pname, GLvoid **params ) *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_POINT_SIZE].Ptr; break; case GL_DEBUG_CALLBACK_FUNCTION_ARB: - if (!_mesa_is_desktop_gl(ctx)) { - goto invalid_pname; - } - else { - struct gl_debug_state *debug = _mesa_get_debug_state(ctx); - *params = debug ? (void *) debug->Callback : NULL; - } - break; case GL_DEBUG_CALLBACK_USER_PARAM_ARB: - if (!_mesa_is_desktop_gl(ctx)) { + if (!_mesa_is_desktop_gl(ctx)) goto invalid_pname; - } - else { - struct gl_debug_state *debug = _mesa_get_debug_state(ctx); - *params = debug ? (void *) debug->CallbackData : NULL; - } + else + *params = _mesa_get_debug_state_ptr(ctx, pname); break; default: goto invalid_pname; diff --git a/mesalib/src/mesa/main/mtypes.h b/mesalib/src/mesa/main/mtypes.h index 66943836c..5fbfffe98 100644 --- a/mesalib/src/mesa/main/mtypes.h +++ b/mesalib/src/mesa/main/mtypes.h @@ -76,6 +76,7 @@ struct gl_list_extensions; struct gl_meta_state; struct gl_program_cache; struct gl_texture_object; +struct gl_debug_state; struct gl_context; struct st_context; struct gl_uniform_storage; @@ -1085,7 +1086,6 @@ typedef enum /** * Bit flags for each type of texture object - * Used for Texture.Unit[]._ReallyEnabled flags. */ /*@{*/ #define TEXTURE_2D_MULTISAMPLE_BIT (1 << TEXTURE_2D_MULTISAMPLE_INDEX) @@ -1327,7 +1327,6 @@ struct gl_texgen struct gl_texture_unit { GLbitfield Enabled; /**< bitmask of TEXTURE_*_BIT flags */ - GLbitfield _ReallyEnabled; /**< 0 or exactly one of TEXTURE_*_BIT flags */ GLenum EnvMode; /**< GL_MODULATE, GL_DECAL, GL_BLEND, etc. */ GLclampf EnvColor[4]; @@ -1388,9 +1387,6 @@ struct gl_texture_attrib /** GL_ARB_seamless_cubemap */ GLboolean CubeMapSeamless; - /** Texture units/samplers used by vertex or fragment texturing */ - GLbitfield _EnabledUnits; - /** Texture coord units/sets used for fragment texturing */ GLbitfield _EnabledCoordUnits; @@ -1403,8 +1399,11 @@ struct gl_texture_attrib /** Bitwise-OR of all Texture.Unit[i]._GenFlags */ GLbitfield _GenFlags; - /** Upper bound on _ReallyEnabled texunits. */ + /** Largest index of a texture unit with _Current != NULL. */ GLint _MaxEnabledTexImageUnit; + + /** Largest index + 1 of texture units that have had any CurrentTex set. */ + GLint NumCurrentTexUsed; }; @@ -3821,45 +3820,6 @@ enum mesa_debug_severity { /** @} */ -/** - * An error, warning, or other piece of debug information for an application - * to consume via GL_ARB_debug_output/GL_KHR_debug. - */ -struct gl_debug_msg -{ - enum mesa_debug_source source; - enum mesa_debug_type type; - GLuint id; - enum mesa_debug_severity severity; - GLsizei length; - GLcharARB *message; -}; - -struct gl_debug_namespace -{ - struct _mesa_HashTable *IDs; - unsigned ZeroID; /* a HashTable won't take zero, so store its state here */ - /** lists of IDs in the hash table at each severity */ - struct simple_node Severity[MESA_DEBUG_SEVERITY_COUNT]; -}; - -struct gl_debug_state -{ - GLDEBUGPROC Callback; - const void *CallbackData; - GLboolean SyncOutput; - GLboolean DebugOutput; - GLboolean Defaults[MAX_DEBUG_GROUP_STACK_DEPTH][MESA_DEBUG_SEVERITY_COUNT][MESA_DEBUG_SOURCE_COUNT][MESA_DEBUG_TYPE_COUNT]; - struct gl_debug_namespace Namespaces[MAX_DEBUG_GROUP_STACK_DEPTH][MESA_DEBUG_SOURCE_COUNT][MESA_DEBUG_TYPE_COUNT]; - struct gl_debug_msg Log[MAX_DEBUG_LOGGED_MESSAGES]; - struct gl_debug_msg DebugGroupMsgs[MAX_DEBUG_GROUP_STACK_DEPTH]; - GLint GroupStackDepth; - GLint NumMessages; - GLint NextMsg; - GLint NextMsgLength; /* redundant, but copied here from Log[NextMsg].length - for the sake of the offsetof() code in get.c */ -}; - /** * Enum for the OpenGL APIs we know about and may support. * diff --git a/mesalib/src/mesa/main/texobj.c b/mesalib/src/mesa/main/texobj.c index 918dd59ed..85246c8ab 100644 --- a/mesalib/src/mesa/main/texobj.c +++ b/mesalib/src/mesa/main/texobj.c @@ -1094,7 +1094,7 @@ unbind_texobj_from_texunits(struct gl_context *ctx, { GLuint u, tex; - for (u = 0; u < Elements(ctx->Texture.Unit); u++) { + for (u = 0; u < ctx->Texture.NumCurrentTexUsed; u++) { struct gl_texture_unit *unit = &ctx->Texture.Unit[u]; for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { if (texObj == unit->CurrentTex[tex]) { @@ -1353,6 +1353,8 @@ _mesa_BindTexture( GLenum target, GLuint texName ) * count hits zero. */ _mesa_reference_texobj(&texUnit->CurrentTex[targetIndex], newTexObj); + ctx->Texture.NumCurrentTexUsed = MAX2(ctx->Texture.NumCurrentTexUsed, + ctx->Texture.CurrentUnit + 1); ASSERT(texUnit->CurrentTex[targetIndex]); /* Pass BindTexture call to device driver */ diff --git a/mesalib/src/mesa/main/texparam.c b/mesalib/src/mesa/main/texparam.c index 40790ff0e..dc17ea584 100644 --- a/mesalib/src/mesa/main/texparam.c +++ b/mesalib/src/mesa/main/texparam.c @@ -485,7 +485,7 @@ set_tex_parameteri(struct gl_context *ctx, const GLuint comp = pname - GL_TEXTURE_SWIZZLE_R_EXT; const GLint swz = comp_to_swizzle(params[0]); if (swz < 0) { - _mesa_error(ctx, GL_INVALID_OPERATION, + _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(swizzle 0x%x)", params[0]); return GL_FALSE; } @@ -510,7 +510,7 @@ set_tex_parameteri(struct gl_context *ctx, set_swizzle_component(&texObj->_Swizzle, comp, swz); } else { - _mesa_error(ctx, GL_INVALID_OPERATION, + _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(swizzle 0x%x)", params[comp]); return GL_FALSE; } diff --git a/mesalib/src/mesa/main/texstate.c b/mesalib/src/mesa/main/texstate.c index b68920ce1..91b290691 100644 --- a/mesalib/src/mesa/main/texstate.c +++ b/mesalib/src/mesa/main/texstate.c @@ -40,7 +40,7 @@ #include "teximage.h" #include "texstate.h" #include "mtypes.h" - +#include "bitset.h" /** @@ -108,6 +108,10 @@ _mesa_copy_texture_state( const struct gl_context *src, struct gl_context *dst ) for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { _mesa_reference_texobj(&dst->Texture.Unit[u].CurrentTex[tex], src->Texture.Unit[u].CurrentTex[tex]); + if (src->Texture.Unit[u].CurrentTex[tex]) { + dst->Texture.NumCurrentTexUsed = + MAX2(dst->Texture.NumCurrentTexUsed, u + 1); + } } _mesa_unlock_context_textures(dst); } @@ -371,7 +375,7 @@ update_texture_matrices( struct gl_context *ctx ) if (_math_matrix_is_dirty(ctx->TextureMatrixStack[u].Top)) { _math_matrix_analyse( ctx->TextureMatrixStack[u].Top ); - if (ctx->Texture.Unit[u]._ReallyEnabled && + if (ctx->Texture.Unit[u]._Current && ctx->TextureMatrixStack[u].Top->type != MATRIX_IDENTITY) ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(u); } @@ -515,83 +519,151 @@ update_texgen(struct gl_context *ctx) } } -/** - * \note This routine refers to derived texture matrix values to - * compute the ENABLE_TEXMAT flags, but is only called on - * _NEW_TEXTURE. On changes to _NEW_TEXTURE_MATRIX, the ENABLE_TEXMAT - * flags are updated by _mesa_update_texture_matrices, above. - * - * \param ctx GL context. - */ +static struct gl_texture_object * +update_single_program_texture(struct gl_context *ctx, struct gl_program *prog, + int s) +{ + gl_texture_index target_index; + struct gl_texture_unit *texUnit; + struct gl_texture_object *texObj; + struct gl_sampler_object *sampler; + int unit; + + if (!(prog->SamplersUsed & (1 << s))) + return NULL; + + unit = prog->SamplerUnits[s]; + texUnit = &ctx->Texture.Unit[unit]; + + /* Note: If more than one bit was set in TexturesUsed[unit], then we should + * have had the draw call rejected already. From the GL 4.4 specification, + * section 7.10 ("Samplers"): + * + * "It is not allowed to have variables of different sampler types + * pointing to the same texture image unit within a program + * object. This situation can only be detected at the next rendering + * command issued which triggers shader invocations, and an + * INVALID_OPERATION error will then be generated." + */ + target_index = ffs(prog->TexturesUsed[unit]) - 1; + texObj = texUnit->CurrentTex[target_index]; + + sampler = texUnit->Sampler ? + texUnit->Sampler : &texObj->Sampler; + + if (likely(texObj)) { + if (_mesa_is_texture_complete(texObj, sampler)) + return texObj; + + _mesa_test_texobj_completeness(ctx, texObj); + if (_mesa_is_texture_complete(texObj, sampler)) + return texObj; + } + + /* If we've reached this point, we didn't find a complete texture of the + * shader's target. From the GL 4.4 core specification, section 11.1.3.5 + * ("Texture Access"): + * + * "If a sampler is used in a shader and the sampler’s associated + * texture is not complete, as defined in section 8.17, (0, 0, 0, 1) + * will be returned for a non-shadow sampler and 0 for a shadow + * sampler." + * + * Mesa implements this by creating a hidden texture object with a pixel of + * that value. + */ + texObj = _mesa_get_fallback_texture(ctx, target_index); + assert(texObj); + + return texObj; +} + static void -update_texture_state( struct gl_context *ctx ) +update_program_texture_state(struct gl_context *ctx, struct gl_program **prog, + BITSET_WORD *enabled_texture_units) { - GLuint unit; - struct gl_program *prog[MESA_SHADER_STAGES]; - GLbitfield enabledFragUnits = 0x0; int i; for (i = 0; i < MESA_SHADER_STAGES; i++) { - if (ctx->_Shader->CurrentProgram[i] && - ctx->_Shader->CurrentProgram[i]->LinkStatus) { - prog[i] = ctx->_Shader->CurrentProgram[i]->_LinkedShaders[i]->Program; - } else { - if (i == MESA_SHADER_FRAGMENT && ctx->FragmentProgram._Enabled) - prog[i] = &ctx->FragmentProgram.Current->Base; - else - prog[i] = NULL; + int s; + + if (!prog[i]) + continue; + + /* We can't only do the shifting trick as the loop condition because if + * sampler 31 is active, the next iteration tries to shift by 32, which is + * undefined. + */ + for (s = 0; s < MAX_SAMPLERS && (1 << s) <= prog[i]->SamplersUsed; s++) { + struct gl_texture_object *texObj; + + texObj = update_single_program_texture(ctx, prog[i], s); + if (texObj) { + int unit = prog[i]->SamplerUnits[s]; + _mesa_reference_texobj(&ctx->Texture.Unit[unit]._Current, texObj); + BITSET_SET(enabled_texture_units, unit); + ctx->Texture._MaxEnabledTexImageUnit = + MAX2(ctx->Texture._MaxEnabledTexImageUnit, (int)unit); + } } } - /* TODO: only set this if there are actual changes */ - ctx->NewState |= _NEW_TEXTURE; + if (prog[MESA_SHADER_FRAGMENT]) { + const GLuint coordMask = (1 << MAX_TEXTURE_COORD_UNITS) - 1; + ctx->Texture._EnabledCoordUnits |= + (prog[MESA_SHADER_FRAGMENT]->InputsRead >> VARYING_SLOT_TEX0) & + coordMask; + } +} - ctx->Texture._EnabledUnits = 0x0; - ctx->Texture._GenFlags = 0x0; - ctx->Texture._TexMatEnabled = 0x0; - ctx->Texture._TexGenEnabled = 0x0; - ctx->Texture._MaxEnabledTexImageUnit = -1; +static void +update_ff_texture_state(struct gl_context *ctx, + BITSET_WORD *enabled_texture_units) +{ + int unit; - /* - * Update texture unit state. - */ - for (unit = 0; unit < ctx->Const.MaxCombinedTextureImageUnits; unit++) { + for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; - GLbitfield enabledTargetsByStage[MESA_SHADER_STAGES]; - GLbitfield enabledTargets = 0x0; GLuint texIndex; - /* Get the bitmask of texture target enables. - * enableBits will be a mask of the TEXTURE_*_BIT flags indicating - * which texture targets are enabled (fixed function) or referenced - * by a fragment program/program. When multiple flags are set, we'll - * settle on the one with highest priority (see below). - */ - for (i = 0; i < MESA_SHADER_STAGES; i++) { - if (prog[i]) - enabledTargetsByStage[i] = prog[i]->TexturesUsed[unit]; - else if (i == MESA_SHADER_FRAGMENT) - enabledTargetsByStage[i] = texUnit->Enabled; - else - enabledTargetsByStage[i] = 0; - enabledTargets |= enabledTargetsByStage[i]; - } - - texUnit->_ReallyEnabled = 0x0; + if (texUnit->Enabled == 0x0) + continue; - if (enabledTargets == 0x0) { - /* neither vertex nor fragment processing uses this unit */ + /* If a shader already dictated what texture target was used for this + * unit, just go along with it. + */ + if (BITSET_TEST(enabled_texture_units, unit)) continue; - } - /* Look for the highest priority texture target that's enabled (or used - * by the vert/frag shaders) and "complete". That's the one we'll use - * for texturing. + /* From the GL 4.4 compat specification, section 16.2 ("Texture Application"): + * + * "Texturing is enabled or disabled using the generic Enable and + * Disable commands, respectively, with the symbolic constants + * TEXTURE_1D, TEXTURE_2D, TEXTURE_RECTANGLE, TEXTURE_3D, or + * TEXTURE_CUBE_MAP to enable the one-, two-, rectangular, + * three-dimensional, or cube map texture, respectively. If more + * than one of these textures is enabled, the first one enabled + * from the following list is used: + * + * • cube map texture + * • three-dimensional texture + * • rectangular texture + * • two-dimensional texture + * • one-dimensional texture" * * Note that the TEXTURE_x_INDEX values are in high to low priority. + * Also: + * + * "If a texture unit is disabled or has an invalid or incomplete + * texture (as defined in section 8.17) bound to it, then blending + * is disabled for that texture unit. If the texture environment + * for a given enabled texture unit references a disabled texture + * unit, or an invalid or incomplete texture that is bound to + * another unit, then the results of texture blending are + * undefined." */ for (texIndex = 0; texIndex < NUM_TEXTURE_TARGETS; texIndex++) { - if (enabledTargets & (1 << texIndex)) { + if (texUnit->Enabled & (1 << texIndex)) { struct gl_texture_object *texObj = texUnit->CurrentTex[texIndex]; struct gl_sampler_object *sampler = texUnit->Sampler ? texUnit->Sampler : &texObj->Sampler; @@ -600,62 +672,84 @@ update_texture_state( struct gl_context *ctx ) _mesa_test_texobj_completeness(ctx, texObj); } if (_mesa_is_texture_complete(texObj, sampler)) { - texUnit->_ReallyEnabled = 1 << texIndex; _mesa_reference_texobj(&texUnit->_Current, texObj); break; } } } - if (!texUnit->_ReallyEnabled) { - if (prog[MESA_SHADER_FRAGMENT]) { - /* If we get here it means the shader is expecting a texture - * object, but there isn't one (or it's incomplete). Use the - * fallback texture. - */ - struct gl_texture_object *texObj; - gl_texture_index texTarget; - - texTarget = (gl_texture_index) (ffs(enabledTargets) - 1); - texObj = _mesa_get_fallback_texture(ctx, texTarget); - - assert(texObj); - if (!texObj) { - /* invalid fallback texture: don't enable the texture unit */ - continue; - } - - _mesa_reference_texobj(&texUnit->_Current, texObj); - texUnit->_ReallyEnabled = 1 << texTarget; - } - else { - /* fixed-function: texture unit is really disabled */ - continue; - } - } + if (texIndex == NUM_TEXTURE_TARGETS) + continue; /* if we get here, we know this texture unit is enabled */ + BITSET_SET(enabled_texture_units, unit); + ctx->Texture._MaxEnabledTexImageUnit = + MAX2(ctx->Texture._MaxEnabledTexImageUnit, (int)unit); - ctx->Texture._EnabledUnits |= (1 << unit); - ctx->Texture._MaxEnabledTexImageUnit = unit; + ctx->Texture._EnabledCoordUnits |= 1 << unit; - if (enabledTargetsByStage[MESA_SHADER_FRAGMENT]) - enabledFragUnits |= (1 << unit); + update_tex_combine(ctx, texUnit); + } +} + +/** + * \note This routine refers to derived texture matrix values to + * compute the ENABLE_TEXMAT flags, but is only called on + * _NEW_TEXTURE. On changes to _NEW_TEXTURE_MATRIX, the ENABLE_TEXMAT + * flags are updated by _mesa_update_texture_matrices, above. + * + * \param ctx GL context. + */ +static void +update_texture_state( struct gl_context *ctx ) +{ + struct gl_program *prog[MESA_SHADER_STAGES]; + int i; + int old_max_unit = ctx->Texture._MaxEnabledTexImageUnit; + BITSET_DECLARE(enabled_texture_units, MAX_COMBINED_TEXTURE_IMAGE_UNITS); - if (!prog[MESA_SHADER_FRAGMENT]) - update_tex_combine(ctx, texUnit); + for (i = 0; i < MESA_SHADER_STAGES; i++) { + if (ctx->_Shader->CurrentProgram[i] && + ctx->_Shader->CurrentProgram[i]->LinkStatus) { + prog[i] = ctx->_Shader->CurrentProgram[i]->_LinkedShaders[i]->Program; + } else { + if (i == MESA_SHADER_FRAGMENT && ctx->FragmentProgram._Enabled) + prog[i] = &ctx->FragmentProgram.Current->Base; + else + prog[i] = NULL; + } } + /* TODO: only set this if there are actual changes */ + ctx->NewState |= _NEW_TEXTURE; - /* Determine which texture coordinate sets are actually needed */ - if (prog[MESA_SHADER_FRAGMENT]) { - const GLuint coordMask = (1 << MAX_TEXTURE_COORD_UNITS) - 1; - ctx->Texture._EnabledCoordUnits - = (prog[MESA_SHADER_FRAGMENT]->InputsRead >> VARYING_SLOT_TEX0) & - coordMask; + ctx->Texture._GenFlags = 0x0; + ctx->Texture._TexMatEnabled = 0x0; + ctx->Texture._TexGenEnabled = 0x0; + ctx->Texture._MaxEnabledTexImageUnit = -1; + ctx->Texture._EnabledCoordUnits = 0x0; + + memset(&enabled_texture_units, 0, sizeof(enabled_texture_units)); + + /* First, walk over our programs pulling in all the textures for them. + * Programs dictate specific texture targets to be enabled, and for a draw + * call to be valid they can't conflict about which texture targets are + * used. + */ + update_program_texture_state(ctx, prog, enabled_texture_units); + + /* Also pull in any textures necessary for fixed function fragment shading. + */ + if (!prog[MESA_SHADER_FRAGMENT]) + update_ff_texture_state(ctx, enabled_texture_units); + + /* Now, clear out the _Current of any disabled texture units. */ + for (i = 0; i <= ctx->Texture._MaxEnabledTexImageUnit; i++) { + if (!BITSET_TEST(enabled_texture_units, i)) + _mesa_reference_texobj(&ctx->Texture.Unit[i]._Current, NULL); } - else { - ctx->Texture._EnabledCoordUnits = enabledFragUnits; + for (i = ctx->Texture._MaxEnabledTexImageUnit + 1; i <= old_max_unit; i++) { + _mesa_reference_texobj(&ctx->Texture.Unit[i]._Current, NULL); } if (!prog[MESA_SHADER_FRAGMENT] || !prog[MESA_SHADER_VERTEX]) @@ -796,7 +890,6 @@ _mesa_init_texture(struct gl_context *ctx) /* Texture group */ ctx->Texture.CurrentUnit = 0; /* multitexture */ - ctx->Texture._EnabledUnits = 0x0; /* Appendix F.2 of the OpenGL ES 3.0 spec says: * @@ -824,6 +917,8 @@ _mesa_init_texture(struct gl_context *ctx) _mesa_reference_buffer_object(ctx, &ctx->Texture.BufferObject, ctx->Shared->NullBufferObj); + ctx->Texture.NumCurrentTexUsed = 0; + return GL_TRUE; } diff --git a/mesalib/src/mesa/state_tracker/st_atom.c b/mesalib/src/mesa/state_tracker/st_atom.c index 99e9df26b..625ea2965 100644 --- a/mesalib/src/mesa/state_tracker/st_atom.c +++ b/mesalib/src/mesa/state_tracker/st_atom.c @@ -61,6 +61,7 @@ static const struct st_tracked_state *atoms[] = &st_update_sampler, /* depends on update_*_texture for swizzle */ &st_update_framebuffer, &st_update_msaa, + &st_update_sample_shading, &st_update_vs_constants, &st_update_gs_constants, &st_update_fs_constants, diff --git a/mesalib/src/mesa/state_tracker/st_atom.h b/mesalib/src/mesa/state_tracker/st_atom.h index 60d89d75f..c50111d50 100644 --- a/mesalib/src/mesa/state_tracker/st_atom.h +++ b/mesalib/src/mesa/state_tracker/st_atom.h @@ -59,6 +59,7 @@ extern const struct st_tracked_state st_update_viewport; extern const struct st_tracked_state st_update_scissor; extern const struct st_tracked_state st_update_blend; extern const struct st_tracked_state st_update_msaa; +extern const struct st_tracked_state st_update_sample_shading; extern const struct st_tracked_state st_update_sampler; extern const struct st_tracked_state st_update_fragment_texture; extern const struct st_tracked_state st_update_vertex_texture; diff --git a/mesalib/src/mesa/state_tracker/st_atom_framebuffer.c b/mesalib/src/mesa/state_tracker/st_atom_framebuffer.c index a17417c35..b195c55b3 100644 --- a/mesalib/src/mesa/state_tracker/st_atom_framebuffer.c +++ b/mesalib/src/mesa/state_tracker/st_atom_framebuffer.c @@ -113,6 +113,12 @@ update_framebuffer_state( struct st_context *st ) pipe_surface_reference(&framebuffer->cbufs[i], NULL); } + /* Remove trailing GL_NONE draw buffers. */ + while (framebuffer->nr_cbufs && + !framebuffer->cbufs[framebuffer->nr_cbufs-1]) { + framebuffer->nr_cbufs--; + } + /* * Depth/Stencil renderbuffer/surface. */ @@ -147,11 +153,10 @@ update_framebuffer_state( struct st_context *st ) } #endif - /* _mesa_test_framebuffer_completeness refuses framebuffers with no - * attachments, so this should never happen. - */ - assert(framebuffer->width != UINT_MAX); - assert(framebuffer->height != UINT_MAX); + if (framebuffer->width == UINT_MAX) + framebuffer->width = 0; + if (framebuffer->height == UINT_MAX) + framebuffer->height = 0; cso_set_framebuffer(st->cso_context, framebuffer); } diff --git a/mesalib/src/mesa/state_tracker/st_atom_msaa.c b/mesalib/src/mesa/state_tracker/st_atom_msaa.c index 2f3a42e02..703cb5e75 100644 --- a/mesalib/src/mesa/state_tracker/st_atom_msaa.c +++ b/mesalib/src/mesa/state_tracker/st_atom_msaa.c @@ -27,8 +27,10 @@ #include "st_context.h" +#include "pipe/p_screen.h" #include "pipe/p_context.h" #include "st_atom.h" +#include "st_program.h" #include "cso_cache/cso_context.h" #include "util/u_framebuffer.h" @@ -70,6 +72,18 @@ static void update_sample_mask( struct st_context *st ) } } +static void update_sample_shading( struct st_context *st ) +{ + if (!st->fp) + return; + + if (!st->ctx->Extensions.ARB_sample_shading) + return; + + cso_set_min_samples( + st->cso_context, + _mesa_get_min_invocations_per_fragment(st->ctx, &st->fp->Base, false)); +} const struct st_tracked_state st_update_msaa = { "st_update_msaa", /* name */ @@ -79,3 +93,12 @@ const struct st_tracked_state st_update_msaa = { }, update_sample_mask /* update */ }; + +const struct st_tracked_state st_update_sample_shading = { + "st_update_sample_shading", /* name */ + { /* dirty */ + (_NEW_MULTISAMPLE | _NEW_PROGRAM | _NEW_BUFFERS), /* mesa */ + ST_NEW_FRAGMENT_PROGRAM | ST_NEW_FRAMEBUFFER, /* st */ + }, + update_sample_shading /* update */ +}; diff --git a/mesalib/src/mesa/state_tracker/st_atom_pixeltransfer.c b/mesalib/src/mesa/state_tracker/st_atom_pixeltransfer.c index 306eeb153..a04163cc1 100644 --- a/mesalib/src/mesa/state_tracker/st_atom_pixeltransfer.c +++ b/mesalib/src/mesa/state_tracker/st_atom_pixeltransfer.c @@ -121,7 +121,7 @@ load_color_map_texture(struct gl_context *ctx, struct pipe_resource *pt) rgba[2] = ctx->PixelMaps.BtoB.Map[j * bSize / texSize]; rgba[3] = ctx->PixelMaps.AtoA.Map[i * aSize / texSize]; util_pack_color(rgba, pt->format, &uc); - *(dest + k) = uc.ui; + *(dest + k) = uc.ui[0]; } } diff --git a/mesalib/src/mesa/state_tracker/st_cb_clear.c b/mesalib/src/mesa/state_tracker/st_cb_clear.c index fcd7e1382..371f7fcda 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_clear.c +++ b/mesalib/src/mesa/state_tracker/st_cb_clear.c @@ -240,6 +240,7 @@ clear_with_quad(struct gl_context *ctx, unsigned clear_buffers) cso_save_depth_stencil_alpha(st->cso_context); cso_save_rasterizer(st->cso_context); cso_save_sample_mask(st->cso_context); + cso_save_min_samples(st->cso_context); cso_save_viewport(st->cso_context); cso_save_fragment_shader(st->cso_context); cso_save_stream_outputs(st->cso_context); @@ -309,6 +310,7 @@ clear_with_quad(struct gl_context *ctx, unsigned clear_buffers) cso_set_vertex_elements(st->cso_context, 2, st->velems_util_draw); cso_set_stream_outputs(st->cso_context, 0, NULL, NULL); cso_set_sample_mask(st->cso_context, ~0); + cso_set_min_samples(st->cso_context, 1); cso_set_rasterizer(st->cso_context, &st->clear.raster); /* viewport state: viewport matching window dims */ @@ -348,6 +350,7 @@ clear_with_quad(struct gl_context *ctx, unsigned clear_buffers) cso_restore_depth_stencil_alpha(st->cso_context); cso_restore_rasterizer(st->cso_context); cso_restore_sample_mask(st->cso_context); + cso_restore_min_samples(st->cso_context); cso_restore_viewport(st->cso_context); cso_restore_fragment_shader(st->cso_context); cso_restore_vertex_shader(st->cso_context); diff --git a/mesalib/src/mesa/state_tracker/st_cb_drawtex.c b/mesalib/src/mesa/state_tracker/st_cb_drawtex.c index b0a44fd90..f997e6b00 100644 --- a/mesalib/src/mesa/state_tracker/st_cb_drawtex.c +++ b/mesalib/src/mesa/state_tracker/st_cb_drawtex.c @@ -123,7 +123,8 @@ st_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z, /* determine how many enabled sets of texcoords */ numTexCoords = 0; for (i = 0; i < ctx->Const.MaxTextureUnits; i++) { - if (ctx->Texture.Unit[i]._ReallyEnabled & TEXTURE_2D_BIT) { + if (ctx->Texture.Unit[i]._Current && + ctx->Texture.Unit[i]._Current->Target == GL_TEXTURE_2D) { numTexCoords++; } } @@ -192,7 +193,8 @@ st_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z, /* texcoords */ for (i = 0; i < ctx->Const.MaxTextureUnits; i++) { - if (ctx->Texture.Unit[i]._ReallyEnabled & TEXTURE_2D_BIT) { + if (ctx->Texture.Unit[i]._Current && + ctx->Texture.Unit[i]._Current->Target == GL_TEXTURE_2D) { struct gl_texture_object *obj = ctx->Texture.Unit[i]._Current; struct gl_texture_image *img = obj->Image[0][obj->BaseLevel]; const GLfloat wt = (GLfloat) img->Width; diff --git a/mesalib/src/mesa/state_tracker/st_extensions.c b/mesalib/src/mesa/state_tracker/st_extensions.c index 70726886e..a245fdf18 100644 --- a/mesalib/src/mesa/state_tracker/st_extensions.c +++ b/mesalib/src/mesa/state_tracker/st_extensions.c @@ -425,7 +425,8 @@ void st_init_extensions(struct st_context *st) { o(OES_standard_derivatives), PIPE_CAP_SM3 }, { o(ARB_texture_cube_map_array), PIPE_CAP_CUBE_MAP_ARRAY }, { o(ARB_texture_multisample), PIPE_CAP_TEXTURE_MULTISAMPLE }, - { o(ARB_texture_query_lod), PIPE_CAP_TEXTURE_QUERY_LOD } + { o(ARB_texture_query_lod), PIPE_CAP_TEXTURE_QUERY_LOD }, + { o(ARB_sample_shading), PIPE_CAP_SAMPLE_SHADING }, }; /* Required: render target and sampler support */ 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 15b5279b8..d1c3856b5 100644 --- a/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp +++ b/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp @@ -241,7 +241,7 @@ public: unsigned op; st_dst_reg dst; - st_src_reg src[3]; + st_src_reg src[4]; /** Pointer to the ir source this tree came from for debugging */ ir_instruction *ir; GLboolean cond_update; @@ -411,7 +411,12 @@ public: glsl_to_tgsi_instruction *emit(ir_instruction *ir, unsigned op, st_dst_reg dst, st_src_reg src0, st_src_reg src1, st_src_reg src2); - + + glsl_to_tgsi_instruction *emit(ir_instruction *ir, unsigned op, + st_dst_reg dst, + st_src_reg src0, st_src_reg src1, + st_src_reg src2, st_src_reg src3); + unsigned get_opcode(ir_instruction *ir, unsigned op, st_dst_reg dst, st_src_reg src0, st_src_reg src1); @@ -524,8 +529,9 @@ num_inst_src_regs(unsigned opcode) glsl_to_tgsi_instruction * glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op, - st_dst_reg dst, - st_src_reg src0, st_src_reg src1, st_src_reg src2) + st_dst_reg dst, + st_src_reg src0, st_src_reg src1, + st_src_reg src2, st_src_reg src3) { glsl_to_tgsi_instruction *inst = new(mem_ctx) glsl_to_tgsi_instruction(); int num_reladdr = 0, i; @@ -540,7 +546,9 @@ glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op, num_reladdr += src0.reladdr != NULL || src0.reladdr2 != NULL; num_reladdr += src1.reladdr != NULL || src1.reladdr2 != NULL; num_reladdr += src2.reladdr != NULL || src2.reladdr2 != NULL; + num_reladdr += src3.reladdr != NULL || src3.reladdr2 != NULL; + reladdr_to_temp(ir, &src3, &num_reladdr); reladdr_to_temp(ir, &src2, &num_reladdr); reladdr_to_temp(ir, &src1, &num_reladdr); reladdr_to_temp(ir, &src0, &num_reladdr); @@ -556,6 +564,7 @@ glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op, inst->src[0] = src0; inst->src[1] = src1; inst->src[2] = src2; + inst->src[3] = src3; inst->ir = ir; inst->dead_mask = 0; @@ -577,7 +586,7 @@ glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op, } } else { - for (i=0; i<3; i++) { + for (i=0; i<4; i++) { if(inst->src[i].reladdr) { switch(inst->src[i].file) { case PROGRAM_STATE_VAR: @@ -600,12 +609,19 @@ glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op, return inst; } +glsl_to_tgsi_instruction * +glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op, + st_dst_reg dst, st_src_reg src0, + st_src_reg src1, st_src_reg src2) +{ + return emit(ir, op, dst, src0, src1, src2, undef_src); +} glsl_to_tgsi_instruction * glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op, st_dst_reg dst, st_src_reg src0, st_src_reg src1) { - return emit(ir, op, dst, src0, src1, undef_src); + return emit(ir, op, dst, src0, src1, undef_src, undef_src); } glsl_to_tgsi_instruction * @@ -613,13 +629,13 @@ glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op, st_dst_reg dst, st_src_reg src0) { assert(dst.writemask != 0); - return emit(ir, op, dst, src0, undef_src, undef_src); + return emit(ir, op, dst, src0, undef_src, undef_src, undef_src); } glsl_to_tgsi_instruction * glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op) { - return emit(ir, op, undef_dst, undef_src, undef_src, undef_src); + return emit(ir, op, undef_dst, undef_src, undef_src, undef_src, undef_src); } /** @@ -690,7 +706,10 @@ glsl_to_tgsi_visitor::get_opcode(ir_instruction *ir, unsigned op, case2fi(SSG, ISSG); case3(ABS, IABS, IABS); - + + case2iu(IBFE, UBFE); + case2iu(IMSB, UMSB); + case2iu(IMUL_HI, UMUL_HI); default: break; } @@ -1934,6 +1953,33 @@ glsl_to_tgsi_visitor::visit(ir_expression *ir) emit(ir, TGSI_OPCODE_CMP, result_dst, op[0], op[1], op[2]); } break; + case ir_triop_bitfield_extract: + emit(ir, TGSI_OPCODE_IBFE, result_dst, op[0], op[1], op[2]); + break; + case ir_quadop_bitfield_insert: + emit(ir, TGSI_OPCODE_BFI, result_dst, op[0], op[1], op[2], op[3]); + break; + case ir_unop_bitfield_reverse: + emit(ir, TGSI_OPCODE_BREV, result_dst, op[0]); + break; + case ir_unop_bit_count: + emit(ir, TGSI_OPCODE_POPC, result_dst, op[0]); + break; + case ir_unop_find_msb: + emit(ir, TGSI_OPCODE_IMSB, result_dst, op[0]); + break; + case ir_unop_find_lsb: + emit(ir, TGSI_OPCODE_LSB, result_dst, op[0]); + break; + case ir_binop_imul_high: + emit(ir, TGSI_OPCODE_IMUL_HI, result_dst, op[0], op[1]); + break; + case ir_triop_fma: + /* NOTE: Perhaps there should be a special opcode that enforces fused + * mul-add. Just use MAD for now. + */ + emit(ir, TGSI_OPCODE_MAD, result_dst, op[0], op[1], op[2]); + break; case ir_unop_pack_snorm_2x16: case ir_unop_pack_unorm_2x16: case ir_unop_pack_half_2x16: @@ -1947,22 +1993,14 @@ glsl_to_tgsi_visitor::visit(ir_expression *ir) case ir_unop_unpack_snorm_4x8: case ir_unop_unpack_unorm_4x8: case ir_binop_pack_half_2x16_split: - case ir_unop_bitfield_reverse: - case ir_unop_bit_count: - case ir_unop_find_msb: - case ir_unop_find_lsb: case ir_binop_bfm: - case ir_triop_fma: case ir_triop_bfi: - case ir_triop_bitfield_extract: - case ir_quadop_bitfield_insert: case ir_quadop_vector: case ir_binop_vector_extract: case ir_triop_vector_insert: case ir_binop_ldexp: case ir_binop_carry: case ir_binop_borrow: - case ir_binop_imul_high: /* This operation is not supported, or should have already been handled. */ assert(!"Invalid ir opcode in glsl_to_tgsi_visitor::visit()"); @@ -4163,7 +4201,11 @@ struct st_translate { static unsigned mesa_sysval_to_semantic[SYSTEM_VALUE_MAX] = { TGSI_SEMANTIC_FACE, TGSI_SEMANTIC_VERTEXID, - TGSI_SEMANTIC_INSTANCEID + TGSI_SEMANTIC_INSTANCEID, + TGSI_SEMANTIC_SAMPLEID, + TGSI_SEMANTIC_SAMPLEPOS, + TGSI_SEMANTIC_SAMPLEMASK, + TGSI_SEMANTIC_INVOCATIONID, }; /** @@ -4381,7 +4423,8 @@ translate_dst(struct st_translate *t, break; case TGSI_PROCESSOR_FRAGMENT: - if (dst_reg->index >= FRAG_RESULT_COLOR) { + if (dst_reg->index == FRAG_RESULT_COLOR || + dst_reg->index >= FRAG_RESULT_DATA0) { dst = ureg_saturate(dst); } break; @@ -4876,6 +4919,15 @@ st_translate_program( TGSI_SEMANTIC_COLOR, outputSemanticIndex[i]); break; + case TGSI_SEMANTIC_SAMPLEMASK: + t->outputs[i] = ureg_DECL_output(ureg, + TGSI_SEMANTIC_SAMPLEMASK, + outputSemanticIndex[i]); + /* TODO: If we ever support more than 32 samples, this will have + * to become an array. + */ + t->outputs[i] = ureg_writemask(t->outputs[i], TGSI_WRITEMASK_X); + break; default: assert(!"fragment shader outputs must be POSITION/STENCIL/COLOR"); ret = PIPE_ERROR_BAD_INPUT; @@ -5343,6 +5395,7 @@ st_link_shader(struct gl_context *ctx, struct gl_shader_program *prog) DIV_TO_MUL_RCP | EXP_TO_EXP2 | LOG_TO_LOG2 | + LDEXP_TO_ARITH | (options->EmitNoPow ? POW_TO_EXP2 : 0) | (!ctx->Const.NativeIntegers ? INT_DIV_TO_MUL_RCP : 0)); diff --git a/mesalib/src/mesa/state_tracker/st_manager.c b/mesalib/src/mesa/state_tracker/st_manager.c index 314d34232..706af7fd1 100644 --- a/mesalib/src/mesa/state_tracker/st_manager.c +++ b/mesalib/src/mesa/state_tracker/st_manager.c @@ -183,8 +183,13 @@ st_framebuffer_validate(struct st_framebuffer *stfb, uint width, height; unsigned i; boolean changed = FALSE; - int32_t new_stamp = p_atomic_read(&stfb->iface->stamp); + int32_t new_stamp; + /* Check for incomplete framebuffers (e.g. EGL_KHR_surfaceless_context) */ + if (!stfb->iface) + return; + + new_stamp = p_atomic_read(&stfb->iface->stamp); if (stfb->iface_stamp == new_stamp) return; @@ -663,13 +668,11 @@ st_api_create_context(struct st_api *stapi, struct st_manager *smapi, } if (attribs->flags & ST_CONTEXT_FLAG_DEBUG){ - struct gl_debug_state *debug = _mesa_get_debug_state(st->ctx); - if (!debug) { + if (!_mesa_set_debug_state_int(st->ctx, GL_DEBUG_OUTPUT, GL_TRUE)) { *error = ST_CONTEXT_ERROR_NO_MEMORY; return NULL; } st->ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_DEBUG_BIT; - debug->DebugOutput = GL_TRUE; } if (attribs->flags & ST_CONTEXT_FLAG_FORWARD_COMPATIBLE) diff --git a/mesalib/src/mesa/state_tracker/st_program.c b/mesalib/src/mesa/state_tracker/st_program.c index 2f0ec32f5..f9887a2c4 100644 --- a/mesalib/src/mesa/state_tracker/st_program.c +++ b/mesalib/src/mesa/state_tracker/st_program.c @@ -682,6 +682,7 @@ st_translate_fragment_program(struct st_context *st, /* handle remaining outputs (color) */ for (attr = 0; attr < FRAG_RESULT_MAX; attr++) { if (outputsWritten & BITFIELD64_BIT(attr)) { + int semantic = TGSI_SEMANTIC_COLOR; switch (attr) { case FRAG_RESULT_DEPTH: case FRAG_RESULT_STENCIL: @@ -689,17 +690,21 @@ st_translate_fragment_program(struct st_context *st, assert(0); break; case FRAG_RESULT_COLOR: - write_all = GL_TRUE; /* fallthrough */ - default: - assert(attr == FRAG_RESULT_COLOR || - (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX)); - fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR; - fs_output_semantic_index[fs_num_outputs] = numColors; - outputMapping[attr] = fs_num_outputs; - numColors++; + write_all = GL_TRUE; + break; + case FRAG_RESULT_SAMPLE_MASK: + semantic = TGSI_SEMANTIC_SAMPLEMASK; break; } + assert(attr == FRAG_RESULT_COLOR || + attr == FRAG_RESULT_SAMPLE_MASK || + (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX)); + fs_output_semantic_name[fs_num_outputs] = semantic; + fs_output_semantic_index[fs_num_outputs] = numColors; + outputMapping[attr] = fs_num_outputs; + numColors++; + fs_num_outputs++; } } diff --git a/mesalib/src/mesa/swrast/s_context.c b/mesalib/src/mesa/swrast/s_context.c index 07485006c..ad11aa2c1 100644 --- a/mesalib/src/mesa/swrast/s_context.c +++ b/mesalib/src/mesa/swrast/s_context.c @@ -73,7 +73,7 @@ _swrast_update_rasterflags( struct gl_context *ctx ) } } if (ctx->Color.ColorLogicOpEnabled) rasterMask |= LOGIC_OP_BIT; - if (ctx->Texture._EnabledUnits) rasterMask |= TEXTURE_BIT; + if (ctx->Texture._MaxEnabledTexImageUnit >= 0) rasterMask |= TEXTURE_BIT; if ( ctx->ViewportArray[0].X < 0 || ctx->ViewportArray[0].X + ctx->ViewportArray[0].Width > (GLfloat) ctx->DrawBuffer->Width || ctx->ViewportArray[0].Y < 0 @@ -286,7 +286,7 @@ _swrast_update_specular_vertex_add(struct gl_context *ctx) ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR); swrast->SpecularVertexAdd = (separateSpecular - && ctx->Texture._EnabledUnits == 0x0 + && ctx->Texture._MaxEnabledTexImageUnit == -1 && !_swrast_use_fragment_program(ctx) && !ctx->ATIFragmentShader._Enabled); } @@ -523,7 +523,7 @@ _swrast_update_active_attribs(struct gl_context *ctx) if (swrast->_FogEnabled) attribsMask |= VARYING_BIT_FOGC; - attribsMask |= (ctx->Texture._EnabledUnits << VARYING_SLOT_TEX0); + attribsMask |= (ctx->Texture._EnabledCoordUnits << VARYING_SLOT_TEX0); } swrast->_ActiveAttribMask = attribsMask; @@ -923,7 +923,7 @@ _swrast_print_vertex( struct gl_context *ctx, const SWvertex *v ) v->attrib[VARYING_SLOT_POS][3]); for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) - if (ctx->Texture.Unit[i]._ReallyEnabled) + if (ctx->Texture.Unit[i]._Current) _mesa_debug(ctx, "texcoord[%d] %f %f %f %f\n", i, v->attrib[VARYING_SLOT_TEX0 + i][0], v->attrib[VARYING_SLOT_TEX0 + i][1], diff --git a/mesalib/src/mesa/swrast/s_texcombine.c b/mesalib/src/mesa/swrast/s_texcombine.c index 32d7c0944..c1a152aa8 100644 --- a/mesalib/src/mesa/swrast/s_texcombine.c +++ b/mesalib/src/mesa/swrast/s_texcombine.c @@ -189,7 +189,7 @@ texture_combine( struct gl_context *ctx, GLuint unit, { const GLuint srcUnit = srcRGB - GL_TEXTURE0; ASSERT(srcUnit < ctx->Const.MaxTextureUnits); - if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled) + if (!ctx->Texture.Unit[srcUnit]._Current) goto end; argRGB[term] = get_texel_array(swrast, srcUnit); } @@ -279,7 +279,7 @@ texture_combine( struct gl_context *ctx, GLuint unit, { const GLuint srcUnit = srcA - GL_TEXTURE0; ASSERT(srcUnit < ctx->Const.MaxTextureUnits); - if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled) + if (!ctx->Texture.Unit[srcUnit]._Current) goto end; argA[term] = get_texel_array(swrast, srcUnit); } @@ -657,7 +657,7 @@ _swrast_texture_span( struct gl_context *ctx, SWspan *span ) for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; - if (texUnit->_ReallyEnabled && + if (texUnit->_Current && texUnit->_CurrentCombine->ModeRGB == GL_BUMP_ENVMAP_ATI) { const GLfloat (*texcoords)[4] = (const GLfloat (*)[4]) span->array->attribs[VARYING_SLOT_TEX0 + unit]; @@ -723,7 +723,7 @@ _swrast_texture_span( struct gl_context *ctx, SWspan *span ) */ for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; - if (texUnit->_ReallyEnabled && + if (texUnit->_Current && texUnit->_CurrentCombine->ModeRGB != GL_BUMP_ENVMAP_ATI) { const GLfloat (*texcoords)[4] = (const GLfloat (*)[4]) span->array->attribs[VARYING_SLOT_TEX0 + unit]; @@ -787,7 +787,7 @@ _swrast_texture_span( struct gl_context *ctx, SWspan *span ) * We modify the span->color.rgba values. */ for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { - if (ctx->Texture.Unit[unit]._ReallyEnabled) + if (ctx->Texture.Unit[unit]._Current) texture_combine(ctx, unit, primary_rgba, swrast->TexelBuffer, span); } diff --git a/mesalib/src/mesa/swrast/s_texture.c b/mesalib/src/mesa/swrast/s_texture.c index c08a4e9d1..9ccd0e347 100644 --- a/mesalib/src/mesa/swrast/s_texture.c +++ b/mesalib/src/mesa/swrast/s_texture.c @@ -177,8 +177,8 @@ _swrast_free_texture_image_buffer(struct gl_context *ctx, * Error checking for debugging only. */ static void -_mesa_check_map_teximage(struct gl_texture_image *texImage, - GLuint slice, GLuint x, GLuint y, GLuint w, GLuint h) +check_map_teximage(const struct gl_texture_image *texImage, + GLuint slice, GLuint x, GLuint y, GLuint w, GLuint h) { if (texImage->TexObject->Target == GL_TEXTURE_1D) @@ -216,7 +216,16 @@ _swrast_map_teximage(struct gl_context *ctx, GLint stride, texelSize; GLuint bw, bh; - _mesa_check_map_teximage(texImage, slice, x, y, w, h); + check_map_teximage(texImage, slice, x, y, w, h); + + if (!swImage->Buffer) { + /* Either glTexImage was called with a NULL argument or + * we ran out of memory when allocating texture memory, + */ + *mapOut = NULL; + *rowStrideOut = 0; + return; + } texelSize = _mesa_get_format_bytes(texImage->TexFormat); stride = _mesa_format_row_stride(texImage->TexFormat, texImage->Width); @@ -225,12 +234,6 @@ _swrast_map_teximage(struct gl_context *ctx, assert(x % bw == 0); assert(y % bh == 0); - if (!swImage->Buffer) { - /* probably ran out of memory when allocating tex mem */ - *mapOut = NULL; - return; - } - /* This function can only be used with a swrast-allocated buffer, in which * case ImageSlices is populated with pointers into Buffer. */ @@ -266,7 +269,7 @@ _swrast_map_texture(struct gl_context *ctx, struct gl_texture_object *texObj) for (level = texObj->BaseLevel; level < MAX_TEXTURE_LEVELS; level++) { struct gl_texture_image *texImage = texObj->Image[face][level]; struct swrast_texture_image *swImage = swrast_texture_image(texImage); - unsigned int i; + unsigned int i, slices; if (!texImage) continue; @@ -279,7 +282,16 @@ _swrast_map_texture(struct gl_context *ctx, struct gl_texture_object *texObj) continue; } - for (i = 0; i < texture_slices(texImage); i++) { + if (!swImage->ImageSlices) { + swImage->ImageSlices = + calloc(texture_slices(texImage), sizeof(void *)); + if (!swImage->ImageSlices) + continue; + } + + slices = texture_slices(texImage); + + for (i = 0; i < slices; i++) { GLubyte *map; GLint rowStride; @@ -317,7 +329,7 @@ _swrast_unmap_texture(struct gl_context *ctx, struct gl_texture_object *texObj) for (level = texObj->BaseLevel; level < MAX_TEXTURE_LEVELS; level++) { struct gl_texture_image *texImage = texObj->Image[face][level]; struct swrast_texture_image *swImage = swrast_texture_image(texImage); - unsigned int i; + unsigned int i, slices; if (!texImage) continue; @@ -325,7 +337,12 @@ _swrast_unmap_texture(struct gl_context *ctx, struct gl_texture_object *texObj) if (swImage->Buffer) return; - for (i = 0; i < texture_slices(texImage); i++) { + if (!swImage->ImageSlices) + continue; + + slices = texture_slices(texImage); + + for (i = 0; i < slices; i++) { if (swImage->ImageSlices[i]) { ctx->Driver.UnmapTextureImage(ctx, texImage, i); swImage->ImageSlices[i] = NULL; @@ -342,16 +359,13 @@ _swrast_unmap_texture(struct gl_context *ctx, struct gl_texture_object *texObj) void _swrast_map_textures(struct gl_context *ctx) { - GLbitfield enabledUnits = ctx->Texture._EnabledUnits; + int unit; - /* loop over enabled texture units */ - while (enabledUnits) { - GLuint unit = ffs(enabledUnits) - 1; + for (unit = 0; unit <= ctx->Texture._MaxEnabledTexImageUnit; unit++) { struct gl_texture_object *texObj = ctx->Texture.Unit[unit]._Current; - - _swrast_map_texture(ctx, texObj); - enabledUnits &= ~(1 << unit); + if (texObj) + _swrast_map_texture(ctx, texObj); } } @@ -362,15 +376,11 @@ _swrast_map_textures(struct gl_context *ctx) void _swrast_unmap_textures(struct gl_context *ctx) { - GLbitfield enabledUnits = ctx->Texture._EnabledUnits; - - /* loop over enabled texture units */ - while (enabledUnits) { - GLuint unit = ffs(enabledUnits) - 1; + int unit; + for (unit = 0; unit <= ctx->Texture._MaxEnabledTexImageUnit; unit++) { struct gl_texture_object *texObj = ctx->Texture.Unit[unit]._Current; - - _swrast_unmap_texture(ctx, texObj); - enabledUnits &= ~(1 << unit); + if (texObj) + _swrast_unmap_texture(ctx, texObj); } } diff --git a/mesalib/src/mesa/swrast/s_triangle.c b/mesalib/src/mesa/swrast/s_triangle.c index 00383fb84..164906643 100644 --- a/mesalib/src/mesa/swrast/s_triangle.c +++ b/mesalib/src/mesa/swrast/s_triangle.c @@ -1071,8 +1071,8 @@ _swrast_choose_triangle( struct gl_context *ctx ) if (ctx->Texture._EnabledCoordUnits == 0x1 && !_swrast_use_fragment_program(ctx) && !ctx->ATIFragmentShader._Enabled - && ctx->Texture._EnabledUnits == 0x1 - && ctx->Texture.Unit[0]._ReallyEnabled == TEXTURE_2D_BIT + && ctx->Texture._MaxEnabledTexImageUnit == 0 + && ctx->Texture.Unit[0]._Current->Target == GL_TEXTURE_2D && samp->WrapS == GL_REPEAT && samp->WrapT == GL_REPEAT && texObj2D->_Swizzle == SWIZZLE_NOOP diff --git a/mesalib/src/mesa/swrast_setup/ss_context.c b/mesalib/src/mesa/swrast_setup/ss_context.c index 12a47358f..0b3b9e4df 100644 --- a/mesalib/src/mesa/swrast_setup/ss_context.c +++ b/mesalib/src/mesa/swrast_setup/ss_context.c @@ -287,7 +287,8 @@ _swsetup_Translate( struct gl_context *ctx, const void *vertex, SWvertex *dest ) _tnl_get_attr( ctx, vertex, _TNL_ATTRIB_COLOR0, dest->attrib[VARYING_SLOT_COL0] ); - UNCLAMPED_FLOAT_TO_RGBA_CHAN( dest->color, tmp ); + + UNCLAMPED_FLOAT_TO_RGBA_CHAN(dest->color, dest->attrib[VARYING_SLOT_COL0]); _tnl_get_attr( ctx, vertex, _TNL_ATTRIB_COLOR1, dest->attrib[VARYING_SLOT_COL1]); -- cgit v1.2.3