brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
0f37570e93
mutter/cogl/cogl-debug.h

82 lines
2.6 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 10:48:12 -04:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2007,2008,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 07:47:02 -05:00
#ifndef __COGL_DEBUG_H__
#define __COGL_DEBUG_H__
#include <glib.h>
G_BEGIN_DECLS
typedef enum {
[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 13:46:42 -04:00
COGL_DEBUG_MISC = 1 << 0,
COGL_DEBUG_TEXTURE = 1 << 1,
COGL_DEBUG_MATERIAL = 1 << 2,
COGL_DEBUG_SHADER = 1 << 3,
COGL_DEBUG_OFFSCREEN = 1 << 4,
COGL_DEBUG_DRAW = 1 << 5,
COGL_DEBUG_PANGO = 1 << 6,
COGL_DEBUG_RECTANGLES = 1 << 7,
COGL_DEBUG_HANDLE = 1 << 8,
COGL_DEBUG_BLEND_STRINGS = 1 << 9,
[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 08:50:00 -04:00
COGL_DEBUG_DISABLE_BATCHING = 1 << 10,
[cogl] Adds a debug option for disabling use of VBOs --cogl-debug=disable-vbos For testing the VBO fallback paths it helps to be able to disable the COGL_FEATURE_VBOS feature flag. When VBOs aren't available Cogl should use client side malloc()'d buffers instead.
2009-06-16 20:46:06 -04:00
COGL_DEBUG_FORCE_CLIENT_SIDE_MATRICES = 1 << 11,
[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 06:54:01 -04:00
COGL_DEBUG_DISABLE_VBOS = 1 << 12,
COGL_DEBUG_JOURNAL = 1 << 13,
[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-16 20:31:36 -04:00
COGL_DEBUG_BATCHING = 1 << 14,
[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 07:01:33 -04:00
COGL_DEBUG_DISABLE_SOFTWARE_TRANSFORM = 1 << 15,
[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 11:55:18 -05:00
COGL_DEBUG_MATRICES = 1 << 16,
COGL_DEBUG_FORCE_SCANLINE_PATHS = 1 << 17
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 07:47:02 -05:00
} CoglDebugFlags;
#ifdef COGL_ENABLE_DEBUG
#ifdef __GNUC__
#define COGL_NOTE(type,x,a...) G_STMT_START { \
if (cogl_debug_flags & COGL_DEBUG_##type) { \
g_message ("[" #type "] " G_STRLOC ": " x, ##a); \
} } G_STMT_END
#else
#define COGL_NOTE(type,...) G_STMT_START { \
if (cogl_debug_flags & COGL_DEBUG_##type) { \
gchar *_fmt = g_strdup_printf (__VA_ARGS__); \
g_message ("[" #type "] " G_STRLOC ": %s", _fmt); \
g_free (_fmt); \
} } G_STMT_END
#endif /* __GNUC__ */
#else /* !COGL_ENABLE_DEBUG */
[cogl-debug] avoid warnings when using COGL_NOTE with unbraced else clauses When not building a debug build the compiler was warning about empty else clauses with no braces due to code like: if (blah) do_foo(); else COGL_NOTE (DRAW, "a-wibble"); This simply ensures that even for non debug builds COGL_NOTE will expand to a single statement.
2009-07-27 19:40:29 -04:00
#define COGL_NOTE(type,...) G_STMT_START {} G_STMT_END
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 07:47:02 -05:00
#endif /* COGL_ENABLE_DEBUG */
extern guint cogl_debug_flags;
G_END_DECLS
#endif /* __COGL_DEBUG_H__ */
[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 19:40:41 -04:00
Reference in New Issue Copy Permalink