sungmg/mutter-performance-source
1
0
Fork 0
Code Activity
mutter-performance-source/cogl/cogl-debug.c

135 lines
3.9 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
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
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
#include <glib/gi18n-lib.h>
#include "cogl-debug.h"
#ifdef COGL_ENABLE_DEBUG
static const GDebugKey cogl_debug_keys[] = {
{ "misc", COGL_DEBUG_MISC },
{ "texture", COGL_DEBUG_TEXTURE },
{ "material", COGL_DEBUG_MATERIAL },
{ "shader", COGL_DEBUG_SHADER },
{ "offscreen", COGL_DEBUG_OFFSCREEN },
[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] --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] 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-material] Support string based blending and layer combine descriptions Setting up layer combine functions and blend modes is very awkward to do programatically. This adds a parser for string based descriptions which are more consise and readable. E.g. a material layer combine function could now be given as: "RGBA = ADD (TEXTURE[A], PREVIOUS[RGB])" or "RGB = REPLACE (PREVIOUS)" "A = MODULATE (PREVIOUS, TEXTURE)" The simple syntax and grammar are only designed to expose standard fixed function hardware, more advanced combining must be done with shaders. This includes standalone documentation of blend strings covering the aspects that are common to blending and texture combining, and adds documentation with examples specific to the new cogl_material_set_blend() and cogl_material_layer_set_combine() functions. Note: The hope is to remove the now redundant bits of the material API before 1.0
2009-05-10 23:40:41 +00:00
{ "handle", COGL_DEBUG_HANDLE },
[cogl] Improving Cogl journal to minimize driver overheads + GPU state changes Previously the journal was always flushed at the end of _cogl_rectangles_with_multitexture_coords, (i.e. the end of any cogl_rectangle* calls) but now we have broadened the potential for batching geometry. In ideal circumstances we will only flush once per scene. In summary the journal works like this: When you use any of the cogl_rectangle* APIs then nothing is emitted to the GPU at this point, we just log one or more quads into the journal. A journal entry consists of the quad coordinates, an associated material reference, and a modelview matrix. Ideally the journal only gets flushed once at the end of a scene, but in fact there are things to consider that may cause unwanted flushing, including: - modifying materials mid-scene This is because each quad in the journal has an associated material reference (i.e. not copy), so if you try and modify a material that is already referenced in the journal we force a flush first) NOTE: For now this means you should avoid using cogl_set_source_color() since that currently uses a single shared material. Later we should change it to use a pool of materials that is recycled when the journal is flushed. - modifying any state that isn't currently logged, such as depth, fog and backface culling enables. The first thing that happens when flushing, is to upload all the vertex data associated with the journal into a single VBO. We then go through a process of splitting up the journal into batches that have compatible state so they can be emitted to the GPU together. This is currently broken up into 3 levels so we can stagger the state changes: 1) we break the journal up according to changes in the number of material layers associated with logged quads. The number of layers in a material determines the stride of the associated vertices, so we have to update our vertex array offsets at this level. (i.e. calling gl{Vertex,Color},Pointer etc) 2) we further split batches up according to material compatability. (e.g. materials with different textures) We flush material state at this level. 3) Finally we split batches up according to modelview changes. At this level we update the modelview matrix and actually emit the actual draw command. This commit is largely about putting the initial design in-place; this will be followed by other changes that take advantage of the extended batching.
2009-06-17 17:46:42 +00:00
{ "blend-strings", COGL_DEBUG_BLEND_STRINGS },
[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 },
[cogl journal] Adds a --cogl-debug=batching option to trace batching Enabling this option makes Cogl trace how the journal is managing to batch your rectangles. The journal staggers how it emmits state to the GL driver and the batches will normally get smaller for each stage, but ideally you don't want to be in a situation where Cogl is only able to draw one quad per modelview change and draw call. E.g. this is a fairly ideal example: BATCHING: journal len = 101 BATCHING: vbo offset batch len = 101 BATCHING: material batch len = 101 BATCHING: modelview batch len = 101 This isn't: BATCHING: journal len = 1 BATCHING: vbo offset batch len = 1 BATCHING: material batch len = 1 BATCHING: modelview batch len = 1 BATCHING: journal len = 1 BATCHING: vbo offset batch len = 1 BATCHING: material batch len = 1 BATCHING: modelview batch len = 1 <repeat>
2009-06-11 10:54:01 +00:00
{ "journal", COGL_DEBUG_JOURNAL },
[cogl journal] Perform software modelview transform on logged quads. Since most Clutter actors aren't much more than textured quads; flushing the journal typically involves lots of 'change modelview; draw quad' sequences. The amount of overhead involved in uploading a new modelview and queuing that primitive is huge in comparison to simply transforming 4 vertices by the current modelview when logging quads. (Note if your GPU supports HW vertex transform, then it still does the projective and viewport transforms) At the same time a --cogl-debug=disable-software-transform option has been added for comparison and debugging. This change allows typical pick scenes to be batched into a single draw call and I'm seeing test-pick run over 200% faster with this. (i965 + Mesa 7.6-devel)
2009-06-17 00:31:36 +00:00
{ "batching", COGL_DEBUG_BATCHING },
[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 },
[debug] Adds a COGL_DEBUG=force-scanline-paths For a long time now the GLES driver for Cogl has supported a fallback scanline rasterizer for filling paths when no stencil buffer is available, but now that we build the same cogl-primitives code for GL and GLES I thought it may sometimes be useful for debugging to force Cogl to use the scanline rasterizer instead of the current stencil buffer approach.
2009-11-04 16:55:18 +00:00
{ "matrices", COGL_DEBUG_MATRICES },
cogl-texture-atlas: Add some debugging notes This adds an 'atlas' category to the COGL_DEBUG environment variable. When enabled Cogl will display messages when textures are added to the atlas and when the atlas is reorganized.
2009-12-04 18:55:53 +00:00
{ "force-scanline-paths", COGL_DEBUG_FORCE_SCANLINE_PATHS },
cogl-atlas: Add a debug option to visualize the atlas This adds a 'dump-atlas-image' debug category. When enabled, CoglAtlas will use Cairo to create a png which visualizes the leaf rectangles of the atlas.
2009-12-04 19:43:39 +00:00
{ "atlas", COGL_DEBUG_ATLAS },
{ "dump-atlas-image", COGL_DEBUG_DUMP_ATLAS_IMAGE }
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 const gint n_cogl_debug_keys = G_N_ELEMENTS (cogl_debug_keys);
#endif /* COGL_ENABLE_DEBUG */
guint cogl_debug_flags = 0;
#ifdef COGL_ENABLE_DEBUG
static gboolean
cogl_arg_debug_cb (const char *key,
const char *value,
gpointer user_data)
{
cogl_debug_flags |=
g_parse_debug_string (value,
cogl_debug_keys,
n_cogl_debug_keys);
return TRUE;
}
static gboolean
cogl_arg_no_debug_cb (const char *key,
const char *value,
gpointer user_data)
{
cogl_debug_flags &=
~g_parse_debug_string (value,
cogl_debug_keys,
n_cogl_debug_keys);
return TRUE;
}
#endif /* CLUTTER_ENABLE_DEBUG */
static GOptionEntry cogl_args[] = {
#ifdef COGL_ENABLE_DEBUG
{ "cogl-debug", 0, 0, G_OPTION_ARG_CALLBACK, cogl_arg_debug_cb,
N_("COGL debugging flags to set"), "FLAGS" },
{ "cogl-no-debug", 0, 0, G_OPTION_ARG_CALLBACK, cogl_arg_no_debug_cb,
N_("COGL debugging flags to unset"), "FLAGS" },
#endif /* COGL_ENABLE_DEBUG */
{ NULL, },
};
static gboolean
pre_parse_hook (GOptionContext *context,
GOptionGroup *group,
gpointer data,
GError **error)
{
Fix compiler warnings when COGL debug level=minimum
2009-07-28 12:57:07 +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
const char *env_string;
env_string = g_getenv ("COGL_DEBUG");
if (env_string != NULL)
{
cogl_debug_flags =
g_parse_debug_string (env_string,
cogl_debug_keys,
n_cogl_debug_keys);
env_string = NULL;
}
#endif /* COGL_ENABLE_DEBUG */
return TRUE;
}
GOptionGroup *
cogl_get_option_group (void)
{
GOptionGroup *group;
group = g_option_group_new ("cogl",
_("COGL Options"),
_("Show COGL options"),
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;
}
Copy permalink