1cc3ae6944
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.
87 lines
2.8 KiB
C
87 lines
2.8 KiB
C
/*
|
|
* 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, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*
|
|
*/
|
|
|
|
#ifndef __COGL_DEBUG_H__
|
|
#define __COGL_DEBUG_H__
|
|
|
|
#include <glib.h>
|
|
|
|
G_BEGIN_DECLS
|
|
|
|
typedef enum {
|
|
COGL_DEBUG_SLICING = 1 << 1,
|
|
COGL_DEBUG_OFFSCREEN = 1 << 2,
|
|
COGL_DEBUG_DRAW = 1 << 3,
|
|
COGL_DEBUG_PANGO = 1 << 4,
|
|
COGL_DEBUG_RECTANGLES = 1 << 5,
|
|
COGL_DEBUG_HANDLE = 1 << 6,
|
|
COGL_DEBUG_BLEND_STRINGS = 1 << 7,
|
|
COGL_DEBUG_DISABLE_BATCHING = 1 << 8,
|
|
COGL_DEBUG_DISABLE_VBOS = 1 << 9,
|
|
COGL_DEBUG_JOURNAL = 1 << 10,
|
|
COGL_DEBUG_BATCHING = 1 << 11,
|
|
COGL_DEBUG_DISABLE_SOFTWARE_TRANSFORM = 1 << 12,
|
|
COGL_DEBUG_MATRICES = 1 << 13,
|
|
COGL_DEBUG_FORCE_SCANLINE_PATHS = 1 << 14,
|
|
COGL_DEBUG_ATLAS = 1 << 15,
|
|
COGL_DEBUG_DUMP_ATLAS_IMAGE = 1 << 16,
|
|
COGL_DEBUG_DISABLE_ATLAS = 1 << 17,
|
|
COGL_DEBUG_OPENGL = 1 << 18,
|
|
COGL_DEBUG_DISABLE_TEXTURING = 1 << 19,
|
|
COGL_DEBUG_DISABLE_ARBFP = 1 << 20,
|
|
COGL_DEBUG_DISABLE_GLSL = 1 << 21,
|
|
COGL_DEBUG_SHOW_SOURCE = 1 << 22,
|
|
COGL_DEBUG_DISABLE_BLENDING = 1 << 23
|
|
} CoglDebugFlags;
|
|
|
|
#ifdef COGL_ENABLE_DEBUG
|
|
|
|
#ifdef __GNUC__
|
|
#define COGL_NOTE(type,x,a...) G_STMT_START { \
|
|
if (G_UNLIKELY (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 (G_UNLIKELY (cogl_debug_flags & COGL_DEBUG_##type)) { \
|
|
char *_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 */
|
|
|
|
#define COGL_NOTE(type,...) G_STMT_START {} G_STMT_END
|
|
|
|
#endif /* COGL_ENABLE_DEBUG */
|
|
|
|
extern unsigned int cogl_debug_flags;
|
|
|
|
G_END_DECLS
|
|
|
|
#endif /* __COGL_DEBUG_H__ */
|
|
|