OgreTerrainMaterialGenerator.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 
9 Permission is hereby granted, free of charge, to any person obtaining a copy
10 of this software and associated documentation files (the "Software"), to deal
11 in the Software without restriction, including without limitation the rights
12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 copies of the Software, and to permit persons to whom the Software is
14 furnished to do so, subject to the following conditions:
15 
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
18 
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 THE SOFTWARE.
26 -----------------------------------------------------------------------------
27 */
28 
29 #ifndef __Ogre_TerrainMaterialGenerator_H__
30 #define __Ogre_TerrainMaterialGenerator_H__
31 
33 #include "OgrePixelFormat.h"
34 #include "OgreMaterial.h"
35 #include "OgreTexture.h"
36 
37 namespace Ogre
38 {
39  class Terrain;
40 
57  {
66  };
67 
71  {
80 
82  {
83  return source == e.source &&
84  semantic == e.semantic &&
85  elementStart == e.elementStart &&
86  elementCount == e.elementCount;
87  }
88 
90  source(0), semantic(TLSS_ALBEDO), elementStart(0), elementCount(0)
91  {}
92 
94  uint8 elemStart, uint8 elemCount)
95  : source(src), semantic(sem), elementStart(elemStart), elementCount(elemCount)
96  {
97  }
98  };
100 
104  {
109 
110  bool operator==(const TerrainLayerSampler& s) const
111  {
112  return alias == s.alias && format == s.format;
113  }
114 
116  : alias(""), format(PF_UNKNOWN)
117  {
118  }
119 
120  TerrainLayerSampler(const String& aliasName, PixelFormat fmt)
121  : alias(aliasName), format(fmt)
122  {
123  }
124  };
126 
132  {
135 
136  bool operator==(const TerrainLayerDeclaration& dcl) const
137  {
138  return samplers == dcl.samplers && elements == dcl.elements;
139  }
140  };
141 
162  {
163  public:
168  {
169  protected:
173  public:
174  Profile(TerrainMaterialGenerator* parent, const String& name, const String& desc)
175  : mParent(parent), mName(name), mDesc(desc) {}
176  Profile(const Profile& prof)
177  : mParent(prof.mParent), mName(prof.mName), mDesc(prof.mDesc) {}
178  virtual ~Profile() {}
180  TerrainMaterialGenerator* getParent() const { return mParent; }
182  const String& getName() const { return mName; }
184  const String& getDescription() const { return mDesc; }
186  virtual bool isVertexCompressionSupported() const = 0;
188  virtual MaterialPtr generate(const Terrain* terrain) = 0;
190  virtual MaterialPtr generateForCompositeMap(const Terrain* terrain) = 0;
192  virtual void setLightmapEnabled(bool enabled) = 0;
194  virtual uint8 getMaxLayers(const Terrain* terrain) const = 0;
196  virtual void updateCompositeMap(const Terrain* terrain, const Rect& rect);
197 
199  virtual void updateParams(const MaterialPtr& mat, const Terrain* terrain) = 0;
201  virtual void updateParamsForCompositeMap(const MaterialPtr& mat, const Terrain* terrain) = 0;
202 
204  virtual void requestOptions(Terrain* terrain) = 0;
205 
206  };
207 
209  virtual ~TerrainMaterialGenerator();
210 
213 
216  virtual const ProfileList& getProfiles() const { return mProfiles; }
217 
219  virtual void setActiveProfile(const String& name)
220  {
221  if (!mActiveProfile || mActiveProfile->getName() != name)
222  {
223  for (ProfileList::iterator i = mProfiles.begin(); i != mProfiles.end(); ++i)
224  {
225  if ((*i)->getName() == name)
226  {
227  setActiveProfile(*i);
228  break;
229  }
230  }
231  }
232 
233  }
234 
236  virtual void setActiveProfile(Profile* p)
237  {
238  if (mActiveProfile != p)
239  {
240  mActiveProfile = p;
241  _markChanged();
242  }
243  }
246  {
247  // default if not chosen yet
248  if (!mActiveProfile && !mProfiles.empty())
249  mActiveProfile = mProfiles[0];
250 
251  return mActiveProfile;
252  }
253 
255  void _markChanged() { ++mChangeCounter; }
256 
260  unsigned long long int getChangeCount() const { return mChangeCounter; }
261 
264  virtual const TerrainLayerDeclaration& getLayerDeclaration() const { return mLayerDecl; }
272  {
273  return decl == mLayerDecl;
274  }
275 
279  virtual bool isVertexCompressionSupported() const
280  {
281  return getActiveProfile()->isVertexCompressionSupported();
282  }
283 
286  virtual void requestOptions(Terrain* terrain)
287  {
288  Profile* p = getActiveProfile();
289  if (p)
290  p->requestOptions(terrain);
291 
292  }
295  virtual MaterialPtr generate(const Terrain* terrain)
296  {
297  Profile* p = getActiveProfile();
298  if (!p)
299  return MaterialPtr();
300  else
301  return p->generate(terrain);
302  }
306  {
307  Profile* p = getActiveProfile();
308  if (!p)
309  return MaterialPtr();
310  else
311  return p->generateForCompositeMap(terrain);
312  }
316  virtual void setLightmapEnabled(bool enabled)
317  {
318  Profile* p = getActiveProfile();
319  if (p)
320  return p->setLightmapEnabled(enabled);
321  }
325  virtual uint8 getMaxLayers(const Terrain* terrain) const
326  {
327  Profile* p = getActiveProfile();
328  if (p)
329  return p->getMaxLayers(terrain);
330  else
331  return 0;
332  }
333 
340  virtual void updateCompositeMap(const Terrain* terrain, const Rect& rect)
341  {
342  Profile* p = getActiveProfile();
343  if (!p)
344  return;
345  else
346  p->updateCompositeMap(terrain, rect);
347  }
348 
349 
352  virtual void updateParams(const MaterialPtr& mat, const Terrain* terrain)
353  {
354  Profile* p = getActiveProfile();
355  if (p)
356  p->updateParams(mat, terrain);
357  }
360  virtual void updateParamsForCompositeMap(const MaterialPtr& mat, const Terrain* terrain)
361  {
362  Profile* p = getActiveProfile();
363  if (p)
364  p->updateParamsForCompositeMap(mat, terrain);
365  }
366 
375  virtual void setDebugLevel(unsigned int dbg)
376  {
377  if (mDebugLevel != dbg)
378  {
379  mDebugLevel = dbg;
380  _markChanged();
381  }
382  }
384  virtual unsigned int getDebugLevel() const { return mDebugLevel; }
385 
392  virtual void _renderCompositeMap(size_t size, const Rect& rect,
393  const MaterialPtr& mat, const TexturePtr& destCompositeMap);
394 
395  Texture* _getCompositeMapRTT() { return mCompositeMapRTT; }
396  protected:
397 
400  unsigned long long int mChangeCounter;
402  unsigned int mDebugLevel;
405  Texture* mCompositeMapRTT; // deliberately holding this by raw pointer to avoid shutdown issues
408 
409 
410 
411  };
412 
414 
418 }
419 #endif
420 
Ogre::TerrainMaterialGenerator::updateCompositeMap
virtual void updateCompositeMap(const Terrain *terrain, const Rect &rect)
Update the composite map for a terrain.
Definition: OgreTerrainMaterialGenerator.h:340
Ogre::Texture
Abstract class representing a Texture resource.
Definition: OgreTexture.h:102
Ogre::TerrainLayerSamplerElement::source
uint8 source
The source sampler index of this element relative to LayerDeclaration's list.
Definition: OgreTerrainMaterialGenerator.h:73
Ogre::TerrainMaterialGenerator::getActiveProfile
Profile * getActiveProfile() const
Get the active profile.
Definition: OgreTerrainMaterialGenerator.h:245
Ogre::AllocatedObject
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
Definition: OgreMemoryAllocatedObject.h:58
Ogre::PF_UNKNOWN
Unknown pixel format.
Definition: OgrePixelFormat.h:46
Ogre
Definition: OgreAndroidLogListener.h:34
OgrePixelFormat.h
Ogre::TerrainMaterialGenerator::Profile::Profile
Profile(TerrainMaterialGenerator *parent, const String &name, const String &desc)
Definition: OgreTerrainMaterialGenerator.h:174
Ogre::TerrainMaterialGenerator
Class that provides functionality to generate materials for use with a terrain.
Definition: OgreTerrainMaterialGenerator.h:161
Ogre::TerrainMaterialGenerator::Profile::mDesc
String mDesc
Definition: OgreTerrainMaterialGenerator.h:172
Ogre::TerrainMaterialGenerator::mLayerDecl
TerrainLayerDeclaration mLayerDecl
Definition: OgreTerrainMaterialGenerator.h:401
Ogre::Camera
A viewpoint from which the scene will be rendered.
Definition: OgreCamera.h:86
Ogre::TerrainMaterialGenerator::getMaxLayers
virtual uint8 getMaxLayers(const Terrain *terrain) const
Get the maximum number of layers supported with the given terrain.
Definition: OgreTerrainMaterialGenerator.h:325
Ogre::TerrainLayerSampler::TerrainLayerSampler
TerrainLayerSampler(const String &aliasName, PixelFormat fmt)
Definition: OgreTerrainMaterialGenerator.h:120
Ogre::TerrainMaterialGenerator::Profile::getParent
TerrainMaterialGenerator * getParent() const
Get the generator which owns this profile.
Definition: OgreTerrainMaterialGenerator.h:180
Ogre::TerrainMaterialGenerator::Profile::getMaxLayers
virtual uint8 getMaxLayers(const Terrain *terrain) const =0
Get the number of layers supported.
Ogre::TLSS_NORMAL
Tangent-space normal information from a detail texture.
Definition: OgreTerrainMaterialGenerator.h:61
Ogre::TerrainLayerDeclaration::elements
TerrainLayerSamplerElementList elements
Definition: OgreTerrainMaterialGenerator.h:134
Ogre::TerrainMaterialGenerator::Profile::~Profile
virtual ~Profile()
Definition: OgreTerrainMaterialGenerator.h:178
Ogre::TerrainLayerSampler::format
PixelFormat format
The format required of this texture.
Definition: OgreTerrainMaterialGenerator.h:108
_OgreTerrainExport
#define _OgreTerrainExport
Definition: OgreTerrainPrerequisites.h:58
Ogre::TRect< long >
Ogre::TerrainMaterialGenerator::Profile::Profile
Profile(const Profile &prof)
Definition: OgreTerrainMaterialGenerator.h:176
Ogre::MaterialPtr
SharedPtr< Material > MaterialPtr
Definition: OgrePrerequisites.h:314
Ogre::Light
Representation of a dynamic light source in the scene.
Definition: OgreLight.h:73
Ogre::Terrain
The main containing class for a chunk of terrain.
Definition: OgreTerrain.h:262
Ogre::TerrainMaterialGenerator::Profile::getName
const String & getName() const
Get the name of this profile.
Definition: OgreTerrainMaterialGenerator.h:182
Ogre::TerrainLayerDeclaration::samplers
TerrainLayerSamplerList samplers
Definition: OgreTerrainMaterialGenerator.h:133
Ogre::TerrainLayerSamplerElement::semantic
TerrainLayerSamplerSemantic semantic
The semantic this element represents.
Definition: OgreTerrainMaterialGenerator.h:75
Ogre::TerrainLayerSampler::TerrainLayerSampler
TerrainLayerSampler()
Definition: OgreTerrainMaterialGenerator.h:115
Ogre::TerrainMaterialGenerator::Profile::setLightmapEnabled
virtual void setLightmapEnabled(bool enabled)=0
Whether to support a light map over the terrain in the shader, if it's present (default true)
Ogre::ManualObject
Class providing a much simplified interface to generating manual objects with custom geometry.
Definition: OgreManualObject.h:106
Ogre::TerrainLayerDeclaration
The definition of the information each layer will contain in this terrain.
Definition: OgreTerrainMaterialGenerator.h:131
Ogre::TerrainMaterialGenerator::Profile
Inner class which should also be subclassed to provide profile-specific material generation.
Definition: OgreTerrainMaterialGenerator.h:167
Ogre::String
_StringBase String
Definition: OgrePrerequisites.h:439
Ogre::TerrainLayerSampler::alias
String alias
A descriptive name that is merely used to assist in recognition.
Definition: OgreTerrainMaterialGenerator.h:106
Ogre::TerrainMaterialGenerator::generateForCompositeMap
virtual MaterialPtr generateForCompositeMap(const Terrain *terrain)
Generate a material for the given composite map of the terrain using the active profile.
Definition: OgreTerrainMaterialGenerator.h:305
Ogre::TerrainMaterialGenerator::getLayerDeclaration
virtual const TerrainLayerDeclaration & getLayerDeclaration() const
Get the layer declaration that this material generator operates with.
Definition: OgreTerrainMaterialGenerator.h:264
Ogre::TerrainMaterialGenerator::_getCompositeMapRTT
Texture * _getCompositeMapRTT()
Definition: OgreTerrainMaterialGenerator.h:395
OgreMaterial.h
Ogre::TerrainMaterialGenerator::updateParamsForCompositeMap
virtual void updateParamsForCompositeMap(const MaterialPtr &mat, const Terrain *terrain)
Update parameters for the given terrain composite map using the active profile.
Definition: OgreTerrainMaterialGenerator.h:360
OgreTerrainPrerequisites.h
Ogre::TerrainMaterialGenerator::mActiveProfile
Profile * mActiveProfile
Definition: OgreTerrainMaterialGenerator.h:399
Ogre::TerrainMaterialGenerator::setDebugLevel
virtual void setDebugLevel(unsigned int dbg)
Set the debug level of the material.
Definition: OgreTerrainMaterialGenerator.h:375
Ogre::TerrainMaterialGenerator::updateParams
virtual void updateParams(const MaterialPtr &mat, const Terrain *terrain)
Update parameters for the given terrain using the active profile.
Definition: OgreTerrainMaterialGenerator.h:352
Ogre::TerrainLayerSamplerElementList
vector< TerrainLayerSamplerElement >::type TerrainLayerSamplerElementList
Definition: OgreTerrainMaterialGenerator.h:99
Ogre::PixelFormat
PixelFormat
The pixel format used for images, textures, and render surfaces.
Definition: OgrePixelFormat.h:43
Ogre::SceneManager
Manages the organisation and rendering of a 'scene' i.e.
Definition: OgreSceneManager.h:143
OgreTexture.h
Ogre::TerrainLayerSamplerElement::elementCount
uint8 elementCount
The number of colour elements this semantic uses (usually standard per semantic)
Definition: OgreTerrainMaterialGenerator.h:79
Ogre::TerrainMaterialGenerator::mCompositeMapCam
Camera * mCompositeMapCam
Definition: OgreTerrainMaterialGenerator.h:404
Ogre::TerrainMaterialGenerator::setActiveProfile
virtual void setActiveProfile(const String &name)
Set the active profile by name.
Definition: OgreTerrainMaterialGenerator.h:219
Ogre::TerrainLayerSamplerElement::elementStart
uint8 elementStart
The colour element at which this element starts.
Definition: OgreTerrainMaterialGenerator.h:77
Ogre::TerrainLayerSamplerElement::TerrainLayerSamplerElement
TerrainLayerSamplerElement()
Definition: OgreTerrainMaterialGenerator.h:89
Ogre::TerrainMaterialGenerator::Profile::generate
virtual MaterialPtr generate(const Terrain *terrain)=0
Generate / reuse a material for the terrain.
Ogre::TerrainMaterialGenerator::isVertexCompressionSupported
virtual bool isVertexCompressionSupported() const
Return whether this material generator supports using a compressed vertex format.
Definition: OgreTerrainMaterialGenerator.h:279
Ogre::TerrainMaterialGenerator::Profile::updateCompositeMap
virtual void updateCompositeMap(const Terrain *terrain, const Rect &rect)
Update the composite map for a terrain.
Ogre::TerrainMaterialGenerator::setLightmapEnabled
virtual void setLightmapEnabled(bool enabled)
Whether to support a light map over the terrain in the shader, if it's present (default true).
Definition: OgreTerrainMaterialGenerator.h:316
Ogre::TerrainMaterialGenerator::generate
virtual MaterialPtr generate(const Terrain *terrain)
Generate a material for the given terrain using the active profile.
Definition: OgreTerrainMaterialGenerator.h:295
Ogre::TerrainMaterialGenerator::Profile::generateForCompositeMap
virtual MaterialPtr generateForCompositeMap(const Terrain *terrain)=0
Generate / reuse a material for the terrain.
Ogre::TLSS_ALBEDO
Albedo colour (diffuse reflectance colour)
Definition: OgreTerrainMaterialGenerator.h:59
Ogre::TerrainMaterialGenerator::canGenerateUsingDeclaration
virtual bool canGenerateUsingDeclaration(const TerrainLayerDeclaration &decl)
Whether this generator can generate a material for a given declaration.
Definition: OgreTerrainMaterialGenerator.h:271
Ogre::TerrainMaterialGenerator::Profile::requestOptions
virtual void requestOptions(Terrain *terrain)=0
Request the options needed from the terrain.
Ogre::SharedPtr< Material >
Ogre::TerrainMaterialGenerator::getProfiles
virtual const ProfileList & getProfiles() const
Get the list of profiles that this generator supports.
Definition: OgreTerrainMaterialGenerator.h:216
Ogre::uint8
unsigned char uint8
Definition: OgrePlatform.h:361
Ogre::TerrainMaterialGenerator::Profile::mName
String mName
Definition: OgreTerrainMaterialGenerator.h:171
Ogre::TerrainMaterialGenerator::mCompositeMapRTT
Texture * mCompositeMapRTT
Definition: OgreTerrainMaterialGenerator.h:405
Ogre::TerrainMaterialGeneratorPtr
SharedPtr< TerrainMaterialGenerator > TerrainMaterialGeneratorPtr
Definition: OgreTerrainMaterialGenerator.h:413
Ogre::TLSS_SPECULAR
Specular reflectance.
Definition: OgreTerrainMaterialGenerator.h:65
Ogre::TerrainMaterialGenerator::Profile::updateParams
virtual void updateParams(const MaterialPtr &mat, const Terrain *terrain)=0
Update params for a terrain.
Ogre::TerrainLayerSampler::operator==
bool operator==(const TerrainLayerSampler &s) const
Definition: OgreTerrainMaterialGenerator.h:110
Ogre::TLSS_HEIGHT
Height information for the detail texture.
Definition: OgreTerrainMaterialGenerator.h:63
Ogre::TerrainMaterialGenerator::mCompositeMapSM
SceneManager * mCompositeMapSM
Definition: OgreTerrainMaterialGenerator.h:403
Ogre::TerrainMaterialGenerator::mProfiles
ProfileList mProfiles
Definition: OgreTerrainMaterialGenerator.h:398
Ogre::TerrainMaterialGenerator::mDebugLevel
unsigned int mDebugLevel
Definition: OgreTerrainMaterialGenerator.h:402
Ogre::TerrainMaterialGenerator::getDebugLevel
virtual unsigned int getDebugLevel() const
Get the debug level of the material.
Definition: OgreTerrainMaterialGenerator.h:384
Ogre::TerrainMaterialGenerator::Profile::getDescription
const String & getDescription() const
Get the description of this profile.
Definition: OgreTerrainMaterialGenerator.h:184
Ogre::TerrainLayerSamplerSemantic
TerrainLayerSamplerSemantic
Enumeration of types of data that can be read from textures that are specific to a given layer.
Definition: OgreTerrainMaterialGenerator.h:56
Ogre::TerrainLayerSamplerElement::operator==
bool operator==(const TerrainLayerSamplerElement &e) const
Definition: OgreTerrainMaterialGenerator.h:81
Ogre::TerrainLayerSampler
Description of a sampler that will be used with each layer.
Definition: OgreTerrainMaterialGenerator.h:103
Ogre::TerrainLayerSamplerElement::TerrainLayerSamplerElement
TerrainLayerSamplerElement(uint8 src, TerrainLayerSamplerSemantic sem, uint8 elemStart, uint8 elemCount)
Definition: OgreTerrainMaterialGenerator.h:93
Ogre::TerrainMaterialGenerator::mChangeCounter
unsigned long long int mChangeCounter
Definition: OgreTerrainMaterialGenerator.h:400
Ogre::TerrainMaterialGenerator::Profile::updateParamsForCompositeMap
virtual void updateParamsForCompositeMap(const MaterialPtr &mat, const Terrain *terrain)=0
Update params for a terrain.
Ogre::TerrainMaterialGenerator::requestOptions
virtual void requestOptions(Terrain *terrain)
Triggers the generator to request the options that it needs.
Definition: OgreTerrainMaterialGenerator.h:286
Ogre::TerrainLayerSamplerList
vector< TerrainLayerSampler >::type TerrainLayerSamplerList
Definition: OgreTerrainMaterialGenerator.h:125
Ogre::TerrainLayerSamplerElement
Information about one element of a sampler / texture within a layer.
Definition: OgreTerrainMaterialGenerator.h:70
Ogre::vector
Definition: OgrePrerequisites.h:491
Ogre::TerrainMaterialGenerator::ProfileList
vector< Profile * >::type ProfileList
List of profiles - NB should be ordered in descending complexity.
Definition: OgreTerrainMaterialGenerator.h:212
Ogre::TerrainMaterialGenerator::Profile::mParent
TerrainMaterialGenerator * mParent
Definition: OgreTerrainMaterialGenerator.h:170
Ogre::TerrainMaterialGenerator::mCompositeMapPlane
ManualObject * mCompositeMapPlane
Definition: OgreTerrainMaterialGenerator.h:406
Ogre::TerrainMaterialGenerator::getChangeCount
unsigned long long int getChangeCount() const
Returns the number of times the generator has undergone a change which would require materials to be ...
Definition: OgreTerrainMaterialGenerator.h:260
Ogre::TerrainLayerDeclaration::operator==
bool operator==(const TerrainLayerDeclaration &dcl) const
Definition: OgreTerrainMaterialGenerator.h:136
Ogre::TerrainMaterialGenerator::_markChanged
void _markChanged()
Internal method - indicates that a change has been made that would require material regeneration.
Definition: OgreTerrainMaterialGenerator.h:255
Ogre::TerrainMaterialGenerator::setActiveProfile
virtual void setActiveProfile(Profile *p)
Set the active Profile.
Definition: OgreTerrainMaterialGenerator.h:236
Ogre::TerrainMaterialGenerator::mCompositeMapLight
Light * mCompositeMapLight
Definition: OgreTerrainMaterialGenerator.h:407

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