diff options
Diffstat (limited to 'cogl/cogl/cogl-pipeline-private.h')
| -rw-r--r-- | cogl/cogl/cogl-pipeline-private.h | 821 |
1 files changed, 0 insertions, 821 deletions
diff --git a/cogl/cogl/cogl-pipeline-private.h b/cogl/cogl/cogl-pipeline-private.h deleted file mode 100644 index 045af8fa0..000000000 --- a/cogl/cogl/cogl-pipeline-private.h +++ /dev/null @@ -1,821 +0,0 @@ -/* - * Cogl - * - * A Low Level GPU Graphics and Utilities API - * - * Copyright (C) 2008,2009,2010,2011 Intel Corporation. - * - * Permission is hereby granted, free of charge, to any person - * obtaining a copy of this software and associated documentation - * files (the "Software"), to deal in the Software without - * restriction, including without limitation the rights to use, copy, - * modify, merge, publish, distribute, sublicense, and/or sell copies - * of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be - * included in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS - * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN - * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - * - * - * - * Authors: - * Robert Bragg <robert@linux.intel.com> - */ - -#ifndef __COGL_PIPELINE_PRIVATE_H -#define __COGL_PIPELINE_PRIVATE_H - -#include "cogl-node-private.h" -#include "cogl-pipeline-layer-private.h" -#include "cogl-pipeline.h" -#include "cogl-object-private.h" -#include "cogl-profile.h" -#include "cogl-list.h" -#include "cogl-boxed-value.h" -#include "cogl-pipeline-snippet-private.h" -#include "cogl-pipeline-state.h" -#include "cogl-framebuffer.h" -#include "cogl-bitmask.h" - -#include <glib.h> - -#if !(defined(HAVE_COGL_GL) || defined(HAVE_COGL_GLES2)) - -#error No drivers defined - -#endif /* defined(HAVE_COGL_GL) || defined(HAVE_COGL_GLES2) */ - -/* XXX: should I rename these as - * COGL_PIPELINE_STATE_INDEX_XYZ... ? - */ -typedef enum -{ - /* sparse state */ - COGL_PIPELINE_STATE_COLOR_INDEX, - COGL_PIPELINE_STATE_LAYERS_INDEX, - COGL_PIPELINE_STATE_ALPHA_FUNC_INDEX, - COGL_PIPELINE_STATE_ALPHA_FUNC_REFERENCE_INDEX, - COGL_PIPELINE_STATE_BLEND_INDEX, - COGL_PIPELINE_STATE_USER_SHADER_INDEX, - COGL_PIPELINE_STATE_DEPTH_INDEX, - COGL_PIPELINE_STATE_NON_ZERO_POINT_SIZE_INDEX, - COGL_PIPELINE_STATE_POINT_SIZE_INDEX, - COGL_PIPELINE_STATE_PER_VERTEX_POINT_SIZE_INDEX, - COGL_PIPELINE_STATE_CULL_FACE_INDEX, - COGL_PIPELINE_STATE_UNIFORMS_INDEX, - COGL_PIPELINE_STATE_VERTEX_SNIPPETS_INDEX, - COGL_PIPELINE_STATE_FRAGMENT_SNIPPETS_INDEX, - - /* non-sparse */ - COGL_PIPELINE_STATE_REAL_BLEND_ENABLE_INDEX, - - COGL_PIPELINE_STATE_COUNT -} CoglPipelineStateIndex; - -#define COGL_PIPELINE_STATE_SPARSE_COUNT (COGL_PIPELINE_STATE_COUNT - 1) - -/* Used in pipeline->differences masks and for notifying pipeline - * state changes. - * - * XXX: If you add or remove state groups here you may need to update - * some of the state masks following this enum too! - * - * FIXME: perhaps it would be better to rename this enum to - * CoglPipelineStateGroup to better convey the fact that a single enum - * here can map to multiple properties. - */ -typedef enum _CoglPipelineState -{ - COGL_PIPELINE_STATE_COLOR = - 1L<<COGL_PIPELINE_STATE_COLOR_INDEX, - COGL_PIPELINE_STATE_LAYERS = - 1L<<COGL_PIPELINE_STATE_LAYERS_INDEX, - - COGL_PIPELINE_STATE_ALPHA_FUNC = - 1L<<COGL_PIPELINE_STATE_ALPHA_FUNC_INDEX, - COGL_PIPELINE_STATE_ALPHA_FUNC_REFERENCE = - 1L<<COGL_PIPELINE_STATE_ALPHA_FUNC_REFERENCE_INDEX, - COGL_PIPELINE_STATE_BLEND = - 1L<<COGL_PIPELINE_STATE_BLEND_INDEX, - COGL_PIPELINE_STATE_USER_SHADER = - 1L<<COGL_PIPELINE_STATE_USER_SHADER_INDEX, - COGL_PIPELINE_STATE_DEPTH = - 1L<<COGL_PIPELINE_STATE_DEPTH_INDEX, - COGL_PIPELINE_STATE_NON_ZERO_POINT_SIZE = - 1L<<COGL_PIPELINE_STATE_NON_ZERO_POINT_SIZE_INDEX, - COGL_PIPELINE_STATE_POINT_SIZE = - 1L<<COGL_PIPELINE_STATE_POINT_SIZE_INDEX, - COGL_PIPELINE_STATE_PER_VERTEX_POINT_SIZE = - 1L<<COGL_PIPELINE_STATE_PER_VERTEX_POINT_SIZE_INDEX, - COGL_PIPELINE_STATE_CULL_FACE = - 1L<<COGL_PIPELINE_STATE_CULL_FACE_INDEX, - COGL_PIPELINE_STATE_UNIFORMS = - 1L<<COGL_PIPELINE_STATE_UNIFORMS_INDEX, - COGL_PIPELINE_STATE_VERTEX_SNIPPETS = - 1L<<COGL_PIPELINE_STATE_VERTEX_SNIPPETS_INDEX, - COGL_PIPELINE_STATE_FRAGMENT_SNIPPETS = - 1L<<COGL_PIPELINE_STATE_FRAGMENT_SNIPPETS_INDEX, - - COGL_PIPELINE_STATE_REAL_BLEND_ENABLE = - 1L<<COGL_PIPELINE_STATE_REAL_BLEND_ENABLE_INDEX, - -} CoglPipelineState; - -/* - * Various special masks that tag state-groups in different ways... - */ - -#define COGL_PIPELINE_STATE_ALL \ - ((1L<<COGL_PIPELINE_STATE_COUNT) - 1) - -#define COGL_PIPELINE_STATE_ALL_SPARSE \ - (COGL_PIPELINE_STATE_ALL \ - & ~COGL_PIPELINE_STATE_REAL_BLEND_ENABLE) - -#define COGL_PIPELINE_STATE_AFFECTS_BLENDING \ - (COGL_PIPELINE_STATE_COLOR | \ - COGL_PIPELINE_STATE_LAYERS | \ - COGL_PIPELINE_STATE_BLEND | \ - COGL_PIPELINE_STATE_USER_SHADER | \ - COGL_PIPELINE_STATE_VERTEX_SNIPPETS | \ - COGL_PIPELINE_STATE_FRAGMENT_SNIPPETS) - -#define COGL_PIPELINE_STATE_NEEDS_BIG_STATE \ - (COGL_PIPELINE_STATE_ALPHA_FUNC | \ - COGL_PIPELINE_STATE_ALPHA_FUNC_REFERENCE | \ - COGL_PIPELINE_STATE_BLEND | \ - COGL_PIPELINE_STATE_USER_SHADER | \ - COGL_PIPELINE_STATE_DEPTH | \ - COGL_PIPELINE_STATE_NON_ZERO_POINT_SIZE | \ - COGL_PIPELINE_STATE_POINT_SIZE | \ - COGL_PIPELINE_STATE_PER_VERTEX_POINT_SIZE | \ - COGL_PIPELINE_STATE_CULL_FACE | \ - COGL_PIPELINE_STATE_UNIFORMS | \ - COGL_PIPELINE_STATE_VERTEX_SNIPPETS | \ - COGL_PIPELINE_STATE_FRAGMENT_SNIPPETS) - -#define COGL_PIPELINE_STATE_MULTI_PROPERTY \ - (COGL_PIPELINE_STATE_LAYERS | \ - COGL_PIPELINE_STATE_BLEND | \ - COGL_PIPELINE_STATE_DEPTH | \ - COGL_PIPELINE_STATE_CULL_FACE | \ - COGL_PIPELINE_STATE_UNIFORMS | \ - COGL_PIPELINE_STATE_VERTEX_SNIPPETS | \ - COGL_PIPELINE_STATE_FRAGMENT_SNIPPETS) - -typedef struct -{ - /* Determines what fragments are discarded based on their alpha */ - CoglPipelineAlphaFunc alpha_func; - float alpha_func_reference; -} CoglPipelineAlphaFuncState; - -typedef struct -{ - /* Determines how this pipeline is blended with other primitives */ -#if defined(HAVE_COGL_GLES2) || defined(HAVE_COGL_GL) - GLenum blend_equation_rgb; - GLenum blend_equation_alpha; - GLint blend_src_factor_alpha; - GLint blend_dst_factor_alpha; - CoglColor blend_constant; -#endif - GLint blend_src_factor_rgb; - GLint blend_dst_factor_rgb; -} CoglPipelineBlendState; - -typedef struct -{ - CoglPipelineCullFaceMode mode; - CoglWinding front_winding; -} CoglPipelineCullFaceState; - -typedef struct -{ - CoglBitmask override_mask; - - /* This is an array of values. Only the uniforms that have a bit set - in override_mask have a corresponding value here. The uniform's - location is implicit from the order in this array */ - CoglBoxedValue *override_values; - - /* Uniforms that have been modified since this pipeline was last - flushed */ - CoglBitmask changed_mask; -} CoglPipelineUniformsState; - -typedef struct -{ - CoglPipelineAlphaFuncState alpha_state; - CoglPipelineBlendState blend_state; - CoglHandle user_program; - CoglDepthState depth_state; - float point_size; - unsigned int non_zero_point_size : 1; - unsigned int per_vertex_point_size : 1; - CoglPipelineCullFaceState cull_face_state; - CoglPipelineUniformsState uniforms_state; - CoglPipelineSnippetList vertex_snippets; - CoglPipelineSnippetList fragment_snippets; -} CoglPipelineBigState; - -typedef struct -{ - CoglPipeline *owner; - CoglPipelineLayer *layer; -} CoglPipelineLayerCacheEntry; - -typedef struct _CoglPipelineHashState -{ - unsigned long layer_differences; - CoglPipelineEvalFlags flags; - unsigned int hash; -} CoglPipelineHashState; - -/* - * CoglPipelineDestroyCallback - * @pipeline: The #CoglPipeline that has been destroyed - * @user_data: The private data associated with the callback - * - * Notifies when a weak pipeline has been destroyed because one - * of its ancestors has been freed or modified. - */ -typedef void (*CoglPipelineDestroyCallback)(CoglPipeline *pipeline, - void *user_data); - -struct _CoglPipeline -{ - /* XXX: Please think twice about adding members that *have* be - * initialized during a cogl_pipeline_copy. We are aiming to have - * copies be as cheap as possible and copies may be done by the - * primitives APIs which means they may happen in performance - * critical code paths. - * - * XXX: If you are extending the state we track please consider if - * the state is expected to vary frequently across many pipelines or - * if the state can be shared among many derived pipelines instead. - * This will determine if the state should be added directly to this - * structure which will increase the memory overhead for *all* - * pipelines or if instead it can go under ->big_state. - */ - - /* Layers represent their state in a tree structure where some of - * the state relating to a given pipeline or layer may actually be - * owned by one if is ancestors in the tree. We have a common data - * type to track the tree hierarchy so we can share code... */ - CoglNode _parent; - - /* When weak pipelines are destroyed the user is notified via this - * callback */ - CoglPipelineDestroyCallback destroy_callback; - - /* When notifying that a weak pipeline has been destroyed this - * private data is passed to the above callback */ - void *destroy_data; - - /* We need to track if a pipeline is referenced in the journal - * because we can't allow modification to these pipelines without - * flushing the journal first */ - unsigned int journal_ref_count; - - /* A mask of which sparse state groups are different in this - * pipeline in comparison to its parent. */ - unsigned int differences; - - /* Whenever a pipeline is modified we increment the age. There's no - * guarantee that it won't wrap but it can nevertheless be a - * convenient mechanism to determine when a pipeline has been - * changed to you can invalidate some some associated cache that - * depends on the old state. */ - unsigned int age; - - /* This is the primary color of the pipeline. - * - * This is a sparse property, ref COGL_PIPELINE_STATE_COLOR */ - CoglColor color; - - /* A pipeline may be made up with multiple layers used to combine - * textures together. - * - * This is sparse state, ref COGL_PIPELINE_STATE_LAYERS */ - unsigned int n_layers; - GList *layer_differences; - - /* As a basic way to reduce memory usage we divide the pipeline - * state into two groups; the minimal state modified in 90% of - * all pipelines and the rest, so that the second group can - * be allocated dynamically when required... */ - CoglPipelineBigState *big_state; - -#ifdef COGL_DEBUG_ENABLED - /* For debugging purposes it's possible to associate a static const - * string with a pipeline which can be an aid when trying to trace - * where the pipeline originates from */ - const char *static_breadcrumb; -#endif - - /* Cached state... */ - - /* A cached, complete list of the layers this pipeline depends - * on sorted by layer->unit_index. */ - CoglPipelineLayer **layers_cache; - /* To avoid a separate ->layers_cache allocation for common - * pipelines with only a few layers... */ - CoglPipelineLayer *short_layers_cache[3]; - - /* XXX: consider adding an authorities cache to speed up sparse - * property value lookups: - * CoglPipeline *authorities_cache[COGL_PIPELINE_N_SPARSE_PROPERTIES]; - * and corresponding authorities_cache_dirty:1 bitfield - */ - - /* bitfields */ - - /* Weak pipelines don't count as dependants on their parents which - * means that the parent pipeline can be modified without - * considering how the modifications may affect the weak pipeline. - */ - unsigned int is_weak:1; - - /* Determines if pipeline->big_state is valid */ - unsigned int has_big_state:1; - - /* There are many factors that can determine if we need to enable - * blending, this holds our final decision */ - unsigned int real_blend_enable:1; - - /* Since the code for deciding if blending really needs to be - * enabled for a particular pipeline is quite expensive we update - * the real_blend_enable flag lazily when flushing a pipeline if - * this dirty flag has been set. */ - unsigned int dirty_real_blend_enable:1; - - /* Whenever a pipeline is flushed we keep track of whether the - * pipeline was used with a color attribute where we don't know - * whether the colors are opaque. The real_blend_enable state - * depends on this, and must be updated whenever this changes (even - * if dirty_real_blend_enable isn't set) */ - unsigned int unknown_color_alpha:1; - - unsigned int layers_cache_dirty:1; - -#ifdef COGL_DEBUG_ENABLED - /* For debugging purposes it's possible to associate a static const - * string with a pipeline which can be an aid when trying to trace - * where the pipeline originates from */ - unsigned int has_static_breadcrumb:1; -#endif -}; - -typedef struct _CoglPipelineFragend -{ - void (*start) (CoglPipeline *pipeline, - int n_layers, - unsigned long pipelines_difference); - gboolean (*add_layer) (CoglPipeline *pipeline, - CoglPipelineLayer *layer, - unsigned long layers_difference); - gboolean (*end) (CoglPipeline *pipeline, - unsigned long pipelines_difference); - - void (*pipeline_pre_change_notify) (CoglPipeline *pipeline, - CoglPipelineState change, - const CoglColor *new_color); - void (*layer_pre_change_notify) (CoglPipeline *owner, - CoglPipelineLayer *layer, - CoglPipelineLayerState change); -} CoglPipelineFragend; - -typedef struct _CoglPipelineVertend -{ - void (*start) (CoglPipeline *pipeline, - int n_layers, - unsigned long pipelines_difference); - gboolean (*add_layer) (CoglPipeline *pipeline, - CoglPipelineLayer *layer, - unsigned long layers_difference, - CoglFramebuffer *framebuffer); - gboolean (*end) (CoglPipeline *pipeline, - unsigned long pipelines_difference); - - void (*pipeline_pre_change_notify) (CoglPipeline *pipeline, - CoglPipelineState change, - const CoglColor *new_color); - void (*layer_pre_change_notify) (CoglPipeline *owner, - CoglPipelineLayer *layer, - CoglPipelineLayerState change); -} CoglPipelineVertend; - -typedef struct -{ - gboolean (*start) (CoglPipeline *pipeline); - void (*end) (CoglPipeline *pipeline, - unsigned long pipelines_difference); - void (*pipeline_pre_change_notify) (CoglPipeline *pipeline, - CoglPipelineState change, - const CoglColor *new_color); - void (*layer_pre_change_notify) (CoglPipeline *owner, - CoglPipelineLayer *layer, - CoglPipelineLayerState change); - /* This is called after all of the other functions whenever the - pipeline is flushed, even if the pipeline hasn't changed since - the last flush */ - void (* pre_paint) (CoglPipeline *pipeline, CoglFramebuffer *framebuffer); -} CoglPipelineProgend; - -extern const CoglPipelineFragend *_cogl_pipeline_fragend; -extern const CoglPipelineVertend *_cogl_pipeline_vertend; -extern const CoglPipelineProgend *_cogl_pipeline_progend; - -void -_cogl_pipeline_init_default_pipeline (void); - -static inline CoglPipeline * -_cogl_pipeline_get_parent (CoglPipeline *pipeline) -{ - CoglNode *parent_node = COGL_NODE (pipeline)->parent; - return COGL_PIPELINE (parent_node); -} - -static inline CoglPipeline * -_cogl_pipeline_get_authority (CoglPipeline *pipeline, - unsigned long difference) -{ - CoglPipeline *authority = pipeline; - while (!(authority->differences & difference)) - authority = _cogl_pipeline_get_parent (authority); - return authority; -} - -typedef gboolean (*CoglPipelineStateComparator) (CoglPipeline *authority0, - CoglPipeline *authority1); - -void -_cogl_pipeline_update_authority (CoglPipeline *pipeline, - CoglPipeline *authority, - CoglPipelineState state, - CoglPipelineStateComparator comparator); - -void -_cogl_pipeline_pre_change_notify (CoglPipeline *pipeline, - CoglPipelineState change, - const CoglColor *new_color, - gboolean from_layer_change); - -void -_cogl_pipeline_prune_redundant_ancestry (CoglPipeline *pipeline); - -void -_cogl_pipeline_update_real_blend_enable (CoglPipeline *pipeline, - gboolean unknown_color_alpha); - -typedef enum -{ - COGL_PIPELINE_GET_LAYER_NO_CREATE = 1<<0 -} CoglPipelineGetLayerFlags; - -CoglPipelineLayer * -_cogl_pipeline_get_layer_with_flags (CoglPipeline *pipeline, - int layer_index, - CoglPipelineGetLayerFlags flags); - -#define _cogl_pipeline_get_layer(p, l) \ - _cogl_pipeline_get_layer_with_flags (p, l, 0) - -gboolean -_cogl_is_pipeline_layer (void *object); - -void -_cogl_pipeline_prune_empty_layer_difference (CoglPipeline *layers_authority, - CoglPipelineLayer *layer); - -/* - * SECTION:cogl-pipeline-internals - * @short_description: Functions for creating custom primitives that make use - * of Cogl pipelines for filling. - * - * Normally you shouldn't need to use this API directly, but if you need to - * developing a custom/specialised primitive - probably using raw OpenGL - then - * this API aims to expose enough of the pipeline internals to support being - * able to fill your geometry according to a given Cogl pipeline. - */ - -gboolean -_cogl_pipeline_get_real_blend_enabled (CoglPipeline *pipeline); - -/* - * Calls the pre_paint method on the layer texture if there is - * one. This will determine whether mipmaps are needed based on the - * filter settings. - */ -void -_cogl_pipeline_pre_paint_for_layer (CoglPipeline *pipeline, - int layer_id); - -/* - * CoglPipelineFlushFlag: - * @COGL_PIPELINE_FLUSH_FALLBACK_MASK: The fallback_layers member is set to - * a uint32_t mask of the layers that can't be supported with the user - * supplied texture and need to be replaced with fallback textures. (1 = - * fallback, and the least significant bit = layer 0) - * @COGL_PIPELINE_FLUSH_DISABLE_MASK: The disable_layers member is set to - * a uint32_t mask of the layers that you want to completely disable - * texturing for (1 = fallback, and the least significant bit = layer 0) - * @COGL_PIPELINE_FLUSH_LAYER0_OVERRIDE: The layer0_override_texture member is - * set to a GLuint OpenGL texture name to override the texture used for - * layer 0 of the pipeline. This is intended for dealing with sliced - * textures where you will need to point to each of the texture slices in - * turn when drawing your geometry. Passing a value of 0 is the same as - * not passing the option at all. - * @COGL_PIPELINE_FLUSH_SKIP_GL_COLOR: When flushing the GL state for the - * pipeline don't call glColor. - */ -typedef enum _CoglPipelineFlushFlag -{ - COGL_PIPELINE_FLUSH_FALLBACK_MASK = 1L<<0, - COGL_PIPELINE_FLUSH_DISABLE_MASK = 1L<<1, - COGL_PIPELINE_FLUSH_LAYER0_OVERRIDE = 1L<<2, - COGL_PIPELINE_FLUSH_SKIP_GL_COLOR = 1L<<3 -} CoglPipelineFlushFlag; - -/* - * CoglPipelineFlushOptions: - * - */ -typedef struct _CoglPipelineFlushOptions -{ - CoglPipelineFlushFlag flags; - - uint32_t fallback_layers; - uint32_t disable_layers; - CoglTexture *layer0_override_texture; -} CoglPipelineFlushOptions; - -unsigned int -_cogl_get_n_args_for_combine_func (CoglPipelineCombineFunc func); - -/* - * _cogl_pipeline_weak_copy: - * @pipeline: A #CoglPipeline object - * @callback: A callback to notify when your weak pipeline is destroyed - * @user_data: Private data to pass to your given callback. - * - * Returns a weak copy of the given source @pipeline. Unlike a normal - * copy no internal reference is taken on the source @pipeline and you - * can expect that later modifications of the source pipeline (or in - * fact any other pipeline) can result in the weak pipeline being - * destroyed. - * - * To understand this better its good to know a bit about the internal - * design of #CoglPipeline... - * - * Internally #CoglPipeline<!-- -->s are represented as a graph of - * property diff's, where each node is a diff of properties that gets - * applied on top of its parent. Copying a pipeline creates an empty - * diff and a child->parent relationship between the empty diff and - * the source @pipeline, parent. - * - * Because of this internal graph design a single #CoglPipeline may - * indirectly depend on a chain of ancestors to fully define all of - * its properties. Because a node depends on its ancestors it normally - * owns a reference to its parent to stop it from being freed. Also if - * you try to modify a pipeline with children we internally use a - * copy-on-write mechanism to ensure that you don't indirectly change - * the properties those children. - * - * Weak pipelines avoid the use of copy-on-write to preserve the - * integrity of weak dependants and instead weak dependants are - * simply destroyed allowing the parent to be modified directly. Also - * because weak pipelines don't own a reference to their parent they - * won't stop the source @pipeline from being freed when the user - * releases their reference on it. - * - * Because weak pipelines don't own a reference on their parent they - * are the recommended mechanism for creating derived pipelines that you - * want to cache as a private property of the original pipeline - * because they won't result in a circular dependency. - * - * An example use case: - * - * Consider for example you are implementing a custom primitive that is - * not compatible with certain source pipelines. To handle this you - * implement a validation stage that given an arbitrary pipeline as - * input will create a derived pipeline that is suitable for drawing - * your primitive. - * - * Because you don't want to have to repeat this validation every time - * the same incompatible pipeline is given as input you want to cache - * the result as a private property of the original pipeline. If the - * derived pipeline were created using cogl_pipeline_copy that would - * create a circular dependency so the original pipeline can never be - * freed. - * - * If you instead create a weak copy you won't stop the original pipeline - * from being freed if it's no longer needed, and you will instead simply - * be notified that your weak pipeline has been destroyed. - * - * This is the recommended coding pattern for validating an input - * pipeline and caching a derived result: - * |[ - * static CoglUserDataKey _cogl_my_cache_key; - * - * typedef struct { - * CoglPipeline *validated_source; - * } MyValidatedMaterialCache; - * - * static void - * destroy_cache_cb (CoglObject *object, void *user_data) - * { - * g_free (user_data); - * } - * - * static void - * invalidate_cache_cb (CoglPipeline *destroyed, void *user_data) - * { - * MyValidatedMaterialCache *cache = user_data; - * cogl_object_unref (cache->validated_source); - * cache->validated_source = NULL; - * } - * - * static CoglPipeline * - * get_validated_pipeline (CoglPipeline *source) - * { - * MyValidatedMaterialCache *cache = - * cogl_object_get_user_data (COGL_OBJECT (source), - * &_cogl_my_cache_key); - * if (G_UNLIKELY (cache == NULL)) - * { - * cache = g_new0 (MyValidatedMaterialCache, 1); - * cogl_object_set_user_data (COGL_OBJECT (source), - * &_cogl_my_cache_key, - * cache, destroy_cache_cb); - * cache->validated_source = source; - * } - * - * if (G_UNLIKELY (cache->validated_source == NULL)) - * { - * cache->validated_source = source; - * - * / * Start validating source... * / - * - * / * If you find you need to change something... * / - * if (cache->validated_source == source) - * cache->validated_source = - * cogl_pipeline_weak_copy (source, - * invalidate_cache_cb, - * cache); - * - * / * Modify cache->validated_source * / - * } - * - * return cache->validated_source; - * } - * ]| - */ -CoglPipeline * -_cogl_pipeline_weak_copy (CoglPipeline *pipeline, - CoglPipelineDestroyCallback callback, - void *user_data); - -void -_cogl_pipeline_set_progend (CoglPipeline *pipeline, int progend); - -void -_cogl_pipeline_get_colorubv (CoglPipeline *pipeline, - uint8_t *color); - -/* XXX: At some point it could be good for this to accept a mask of - * the state groups we are interested in comparing since we can - * probably use that information in a number situations to reduce - * the work we do. */ -unsigned long -_cogl_pipeline_compare_differences (CoglPipeline *pipeline0, - CoglPipeline *pipeline1); - -gboolean -_cogl_pipeline_equal (CoglPipeline *pipeline0, - CoglPipeline *pipeline1, - unsigned int differences, - unsigned long layer_differences, - CoglPipelineEvalFlags flags); - -unsigned int -_cogl_pipeline_hash (CoglPipeline *pipeline, - unsigned int differences, - unsigned long layer_differences, - CoglPipelineEvalFlags flags); - -/* Makes a copy of the given pipeline that is a child of the root - * pipeline rather than a child of the source pipeline. That way the - * new pipeline won't hold a reference to the source pipeline. The - * differences specified in @differences and @layer_differences are - * copied across and all other state is left with the default - * values. */ -CoglPipeline * -_cogl_pipeline_deep_copy (CoglPipeline *pipeline, - unsigned long differences, - unsigned long layer_differences); - -CoglPipeline * -_cogl_pipeline_journal_ref (CoglPipeline *pipeline); - -void -_cogl_pipeline_journal_unref (CoglPipeline *pipeline); - -const graphene_matrix_t * -_cogl_pipeline_get_layer_matrix (CoglPipeline *pipeline, - int layer_index); - -void -_cogl_pipeline_texture_storage_change_notify (CoglTexture *texture); - -void -_cogl_pipeline_apply_legacy_state (CoglPipeline *pipeline); - -void -_cogl_pipeline_apply_overrides (CoglPipeline *pipeline, - CoglPipelineFlushOptions *options); - -#ifdef COGL_DEBUG_ENABLED -void -_cogl_pipeline_set_static_breadcrumb (CoglPipeline *pipeline, - const char *breadcrumb); -#endif - -unsigned long -_cogl_pipeline_get_age (CoglPipeline *pipeline); - -void -_cogl_pipeline_add_layer_difference (CoglPipeline *pipeline, - CoglPipelineLayer *layer, - gboolean inc_n_layers); - -void -_cogl_pipeline_remove_layer_difference (CoglPipeline *pipeline, - CoglPipelineLayer *layer, - gboolean dec_n_layers); - -CoglPipeline * -_cogl_pipeline_find_equivalent_parent (CoglPipeline *pipeline, - CoglPipelineState pipeline_state, - CoglPipelineLayerState layer_state); - -void -_cogl_pipeline_get_layer_combine_constant (CoglPipeline *pipeline, - int layer_index, - float *constant); - -COGL_EXPORT void -_cogl_pipeline_prune_to_n_layers (CoglPipeline *pipeline, int n); - - -/* - * API to support the deprecate cogl_pipeline_layer_xyz functions... - */ - -typedef gboolean (*CoglPipelineInternalLayerCallback) (CoglPipelineLayer *layer, - void *user_data); - -COGL_EXPORT void -_cogl_pipeline_foreach_layer_internal (CoglPipeline *pipeline, - CoglPipelineInternalLayerCallback callback, - void *user_data); - -gboolean -_cogl_pipeline_layer_numbers_equal (CoglPipeline *pipeline0, - CoglPipeline *pipeline1); - -gboolean -_cogl_pipeline_layer_and_unit_numbers_equal (CoglPipeline *pipeline0, - CoglPipeline *pipeline1); - -gboolean -_cogl_pipeline_need_texture_combine_separate - (CoglPipelineLayer *combine_authority); - -void -_cogl_pipeline_init_state_hash_functions (void); - -void -_cogl_pipeline_init_layer_state_hash_functions (void); - -CoglPipelineState -_cogl_pipeline_get_state_for_vertex_codegen (CoglContext *context); - -CoglPipelineLayerState -_cogl_pipeline_get_layer_state_for_fragment_codegen (CoglContext *context); - -CoglPipelineState -_cogl_pipeline_get_state_for_fragment_codegen (CoglContext *context); - -#endif /* __COGL_PIPELINE_PRIVATE_H */ - |