isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-22 16:10:41 -05:00
Code Issues Packages Projects Releases Wiki Activity
6712aaef45
mutter/cogl/cogl-debug.h

120 lines
3.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
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 07:56:10 -05: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 10:48:12 -04: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 07:47:02 -05:00
#ifndef __COGL_DEBUG_H__
#define __COGL_DEBUG_H__
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 10:36:46 -04:00
#include "cogl-profile.h"
cogl-context: Store winsys features in an array of unsigned ints Previously the mask of available winsys features was stored in a CoglBitmask. That isn't the ideal type to use for this because it is intended for a growable array of bits so it can allocate extra memory if there are more than 31 flags set. For the winsys feature flags the highest used bit is known at compile time so it makes sense to allocate a fixed array instead. This is conceptually similar to the CoglDebugFlags which are stored in an array of integers with macros to test a bit in the array. This moves the macros used for CoglDebugFlags to cogl-flags.h and makes them more generic so they can be shared with CoglContext.
2011-04-15 10:39:14 -04:00
#include "cogl-flags.h"
cogl-debug: Mark _cogl_debug_flags with dllexport for MSVC When building with MSVC, symbols to be exported that point to data need to be marked with dllimport to be successfully imported. The _cogl_debug_flags variable is currently exported because it is used from cogl-pango. This patch adds a COGL_EXPORT macro to cogl-util.h which is used in cogl-debug.h Based on a patch by Chun-wei Fan https://bugzilla.gnome.org/show_bug.cgi?id=650020 Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-24 11:09:16 -05:00
#include "cogl-util.h"
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 10:36:46 -04: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 07:47:02 -05:00
#include <glib.h>
G_BEGIN_DECLS
typedef enum {
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 09:28:00 -05:00
COGL_DEBUG_SLICING,
COGL_DEBUG_OFFSCREEN,
COGL_DEBUG_DRAW,
COGL_DEBUG_PANGO,
COGL_DEBUG_RECTANGLES,
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
COGL_DEBUG_OBJECT,
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 09:28:00 -05:00
COGL_DEBUG_BLEND_STRINGS,
COGL_DEBUG_DISABLE_BATCHING,
COGL_DEBUG_DISABLE_VBOS,
COGL_DEBUG_DISABLE_PBOS,
COGL_DEBUG_JOURNAL,
COGL_DEBUG_BATCHING,
COGL_DEBUG_DISABLE_SOFTWARE_TRANSFORM,
COGL_DEBUG_MATRICES,
COGL_DEBUG_ATLAS,
COGL_DEBUG_DUMP_ATLAS_IMAGE,
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 11:39:38 -04:00
COGL_DEBUG_DISABLE_SHARED_ATLAS,
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 09:28:00 -05:00
COGL_DEBUG_OPENGL,
COGL_DEBUG_DISABLE_TEXTURING,
COGL_DEBUG_DISABLE_ARBFP,
COGL_DEBUG_DISABLE_FIXED,
COGL_DEBUG_DISABLE_GLSL,
COGL_DEBUG_SHOW_SOURCE,
COGL_DEBUG_DISABLE_BLENDING,
COGL_DEBUG_TEXTURE_PIXMAP,
COGL_DEBUG_BITMAP,
COGL_DEBUG_DISABLE_NPOT_TEXTURES,
COGL_DEBUG_WIREFRAME,
COGL_DEBUG_DISABLE_SOFTWARE_CLIP,
COGL_DEBUG_DISABLE_PROGRAM_CACHES,
COGL_DEBUG_DISABLE_FAST_READ_PIXEL,
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 11:36:56 -05:00
COGL_DEBUG_CLIPPING,
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 08:28:33 -04:00
COGL_DEBUG_WINSYS,
Re-design the matrix stack using a graph of ops This re-designs the matrix stack so we now keep track of each separate operation such as rotating, scaling, translating and multiplying as immutable, ref-counted nodes in a graph. Being a "graph" here means that different transformations composed of a sequence of linked operation nodes may share nodes. The first node in a matrix-stack is always a LOAD_IDENTITY operation. As an example consider if an application where to draw three rectangles A, B and C something like this: cogl_framebuffer_scale (fb, 2, 2, 2); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_translate (fb, 10, 0, 0); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_rotate (fb, 45, 0, 0, 1); cogl_framebuffer_draw_rectangle (...); /* A */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_draw_rectangle (...); /* B */ cogl_framebuffer_pop_matrix(fb); cogl_framebuffer_push_matrix(fb); cogl_framebuffer_set_modelview_matrix (fb, &mv); cogl_framebuffer_draw_rectangle (...); /* C */ cogl_framebuffer_pop_matrix(fb); That would result in a graph of nodes like this: LOAD_IDENTITY | SCALE / \ SAVE LOAD | | TRANSLATE RECTANGLE(C) | \ SAVE RECTANGLE(B) | ROTATE | RECTANGLE(A) Each push adds a SAVE operation which serves as a marker to rewind too when a corresponding pop is issued and also each SAVE node may also store a cached matrix representing the composition of all its ancestor nodes. This means if we repeatedly need to resolve a real CoglMatrix for a given node then we don't need to repeat the composition. Some advantages of this design are: - A single pointer to any node in the graph can now represent a complete, immutable transformation that can be logged for example into a journal. Previously we were storing a full CoglMatrix in each journal entry which is 16 floats for the matrix itself as well as space for flags and another 16 floats for possibly storing a cache of the inverse. This means that we significantly reduce the size of the journal when drawing lots of primitives and we also avoid copying over 128 bytes per entry. - It becomes much cheaper to check for equality. In cases where some (unlikely) false negatives are allowed simply comparing the pointers of two matrix stack graph entries is enough. Previously we would use memcmp() to compare matrices. - It becomes easier to do comparisons of transformations. By looking for the common ancestry between nodes we can determine the operations that differentiate the transforms and use those to gain a high level understanding of the differences. For example we use this in the journal to be able to efficiently determine when two rectangle transforms only differ by some translation so that we can perform software clipping. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f75aee93f6b293ca7a7babbd8fcc326ee6bf7aef)
2012-02-20 10:59:48 -05:00
COGL_DEBUG_PERFORMANCE,
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 09:28:00 -05:00
COGL_DEBUG_N_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 07:47:02 -05:00
} CoglDebugFlags;
Fix disabling debugging When --disable-debug is passed to the configure script it was actually still defining COGL_ENABLE_DEBUG so very little would end up being disabled. If COGL_ENABLE_DEBUG actually got defined it would also fail to compile because _cogl_debug_instances and COGL_DEBUG_N_LONGS from cogl-debug.h were only defined if debugging is enabled but they are used regardless. This patch also makes it so that the _COGL_RETURN_IF_FAIL family of macros that are used when glib support is disabled are now disabled if debugging is disabled. When the glib macros are used they are already disabled because we additionally define G_DISABLE_CHECKS. 'COGL_HANDLE_DEBUG' has been removed from the list of defines passed when debugging is enabled because CoglHandle has already been removed and it is not used anywhere in the code. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 9811a0101c9cbb4ab95c55a2b41fd10ff4c77d9f)
2012-05-17 09:51:43 -04:00
extern GHashTable *_cogl_debug_instances;
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 10:19:10 -04:00
#define COGL_DEBUG_N_LONGS COGL_FLAGS_N_LONGS_FOR_SIZE (COGL_DEBUG_N_FLAGS)
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 09:28:00 -05:00
cogl-debug: Mark _cogl_debug_flags with dllexport for MSVC When building with MSVC, symbols to be exported that point to data need to be marked with dllimport to be successfully imported. The _cogl_debug_flags variable is currently exported because it is used from cogl-pango. This patch adds a COGL_EXPORT macro to cogl-util.h which is used in cogl-debug.h Based on a patch by Chun-wei Fan https://bugzilla.gnome.org/show_bug.cgi?id=650020 Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-24 11:09:16 -05:00
/* _cogl_debug_flags currently needs to exported outside of the shared
library for cogl-pango. The special COGL_EXPORT macro is needed to
get this to work when building with MSVC */
COGL_EXPORT extern unsigned long _cogl_debug_flags[COGL_DEBUG_N_LONGS];
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 09:28:00 -05:00
#define COGL_DEBUG_ENABLED(flag) \
cogl-context: Store winsys features in an array of unsigned ints Previously the mask of available winsys features was stored in a CoglBitmask. That isn't the ideal type to use for this because it is intended for a growable array of bits so it can allocate extra memory if there are more than 31 flags set. For the winsys feature flags the highest used bit is known at compile time so it makes sense to allocate a fixed array instead. This is conceptually similar to the CoglDebugFlags which are stored in an array of integers with macros to test a bit in the array. This moves the macros used for CoglDebugFlags to cogl-flags.h and makes them more generic so they can be shared with CoglContext.
2011-04-15 10:39:14 -04:00
COGL_FLAGS_GET (_cogl_debug_flags, flag)
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 09:28:00 -05:00
#define COGL_DEBUG_SET_FLAG(flag) \
cogl-context: Store winsys features in an array of unsigned ints Previously the mask of available winsys features was stored in a CoglBitmask. That isn't the ideal type to use for this because it is intended for a growable array of bits so it can allocate extra memory if there are more than 31 flags set. For the winsys feature flags the highest used bit is known at compile time so it makes sense to allocate a fixed array instead. This is conceptually similar to the CoglDebugFlags which are stored in an array of integers with macros to test a bit in the array. This moves the macros used for CoglDebugFlags to cogl-flags.h and makes them more generic so they can be shared with CoglContext.
2011-04-15 10:39:14 -04:00
COGL_FLAGS_SET (_cogl_debug_flags, flag, TRUE)
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 09:28:00 -05:00
#define COGL_DEBUG_CLEAR_FLAG(flag) \
cogl-context: Store winsys features in an array of unsigned ints Previously the mask of available winsys features was stored in a CoglBitmask. That isn't the ideal type to use for this because it is intended for a growable array of bits so it can allocate extra memory if there are more than 31 flags set. For the winsys feature flags the highest used bit is known at compile time so it makes sense to allocate a fixed array instead. This is conceptually similar to the CoglDebugFlags which are stored in an array of integers with macros to test a bit in the array. This moves the macros used for CoglDebugFlags to cogl-flags.h and makes them more generic so they can be shared with CoglContext.
2011-04-15 10:39:14 -04:00
COGL_FLAGS_SET (_cogl_debug_flags, flag, FALSE)
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 09:28:00 -05: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 07:47:02 -05:00
#ifdef __GNUC__
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 10:36:46 -04:00
#define COGL_NOTE(type,x,a...) G_STMT_START { \
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 09:28:00 -05:00
if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_##type))) { \
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 10:36:46 -04:00
_cogl_profile_trace_message ("[" #type "] " G_STRLOC " & " x, ##a); \
debug: Use G_UNLIKELY in the tests Debugging code is not meant to be run in the nominal code path. Use G_UNLIKELY to be reduce the number of bubbles in the instruction pipeline. Took the opportunity to re-indent the macros.
2010-05-03 14:41:17 -04:00
} } 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
#else
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 10:36:46 -04:00
#define COGL_NOTE(type,...) G_STMT_START { \
Compilation fixes for suncc https://bugzilla.gnome.org/show_bug.cgi?id=654718 Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-07-18 08:52:45 -04:00
if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_##type))) { \
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 10:36:46 -04:00
char *_fmt = g_strdup_printf (__VA_ARGS__); \
_cogl_profile_trace_message ("[" #type "] " G_STRLOC " & %s", _fmt);\
g_free (_fmt); \
debug: Use G_UNLIKELY in the tests Debugging code is not meant to be run in the nominal code path. Use G_UNLIKELY to be reduce the number of bubbles in the instruction pipeline. Took the opportunity to re-indent the macros.
2010-05-03 14:41:17 -04:00
} } 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 /* __GNUC__ */
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 17:33:44 -04:00
void
_cogl_debug_check_environment (void);
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 13:15:54 -04:00
void
_cogl_parse_debug_string (const char *value,
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
CoglBool enable,
CoglBool ignore_help);
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 13:15:54 -04: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 07:47:02 -05:00
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