OgreShaderProgramManager.h
Go to the documentation of this file.
1 /*
2 -----------------------------------------------------------------------------
3 This source file is part of OGRE
4 (Object-oriented Graphics Rendering Engine)
5 For the latest info, see http://www.ogre3d.org
6 
7 Copyright (c) 2000-2013 Torus Knot Software Ltd
8 Permission is hereby granted, free of charge, to any person obtaining a copy
9 of this software and associated documentation files (the "Software"), to deal
10 in the Software without restriction, including without limitation the rights
11 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 copies of the Software, and to permit persons to whom the Software is
13 furnished to do so, subject to the following conditions:
14 
15 The above copyright notice and this permission notice shall be included in
16 all copies or substantial portions of the Software.
17 
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 THE SOFTWARE.
25 -----------------------------------------------------------------------------
26 */
27 #ifndef _ShaderProgramManager_
28 #define _ShaderProgramManager_
29 
31 #include "OgreShaderProgram.h"
33 
34 namespace Ogre {
35 namespace RTShader {
36 
46 class _OgreRTSSExport ProgramManager : public Singleton<ProgramManager>, public RTShaderSystemAlloc
47 {
48 // Interface.
49 public:
50 
53 
56 
57 
74 
91 
96  void acquirePrograms(Pass* pass, TargetRenderState* renderState);
97 
102  void releasePrograms(Pass* pass, TargetRenderState* renderState);
103 
107 
108 protected:
109 
110  //-----------------------------------------------------------------------------
112  typedef GpuProgramsMap::iterator GpuProgramsMapIterator;
113  typedef GpuProgramsMap::const_iterator GpuProgramsMapConstIterator;
114 
115  //-----------------------------------------------------------------------------
117  typedef ProgramList::iterator ProgramListIterator;
119  typedef ProgramWriterMap::iterator ProgramWriterIterator;
121 
122  //-----------------------------------------------------------------------------
124  typedef ProgramProcessorMap::iterator ProgramProcessorIterator;
125  typedef ProgramProcessorMap::const_iterator ProgramProcessorConstIterator;
127 
128 
129 protected:
132 
135 
138 
141 
144 
149 
153  void destroyCpuProgram(Program* shaderProgram);
154 
158  bool createGpuPrograms(ProgramSet* programSet);
159 
165  String generateGUID(const String& programString);
166 
176  ProgramWriter* programWriter,
177  const String& language,
178  const String& profiles,
179  const StringVector& profilesList,
180  const String& cachePath);
181 
187 
193 
197  void destroyGpuProgram(GpuProgramPtr& gpuProgram);
198 
202  void flushGpuProgramsCache(GpuProgramsMap& gpuProgramsMap);
203 
205  size_t getVertexShaderCount() const { return mVertexShaderMap.size(); }
206 
208  size_t getFragmentShaderCount() const { return mFragmentShaderMap.size(); }
209 
212 
214  void bindUniformParameters(Program* pCpuProgram, const GpuProgramParametersSharedPtr& passParams);
215 
216 
217 protected:
218 
219 
220 protected:
221  // CPU programs list.
223  // Map between target language and shader program writer.
225  // Map between target language and shader program processor.
227  // Holds standard shader writer factories
229  // The generated vertex shaders.
231  // The generated fragment shaders.
233  // The default program processors.
235 
236 private:
237  friend class ProgramSet;
238  friend class TargetRenderState;
239  friend class ShaderGenerator;
240 };
241 
245 }
246 }
247 
248 #endif
249 
Ogre::RTShader::ProgramManager::releasePrograms
void releasePrograms(Pass *pass, TargetRenderState *renderState)
Release CPU/GPU programs set associated with the given render state and pass.
Ogre::RTShader::ProgramManager::GpuProgramsMapConstIterator
GpuProgramsMap::const_iterator GpuProgramsMapConstIterator
Definition: OgreShaderProgramManager.h:113
Ogre::RTShader::ProgramManager::createDefaultProgramProcessors
void createDefaultProgramProcessors()
Create default program processors.
Ogre::RTShader::ProgramManager::createDefaultProgramWriterFactories
void createDefaultProgramWriterFactories()
Create default program processors.
Ogre::AllocatedObject
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
Definition: OgreMemoryAllocatedObject.h:59
Ogre
Definition: OgreAndroidLogListener.h:35
OgreShaderProgramWriter.h
Ogre::map
Definition: OgrePrerequisites.h:534
Ogre::RTShader::ProgramManager::destroyDefaultProgramWriterFactories
void destroyDefaultProgramWriterFactories()
Destroy default program processors.
Ogre::set
Definition: OgrePrerequisites.h:520
Ogre::RTShader::ProgramManager::ProgramManager
ProgramManager()
Class default constructor.
Ogre::RTShader::ProgramManager::flushGpuProgramsCache
void flushGpuProgramsCache()
Flush the local GPU programs cache.
Ogre::RTShader::ProgramManager::ProgramWriterFactoryList
vector< ProgramWriterFactory * >::type ProgramWriterFactoryList
Definition: OgreShaderProgramManager.h:120
Ogre::RTShader::ProgramSet
Container class for shader based programs.
Definition: OgreShaderProgramSet.h:47
Ogre::StringVector
vector< String >::type StringVector
Definition: OgreStringVector.h:45
Ogre::RTShader::ProgramManager::getFragmentShaderCount
size_t getFragmentShaderCount() const
Return the number of created fragment shaders.
Definition: OgreShaderProgramManager.h:208
Ogre::RTShader::ProgramManager::mFragmentShaderMap
GpuProgramsMap mFragmentShaderMap
Definition: OgreShaderProgramManager.h:232
Ogre::RTShader::ProgramManager::createCpuProgram
Program * createCpuProgram(GpuProgramType type)
Create CPU program .
Ogre::RTShader::ProgramManager::synchronizePixelnToBeVertexOut
void synchronizePixelnToBeVertexOut(ProgramSet *programSet)
Fix the input of the pixel shader to be the same as the output of the vertex shader.
Ogre::RTShader::ProgramManager::acquirePrograms
void acquirePrograms(Pass *pass, TargetRenderState *renderState)
Acquire CPU/GPU programs set associated with the given render state and bind them to the pass.
Ogre::RTShader::ProgramManager::~ProgramManager
~ProgramManager()
Class destructor.
Ogre::RTShader::ProgramWriter
Base class interface for shader program writers.
Definition: OgreShaderProgramWriter.h:53
Ogre::String
_StringBase String
Definition: OgrePrerequisites.h:439
Ogre::RTShader::ProgramManager::mProgramProcessorsMap
ProgramProcessorMap mProgramProcessorsMap
Definition: OgreShaderProgramManager.h:226
Ogre::Pass
Class defining a single pass of a Technique (of a Material), i.e.
Definition: OgrePass.h:81
OgreShaderPrerequisites.h
Ogre::RTShader::ProgramManager::mVertexShaderMap
GpuProgramsMap mVertexShaderMap
Definition: OgreShaderProgramManager.h:230
Ogre::RTShader::ProgramManager::flushGpuProgramsCache
void flushGpuProgramsCache(GpuProgramsMap &gpuProgramsMap)
Flush the local GPU programs cache.
Ogre::RTShader::ProgramManager::ProgramProcessorMap
map< String, ProgramProcessor * >::type ProgramProcessorMap
Definition: OgreShaderProgramManager.h:123
Ogre::RTShader::ProgramManager::generateGUID
String generateGUID(const String &programString)
Generates a unique guid value from a string.
Ogre::GpuProgramType
GpuProgramType
Enumerates the types of programs which can run on the GPU.
Definition: OgreGpuProgram.h:51
Ogre::RTShader::ProgramManager::destroyDefaultProgramProcessors
void destroyDefaultProgramProcessors()
Destroy default program processors.
Ogre::RTShader::ProgramManager::mProgramWritersMap
ProgramWriterMap mProgramWritersMap
Definition: OgreShaderProgramManager.h:224
Ogre::RTShader::ProgramManager::bindUniformParameters
void bindUniformParameters(Program *pCpuProgram, const GpuProgramParametersSharedPtr &passParams)
Bind the uniform parameters of a given CPU and GPU program set.
Ogre::RTShader::Program
A class that represents a shader based program.
Definition: OgreShaderProgram.h:51
Ogre::RTShader::ProgramManager::addProgramProcessor
void addProgramProcessor(ProgramProcessor *processor)
Add program processor instance to this manager.
Ogre::Singleton
Template class for creating single-instance global classes.
Definition: OgreSingleton.h:65
Ogre::RTShader::ProgramManager::ProgramList
set< Program * >::type ProgramList
Definition: OgreShaderProgramManager.h:116
Ogre::RTShader::ProgramManager::createGpuProgram
GpuProgramPtr createGpuProgram(Program *shaderProgram, ProgramWriter *programWriter, const String &language, const String &profiles, const StringVector &profilesList, const String &cachePath)
Create GPU program based on the give CPU program.
Ogre::RTShader::ProgramManager::getSingleton
static ProgramManager & getSingleton()
Override standard Singleton retrieval.
Ogre::RTShader::ProgramManager::GpuProgramsMapIterator
GpuProgramsMap::iterator GpuProgramsMapIterator
Definition: OgreShaderProgramManager.h:112
Ogre::RTShader::ProgramManager::GpuProgramsMap
map< String, GpuProgramPtr >::type GpuProgramsMap
Definition: OgreShaderProgramManager.h:111
Ogre::RTShader::ProgramManager::ProgramProcessorList
vector< ProgramProcessor * >::type ProgramProcessorList
Definition: OgreShaderProgramManager.h:126
Ogre::RTShader::ProgramManager::mProgramWriterFactories
ProgramWriterFactoryList mProgramWriterFactories
Definition: OgreShaderProgramManager.h:228
Ogre::SharedPtr< GpuProgram >
Ogre::RTShader::ProgramProcessor
A class that provides extra processing services on CPU based programs.
Definition: OgreShaderProgramProcessor.h:50
Ogre::RTShader::ProgramManager
A singleton manager class that manages shader based programs.
Definition: OgreShaderProgramManager.h:47
Ogre::RTShader::ProgramManager::destroyProgramWriters
void destroyProgramWriters()
Destroy all program writers.
Ogre::RTShader::ProgramManager::mCpuProgramsList
ProgramList mCpuProgramsList
Definition: OgreShaderProgramManager.h:222
Ogre::RTShader::ProgramManager::getVertexShaderCount
size_t getVertexShaderCount() const
Return the number of created vertex shaders.
Definition: OgreShaderProgramManager.h:205
Ogre::RTShader::ProgramManager::ProgramWriterMap
map< String, ProgramWriter * >::type ProgramWriterMap
Definition: OgreShaderProgramManager.h:118
Ogre::RTShader::ProgramManager::mDefaultProgramProcessors
ProgramProcessorList mDefaultProgramProcessors
Definition: OgreShaderProgramManager.h:234
Ogre::RTShader::ProgramManager::destroyCpuProgram
void destroyCpuProgram(Program *shaderProgram)
Destroy a CPU program by name.
Ogre::RTShader::TargetRenderState
This is the target render state.
Definition: OgreShaderRenderState.h:139
Ogre::RTShader::ProgramManager::ProgramProcessorIterator
ProgramProcessorMap::iterator ProgramProcessorIterator
Definition: OgreShaderProgramManager.h:124
Ogre::RTShader::ProgramManager::destroyGpuProgram
void destroyGpuProgram(GpuProgramPtr &gpuProgram)
Destroy a GPU program by name.
Ogre::RTShader::ProgramManager::ProgramListIterator
ProgramList::iterator ProgramListIterator
Definition: OgreShaderProgramManager.h:117
OgreShaderProgram.h
Ogre::RTShader::ProgramManager::ProgramProcessorConstIterator
ProgramProcessorMap::const_iterator ProgramProcessorConstIterator
Definition: OgreShaderProgramManager.h:125
Ogre::RTShader::ProgramManager::ProgramWriterIterator
ProgramWriterMap::iterator ProgramWriterIterator
Definition: OgreShaderProgramManager.h:119
Ogre::vector
Definition: OgrePrerequisites.h:492
Ogre::RTShader::ProgramManager::createGpuPrograms
bool createGpuPrograms(ProgramSet *programSet)
Create GPU programs for the given program set based on the CPU programs it contains.
Ogre::RTShader::ShaderGenerator
Shader generator system main interface.
Definition: OgreShaderGenerator.h:54
Ogre::RTShader::ProgramManager::removeProgramProcessor
void removeProgramProcessor(ProgramProcessor *processor)
Remove program processor instance from this manager.
Ogre::RTShader::ProgramManager::getSingletonPtr
static ProgramManager * getSingletonPtr()
Override standard Singleton retrieval.
_OgreRTSSExport
#define _OgreRTSSExport
Definition: OgreShaderPrerequisites.h:108

Copyright © 2012 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.