OgreTechnique.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 #ifndef __Technique_H__
29 #define __Technique_H__
30 
31 #include "OgrePrerequisites.h"
32 #include "OgreIteratorWrappers.h"
33 #include "OgreBlendMode.h"
34 #include "OgreCommon.h"
35 #include "OgrePass.h"
36 #include "OgreIteratorWrappers.h"
38 #include "OgreUserObjectBindings.h"
39 
40 namespace Ogre {
54  {
55  protected:
58  {
59  IPS_COMPILE_DISABLED = -1,
60  IPS_NOT_COMPILED = 0,
61  IPS_COMPILED = 1
62  };
63 
69  // Raw pointer since we don't want child to stop parent's destruction
74  unsigned short mLodIndex;
78  unsigned short mSchemeIndex;
81 
86 
87 
108 
109  // User objects binding.
111 
112  public:
117  {
119  INCLUDE = 0,
121  EXCLUDE = 1
122  };
125  {
129  : vendor(GPU_UNKNOWN), includeOrExclude(EXCLUDE) {}
131  : vendor(v), includeOrExclude(ie) {}
132  };
135  {
140  : includeOrExclude(EXCLUDE), caseSensitive(false) {}
141  GPUDeviceNameRule(const String& pattern, IncludeOrExclude ie, bool caseSen)
142  : devicePattern(pattern), includeOrExclude(ie), caseSensitive(caseSen) {}
143  };
146  protected:
149  public:
151  Technique(Material* parent);
153  Technique(Material* parent, const Technique& oth);
160  bool isSupported(void) const;
164  String _compile(bool autoManageTextureUnits);
168  bool checkHardwareSupport(bool autoManageTextureUnits, StringUtil::StrStreamType& compileErrors);
171  size_t calculateSize(void) const;
172 
183  Pass* createPass(void);
185  Pass* getPass(unsigned short index);
189  Pass* getPass(const String& name);
191  unsigned short getNumPasses(void) const;
193  void removePass(unsigned short index);
195  void removeAllPasses(void);
199  bool movePass(const unsigned short sourceIndex, const unsigned short destinationIndex);
207  Material* getParent(void) const { return mParent; }
208 
211 
213  const String& getResourceGroup(void) const;
214 
223  bool isTransparent(void) const;
224 
230  bool isTransparentSortingEnabled(void) const;
231 
237  bool isTransparentSortingForced(void) const;
238 
240  void _prepare(void);
242  void _unprepare(void);
244  void _load(void);
246  void _unload(void);
247 
249  bool isLoaded(void) const;
250 
253 
272 
273  // -------------------------------------------------------------------------------
274  // The following methods are to make migration from previous versions simpler
275  // and to make code easier to write when dealing with simple materials
276  // They set the properties which have been moved to Pass for all Techniques and all Passes
277 
286  void setPointSize(Real ps);
287 
296  void setAmbient(Real red, Real green, Real blue);
297 
306  void setAmbient(const ColourValue& ambient);
307 
316  void setDiffuse(Real red, Real green, Real blue, Real alpha);
317 
326  void setDiffuse(const ColourValue& diffuse);
327 
336  void setSpecular(Real red, Real green, Real blue, Real alpha);
337 
346  void setSpecular(const ColourValue& specular);
347 
356  void setShininess(Real val);
357 
366  void setSelfIllumination(Real red, Real green, Real blue);
367 
376  void setSelfIllumination(const ColourValue& selfIllum);
377 
386  void setDepthCheckEnabled(bool enabled);
387 
396  void setDepthWriteEnabled(bool enabled);
397 
407 
416  void setColourWriteEnabled(bool enabled);
417 
427 
437 
446  void setLightingEnabled(bool enabled);
447 
457 
466  void setFog(
467  bool overrideScene,
468  FogMode mode = FOG_NONE,
469  const ColourValue& colour = ColourValue::White,
470  Real expDensity = 0.001, Real linearStart = 0.0, Real linearEnd = 1.0 );
471 
480  void setDepthBias(float constantBias, float slopeScaleBias);
481 
499  void setTextureAnisotropy(unsigned int maxAniso);
500 
509  void setSceneBlending( const SceneBlendType sbt );
510 
520 
529  void setSceneBlending( const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor);
530 
539  void setSeparateSceneBlending( const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor, const SceneBlendFactor sourceFactorAlpha, const SceneBlendFactor destFactorAlpha);
540 
557  void setLodIndex(unsigned short index);
559  unsigned short getLodIndex(void) const { return mLodIndex; }
560 
578  void setSchemeName(const String& schemeName);
582  const String& getSchemeName(void) const;
583 
585  unsigned short _getSchemeIndex(void) const;
586 
588  bool isDepthWriteEnabled(void) const;
589 
591  bool isDepthCheckEnabled(void) const;
592 
594  bool hasColourWriteDisabled(void) const;
595 
601  void setName(const String& name);
603  const String& getName(void) const { return mName; }
604 
616  bool applyTextureAliases(const AliasTextureNamePairList& aliasList, const bool apply = true) const;
617 
618 
634  void addGPUVendorRule(GPUVendor vendor, IncludeOrExclude includeOrExclude);
648  void addGPUVendorRule(const GPUVendorRule& rule);
656 
674  void addGPUDeviceNameRule(const String& devicePattern, IncludeOrExclude includeOrExclude, bool caseSensitive = false);
693  void removeGPUDeviceNameRule(const String& devicePattern);
697 
702  UserObjectBindings& getUserObjectBindings() { return mUserObjectBindings; }
703 
708  const UserObjectBindings& getUserObjectBindings() const { return mUserObjectBindings; }
709 
710  };
711 
715 }
716 #endif
Ogre::Technique::setSpecular
void setSpecular(const ColourValue &specular)
Sets the specular colour reflectance properties of every Pass in every Technique.
Ogre::Technique::_unload
void _unload(void)
Internal unload method, derived from call to Material::unload.
Ogre::Technique::getIlluminationPassIterator
const IlluminationPassIterator getIlluminationPassIterator(void)
Gets an iterator over the illumination-stage categorised passes.
Ogre::Technique::GPUDeviceNameRule::GPUDeviceNameRule
GPUDeviceNameRule(const String &pattern, IncludeOrExclude ie, bool caseSen)
Definition: OgreTechnique.h:141
Ogre::Technique::IlluminationPassIterator
VectorIterator< IlluminationPassList > IlluminationPassIterator
Definition: OgreTechnique.h:203
Ogre::Technique::GPUVendorRuleList
vector< GPUVendorRule >::type GPUVendorRuleList
Definition: OgreTechnique.h:144
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
Ogre::Technique::getPass
Pass * getPass(const String &name)
Retrieves the Pass matching name.
Ogre::Technique::setSeparateSceneBlending
void setSeparateSceneBlending(const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor, const SceneBlendFactor sourceFactorAlpha, const SceneBlendFactor destFactorAlpha)
Allows very fine control of blending every Pass with the existing contents of the scene,...
Ogre::Technique::getPassIterator
const PassIterator getPassIterator(void)
Gets an iterator over the passes in this Technique.
Ogre::Technique::setShadingMode
void setShadingMode(ShadeOptions mode)
Sets the type of light shading required.
Ogre::Technique::setSelfIllumination
void setSelfIllumination(const ColourValue &selfIllum)
Sets the amount of self-illumination of every Pass in every Technique.
Ogre::Technique::setShadowCasterMaterial
void setShadowCasterMaterial(const Ogre::String &name)
set this material specific shadow casting specific material
Ogre::Technique::isDepthWriteEnabled
bool isDepthWriteEnabled(void) const
Is depth writing going to occur on this technique?
Ogre::Technique::setSeparateSceneBlending
void setSeparateSceneBlending(const SceneBlendType sbt, const SceneBlendType sbta)
Sets the kind of blending every pass has with the existing contents of the scene, using individual fa...
Ogre::Technique::mParent
Material * mParent
Definition: OgreTechnique.h:70
Ogre::Technique::GPUVendorRule::includeOrExclude
IncludeOrExclude includeOrExclude
Definition: OgreTechnique.h:127
Ogre::Technique::Passes
vector< Pass * >::type Passes
Definition: OgreTechnique.h:64
Ogre::Technique::GPUDeviceNameRuleIterator
ConstVectorIterator< GPUDeviceNameRuleList > GPUDeviceNameRuleIterator
Definition: OgreTechnique.h:694
Ogre::Technique::setPointSize
void setPointSize(Real ps)
Sets the point size properties for every Pass in this Technique.
Ogre::Technique::removePass
void removePass(unsigned short index)
Removes the Pass with the given index.
Ogre::Technique::getGPUVendorRuleIterator
GPUVendorRuleIterator getGPUVendorRuleIterator() const
Get an iterator over the currently registered vendor rules.
Ogre::Technique::mUserObjectBindings
UserObjectBindings mUserObjectBindings
Definition: OgreTechnique.h:110
Ogre::Technique::calculateSize
size_t calculateSize(void) const
Ogre::Technique::setSceneBlending
void setSceneBlending(const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor)
Allows very fine control of blending every Pass with the existing contents of the scene.
Ogre::Technique::mIlluminationPasses
IlluminationPassList mIlluminationPasses
List of derived passes, categorised into IlluminationStage (ordered)
Definition: OgreTechnique.h:68
Ogre::Technique::applyTextureAliases
bool applyTextureAliases(const AliasTextureNamePairList &aliasList, const bool apply=true) const
Applies texture names to Texture Unit State with matching texture name aliases.
Ogre::VectorIterator
Concrete IteratorWrapper for nonconst access to the underlying container.
Definition: OgreIteratorWrapper.h:186
Ogre::FogMode
FogMode
Fog modes.
Definition: OgreCommon.h:122
Ogre::Technique::_prepare
void _prepare(void)
Internal prepare method, derived from call to Material::prepare.
Ogre::Technique::mShadowCasterMaterial
MaterialPtr mShadowCasterMaterial
When casting shadow, if not using default Ogre shadow casting material, or nor using fixed function c...
Definition: OgreTechnique.h:92
Ogre::GPUVendor
GPUVendor
Enumeration of GPU vendors.
Definition: OgreRenderSystemCapabilities.h:253
Ogre::Material
Class encapsulates rendering properties of an object.
Definition: OgreMaterial.h:89
Ogre::Technique::mName
String mName
Optional name for the technique.
Definition: OgreTechnique.h:80
Ogre::Technique::operator=
Technique & operator=(const Technique &rhs)
Overloaded operator to copy on Technique to another.
Ogre::Technique::checkHardwareSupport
bool checkHardwareSupport(bool autoManageTextureUnits, StringUtil::StrStreamType &compileErrors)
Internal method for checking hardware support.
Ogre::Technique::_compileIlluminationPasses
void _compileIlluminationPasses(void)
Internal method for splitting the passes into illumination passes.
Ogre::Technique::addGPUVendorRule
void addGPUVendorRule(const GPUVendorRule &rule)
Add a rule which manually influences the support for this technique based on a GPU vendor.
Ogre::Technique::setFog
void setFog(bool overrideScene, FogMode mode=FOG_NONE, const ColourValue &colour=ColourValue::White, Real expDensity=0.001, Real linearStart=0.0, Real linearEnd=1.0)
Sets the fogging mode applied to each pass.
Ogre::TextureFilterOptions
TextureFilterOptions
High-level filtering options providing shortcuts to settings the minification, magnification and mip ...
Definition: OgreCommon.h:79
Ogre::IlluminationPassList
vector< IlluminationPass * >::type IlluminationPassList
Definition: OgrePass.h:1872
Ogre::Technique::mSchemeIndex
unsigned short mSchemeIndex
Scheme index, derived from scheme name but the names are held on MaterialManager, for speed an index ...
Definition: OgreTechnique.h:78
Ogre::String
_StringBase String
Definition: OgrePrerequisites.h:439
Ogre::Technique::getUserObjectBindings
UserObjectBindings & getUserObjectBindings()
Return an instance of user objects binding associated with this class.
Definition: OgreTechnique.h:702
Ogre::StringUtil::StrStreamType
StringStream StrStreamType
Definition: OgreString.h:78
Ogre::Pass
Class defining a single pass of a Technique (of a Material), i.e.
Definition: OgrePass.h:81
Ogre::Technique
Class representing an approach to rendering this particular Material.
Definition: OgreTechnique.h:54
Ogre::Technique::IncludeOrExclude
IncludeOrExclude
Directive used to manually control technique support based on the inclusion or exclusion of some fact...
Definition: OgreTechnique.h:117
Ogre::UserObjectBindings
Class that provides convenient interface to establish a linkage between custom user application objec...
Definition: OgreUserObjectBindings.h:50
Ogre::Technique::IlluminationPassesState
IlluminationPassesState
Illumination pass state type.
Definition: OgreTechnique.h:58
Ogre::Technique::GPUDeviceNameRule::caseSensitive
bool caseSensitive
Definition: OgreTechnique.h:138
Ogre::CompareFunction
CompareFunction
Comparison functions used for the depth/stencil buffer operations and others.
Definition: OgreCommon.h:65
Ogre::Technique::setDepthFunction
void setDepthFunction(CompareFunction func)
Sets the function used to compare depth values when depth checking is on.
Ogre::Technique::setSelfIllumination
void setSelfIllumination(Real red, Real green, Real blue)
Sets the amount of self-illumination of every Pass in every Technique.
Ogre::Technique::GPUDeviceNameRule
Rule controlling whether technique is deemed supported based on GPU device name.
Definition: OgreTechnique.h:135
Ogre::Technique::setDiffuse
void setDiffuse(Real red, Real green, Real blue, Real alpha)
Sets the diffuse colour reflectance properties of every Pass in every Technique.
Ogre::Technique::PassIterator
VectorIterator< Passes > PassIterator
Definition: OgreTechnique.h:200
Ogre::Technique::getPass
Pass * getPass(unsigned short index)
Retrieves the Pass with the given index.
Ogre::Technique::getNumPasses
unsigned short getNumPasses(void) const
Retrieves the number of passes.
Ogre::Technique::getGPUDeviceNameRuleIterator
GPUDeviceNameRuleIterator getGPUDeviceNameRuleIterator() const
Get an iterator over the currently registered device name rules.
Ogre::Technique::checkGPURules
bool checkGPURules(StringUtil::StrStreamType &errors)
Internal method for checking GPU vendor / device rules.
Ogre::Technique::Technique
Technique(Material *parent)
Constructor.
Ogre::Technique::getLodIndex
unsigned short getLodIndex(void) const
Gets the level-of-detail index assigned to this Technique.
Definition: OgreTechnique.h:559
Ogre::SceneBlendFactor
SceneBlendFactor
Blending factors for manually blending objects with the scene.
Definition: OgreBlendMode.h:235
Ogre::Technique::checkManuallyOrganisedIlluminationPasses
bool checkManuallyOrganisedIlluminationPasses()
Internal method - check for manually assigned illumination passes.
Ogre::Technique::setDepthCheckEnabled
void setDepthCheckEnabled(bool enabled)
Sets whether or not each Pass renders with depth-buffer checking on or not.
Ogre::Technique::clearIlluminationPasses
void clearIlluminationPasses(void)
Internal method for clearing illumination pass list.
OgrePrerequisites.h
Ogre::Technique::addGPUDeviceNameRule
void addGPUDeviceNameRule(const GPUDeviceNameRule &rule)
Add a rule which manually influences the support for this technique based on a pattern that matches a...
Ogre::Technique::setLodIndex
void setLodIndex(unsigned short index)
Assigns a level-of-detail (LOD) index to this Technique.
Ogre::Technique::_unprepare
void _unprepare(void)
Internal unprepare method, derived from call to Material::unprepare.
Ogre::Technique::GPUVendorRule::GPUVendorRule
GPUVendorRule(GPUVendor v, IncludeOrExclude ie)
Definition: OgreTechnique.h:130
Ogre::AliasTextureNamePairList
map< String, String >::type AliasTextureNamePairList
Alias / Texture name pair (first = alias, second = texture name)
Definition: OgreCommon.h:553
Ogre::Technique::setLightingEnabled
void setLightingEnabled(bool enabled)
Sets whether or not dynamic lighting is enabled for every Pass.
Ogre::Technique::isTransparent
bool isTransparent(void) const
Returns true if this Technique involves transparency.
Ogre::Technique::isTransparentSortingEnabled
bool isTransparentSortingEnabled(void) const
Returns true if this Technique has transparent sorting enabled.
Ogre::Technique::mShadowReceiverMaterial
MaterialPtr mShadowReceiverMaterial
When receiving shadow, if not using default Ogre shadow receiving material, or nor using fixed functi...
Definition: OgreTechnique.h:102
Ogre::Technique::mShadowCasterMaterialName
String mShadowCasterMaterialName
When casting shadow, if not using default Ogre shadow casting material, or nor using fixed function c...
Definition: OgreTechnique.h:97
Ogre::Technique::movePass
bool movePass(const unsigned short sourceIndex, const unsigned short destinationIndex)
Move a pass from source index to destination index.
Ogre::Technique::hasColourWriteDisabled
bool hasColourWriteDisabled(void) const
Exists colour writing disabled pass on this technique?
Ogre::Technique::setCullingMode
void setCullingMode(CullingMode mode)
Sets the culling mode for each pass based on the 'vertex winding'.
Ogre::Technique::GPUDeviceNameRule::GPUDeviceNameRule
GPUDeviceNameRule()
Definition: OgreTechnique.h:139
Ogre::Technique::setDiffuse
void setDiffuse(const ColourValue &diffuse)
Sets the diffuse colour reflectance properties of every Pass in every Technique.
Ogre::Technique::setDepthWriteEnabled
void setDepthWriteEnabled(bool enabled)
Sets whether or not each Pass renders with depth-buffer writing on or not.
_OgreExport
#define _OgreExport
Definition: OgrePlatform.h:257
Ogre::Technique::setSchemeName
void setSchemeName(const String &schemeName)
Set the 'scheme name' for this technique.
Ogre::Technique::setColourWriteEnabled
void setColourWriteEnabled(bool enabled)
Sets whether or not colour buffer writing is enabled for each Pass.
Ogre::Technique::GPUDeviceNameRule::includeOrExclude
IncludeOrExclude includeOrExclude
Definition: OgreTechnique.h:137
OgreCommon.h
OgrePass.h
Ogre::Technique::setTextureAnisotropy
void setTextureAnisotropy(unsigned int maxAniso)
Sets the anisotropy level to be used for all textures.
Ogre::Technique::getParent
Material * getParent(void) const
Gets the parent Material.
Definition: OgreTechnique.h:207
Ogre::Technique::getResourceGroup
const String & getResourceGroup(void) const
Gets the resource group of the ultimate parent Material.
Ogre::CullingMode
CullingMode
Hardware culling modes based on vertex winding.
Definition: OgreCommon.h:136
Ogre::Technique::GPUVendorRule::GPUVendorRule
GPUVendorRule()
Definition: OgreTechnique.h:128
Ogre::Technique::mLodIndex
unsigned short mLodIndex
LOD level.
Definition: OgreTechnique.h:74
Ogre::Technique::_load
void _load(void)
Internal load method, derived from call to Material::load.
Ogre::Technique::setSpecular
void setSpecular(Real red, Real green, Real blue, Real alpha)
Sets the specular colour reflectance properties of every Pass in every Technique.
Ogre::Technique::Technique
Technique(Material *parent, const Technique &oth)
Copy constructor.
Ogre::Technique::addGPUDeviceNameRule
void addGPUDeviceNameRule(const String &devicePattern, IncludeOrExclude includeOrExclude, bool caseSensitive=false)
Add a rule which manually influences the support for this technique based on a pattern that matches a...
Ogre::ColourValue::White
static const ColourValue White
Definition: OgreColourValue.h:62
Ogre::Technique::mShadowReceiverMaterialName
String mShadowReceiverMaterialName
When receiving shadow, if not using default Ogre shadow receiving material, or nor using fixed functi...
Definition: OgreTechnique.h:107
Ogre::Technique::_getSchemeIndex
unsigned short _getSchemeIndex(void) const
Internal method for getting the scheme index.
Ogre::Technique::addGPUVendorRule
void addGPUVendorRule(GPUVendor vendor, IncludeOrExclude includeOrExclude)
Add a rule which manually influences the support for this technique based on a GPU vendor.
Ogre::Technique::getShadowReceiverMaterial
Ogre::MaterialPtr getShadowReceiverMaterial() const
return this material specific shadow receiving specific material
Ogre::Technique::GPUDeviceNameRuleList
vector< GPUDeviceNameRule >::type GPUDeviceNameRuleList
Definition: OgreTechnique.h:145
Ogre::SharedPtr< Material >
Ogre::Technique::_compile
String _compile(bool autoManageTextureUnits)
Internal compilation method; see Material::compile.
Ogre::Technique::setShadowCasterMaterial
void setShadowCasterMaterial(Ogre::MaterialPtr val)
set this material specific shadow casting specific material
Ogre::Technique::removeGPUDeviceNameRule
void removeGPUDeviceNameRule(const String &devicePattern)
Removes a matching device name rule.
OgreIteratorWrappers.h
Ogre::Technique::setName
void setName(const String &name)
Set the name of the technique.
Ogre::FOG_NONE
@ FOG_NONE
No fog. Duh.
Definition: OgreCommon.h:124
Ogre::Technique::setShadowReceiverMaterial
void setShadowReceiverMaterial(Ogre::MaterialPtr val)
set this material specific shadow receiving specific material
Ogre::Technique::setAmbient
void setAmbient(Real red, Real green, Real blue)
Sets the ambient colour reflectance properties for every Pass in every Technique.
OgreBlendMode.h
Ogre::ColourValue
Class representing colour.
Definition: OgreColourValue.h:58
Ogre::Technique::GPUDeviceNameRule::devicePattern
String devicePattern
Definition: OgreTechnique.h:136
Ogre::Technique::removeAllPasses
void removeAllPasses(void)
Removes all Passes from this Technique.
Ogre::Technique::setShininess
void setShininess(Real val)
Sets the shininess properties of every Pass in every Technique.
Ogre::Technique::GPUVendorRule::vendor
GPUVendor vendor
Definition: OgreTechnique.h:126
Ogre::Technique::setShadowReceiverMaterial
void setShadowReceiverMaterial(const Ogre::String &name)
set this material specific shadow receiving specific material
Ogre::Technique::setTextureFiltering
void setTextureFiltering(TextureFilterOptions filterType)
Set texture filtering for every texture unit in every Pass.
Ogre::GPU_UNKNOWN
@ GPU_UNKNOWN
Definition: OgreRenderSystemCapabilities.h:254
OgreUserObjectBindings.h
Ogre::ShadeOptions
ShadeOptions
Light shading modes.
Definition: OgreCommon.h:114
Ogre::Technique::mPasses
Passes mPasses
List of primary passes.
Definition: OgreTechnique.h:66
Ogre::Technique::getUserObjectBindings
const UserObjectBindings & getUserObjectBindings() const
Return an instance of user objects binding associated with this class.
Definition: OgreTechnique.h:708
Ogre::Technique::mGPUDeviceNameRules
GPUDeviceNameRuleList mGPUDeviceNameRules
Definition: OgreTechnique.h:148
Ogre::ManualCullingMode
ManualCullingMode
Manual culling modes based on vertex normals.
Definition: OgreCommon.h:151
Ogre::Real
float Real
Software floating point type.
Definition: OgrePrerequisites.h:70
Ogre::Technique::setDepthBias
void setDepthBias(float constantBias, float slopeScaleBias)
Sets the depth bias to be used for each Pass.
Ogre::Technique::removeGPUVendorRule
void removeGPUVendorRule(GPUVendor vendor)
Removes a matching vendor rule.
Ogre::Technique::isDepthCheckEnabled
bool isDepthCheckEnabled(void) const
Is depth checking going to occur on this technique?
Ogre::Technique::isLoaded
bool isLoaded(void) const
Is this loaded?
OgreRenderSystemCapabilities.h
Ogre::Technique::mGPUVendorRules
GPUVendorRuleList mGPUVendorRules
Definition: OgreTechnique.h:147
Ogre::Technique::getShadowCasterMaterial
Ogre::MaterialPtr getShadowCasterMaterial() const
return this material specific shadow casting specific material
Ogre::Technique::GPUVendorRuleIterator
ConstVectorIterator< GPUVendorRuleList > GPUVendorRuleIterator
Definition: OgreTechnique.h:653
Ogre::Technique::mIlluminationPassesCompilationPhase
IlluminationPassesState mIlluminationPassesCompilationPhase
Definition: OgreTechnique.h:72
Ogre::Technique::isSupported
bool isSupported(void) const
Indicates if this technique is supported by the current graphics card.
Ogre::Technique::GPUVendorRule
Rule controlling whether technique is deemed supported based on GPU vendor.
Definition: OgreTechnique.h:125
Ogre::vector
Definition: OgrePrerequisites.h:492
Ogre::Technique::mIsSupported
bool mIsSupported
Definition: OgreTechnique.h:71
Ogre::Technique::getName
const String & getName(void) const
Gets the name of the technique.
Definition: OgreTechnique.h:603
Ogre::Technique::isTransparentSortingForced
bool isTransparentSortingForced(void) const
Returns true if this Technique has transparent sorting forced.
Ogre::Technique::setManualCullingMode
void setManualCullingMode(ManualCullingMode mode)
Sets the manual culling mode, performed by CPU rather than hardware.
Ogre::Technique::setSceneBlending
void setSceneBlending(const SceneBlendType sbt)
Sets the kind of blending every pass has with the existing contents of the scene.
Ogre::Technique::_notifyNeedsRecompile
void _notifyNeedsRecompile(void)
Tells the technique that it needs recompilation.
Ogre::Technique::createPass
Pass * createPass(void)
Creates a new Pass for this Technique.
Ogre::ConstVectorIterator
Concrete IteratorWrapper for const access to the underlying container.
Definition: OgreIteratorWrapper.h:217
Ogre::Technique::setAmbient
void setAmbient(const ColourValue &ambient)
Sets the ambient colour reflectance properties for every Pass in every Technique.
Ogre::SceneBlendType
SceneBlendType
Types of blending that you can specify between an object and the existing contents of the scene.
Definition: OgreBlendMode.h:216
Ogre::Technique::getSchemeName
const String & getSchemeName(void) const
Returns the scheme to which this technique is assigned.
Ogre::Technique::~Technique
~Technique()

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