isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-26 12:52:14 +00:00
Code Issues Packages Projects Releases Wiki Activity
32a0f88b04
mutter/cogl/cogl-pipeline-cache.c

112 lines
3.5 KiB
C
Raw Normal View History

fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 14:55:56 +00:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 16:54:51 +00:00
* Copyright (C) 2011, 2013 Intel Corporation.
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 14:55:56 +00:00
*
* 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/>.
*
*
* Authors:
* Neil Roberts <neil@linux.intel.com>
* Robert Bragg <robert@linux.intel.com>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
cogl-pipeline/cogl-pango: Added forgotten includes It seems that cogl-context-private.h needs to be included before including any of the pipeline-related stuff to avoid build errors on C89 compilers. This is due to the recent cogl-pipeline decoupling, seems like. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-09-23 08:43:05 +00:00
#include "cogl-context-private.h"
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 14:55:56 +00:00
#include "cogl-pipeline-private.h"
#include "cogl-pipeline-cache.h"
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 16:54:51 +00:00
#include "cogl-pipeline-hash-table.h"
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 14:55:56 +00:00
struct _CoglPipelineCache
{
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 16:54:51 +00:00
CoglPipelineHashTable fragment_hash;
CoglPipelineHashTable vertex_hash;
CoglPipelineHashTable combined_hash;
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 14:55:56 +00:00
};
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 16:54:51 +00:00
CoglPipelineCache *
_cogl_pipeline_cache_new (void)
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 14:55:56 +00:00
{
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 16:54:51 +00:00
CoglPipelineCache *cache = g_new (CoglPipelineCache, 1);
unsigned long vertex_state;
unsigned long layer_vertex_state;
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 14:55:56 +00:00
unsigned int fragment_state;
unsigned int layer_fragment_state;
_COGL_GET_CONTEXT (ctx, 0);
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 16:54:51 +00:00
vertex_state =
COGL_PIPELINE_STATE_AFFECTS_VERTEX_CODEGEN;
layer_vertex_state =
COGL_PIPELINE_LAYER_STATE_AFFECTS_VERTEX_CODEGEN;
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 14:55:56 +00:00
fragment_state =
_cogl_pipeline_get_state_for_fragment_codegen (ctx);
layer_fragment_state =
_cogl_pipeline_get_layer_state_for_fragment_codegen (ctx);
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 16:54:51 +00:00
_cogl_pipeline_hash_table_init (&cache->vertex_hash,
vertex_state,
layer_vertex_state,
"vertex shaders");
_cogl_pipeline_hash_table_init (&cache->fragment_hash,
fragment_state,
layer_fragment_state,
"fragment shaders");
_cogl_pipeline_hash_table_init (&cache->combined_hash,
vertex_state | fragment_state,
layer_vertex_state | layer_fragment_state,
"programs");
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 14:55:56 +00:00
return cache;
}
void
build: Hide cogl_pipeline_cache_{new,free}() Those symbols should not be public and were exported as they started with cogl_. (cherry picked from commit 68a55f1dc70ea60fcccbe226029e585886feddc2)
2013-01-01 14:15:25 +00:00
_cogl_pipeline_cache_free (CoglPipelineCache *cache)
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 14:55:56 +00:00
{
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 16:54:51 +00:00
_cogl_pipeline_hash_table_destroy (&cache->fragment_hash);
_cogl_pipeline_hash_table_destroy (&cache->vertex_hash);
_cogl_pipeline_hash_table_destroy (&cache->combined_hash);
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 14:55:56 +00:00
g_free (cache);
}
CoglPipeline *
_cogl_pipeline_cache_get_fragment_template (CoglPipelineCache *cache,
CoglPipeline *key_pipeline)
{
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 16:54:51 +00:00
return _cogl_pipeline_hash_table_get (&cache->fragment_hash,
key_pipeline);
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 14:55:56 +00:00
}
cogl-pipeline: Use the pipeline cache for the GLSL backends The CoglPipelineCache is now extended to store templates for state affecting vertex shaders and combined programs. The GLSL fragend, vertend and progend now uses this to get cached shaders and a program. When a new pipeline is created it will now get hashed three times if the GLSL backends are in use (once for the fragend, once for the vertend and once for the progend). Ideally we should add some way for the progend to check its cache before the fragends and vertends are checked so that it can bypass them entirely if it can find a cached combined program.
2011-06-30 17:34:05 +00:00
CoglPipeline *
_cogl_pipeline_cache_get_vertex_template (CoglPipelineCache *cache,
CoglPipeline *key_pipeline)
{
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 16:54:51 +00:00
return _cogl_pipeline_hash_table_get (&cache->vertex_hash,
key_pipeline);
cogl-pipeline: Use the pipeline cache for the GLSL backends The CoglPipelineCache is now extended to store templates for state affecting vertex shaders and combined programs. The GLSL fragend, vertend and progend now uses this to get cached shaders and a program. When a new pipeline is created it will now get hashed three times if the GLSL backends are in use (once for the fragend, once for the vertend and once for the progend). Ideally we should add some way for the progend to check its cache before the fragends and vertends are checked so that it can bypass them entirely if it can find a cached combined program.
2011-06-30 17:34:05 +00:00
}
CoglPipeline *
_cogl_pipeline_cache_get_combined_template (CoglPipelineCache *cache,
CoglPipeline *key_pipeline)
{
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 16:54:51 +00:00
return _cogl_pipeline_hash_table_get (&cache->combined_hash,
key_pipeline);
cogl-pipeline: Use the pipeline cache for the GLSL backends The CoglPipelineCache is now extended to store templates for state affecting vertex shaders and combined programs. The GLSL fragend, vertend and progend now uses this to get cached shaders and a program. When a new pipeline is created it will now get hashed three times if the GLSL backends are in use (once for the fragend, once for the vertend and once for the progend). Ideally we should add some way for the progend to check its cache before the fragends and vertends are checked so that it can bypass them entirely if it can find a cached combined program.
2011-06-30 17:34:05 +00:00
}
Reference in New Issue Copy Permalink