isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-25 04:22:05 +00:00
Code Issues Packages Projects Releases Wiki Activity
07e972505c
mutter/cogl/cogl-debug.c

287 lines
9.5 KiB
C
Raw Normal View History

[cogl] Updates all file headers and removes lots of trailing white space Adds missing notices, and ensures all the notices are consistent. The Cogl blurb also now reads: * Cogl * * An object oriented GL/GLES Abstraction/Utility Layer
2009-04-27 14:48:12 +00:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2009 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
Remove mentions of the FSF address Since using addresses that might change is something that finally the FSF acknowledge as a plausible scenario (after changing address twice), the license blurb in the source files should use the URI for getting the license in case the library did not come with it. Not that URIs cannot possibly change, but at least it's easier to set up a redirection at the same place. As a side note: this commit closes the oldes bug in Clutter's bug report tool. http://bugzilla.openedhand.com/show_bug.cgi?id=521
2010-03-01 12:56:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
[cogl] Updates all file headers and removes lots of trailing white space Adds missing notices, and ensures all the notices are consistent. The Cogl blurb also now reads: * Cogl * * An object oriented GL/GLES Abstraction/Utility Layer
2009-04-27 14:48:12 +00:00
*/
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
cogl debug: Makes COGL_DEBUG=all|verbose|help more useful COGL_DEBUG=all wasn't previously useful as there are several options that change the behaviour of Cogl and all together wouldn't help anyone debug anything. This patch makes it so COGL_DEBUG=all|verbose now only enables options that don't change the behaviour of Cogl, i.e. they only affect the amount of noise we'll print to a terminal. In addition to that this patch also improves the output from COGL_DEBUG=help so we now print a table of options including one liner descriptions of what each option enables.
2010-02-17 14:38:11 +00:00
#include <stdlib.h>
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
#include <glib/gi18n-lib.h>
Add internal _cogl_init() function This adds a _cogl_init function for Cogl that we expect to be the first thing called before anything else is done with Cogl. It's not a public API so it's expected that all entry points for Cogl that might be the first function used should call _cogl_init(). We currently call _cogl_init() in these functions: cogl_renderer_new cogl_display_new cogl_context_new cogl_android_set_native_window _cogl_init() can be called multiple times, and only the first call has any affect. For example _cogl_init() gives us a place check and parse the COGL_DEBUG environment variable. Since we don't have any need to parse command line arguments (we can always get user configuration options from the environment) our init function doesn't require argc/argv pointers. By saying up front that we aren't interested in command line arguments that means we can avoid the mess that is GOption based library initialization which is extremely fragile due to its lack of dependency tracking between modules. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-14 21:33:44 +00:00
#include "cogl.h"
#include "cogl-private.h"
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
#include "cogl-debug.h"
arbfp: Adds an ARBfp program cache This adds a cache (A GHashTable) of ARBfp programs and before ever starting to code-generate a new program we will always first try and find an existing program in the cache. This uses _cogl_pipeline_hash and _cogl_pipeline_equal to hash and compare the keys for the cache. There is a new COGL_DEBUG=disable-program-caches option that can disable the cache for debugging purposes.
2010-12-03 12:01:18 +00:00
/* XXX: If you add a debug option, please also add an option
* definition to cogl-debug-options.h. This will enable us - for
* example - to emit a "help" description for the option.
cogl debug: Makes COGL_DEBUG=all|verbose|help more useful COGL_DEBUG=all wasn't previously useful as there are several options that change the behaviour of Cogl and all together wouldn't help anyone debug anything. This patch makes it so COGL_DEBUG=all|verbose now only enables options that don't change the behaviour of Cogl, i.e. they only affect the amount of noise we'll print to a terminal. In addition to that this patch also improves the output from COGL_DEBUG=help so we now print a table of options including one liner descriptions of what each option enables.
2010-02-17 14:38:11 +00:00
*/
/* NB: Only these options get enabled if COGL_DEBUG=all is
* used since they don't affect the behaviour of Cogl they
* simply print out verbose information */
static const GDebugKey cogl_log_debug_keys[] = {
{ "handle", COGL_DEBUG_HANDLE },
{ "slicing", COGL_DEBUG_SLICING },
{ "atlas", COGL_DEBUG_ATLAS },
{ "blend-strings", COGL_DEBUG_BLEND_STRINGS },
{ "journal", COGL_DEBUG_JOURNAL },
{ "batching", COGL_DEBUG_BATCHING },
{ "matrices", COGL_DEBUG_MATRICES },
[cogl] Add a PANGO debug flag for CoglPango use The CoglPango code falls under the COGL "jurisdiction"; this means that it cannot include Clutter headers unless strictly necessary. The CoglPangoRenderer code was using the CLUTTER_NOTE() macro. Now that COGL has it's own COGL_NOTE() similar macro, CoglPango should use that and avoid including clutter-debug.h (which pulls in clutter-private.h which in turn pulls in clutter-actor.h). A new flag, COGL_DEBUG_PANGO, has been added to the COGL debug flags.
2009-02-28 16:03:11 +00:00
{ "draw", COGL_DEBUG_DRAW },
cogl debug: Adds glViewport call tracing To aid in the debugging of Clutter stage resize issues this adds a COGL_DEBUG=opengl option that will trace "some select OpenGL calls" (currently just glViewport calls)
2010-02-17 18:45:08 +00:00
{ "opengl", COGL_DEBUG_OPENGL },
[cogl debug] --cogl-debug=rectangles now outlines all cogl rectangles This makes the #if 0'd debug code that was in _cogl_journal_flush_quad_batch - which we have repeatedly found usefull for debugging various geometry issues in Clutter apps - a runtime debug option. The outline colors rotate in order from red to green to blue which can also help confirm the order that your geometry really drawn. The outlines are not affected by the current material state, so if you e.g. have a blending bug where geometry mysteriously disappears this can confirm if the underlying rectangles are actually being emitted but blending is causing them to be invisible.
2009-04-17 14:10:55 +00:00
{ "pango", COGL_DEBUG_PANGO },
cogl-framebuffer: Use the FBO extension for color sizes OpenGL 3.0 deprecated querying of the GL_{RED,GREEN,BLUE}_BITS constants, and the FBO extension provides a mechanism to query for the color buffer sizes which *should* work even with the default framebuffer. Unfortunately, this doesn't seem to hold for Mesa - so we just use this for the offscreen CoglFramebuffer type, and we fall back to glGetIntegerv() for the onscreen one. http://bugzilla.openedhand.com/show_bug.cgi?id=2094
2010-05-26 16:14:53 +00:00
{ "show-source", COGL_DEBUG_SHOW_SOURCE},
Add a CoglTexturePixmapX11 texture backend This is a publicly exposed texture backend to create a texture which contains the contents of an X11 pixmap. The API is currently marked as experimental. The backend internally holds a handle to another texture. All of the backend virtuals simply redirect to the internal texture. The texture can optionally be automatically updated if the automatic_updates parameter is TRUE. If set then Cogl will listen for damage events on the pixmap and update the texture accordingly. Alternatively a damage object can be created externally and passed down to Cogl. The updates can be performed with XGetImage, XShmGetImage or the GLX_EXT_texture_pixmap extension. If the TFP extension is used it will optionally try to create a rectangle texture if the driver does not support NPOTs or it is forced through the COGL_PIXMAP_TEXTURE_RECTANGLE or CLUTTER_PIXMAP_TEXTURE_RECTANGLE environment variables. If the GLXFBConfig does not support mipmapping then it will fallback to using X{Shm,}GetImage. It keeps a separate texture around for this so that it can later start using the TFP texture again if the texture is later drawn with mipmaps disabled.
2010-05-25 17:56:14 +00:00
{ "offscreen", COGL_DEBUG_OFFSCREEN },
Add a Cogl debug flag for BITMAP CoglBitmap will soon want to report notes as it gets more complicated so this adds a debug flag for it.
2010-07-15 12:02:23 +00:00
{ "texture-pixmap", COGL_DEBUG_TEXTURE_PIXMAP },
cogl-debug: Add a debug option for tracing clipping This adds a COGL_DEBUG=clipping option that reports how the clip is being flushed. This is needed to determine whether the scissor, stencil clip planes or software clipping is being used.
2011-01-24 16:36:56 +00:00
{ "bitmap", COGL_DEBUG_BITMAP },
debug: Adds COGL_DEBUG=winsys option Although we internally had a COGL_DEBUG_WINSYS enum we weren't providing a way to enable that via the COGL_DEBUG environment variable. This adds a "winsys" option that can be used to enable printing of winsys debug notes. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-07 16:53:12 +00:00
{ "clipping", COGL_DEBUG_CLIPPING },
{ "winsys", COGL_DEBUG_WINSYS }
cogl debug: Makes COGL_DEBUG=all|verbose|help more useful COGL_DEBUG=all wasn't previously useful as there are several options that change the behaviour of Cogl and all together wouldn't help anyone debug anything. This patch makes it so COGL_DEBUG=all|verbose now only enables options that don't change the behaviour of Cogl, i.e. they only affect the amount of noise we'll print to a terminal. In addition to that this patch also improves the output from COGL_DEBUG=help so we now print a table of options including one liner descriptions of what each option enables.
2010-02-17 14:38:11 +00:00
};
static const int n_cogl_log_debug_keys =
G_N_ELEMENTS (cogl_log_debug_keys);
static const GDebugKey cogl_behavioural_debug_keys[] = {
[cogl] Move debugging to a configure-time switch Currently, COGL depends on defining debug symbols by manually modifying the source code. When it's done, it will forcefully print stuff to the console. Since COGL has also a pretty, runtime selectable debugging API we might as well switch everything to it. In order for this to happen, configure needs a new: --enable-cogl-debug command line switch; this will enable COGL debugging, the CoglHandle debugging and will also turn on the error checking for each GL operation. The default setting for the COGL debug defines is off, since it slows down the GL operations; enabling it for a particular debug build is trivial, though.
2009-05-19 15:00:18 +00:00
{ "rectangles", COGL_DEBUG_RECTANGLES },
[cogl-debug] Adds a "client-side-matrices" Cogl debug option This allows us to force Cogl to use the client side matrix stack even when direct rendering.
2009-06-05 12:50:00 +00:00
{ "disable-batching", COGL_DEBUG_DISABLE_BATCHING },
[Cogl journal] Adds a --cogl-debug=journal option for tracing the journal When this option is used Cogl will print a trace of all quads that get logged into the journal, and a trace of quads as they get flushed. If you are seeing a bug with the geometry being drawn by Cogl this may give some clues by letting you sanity check the numbers being logged vs the numbers being emitted.
2009-06-17 00:59:28 +00:00
{ "disable-vbos", COGL_DEBUG_DISABLE_VBOS },
debug: Adds a COGL_DEBUG=disable-pbos debug option For testing purposes, either to identify bugs in Cogl or the driver or simulate lack of PBO support COGL_DEBUG=disable-pbos can be used to fallback to malloc instead.
2010-07-06 00:30:25 +00:00
{ "disable-pbos", COGL_DEBUG_DISABLE_PBOS },
[debug] Adds a COGL_DEBUG=matrices debug option This adds a COGL_DEBUG=matrices debug option that can be used to trace all matrix manipulation done using the Cogl API. This can be handy when you break something in such a way that a trace is still comparable with a previous working version since you can simply diff a log of the broken version vs the working version to home in on the bug.
2009-10-26 11:01:33 +00:00
{ "disable-software-transform", COGL_DEBUG_DISABLE_SOFTWARE_TRANSFORM },
cogl-atlas-texture: Add a debug option to disable the atlas If the user specifies the 'disable-atlas' debug option then no texture will be put in the atlas.
2010-01-21 15:34:19 +00:00
{ "dump-atlas-image", COGL_DEBUG_DUMP_ATLAS_IMAGE },
material: Adds backend abstraction for fragment processing As part of an effort to improve the architecture of CoglMaterial internally this overhauls how we flush layer state to OpenGL by adding a formal backend abstraction for fragment processing and further formalizing the CoglTextureUnit abstraction. There are three backends: "glsl", "arbfp" and "fixed". The fixed backend uses the OpenGL fixed function APIs to setup the fragment processing, the arbfp backend uses code generation to handle fragment processing using an ARBfp program, and the GLSL backend is currently only there as a formality to handle user programs associated with a material. (i.e. the glsl backend doesn't yet support code generation) The GLSL backend has highest precedence, then arbfp and finally the fixed. If a backend can't support some particular CoglMaterial feature then it will fallback to the next backend. This adds three new COGL_DEBUG options: * "disable-texturing" as expected should disable all texturing * "disable-arbfp" always make the arbfp backend fallback * "disable-glsl" always make the glsl backend fallback * "show-source" show code generated by the arbfp/glsl backends
2010-04-26 09:01:43 +00:00
{ "disable-atlas", COGL_DEBUG_DISABLE_ATLAS },
cogl-debug: Add an option to disable atlasing sharing If COGL_DEBUG contains disable-shared-atlas Cogl will not try to share the atlas between glyphs and images.
2011-03-30 15:39:38 +00:00
{ "disable-shared-atlas", COGL_DEBUG_DISABLE_SHARED_ATLAS },
material: Adds backend abstraction for fragment processing As part of an effort to improve the architecture of CoglMaterial internally this overhauls how we flush layer state to OpenGL by adding a formal backend abstraction for fragment processing and further formalizing the CoglTextureUnit abstraction. There are three backends: "glsl", "arbfp" and "fixed". The fixed backend uses the OpenGL fixed function APIs to setup the fragment processing, the arbfp backend uses code generation to handle fragment processing using an ARBfp program, and the GLSL backend is currently only there as a formality to handle user programs associated with a material. (i.e. the glsl backend doesn't yet support code generation) The GLSL backend has highest precedence, then arbfp and finally the fixed. If a backend can't support some particular CoglMaterial feature then it will fallback to the next backend. This adds three new COGL_DEBUG options: * "disable-texturing" as expected should disable all texturing * "disable-arbfp" always make the arbfp backend fallback * "disable-glsl" always make the glsl backend fallback * "show-source" show code generated by the arbfp/glsl backends
2010-04-26 09:01:43 +00:00
{ "disable-texturing", COGL_DEBUG_DISABLE_TEXTURING},
{ "disable-arbfp", COGL_DEBUG_DISABLE_ARBFP},
Add a COGL_DEBUG option to disable the fixed function pipeline backend This adds COGL_DEBUG=disable-fixed to disable the fixed function pipeline backend. This is needed to test the GLSL shader generation because otherwise the fixed function backend would always override it.
2010-11-24 17:29:00 +00:00
{ "disable-fixed", COGL_DEBUG_DISABLE_FIXED},
CoglMaterial: Implements sparse materials design This is a complete overhaul of the data structures used to manage CoglMaterial state. We have these requirements that were aiming to meet: (Note: the references to "renderlists" correspond to the effort to support scenegraph level shuffling of Clutter actor primitives so we can minimize GPU state changes) Sparse State: We wanted a design that allows sparse descriptions of state so it scales well as we make CoglMaterial responsible for more and more state. It needs to scale well in terms of memory usage and the cost of operations we need to apply to materials such as comparing, copying and flushing their state. I.e. we would rather have these things scale by the number of real changes a material represents not by how much overall state CoglMaterial becomes responsible for. Cheap Copies: As we add support for renderlists in Clutter we will need to be able to get an immutable handle for a given material's current state so that we can retain a record of a primitive with its associated material without worrying that changes to the original material will invalidate that record. No more flush override options: We want to get rid of the flush overrides mechanism we currently use to deal with texture fallbacks, wrap mode changes and to handle the use of highlevel CoglTextures that need to be resolved into lowlevel textures before flushing the material state. The flush options structure has been expanding in size and the structure is logged with every journal entry so it is not an approach that scales well at all. It also makes flushing material state that much more complex. Weak Materials: Again for renderlists we need a way to create materials derived from other materials but without the strict requirement that modifications to the original material wont affect the derived ("weak") material. The only requirement is that its possible to later check if the original material has been changed. A summary of the new design: A CoglMaterial now basically represents a diff against its parent. Each material has a single parent and a mask of state that it changes. Each group of state (such as the blending state) has an "authority" which is found by walking up from a given material through its ancestors checking the difference mask until a match for that group is found. There is only one root node to the graph of all materials, which is the default material first created when Cogl is being initialized. All the groups of state are divided into two types, such that infrequently changed state belongs in a separate "BigState" structure that is only allocated and attached to a material when necessary. CoglMaterialLayers are another sparse structure. Like CoglMaterials they represent a diff against their parent and all the layers are part of another graph with the "default_layer_0" layer being the root node that Cogl creates during initialization. Copying a material is now basically just a case of slice allocating a CoglMaterial, setting the parent to be the source being copied and zeroing the mask of changes. Flush overrides should now be handled by simply relying on the cheapness of copying a material and making changes to it. (This will be done in a follow on commit) Weak material support will be added in a follow on commit.
2010-04-08 11:21:04 +00:00
{ "disable-glsl", COGL_DEBUG_DISABLE_GLSL},
Replace the disable-npots tool with a COGL_DEBUG option Previously in the tests/tools directory we build a disable-npots library which was used as an LD_PRELOAD to trick Cogl in to thinking there is no NPOT texture extension. This is a little awkward to use so it seems much simpler to just define a COGL_DEBUG option to disable npot textures.
2010-11-05 14:55:46 +00:00
{ "disable-blending", COGL_DEBUG_DISABLE_BLENDING},
debug: Adds a COGL_DEBUG=wireframe option This adds a COGL_DEBUG=wireframe option to visualize the underlying geometry of the primitives being drawn via Cogl. This works for triangle list, triangle fan, triangle strip and quad (internal only) primitives. It also works for indexed vertex arrays.
2010-11-16 13:06:08 +00:00
{ "disable-npot-textures", COGL_DEBUG_DISABLE_NPOT_TEXTURES},
Add a COGL_DEBUG option to disable software clipping This adds a debug option called disable-software-clipping which causes the journal to always log the clip stack state rather than trying to manually clip rectangles.
2010-11-10 14:02:31 +00:00
{ "wireframe", COGL_DEBUG_WIREFRAME},
arbfp: Adds an ARBfp program cache This adds a cache (A GHashTable) of ARBfp programs and before ever starting to code-generate a new program we will always first try and find an existing program in the cache. This uses _cogl_pipeline_hash and _cogl_pipeline_equal to hash and compare the keys for the cache. There is a new COGL_DEBUG=disable-program-caches option that can disable the cache for debugging purposes.
2010-12-03 12:01:18 +00:00
{ "disable-software-clip", COGL_DEBUG_DISABLE_SOFTWARE_CLIP},
debug: Adds a COGL_DEBUG=disable-fast-read-pixel option COGL_DEBUG=disable-fast-read-pixel can be used to disable the optimization for reading a single pixel colour back by looking at the geometry in the journal and not involving the GPU. With this disabled we will always flush the journal, rendering to the framebuffer and then use glReadPixels to get the result.
2011-01-20 14:41:51 +00:00
{ "disable-program-caches", COGL_DEBUG_DISABLE_PROGRAM_CACHES},
{ "disable-fast-read-pixel", COGL_DEBUG_DISABLE_FAST_READ_PIXEL}
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
};
cogl debug: Makes COGL_DEBUG=all|verbose|help more useful COGL_DEBUG=all wasn't previously useful as there are several options that change the behaviour of Cogl and all together wouldn't help anyone debug anything. This patch makes it so COGL_DEBUG=all|verbose now only enables options that don't change the behaviour of Cogl, i.e. they only affect the amount of noise we'll print to a terminal. In addition to that this patch also improves the output from COGL_DEBUG=help so we now print a table of options including one liner descriptions of what each option enables.
2010-02-17 14:38:11 +00:00
static const int n_cogl_behavioural_debug_keys =
G_N_ELEMENTS (cogl_behavioural_debug_keys);
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
cogl-flags: Use longs instead of ints Previously cogl-flags was using an array of ints to store the flags. There was a comment saying that it would be nice to use longs but this is awkward because g_parse_debug_flags can only work in ints. This is a silly reason not to use longs because we can just parse multiple sets of flags per long. This patch therefore changes cogl-flags to use longs and tweaks the debug key parsing code. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-31 14:19:10 +00:00
unsigned long _cogl_debug_flags[COGL_DEBUG_N_LONGS];
cogl-debug: add instrumentation to track the number of objects This allows to track the number of objects allocated by Cogl. The results are displayed on the standard output by calling : cogl_debug_print_instances (); Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@linux.intel.com> Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-10 17:44:09 +00:00
GHashTable *_cogl_debug_instances;
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
static void
_cogl_parse_debug_string_for_keys (const char *value,
gboolean enable,
const GDebugKey *keys,
unsigned int nkeys)
{
cogl-flags: Use longs instead of ints Previously cogl-flags was using an array of ints to store the flags. There was a comment saying that it would be nice to use longs but this is awkward because g_parse_debug_flags can only work in ints. This is a silly reason not to use longs because we can just parse multiple sets of flags per long. This patch therefore changes cogl-flags to use longs and tweaks the debug key parsing code. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-31 14:19:10 +00:00
int long_num, key_num;
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
/* g_parse_debug_string expects the value field in GDebugKey to be a
cogl-flags: Use longs instead of ints Previously cogl-flags was using an array of ints to store the flags. There was a comment saying that it would be nice to use longs but this is awkward because g_parse_debug_flags can only work in ints. This is a silly reason not to use longs because we can just parse multiple sets of flags per long. This patch therefore changes cogl-flags to use longs and tweaks the debug key parsing code. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-31 14:19:10 +00:00
mask in a guint but the flags is stored in an array of multiple
longs so we need to build a separate array for each possible
guint */
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
cogl-flags: Use longs instead of ints Previously cogl-flags was using an array of ints to store the flags. There was a comment saying that it would be nice to use longs but this is awkward because g_parse_debug_flags can only work in ints. This is a silly reason not to use longs because we can just parse multiple sets of flags per long. This patch therefore changes cogl-flags to use longs and tweaks the debug key parsing code. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-31 14:19:10 +00:00
for (long_num = 0; long_num < COGL_DEBUG_N_LONGS; long_num++)
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
{
cogl-flags: Use longs instead of ints Previously cogl-flags was using an array of ints to store the flags. There was a comment saying that it would be nice to use longs but this is awkward because g_parse_debug_flags can only work in ints. This is a silly reason not to use longs because we can just parse multiple sets of flags per long. This patch therefore changes cogl-flags to use longs and tweaks the debug key parsing code. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-31 14:19:10 +00:00
int int_num;
for (int_num = 0;
int_num < sizeof (unsigned long) / sizeof (unsigned int);
int_num++)
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
{
cogl-flags: Use longs instead of ints Previously cogl-flags was using an array of ints to store the flags. There was a comment saying that it would be nice to use longs but this is awkward because g_parse_debug_flags can only work in ints. This is a silly reason not to use longs because we can just parse multiple sets of flags per long. This patch therefore changes cogl-flags to use longs and tweaks the debug key parsing code. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-31 14:19:10 +00:00
GDebugKey keys_for_int[sizeof (unsigned int) * 8];
int nkeys_for_int = 0;
for (key_num = 0; key_num < nkeys; key_num++)
{
int long_index = COGL_FLAGS_GET_INDEX (keys[key_num].value);
int int_index = (keys[key_num].value %
(sizeof (unsigned long) * 8) /
(sizeof (unsigned int) * 8));
if (long_index == long_num && int_index == int_num)
{
keys_for_int[nkeys_for_int] = keys[key_num];
keys_for_int[nkeys_for_int].value =
COGL_FLAGS_GET_MASK (keys[key_num].value) >>
(int_num * sizeof (unsigned int) * 8);
nkeys_for_int++;
}
}
if (nkeys_for_int > 0)
{
unsigned long mask =
((unsigned long) g_parse_debug_string (value,
keys_for_int,
nkeys_for_int)) <<
(int_num * sizeof (unsigned int) * 8);
if (enable)
_cogl_debug_flags[long_num] |= mask;
else
_cogl_debug_flags[long_num] &= ~mask;
}
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
}
}
}
cogl: Add support for reading a cogl.conf config file When cogl initializes we now check for a cogl/cogl.conf in any of the system config dirs (determined using $XDG_CONFIG_DIRS on linux) we then also check the user's config directory (determined using XDG_CONFIG_HOME on linux) for a cogl/cogl.conf file. Options specified in the user config file have priority over the system config options. The config file has an .ini style syntax with a mandatory [global] section and we currently understand 3 keynames: COGL_DEBUG, COGL_DRIVER and COGL_RENDERER which have the same semantics as the corresponding environment variables. Options set using the environment variables have priority over options set in the config files. To allow users to undo the enabling of debug options in config files this patch also adds a check for COGL_NO_DEBUG environment variable which will disable the specified options which may have been enabled in config files. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-03 17:15:54 +00:00
void
cogl debug: Makes COGL_DEBUG=all|verbose|help more useful COGL_DEBUG=all wasn't previously useful as there are several options that change the behaviour of Cogl and all together wouldn't help anyone debug anything. This patch makes it so COGL_DEBUG=all|verbose now only enables options that don't change the behaviour of Cogl, i.e. they only affect the amount of noise we'll print to a terminal. In addition to that this patch also improves the output from COGL_DEBUG=help so we now print a table of options including one liner descriptions of what each option enables.
2010-02-17 14:38:11 +00:00
_cogl_parse_debug_string (const char *value,
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
gboolean enable,
cogl debug: Makes COGL_DEBUG=all|verbose|help more useful COGL_DEBUG=all wasn't previously useful as there are several options that change the behaviour of Cogl and all together wouldn't help anyone debug anything. This patch makes it so COGL_DEBUG=all|verbose now only enables options that don't change the behaviour of Cogl, i.e. they only affect the amount of noise we'll print to a terminal. In addition to that this patch also improves the output from COGL_DEBUG=help so we now print a table of options including one liner descriptions of what each option enables.
2010-02-17 14:38:11 +00:00
gboolean ignore_help)
{
if (ignore_help && strcmp (value, "help") == 0)
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
return;
cogl debug: Makes COGL_DEBUG=all|verbose|help more useful COGL_DEBUG=all wasn't previously useful as there are several options that change the behaviour of Cogl and all together wouldn't help anyone debug anything. This patch makes it so COGL_DEBUG=all|verbose now only enables options that don't change the behaviour of Cogl, i.e. they only affect the amount of noise we'll print to a terminal. In addition to that this patch also improves the output from COGL_DEBUG=help so we now print a table of options including one liner descriptions of what each option enables.
2010-02-17 14:38:11 +00:00
/* We don't want to let g_parse_debug_string handle "all" because
* literally enabling all the debug options wouldn't be useful to
* anyone; instead the all option enables all non behavioural
* options.
*/
if (strcmp (value, "all") == 0 ||
strcmp (value, "verbose") == 0)
{
int i;
for (i = 0; i < n_cogl_log_debug_keys; i++)
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
if (enable)
COGL_DEBUG_SET_FLAG (cogl_log_debug_keys[i].value);
else
COGL_DEBUG_CLEAR_FLAG (cogl_log_debug_keys[i].value);
cogl debug: Makes COGL_DEBUG=all|verbose|help more useful COGL_DEBUG=all wasn't previously useful as there are several options that change the behaviour of Cogl and all together wouldn't help anyone debug anything. This patch makes it so COGL_DEBUG=all|verbose now only enables options that don't change the behaviour of Cogl, i.e. they only affect the amount of noise we'll print to a terminal. In addition to that this patch also improves the output from COGL_DEBUG=help so we now print a table of options including one liner descriptions of what each option enables.
2010-02-17 14:38:11 +00:00
}
debug: Accept HELP for the COGL_DEBUG environment variable. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-09 17:17:51 +00:00
else if (g_ascii_strcasecmp (value, "help") == 0)
cogl debug: Makes COGL_DEBUG=all|verbose|help more useful COGL_DEBUG=all wasn't previously useful as there are several options that change the behaviour of Cogl and all together wouldn't help anyone debug anything. This patch makes it so COGL_DEBUG=all|verbose now only enables options that don't change the behaviour of Cogl, i.e. they only affect the amount of noise we'll print to a terminal. In addition to that this patch also improves the output from COGL_DEBUG=help so we now print a table of options including one liner descriptions of what each option enables.
2010-02-17 14:38:11 +00:00
{
Mark the debug options for translation This adds the descriptions of the debug options to the list of translatable strings. https://bugzilla.gnome.org/show_bug.cgi?id=658700
2011-09-10 08:52:48 +00:00
g_printerr ("\n\n%28s\n", _("Supported debug values:"));
profile: Update to uprof-0.3 dep for --enable-profile When building with --enable-profile we now depend on the uprof-0.3 developer release which brings a few improvements: » It lets us "fix" how we initialize uprof so that instead of using a shared object constructor/destructor (which was a hack used when first adding uprof support to Clutter) we can now initialize as part of clutter's normal initialization code. As a side note though, I found that the way Clutter initializes has some quite serious problems whenever it involves GOptionGroups. It is not able to guarantee the initialization of dependencies like uprof and Cogl. For this reason we still use the contructor/destructor approach to initialize uprof in Cogl. » uprof-0.3 provides a better API for adding custom columns when reporting timer and counter statistics which lets us remove quite a lot of manual report generation code in clutter-profile.c. » uprof-0.3 provides a shared context for tracking mainloop timer statistics. This means any mainloop based library following the same "Mainloop" timer naming convention can use the shared context and no matter who ends up owning the final mainloop the statistics will always be in the same place. This allows profiling of Clutter with an external mainloop such as with the Mutter compositor. » uprof-0.3 can export statistics over dbus and comes with an ncurses based ui to vizualize timer and counter stats live. The latest version of uprof can be cloned from: git://github.com/rib/UProf.git
2010-06-21 14:36:46 +00:00
#define OPT(MASK_NAME, GROUP, NAME, NAME_FORMATTED, DESCRIPTION) \
Mark the debug options for translation This adds the descriptions of the debug options to the list of translatable strings. https://bugzilla.gnome.org/show_bug.cgi?id=658700
2011-09-10 08:52:48 +00:00
g_printerr ("%28s %s\n", NAME ":", g_dgettext (GETTEXT_PACKAGE, \
DESCRIPTION));
profile: Update to uprof-0.3 dep for --enable-profile When building with --enable-profile we now depend on the uprof-0.3 developer release which brings a few improvements: » It lets us "fix" how we initialize uprof so that instead of using a shared object constructor/destructor (which was a hack used when first adding uprof support to Clutter) we can now initialize as part of clutter's normal initialization code. As a side note though, I found that the way Clutter initializes has some quite serious problems whenever it involves GOptionGroups. It is not able to guarantee the initialization of dependencies like uprof and Cogl. For this reason we still use the contructor/destructor approach to initialize uprof in Cogl. » uprof-0.3 provides a better API for adding custom columns when reporting timer and counter statistics which lets us remove quite a lot of manual report generation code in clutter-profile.c. » uprof-0.3 provides a shared context for tracking mainloop timer statistics. This means any mainloop based library following the same "Mainloop" timer naming convention can use the shared context and no matter who ends up owning the final mainloop the statistics will always be in the same place. This allows profiling of Clutter with an external mainloop such as with the Mutter compositor. » uprof-0.3 can export statistics over dbus and comes with an ncurses based ui to vizualize timer and counter stats live. The latest version of uprof can be cloned from: git://github.com/rib/UProf.git
2010-06-21 14:36:46 +00:00
#include "cogl-debug-options.h"
Mark the debug options for translation This adds the descriptions of the debug options to the list of translatable strings. https://bugzilla.gnome.org/show_bug.cgi?id=658700
2011-09-10 08:52:48 +00:00
g_printerr ("\n%28s\n", _("Special debug values:"));
profile: Update to uprof-0.3 dep for --enable-profile When building with --enable-profile we now depend on the uprof-0.3 developer release which brings a few improvements: » It lets us "fix" how we initialize uprof so that instead of using a shared object constructor/destructor (which was a hack used when first adding uprof support to Clutter) we can now initialize as part of clutter's normal initialization code. As a side note though, I found that the way Clutter initializes has some quite serious problems whenever it involves GOptionGroups. It is not able to guarantee the initialization of dependencies like uprof and Cogl. For this reason we still use the contructor/destructor approach to initialize uprof in Cogl. » uprof-0.3 provides a better API for adding custom columns when reporting timer and counter statistics which lets us remove quite a lot of manual report generation code in clutter-profile.c. » uprof-0.3 provides a shared context for tracking mainloop timer statistics. This means any mainloop based library following the same "Mainloop" timer naming convention can use the shared context and no matter who ends up owning the final mainloop the statistics will always be in the same place. This allows profiling of Clutter with an external mainloop such as with the Mutter compositor. » uprof-0.3 can export statistics over dbus and comes with an ncurses based ui to vizualize timer and counter stats live. The latest version of uprof can be cloned from: git://github.com/rib/UProf.git
2010-06-21 14:36:46 +00:00
OPT (IGNORED, "ignored", "all", "ignored", \
Mark the debug options for translation This adds the descriptions of the debug options to the list of translatable strings. https://bugzilla.gnome.org/show_bug.cgi?id=658700
2011-09-10 08:52:48 +00:00
N_("Enables all non-behavioural debug options"));
profile: Update to uprof-0.3 dep for --enable-profile When building with --enable-profile we now depend on the uprof-0.3 developer release which brings a few improvements: » It lets us "fix" how we initialize uprof so that instead of using a shared object constructor/destructor (which was a hack used when first adding uprof support to Clutter) we can now initialize as part of clutter's normal initialization code. As a side note though, I found that the way Clutter initializes has some quite serious problems whenever it involves GOptionGroups. It is not able to guarantee the initialization of dependencies like uprof and Cogl. For this reason we still use the contructor/destructor approach to initialize uprof in Cogl. » uprof-0.3 provides a better API for adding custom columns when reporting timer and counter statistics which lets us remove quite a lot of manual report generation code in clutter-profile.c. » uprof-0.3 provides a shared context for tracking mainloop timer statistics. This means any mainloop based library following the same "Mainloop" timer naming convention can use the shared context and no matter who ends up owning the final mainloop the statistics will always be in the same place. This allows profiling of Clutter with an external mainloop such as with the Mutter compositor. » uprof-0.3 can export statistics over dbus and comes with an ncurses based ui to vizualize timer and counter stats live. The latest version of uprof can be cloned from: git://github.com/rib/UProf.git
2010-06-21 14:36:46 +00:00
OPT (IGNORED, "ignored", "verbose", "ignored", \
Mark the debug options for translation This adds the descriptions of the debug options to the list of translatable strings. https://bugzilla.gnome.org/show_bug.cgi?id=658700
2011-09-10 08:52:48 +00:00
N_("Enables all non-behavioural debug options"));
cogl debug: Makes COGL_DEBUG=all|verbose|help more useful COGL_DEBUG=all wasn't previously useful as there are several options that change the behaviour of Cogl and all together wouldn't help anyone debug anything. This patch makes it so COGL_DEBUG=all|verbose now only enables options that don't change the behaviour of Cogl, i.e. they only affect the amount of noise we'll print to a terminal. In addition to that this patch also improves the output from COGL_DEBUG=help so we now print a table of options including one liner descriptions of what each option enables.
2010-02-17 14:38:11 +00:00
#undef OPT
exit (1);
}
else
{
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
_cogl_parse_debug_string_for_keys (value,
enable,
cogl_log_debug_keys,
n_cogl_log_debug_keys);
_cogl_parse_debug_string_for_keys (value,
enable,
cogl_behavioural_debug_keys,
n_cogl_behavioural_debug_keys);
cogl debug: Makes COGL_DEBUG=all|verbose|help more useful COGL_DEBUG=all wasn't previously useful as there are several options that change the behaviour of Cogl and all together wouldn't help anyone debug anything. This patch makes it so COGL_DEBUG=all|verbose now only enables options that don't change the behaviour of Cogl, i.e. they only affect the amount of noise we'll print to a terminal. In addition to that this patch also improves the output from COGL_DEBUG=help so we now print a table of options including one liner descriptions of what each option enables.
2010-02-17 14:38:11 +00:00
}
}
Add internal _cogl_init() function This adds a _cogl_init function for Cogl that we expect to be the first thing called before anything else is done with Cogl. It's not a public API so it's expected that all entry points for Cogl that might be the first function used should call _cogl_init(). We currently call _cogl_init() in these functions: cogl_renderer_new cogl_display_new cogl_context_new cogl_android_set_native_window _cogl_init() can be called multiple times, and only the first call has any affect. For example _cogl_init() gives us a place check and parse the COGL_DEBUG environment variable. Since we don't have any need to parse command line arguments (we can always get user configuration options from the environment) our init function doesn't require argc/argv pointers. By saying up front that we aren't interested in command line arguments that means we can avoid the mess that is GOption based library initialization which is extremely fragile due to its lack of dependency tracking between modules. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-14 21:33:44 +00:00
#ifdef COGL_ENABLE_DEBUG
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
static gboolean
cogl_arg_debug_cb (const char *key,
const char *value,
gpointer user_data)
{
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
_cogl_parse_debug_string (value,
TRUE /* enable the flags */,
FALSE /* don't ignore help */);
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
return TRUE;
}
static gboolean
cogl_arg_no_debug_cb (const char *key,
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-10 01:57:32 +00:00
const char *value,
gpointer user_data)
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
{
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
_cogl_parse_debug_string (value,
FALSE, /* disable the flags */
TRUE /* ignore help */);
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
return TRUE;
}
cogl debug: Makes COGL_DEBUG=all|verbose|help more useful COGL_DEBUG=all wasn't previously useful as there are several options that change the behaviour of Cogl and all together wouldn't help anyone debug anything. This patch makes it so COGL_DEBUG=all|verbose now only enables options that don't change the behaviour of Cogl, i.e. they only affect the amount of noise we'll print to a terminal. In addition to that this patch also improves the output from COGL_DEBUG=help so we now print a table of options including one liner descriptions of what each option enables.
2010-02-17 14:38:11 +00:00
#endif /* COGL_ENABLE_DEBUG */
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
static GOptionEntry cogl_args[] = {
cogl debug: Adds missing guards around debug cogl_args[] commit 511e5ceb516dc accidentally removed the #ifdef COGL_ENABLE_DEBUG guards around the "cogl-debug" and "cogl-no-debug" cogl_args[] which this patch restores.
2010-03-02 02:07:40 +00:00
#ifdef COGL_ENABLE_DEBUG
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
{ "cogl-debug", 0, 0, G_OPTION_ARG_CALLBACK, cogl_arg_debug_cb,
cogl: Use Cogl (not COGL) consistently If I remember correctly, Robert wants to name Cogl, Cogl (not COGL) so start by having a consistent naming in the code.
2010-10-05 07:03:19 +00:00
N_("Cogl debugging flags to set"), "FLAGS" },
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
{ "cogl-no-debug", 0, 0, G_OPTION_ARG_CALLBACK, cogl_arg_no_debug_cb,
cogl: Use Cogl (not COGL) consistently If I remember correctly, Robert wants to name Cogl, Cogl (not COGL) so start by having a consistent naming in the code.
2010-10-05 07:03:19 +00:00
N_("Cogl debugging flags to unset"), "FLAGS" },
cogl debug: Adds missing guards around debug cogl_args[] commit 511e5ceb516dc accidentally removed the #ifdef COGL_ENABLE_DEBUG guards around the "cogl-debug" and "cogl-no-debug" cogl_args[] which this patch restores.
2010-03-02 02:07:40 +00:00
#endif /* COGL_ENABLE_DEBUG */
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
{ NULL, },
};
Add internal _cogl_init() function This adds a _cogl_init function for Cogl that we expect to be the first thing called before anything else is done with Cogl. It's not a public API so it's expected that all entry points for Cogl that might be the first function used should call _cogl_init(). We currently call _cogl_init() in these functions: cogl_renderer_new cogl_display_new cogl_context_new cogl_android_set_native_window _cogl_init() can be called multiple times, and only the first call has any affect. For example _cogl_init() gives us a place check and parse the COGL_DEBUG environment variable. Since we don't have any need to parse command line arguments (we can always get user configuration options from the environment) our init function doesn't require argc/argv pointers. By saying up front that we aren't interested in command line arguments that means we can avoid the mess that is GOption based library initialization which is extremely fragile due to its lack of dependency tracking between modules. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-14 21:33:44 +00:00
void
_cogl_debug_check_environment (void)
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
{
const char *env_string;
env_string = g_getenv ("COGL_DEBUG");
if (env_string != NULL)
{
cogl-debug: Split the flags to support more than 32 The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
2011-01-24 14:28:00 +00:00
_cogl_parse_debug_string (env_string,
TRUE /* enable the flags */,
FALSE /* don't ignore help */);
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
env_string = NULL;
}
cogl: Add support for reading a cogl.conf config file When cogl initializes we now check for a cogl/cogl.conf in any of the system config dirs (determined using $XDG_CONFIG_DIRS on linux) we then also check the user's config directory (determined using XDG_CONFIG_HOME on linux) for a cogl/cogl.conf file. Options specified in the user config file have priority over the system config options. The config file has an .ini style syntax with a mandatory [global] section and we currently understand 3 keynames: COGL_DEBUG, COGL_DRIVER and COGL_RENDERER which have the same semantics as the corresponding environment variables. Options set using the environment variables have priority over options set in the config files. To allow users to undo the enabling of debug options in config files this patch also adds a check for COGL_NO_DEBUG environment variable which will disable the specified options which may have been enabled in config files. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-03 17:15:54 +00:00
env_string = g_getenv ("COGL_NO_DEBUG");
if (env_string != NULL)
{
_cogl_parse_debug_string (env_string,
FALSE /* disable the flags */,
FALSE /* don't ignore help */);
env_string = NULL;
}
Add internal _cogl_init() function This adds a _cogl_init function for Cogl that we expect to be the first thing called before anything else is done with Cogl. It's not a public API so it's expected that all entry points for Cogl that might be the first function used should call _cogl_init(). We currently call _cogl_init() in these functions: cogl_renderer_new cogl_display_new cogl_context_new cogl_android_set_native_window _cogl_init() can be called multiple times, and only the first call has any affect. For example _cogl_init() gives us a place check and parse the COGL_DEBUG environment variable. Since we don't have any need to parse command line arguments (we can always get user configuration options from the environment) our init function doesn't require argc/argv pointers. By saying up front that we aren't interested in command line arguments that means we can avoid the mess that is GOption based library initialization which is extremely fragile due to its lack of dependency tracking between modules. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-14 21:33:44 +00:00
}
static gboolean
pre_parse_hook (GOptionContext *context,
GOptionGroup *group,
gpointer data,
GError **error)
{
_cogl_init ();
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
return TRUE;
}
Add internal _cogl_init() function This adds a _cogl_init function for Cogl that we expect to be the first thing called before anything else is done with Cogl. It's not a public API so it's expected that all entry points for Cogl that might be the first function used should call _cogl_init(). We currently call _cogl_init() in these functions: cogl_renderer_new cogl_display_new cogl_context_new cogl_android_set_native_window _cogl_init() can be called multiple times, and only the first call has any affect. For example _cogl_init() gives us a place check and parse the COGL_DEBUG environment variable. Since we don't have any need to parse command line arguments (we can always get user configuration options from the environment) our init function doesn't require argc/argv pointers. By saying up front that we aren't interested in command line arguments that means we can avoid the mess that is GOption based library initialization which is extremely fragile due to its lack of dependency tracking between modules. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-06-14 21:33:44 +00:00
/* XXX: GOption based library initialization is not reliable because the
* GOption API has no way to represent dependencies between libraries.
*/
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
GOptionGroup *
cogl_get_option_group (void)
{
GOptionGroup *group;
group = g_option_group_new ("cogl",
cogl: Use Cogl (not COGL) consistently If I remember correctly, Robert wants to name Cogl, Cogl (not COGL) so start by having a consistent naming in the code.
2010-10-05 07:03:19 +00:00
_("Cogl Options"),
_("Show Cogl options"),
Add runtime debug messages for COGL Clutter is able to show debug messages written using the CLUTTER_NOTE() macro at runtime, either by using an environment variable: CLUTTER_DEBUG=... or by using a command line switch: --clutter-debug=... --clutter-no-debug=... Both are parsed during the initialization process by using the GOption API. COGL would benefit from having the same support. In order to do this, we need a cogl_get_option_group() function in COGL that sets up a GOptionGroup for COGL and adds a pre-parse hook that will check the COGL_DEBUG environment variable. The OptionGroup will also install two command line switches: --cogl-debug --cogl-no-debug With the same semantics of the Clutter ones. During Clutter initialization, the COGL option group will be attached to the GOptionContext used to parse the command line options passed to a Clutter application. Every debug message written using: COGL_NOTE (SECTION, "message format", arguments); Will then be printed only if SECTION was enabled at runtime. This whole machinery, like the equivalent one in Clutter, depends on a compile time switch, COGL_ENABLE_DEBUG, which is enabled at the same time as CLUTTER_ENABLE_DEBUG. Having two different symbols allows greater granularity.
2009-02-23 12:47:02 +00:00
NULL, NULL);
g_option_group_set_parse_hooks (group, pre_parse_hook, NULL);
g_option_group_add_entries (group, cogl_args);
g_option_group_set_translation_domain (group, GETTEXT_PACKAGE);
return group;
}
Reference in New Issue Copy Permalink