OgrePass.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 __Pass_H__
29 #define __Pass_H__
30 
31 #include "OgrePrerequisites.h"
32 #include "OgreGpuProgram.h"
33 #include "OgreColourValue.h"
34 #include "OgreBlendMode.h"
35 #include "OgreCommon.h"
36 #include "OgreLight.h"
37 #include "OgreTextureUnitState.h"
38 #include "OgreUserObjectBindings.h"
39 
40 namespace Ogre {
41 
50  {
59  };
60 
80  class _OgreExport Pass : public PassAlloc
81  {
82  public:
93  struct HashFunc
94  {
95  virtual uint32 operator()(const Pass* p) const = 0;
97  virtual ~HashFunc() {}
98  };
99  protected:
101  unsigned short mIndex;
105  //-------------------------------------------------------------------------
106  // Colour properties, only applicable in fixed-function passes
113  //-------------------------------------------------------------------------
114 
115  //-------------------------------------------------------------------------
116  // Blending factors
121 
122  // Used to determine if separate alpha blending should be used for color and alpha channels
124 
125  //-------------------------------------------------------------------------
126  // Blending operations
129 
132 
133  //-------------------------------------------------------------------------
134 
135  //-------------------------------------------------------------------------
136  // Depth buffer settings
143 
146 
147  // Alpha reject settings
149  unsigned char mAlphaRejectVal;
151 
156  //-------------------------------------------------------------------------
157 
158  //-------------------------------------------------------------------------
159  // Culling mode
162  //-------------------------------------------------------------------------
163 
167  unsigned short mMaxSimultaneousLights;
169  unsigned short mStartLight;
173  unsigned short mLightsPerIteration;
179 
187  //-------------------------------------------------------------------------
188  // Fog
195  //-------------------------------------------------------------------------
196 
200 
232  Real mPointAttenuationCoeffs[3];
233  // TU Content type lookups
245 
246 
249 
250  public:
252  protected:
259  public:
260  OGRE_STATIC_MUTEX(msDirtyHashListMutex);
261  OGRE_STATIC_MUTEX(msPassGraveyardMutex);
262  OGRE_MUTEX(mTexUnitChangeMutex);
263  OGRE_MUTEX(mGpuProgramChangeMutex);
265  Pass(Technique* parent, unsigned short index);
267  Pass(Technique* parent, unsigned short index, const Pass& oth );
269  Pass& operator=(const Pass& oth);
270  virtual ~Pass();
271 
273  bool isProgrammable(void) const { return mVertexProgramUsage || mFragmentProgramUsage || mGeometryProgramUsage ||
274  mTesselationHullProgramUsage || mTesselationDomainProgramUsage || mComputeProgramUsage; }
275 
277  bool hasVertexProgram(void) const { return mVertexProgramUsage != NULL; }
279  bool hasFragmentProgram(void) const { return mFragmentProgramUsage != NULL; }
281  bool hasGeometryProgram(void) const { return mGeometryProgramUsage != NULL; }
283  bool hasTesselationHullProgram(void) const { return mTesselationHullProgramUsage != NULL; }
285  bool hasTesselationDomainProgram(void) const { return mTesselationDomainProgramUsage != NULL; }
287  bool hasComputeProgram(void) const { return mComputeProgramUsage != NULL; }
289  bool hasShadowCasterVertexProgram(void) const { return mShadowCasterVertexProgramUsage != NULL; }
291  bool hasShadowCasterFragmentProgram(void) const { return mShadowCasterFragmentProgramUsage != NULL; }
293  bool hasShadowReceiverVertexProgram(void) const { return mShadowReceiverVertexProgramUsage != NULL; }
295  bool hasShadowReceiverFragmentProgram(void) const { return mShadowReceiverFragmentProgramUsage != NULL; }
296 
297  size_t calculateSize(void) const;
298 
300  unsigned short getIndex(void) const { return mIndex; }
301  /* Set the name of the pass
302  @remarks
303  The name of the pass is optional. Its useful in material scripts where a material could inherit
304  from another material and only want to modify a particular pass.
305  */
306  void setName(const String& name);
308  const String& getName(void) const { return mName; }
309 
321  void setAmbient(Real red, Real green, Real blue);
322 
335  void setAmbient(const ColourValue& ambient);
336 
347  void setDiffuse(Real red, Real green, Real blue, Real alpha);
348 
359  void setDiffuse(const ColourValue& diffuse);
360 
373  void setSpecular(Real red, Real green, Real blue, Real alpha);
374 
387  void setSpecular(const ColourValue& specular);
388 
394  void setShininess(Real val);
395 
405  void setSelfIllumination(Real red, Real green, Real blue);
406 
411  void setEmissive(Real red, Real green, Real blue)
412  {
413  setSelfIllumination(red, green, blue);
414  }
415 
425  void setSelfIllumination(const ColourValue& selfIllum);
426 
431  void setEmissive(const ColourValue& emissive)
432  {
433  setSelfIllumination(emissive);
434  }
435 
439 
445  Real getPointSize(void) const;
446 
462  void setPointSize(Real ps);
463 
469  void setPointSpritesEnabled(bool enabled);
470 
474  bool getPointSpritesEnabled(void) const;
475 
493  void setPointAttenuation(bool enabled,
494  Real constant = 0.0f, Real linear = 1.0f, Real quadratic = 0.0f);
495 
497  bool isPointAttenuationEnabled(void) const;
498 
505 
509  Real getPointMinSize(void) const;
517  Real getPointMaxSize(void) const;
518 
521  const ColourValue& getAmbient(void) const;
522 
525  const ColourValue& getDiffuse(void) const;
526 
529  const ColourValue& getSpecular(void) const;
530 
533  const ColourValue& getSelfIllumination(void) const;
534 
539  const ColourValue& getEmissive(void) const
540  {
541  return getSelfIllumination();
542  }
543 
546  Real getShininess(void) const;
547 
551 
567  TextureUnitState* createTextureUnitState( const String& textureName, unsigned short texCoordSet = 0);
576  TextureUnitState* getTextureUnitState(unsigned short index);
583  const TextureUnitState* getTextureUnitState(unsigned short index) const;
587  const TextureUnitState* getTextureUnitState(const String& name) const;
588 
595  unsigned short getTextureUnitStateIndex(const TextureUnitState* state) const;
596 
600 
604 
609  void removeTextureUnitState(unsigned short index);
610 
614 
617  unsigned short getNumTextureUnitStates(void) const
618  {
619  return static_cast<unsigned short>(mTextureUnitStates.size());
620  }
621 
638  void setSceneBlending( const SceneBlendType sbt );
639 
659 
682  void setSceneBlending( const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor);
683 
710  void setSeparateSceneBlending( const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor, const SceneBlendFactor sourceFactorAlpha, const SceneBlendFactor destFactorAlpha );
711 
714 
718 
722 
726 
730 
742 
757 
760 
763 
766 
768  bool isTransparent(void) const;
769 
781  void setDepthCheckEnabled(bool enabled);
782 
787  bool getDepthCheckEnabled(void) const;
788 
799  void setDepthWriteEnabled(bool enabled);
800 
805  bool getDepthWriteEnabled(void) const;
806 
820 
831  void setColourWriteEnabled(bool enabled);
833  bool getColourWriteEnabled(void) const;
834 
849 
853 
868 
874 
883  void setLightingEnabled(bool enabled);
884 
887  bool getLightingEnabled(void) const;
888 
897  void setMaxSimultaneousLights(unsigned short maxLights);
899  unsigned short getMaxSimultaneousLights(void) const;
900 
911  void setStartLight(unsigned short startLight);
913  unsigned short getStartLight(void) const;
914 
916  void setLightMask(uint32 mask);
919 
925 
929 
935 
939 
945  virtual void setPolygonModeOverrideable(bool override)
946  {
947  mPolygonModeOverrideable = override;
948  }
949 
953  virtual bool getPolygonModeOverrideable(void) const
954  {
955  return mPolygonModeOverrideable;
956  }
986  void setFog(
987  bool overrideScene,
988  FogMode mode = FOG_NONE,
989  const ColourValue& colour = ColourValue::White,
990  Real expDensity = 0.001, Real linearStart = 0.0, Real linearEnd = 1.0 );
991 
994  bool getFogOverride(void) const;
995 
1000  FogMode getFogMode(void) const;
1001 
1004  const ColourValue& getFogColour(void) const;
1005 
1010  Real getFogStart(void) const;
1011 
1016  Real getFogEnd(void) const;
1017 
1022  Real getFogDensity(void) const;
1023 
1043  void setDepthBias(float constantBias, float slopeScaleBias = 0.0f);
1044 
1046  float getDepthBiasConstant(void) const;
1048  float getDepthBiasSlopeScale(void) const;
1055  void setIterationDepthBias(float biasPerIteration);
1059  float getIterationDepthBias() const;
1060 
1070  void setAlphaRejectSettings(CompareFunction func, unsigned char value, bool alphaToCoverageEnabled = false);
1071 
1075 
1078  void setAlphaRejectValue(unsigned char val);
1079 
1082  CompareFunction getAlphaRejectFunction(void) const { return mAlphaRejectFunc; }
1083 
1086  unsigned char getAlphaRejectValue(void) const { return mAlphaRejectVal; }
1087 
1095  void setAlphaToCoverageEnabled(bool enabled);
1096 
1099  bool isAlphaToCoverageEnabled() const { return mAlphaToCoverageEnabled; }
1100 
1113  void setTransparentSortingEnabled(bool enabled);
1114 
1118 
1128  void setTransparentSortingForced(bool enabled);
1129 
1133 
1176  void setIteratePerLight(bool enabled,
1177  bool onlyForOneLightType = true, Light::LightTypes lightType = Light::LT_POINT);
1178 
1180  bool getIteratePerLight(void) const { return mIteratePerLight; }
1182  bool getRunOnlyForOneLightType(void) const { return mRunOnlyForOneLightType; }
1185  Light::LightTypes getOnlyLightType() const { return mOnlyLightType; }
1186 
1196  void setLightCountPerIteration(unsigned short c);
1200  unsigned short getLightCountPerIteration(void) const;
1201 
1203  Technique* getParent(void) const { return mParent; }
1204 
1206  const String& getResourceGroup(void) const;
1207 
1224  void setVertexProgram(const String& name, bool resetParams = true);
1233  const String& getVertexProgramName(void) const;
1237  const GpuProgramPtr& getVertexProgram(void) const;
1238 
1239 
1284 
1329 
1363 
1392 
1400 
1408 
1425  void setFragmentProgram(const String& name, bool resetParams = true);
1432  const String& getFragmentProgramName(void) const;
1436  const GpuProgramPtr& getFragmentProgram(void) const;
1437 
1454  void setGeometryProgram(const String& name, bool resetParams = true);
1461  const String& getGeometryProgramName(void) const;
1465  const GpuProgramPtr& getGeometryProgram(void) const;
1466 
1478  Pass* _split(unsigned short numUnits);
1479 
1481  void _notifyIndex(unsigned short index);
1482 
1484  void _prepare(void);
1486  void _unprepare(void);
1488  void _load(void);
1490  void _unload(void);
1492  bool isLoaded(void) const;
1493 
1500  uint32 getHash(void) const { return mHash; }
1502  void _dirtyHash(void);
1509  void _recalculateHash(void);
1512 
1517  void _updateAutoParams(const AutoParamDataSource* source, uint16 variabilityMask) const;
1518 
1526  TextureUnitState::ContentType contentType, unsigned short index) const;
1527 
1545  void setTextureAnisotropy(unsigned int maxAniso);
1557  void setNormaliseNormals(bool normalise) { mNormaliseNormals = normalise; }
1558 
1560  bool getNormaliseNormals(void) const {return mNormaliseNormals; }
1561 
1565  static const PassSet& getDirtyHashList(void)
1566  { return msDirtyHashList; }
1569  static const PassSet& getPassGraveyard(void)
1570  { return msPassGraveyard; }
1578  static void clearDirtyHashList(void);
1579 
1581  static void processPendingPassUpdates(void);
1582 
1584  void queueForDeletion(void);
1585 
1588  bool isAmbientOnly(void) const;
1589 
1603  void setPassIterationCount(const size_t count) { mPassIterationCount = count; }
1604 
1607  size_t getPassIterationCount(void) const { return mPassIterationCount; }
1608 
1620  bool applyTextureAliases(const AliasTextureNamePairList& aliasList, const bool apply = true) const;
1621 
1642  void setLightScissoringEnabled(bool enabled) { mLightScissoring = enabled; }
1646  bool getLightScissoringEnabled() const { return mLightScissoring; }
1647 
1671  void setLightClipPlanesEnabled(bool enabled) { mLightClipPlanes = enabled; }
1675  bool getLightClipPlanesEnabled() const { return mLightClipPlanes; }
1676 
1698  void setIlluminationStage(IlluminationStage is) { mIlluminationStage = is; }
1700  IlluminationStage getIlluminationStage() const { return mIlluminationStage; }
1705  {
1712  MIN_GPU_PROGRAM_CHANGE
1713  };
1726  static void setHashFunction(BuiltinHashFunction builtin);
1727 
1739  static void setHashFunction(HashFunc* hashFunc) { msHashFunc = hashFunc; }
1740 
1743  static HashFunc* getHashFunction(void) { return msHashFunc; }
1744 
1748 
1753  UserObjectBindings& getUserObjectBindings() { return mUserObjectBindings; }
1754 
1759  const UserObjectBindings& getUserObjectBindings() const { return mUserObjectBindings; }
1760 
1762 
1778  void setTesselationHullProgram(const String& name, bool resetParams = true);
1790 
1807  void setTesselationDomainProgram(const String& name, bool resetParams = true);
1819 
1836  void setComputeProgram(const String& name, bool resetParams = true);
1843  const String& getComputeProgramName(void) const;
1847  const GpuProgramPtr& getComputeProgram(void) const;
1848  };
1849 
1859  struct IlluminationPass : public PassAlloc
1860  {
1868 
1870  };
1871 
1873 
1877 }
1878 
1879 #endif
Ogre::Pass::getDepthBiasSlopeScale
float getDepthBiasSlopeScale(void) const
Retrieves the slope-scale depth bias value as set by setDepthBias.
Ogre::Pass::mDestBlendFactor
SceneBlendFactor mDestBlendFactor
Definition: OgrePass.h:118
Ogre::IlluminationPass::pass
Pass * pass
The pass to use in this stage.
Definition: OgrePass.h:1863
Ogre::Pass::getFogOverride
bool getFogOverride(void) const
Returns true if this pass is to override the scene fog settings.
Ogre::Pass::HashFunc
Definition of a functor for calculating the hashcode of a Pass.
Definition: OgrePass.h:94
Ogre::Pass::mCullMode
CullingMode mCullMode
Definition: OgrePass.h:160
Ogre::Pass::mOnlyLightType
Light::LightTypes mOnlyLightType
Definition: OgrePass.h:176
Ogre::Pass::mShadowCasterFragmentProgramUsage
GpuProgramUsage * mShadowCasterFragmentProgramUsage
Fragment program details.
Definition: OgrePass.h:206
Ogre::Pass::hasShadowReceiverFragmentProgram
bool hasShadowReceiverFragmentProgram(void) const
Returns true if this pass uses a shadow receiver fragment program.
Definition: OgrePass.h:295
Ogre::AutoParamDataSource
This utility class is used to hold the information used to generate the matrices and other informatio...
Definition: OgreAutoParamDataSource.h:61
Ogre::TextureUnitState
Class representing the state of a single texture unit during a Pass of a Technique,...
Definition: OgreTextureUnitState.h:63
Ogre::Pass::getBuiltinHashFunction
static HashFunc * getBuiltinHashFunction(BuiltinHashFunction builtin)
Get the builtin hash function.
Ogre::Pass::mPointMaxSize
Real mPointMaxSize
Definition: OgrePass.h:228
Ogre::Pass::mColourWrite
bool mColourWrite
Colour buffer settings.
Definition: OgrePass.h:145
Ogre::IS_UNKNOWN
@ IS_UNKNOWN
Not determined.
Definition: OgrePass.h:58
Ogre::Pass::setTransparentSortingForced
void setTransparentSortingForced(bool enabled)
Sets whether or not transparent sorting is forced.
Ogre::Pass::applyTextureAliases
bool applyTextureAliases(const AliasTextureNamePairList &aliasList, const bool apply=true) const
Applies texture names to Texture Unit State with matching texture name aliases.
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::Pass::setAmbient
void setAmbient(Real red, Real green, Real blue)
Sets the ambient colour reflectance properties of this pass.
Ogre::Pass::getShadowCasterVertexProgram
const GpuProgramPtr & getShadowCasterVertexProgram(void) const
Gets the vertex program used by this pass when rendering shadow casters, only available after _load()...
Ogre::Pass::setTextureFiltering
void setTextureFiltering(TextureFilterOptions filterType)
Set texture filtering for every texture unit.
Ogre::Pass::setPointSpritesEnabled
void setPointSpritesEnabled(bool enabled)
Sets whether or not rendering points using OT_POINT_LIST will render point sprites (textured quads) o...
OgreTextureUnitState.h
Ogre::Pass::getName
const String & getName(void) const
Get the name of the pass.
Definition: OgrePass.h:308
Ogre::Pass::setGeometryProgramParameters
void setGeometryProgramParameters(GpuProgramParametersSharedPtr params)
Sets the geometry program parameters.
Ogre::Pass::mFogMode
FogMode mFogMode
Definition: OgrePass.h:190
Ogre::Pass::operator=
Pass & operator=(const Pass &oth)
Operator = overload.
Ogre::Light::LightTypes
LightTypes
Defines the type of light.
Definition: OgreLight.h:83
Ogre::Pass::HashFunc::operator()
virtual uint32 operator()(const Pass *p) const =0
Ogre::Pass::setPassIterationCount
void setPassIterationCount(const size_t count)
set the number of iterations that this pass should perform when doing fast multi pass operation.
Definition: OgrePass.h:1603
Ogre::Pass::getParent
Technique * getParent(void) const
Gets the parent Technique.
Definition: OgrePass.h:1203
Ogre::Pass::mSeparateBlendOperation
bool mSeparateBlendOperation
Determines if we should use separate blending operations for color and alpha channels.
Definition: OgrePass.h:131
Ogre::Pass::getGeometryProgram
const GpuProgramPtr & getGeometryProgram(void) const
Gets the geometry program used by this pass, only available after _load().
Ogre::Pass::setTesselationDomainProgram
void setTesselationDomainProgram(const String &name, bool resetParams=true)
Sets the details of the tesselation domain program to use.
Ogre::Pass::setGeometryProgram
void setGeometryProgram(const String &name, bool resetParams=true)
Sets the details of the geometry program to use.
Ogre::Pass::mDepthWrite
bool mDepthWrite
Definition: OgrePass.h:138
Ogre::Pass::mHashDirtyQueued
bool mHashDirtyQueued
Pass hash.
Definition: OgrePass.h:104
Ogre::Pass::setCullingMode
void setCullingMode(CullingMode mode)
Sets the culling mode for this pass based on the 'vertex winding'.
Ogre::Pass::hasTesselationDomainProgram
bool hasTesselationDomainProgram(void) const
Returns true if this pass uses a programmable tesselation control pipeline.
Definition: OgrePass.h:285
Ogre::set::type
std::set< T, P, A > type
Definition: OgrePrerequisites.h:522
Ogre::Pass::getFogStart
Real getFogStart(void) const
Returns the fog start distance for this pass.
Ogre::Pass::mShadeOptions
ShadeOptions mShadeOptions
Shading options.
Definition: OgrePass.h:181
Ogre::Pass::getTextureUnitStateIterator
TextureUnitStateIterator getTextureUnitStateIterator(void)
Get an iterator over the TextureUnitStates contained in this Pass.
Ogre::Pass::setAlphaRejectSettings
void setAlphaRejectSettings(CompareFunction func, unsigned char value, bool alphaToCoverageEnabled=false)
Sets the way the pass will have use alpha to totally reject pixels from the pipeline.
Ogre::Pass::setSeparateSceneBlending
void setSeparateSceneBlending(const SceneBlendType sbt, const SceneBlendType sbta)
Sets the kind of blending this pass has with the existing contents of the scene, separately for color...
Ogre::Pass::BuiltinHashFunction
BuiltinHashFunction
There are some default hash functions used to order passes so that render state changes are minimised...
Definition: OgrePass.h:1705
Ogre::Pass::MIN_TEXTURE_CHANGE
@ MIN_TEXTURE_CHANGE
Try to minimise the number of texture changes.
Definition: OgrePass.h:1707
Ogre::Pass::getPolygonModeOverrideable
virtual bool getPolygonModeOverrideable(void) const
Gets whether this renderable's chosen detail level can be overridden (downgraded) by the camera setti...
Definition: OgrePass.h:953
Ogre::Pass::createTextureUnitState
TextureUnitState * createTextureUnitState(void)
Inserts a new TextureUnitState object into the Pass.
Ogre::Pass::_unprepare
void _unprepare(void)
Internal method for undoing the load preparartion for this pass.
Ogre::Pass::setSceneBlendingOperation
void setSceneBlendingOperation(SceneBlendOperation op)
Sets the specific operation used to blend source and destination pixels together.
Ogre::Pass::setPolygonMode
void setPolygonMode(PolygonMode mode)
Sets the type of polygon rendering required.
Ogre::Pass::OGRE_STATIC_MUTEX
OGRE_STATIC_MUTEX(msDirtyHashListMutex)
Ogre::Pass::setAmbient
void setAmbient(const ColourValue &ambient)
Sets the ambient colour reflectance properties of this pass.
Ogre::Pass::setShadowReceiverVertexProgramParameters
void setShadowReceiverVertexProgramParameters(GpuProgramParametersSharedPtr params)
Sets the vertex program parameters for rendering as a shadow receiver.
Ogre::Pass::getShadowReceiverVertexProgramParameters
GpuProgramParametersSharedPtr getShadowReceiverVertexProgramParameters(void) const
Gets the vertex program parameters used by this pass when rendering shadow receivers.
Ogre::Pass::hasGeometryProgram
bool hasGeometryProgram(void) const
Returns true if this pass uses a programmable geometry pipeline.
Definition: OgrePass.h:281
Ogre::Pass::setShadowCasterVertexProgram
void setShadowCasterVertexProgram(const String &name)
Sets the details of the vertex program to use when rendering as a shadow caster.
Ogre::Pass::setAlphaRejectFunction
void setAlphaRejectFunction(CompareFunction func)
Sets the alpha reject function.
Ogre::Pass::setVertexProgramParameters
void setVertexProgramParameters(GpuProgramParametersSharedPtr params)
Sets the vertex program parameters.
Ogre::Pass::hasFragmentProgram
bool hasFragmentProgram(void) const
Returns true if this pass uses a programmable fragment pipeline.
Definition: OgrePass.h:279
Ogre::Pass::getMaxSimultaneousLights
unsigned short getMaxSimultaneousLights(void) const
Gets the maximum number of lights to be used by this pass.
Ogre::Pass::getVertexColourTracking
TrackVertexColourType getVertexColourTracking(void) const
Gets which material properties follow the vertex colour.
Ogre::Pass::getTransparentSortingForced
bool getTransparentSortingForced(void) const
Returns whether or not transparent sorting is forced.
Ogre::Pass::getSourceBlendFactor
SceneBlendFactor getSourceBlendFactor() const
Retrieves the source blending factor for the material (as set using Materiall::setSceneBlending).
Ogre::Pass::getGeometryProgramName
const String & getGeometryProgramName(void) const
Gets the name of the geometry program used by this pass.
Ogre::IlluminationPass::IlluminationPass
IlluminationPass()
Definition: OgrePass.h:1869
Ogre::Pass::_updateAutoParams
void _updateAutoParams(const AutoParamDataSource *source, uint16 variabilityMask) const
Update automatic parameters.
Ogre::Pass::isAmbientOnly
bool isAmbientOnly(void) const
Returns whether this pass is ambient only.
Ogre::Pass::getSpecular
const ColourValue & getSpecular(void) const
Gets the specular colour reflectance of the pass.
Ogre::Pass::getShadowReceiverFragmentProgram
const GpuProgramPtr & getShadowReceiverFragmentProgram(void) const
Gets the fragment program used by this pass when rendering shadow receivers, only available after _lo...
Ogre::Pass::setShadowCasterFragmentProgramParameters
void setShadowCasterFragmentProgramParameters(GpuProgramParametersSharedPtr params)
Sets the fragment program parameters for rendering as a shadow caster.
Ogre::VectorIterator
Concrete IteratorWrapper for nonconst access to the underlying container.
Definition: OgreIteratorWrapper.h:186
Ogre::Pass::setShadowCasterVertexProgramParameters
void setShadowCasterVertexProgramParameters(GpuProgramParametersSharedPtr params)
Sets the vertex program parameters for rendering as a shadow caster.
Ogre::Pass::getTextureUnitState
TextureUnitState * getTextureUnitState(unsigned short index)
Retrieves a pointer to a texture unit state so it may be modified.
Ogre::Pass::_getTextureUnitWithContentTypeIndex
unsigned short _getTextureUnitWithContentTypeIndex(TextureUnitState::ContentType contentType, unsigned short index) const
Gets the 'nth' texture which references the given content type.
Ogre::Pass::getFragmentProgram
const GpuProgramPtr & getFragmentProgram(void) const
Gets the fragment program used by this pass, only available after _load().
Ogre::Pass::mDepthBiasSlopeScale
float mDepthBiasSlopeScale
Definition: OgrePass.h:141
Ogre::Pass::mShininess
Real mShininess
Definition: OgrePass.h:111
Ogre::FogMode
FogMode
Fog modes.
Definition: OgreCommon.h:122
Ogre::Pass::getResourceGroup
const String & getResourceGroup(void) const
Gets the resource group of the ultimate parent Material.
Ogre::Pass::getAlphaRejectFunction
CompareFunction getAlphaRejectFunction(void) const
Gets the alpha reject function.
Definition: OgrePass.h:1082
Ogre::Pass::_getBlendFlags
void _getBlendFlags(SceneBlendType type, SceneBlendFactor &source, SceneBlendFactor &dest)
Used to get scene blending flags from a blending type.
Ogre::Pass::_notifyNeedsRecompile
void _notifyNeedsRecompile(void)
Tells the pass that it needs recompilation.
Ogre::Pass::OGRE_MUTEX
OGRE_MUTEX(mGpuProgramChangeMutex)
Ogre::Pass::mAlphaBlendOperation
SceneBlendOperation mAlphaBlendOperation
Definition: OgrePass.h:128
Ogre::uint16
unsigned short uint16
Definition: OgrePlatform.h:360
Ogre::Pass::getEmissive
const ColourValue & getEmissive(void) const
Gets the self illumination colour of the pass.
Definition: OgrePass.h:539
Ogre::Pass::mPointAttenuationEnabled
bool mPointAttenuationEnabled
Definition: OgrePass.h:230
Ogre::Pass::getFogEnd
Real getFogEnd(void) const
Returns the fog end distance for this pass.
Ogre::Pass::mLightingEnabled
bool mLightingEnabled
Lighting enabled?
Definition: OgrePass.h:165
Ogre::Pass::mFogEnd
Real mFogEnd
Definition: OgrePass.h:193
Ogre::Pass::getSceneBlendingOperationAlpha
SceneBlendOperation getSceneBlendingOperationAlpha() const
Returns the current alpha blending operation.
Ogre::Pass::setComputeProgramParameters
void setComputeProgramParameters(GpuProgramParametersSharedPtr params)
Sets the Tesselation Evaluation program parameters.
Ogre::Pass::mHash
uint32 mHash
Optional name for the pass.
Definition: OgrePass.h:103
Ogre::Pass::mShadowCasterVertexProgramUsage
GpuProgramUsage * mShadowCasterVertexProgramUsage
Vertex program details.
Definition: OgrePass.h:204
Ogre::Pass::setSeparateSceneBlendingOperation
void setSeparateSceneBlendingOperation(SceneBlendOperation op, SceneBlendOperation alphaOp)
Sets the specific operation used to blend source and destination pixels together.
Ogre::Pass::getShininess
Real getShininess(void) const
Gets the 'shininess' property of the pass (affects specular highlights).
Ogre::Pass::getOnlyLightType
Light::LightTypes getOnlyLightType() const
Gets the single light type this pass runs for if getIteratePerLight and getRunOnlyForOneLightType are...
Definition: OgrePass.h:1185
Ogre::TextureFilterOptions
TextureFilterOptions
High-level filtering options providing shortcuts to settings the minification, magnification and mip ...
Definition: OgreCommon.h:79
Ogre::uint32
unsigned int uint32
Definition: OgrePlatform.h:359
Ogre::Pass::isLoaded
bool isLoaded(void) const
Is this loaded?
Ogre::Pass::getComputeProgramName
const String & getComputeProgramName(void) const
Gets the name of the Tesselation Hull program used by this pass.
Ogre::Pass::PassSet
set< Pass * >::type PassSet
Definition: OgrePass.h:251
Ogre::Pass::getPointAttenuationConstant
Real getPointAttenuationConstant(void) const
Returns the constant coefficient of point attenuation.
Ogre::IlluminationPassList
vector< IlluminationPass * >::type IlluminationPassList
Definition: OgrePass.h:1872
Ogre::Pass::setDepthBias
void setDepthBias(float constantBias, float slopeScaleBias=0.0f)
Sets the depth bias to be used for this material.
Ogre::String
_StringBase String
Definition: OgrePrerequisites.h:439
Ogre::Pass::hasComputeProgram
bool hasComputeProgram(void) const
Returns true if this pass uses a programmable compute pipeline.
Definition: OgrePass.h:287
Ogre::Pass::getSelfIllumination
const ColourValue & getSelfIllumination(void) const
Gets the self illumination colour of the pass.
Ogre::Pass::mNormaliseNormals
bool mNormaliseNormals
Normalisation.
Definition: OgrePass.h:185
Ogre::Pass::setComputeProgram
void setComputeProgram(const String &name, bool resetParams=true)
Sets the details of the compute program to use.
Ogre::Pass::getShadowReceiverVertexProgram
const GpuProgramPtr & getShadowReceiverVertexProgram(void) const
Gets the vertex program used by this pass when rendering shadow receivers, only available after _load...
Ogre::Pass::getLightCountPerIteration
unsigned short getLightCountPerIteration(void) const
If light iteration is enabled, determine the number of lights per iteration.
Ogre::Pass::getUserObjectBindings
UserObjectBindings & getUserObjectBindings()
Return an instance of user objects binding associated with this class.
Definition: OgrePass.h:1753
Ogre::Pass::setLightingEnabled
void setLightingEnabled(bool enabled)
Sets whether or not dynamic lighting is enabled.
Ogre::Pass::isAlphaToCoverageEnabled
bool isAlphaToCoverageEnabled() const
Gets whether to use alpha to coverage (A2C) when blending alpha rejected values.
Definition: OgrePass.h:1099
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::Pass::setShadowCasterFragmentProgram
void setShadowCasterFragmentProgram(const String &name)
Sets the details of the fragment program to use when rendering as a shadow caster.
Ogre::Pass::getShadingMode
ShadeOptions getShadingMode(void) const
Returns the type of light shading to be used.
Ogre::Pass::mQueuedForDeletion
bool mQueuedForDeletion
Is this pass queued for deletion?
Definition: OgrePass.h:222
Ogre::Pass::hasSeparateSceneBlendingOperations
bool hasSeparateSceneBlendingOperations() const
Returns true if this pass uses separate scene blending operations.
Ogre::Pass::getPointAttenuationLinear
Real getPointAttenuationLinear(void) const
Returns the linear coefficient of point attenuation.
Ogre::UserObjectBindings
Class that provides convenient interface to establish a linkage between custom user application objec...
Definition: OgreUserObjectBindings.h:50
Ogre::Pass::mFogDensity
Real mFogDensity
Definition: OgrePass.h:194
Ogre::Pass::getIterationDepthBias
float getIterationDepthBias() const
Gets a factor which derives an additional depth bias from the number of times a pass is iterated.
Ogre::Pass::getManualCullingMode
ManualCullingMode getManualCullingMode(void) const
Retrieves the manual culling mode for this pass.
Ogre::Pass::ConstTextureUnitStateIterator
ConstVectorIterator< TextureUnitStates > ConstTextureUnitStateIterator
Definition: OgrePass.h:601
Ogre::CompareFunction
CompareFunction
Comparison functions used for the depth/stencil buffer operations and others.
Definition: OgreCommon.h:65
Ogre::Pass::getDepthFunction
CompareFunction getDepthFunction(void) const
Returns the function used to compare depth values when depth checking is on.
Ogre::Pass::mPointMinSize
Real mPointMinSize
Definition: OgrePass.h:227
Ogre::Pass::setShininess
void setShininess(Real val)
Sets the shininess of the pass, affecting the size of specular highlights.
Ogre::Pass::mMaxSimultaneousLights
unsigned short mMaxSimultaneousLights
Max simultaneous lights.
Definition: OgrePass.h:167
Ogre::Pass::mDepthFunc
CompareFunction mDepthFunc
Definition: OgrePass.h:139
Ogre::Pass::mContentTypeLookupBuilt
bool mContentTypeLookupBuilt
Definition: OgrePass.h:236
Ogre::Pass::hasSeparateSceneBlending
bool hasSeparateSceneBlending() const
Return true if this pass uses separate scene blending.
Ogre::Pass::mLightClipPlanes
bool mLightClipPlanes
User clip planes for light?
Definition: OgrePass.h:240
Ogre::Pass::setSeparateSceneBlending
void setSeparateSceneBlending(const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor, const SceneBlendFactor sourceFactorAlpha, const SceneBlendFactor destFactorAlpha)
Allows very fine control of blending this Pass with the existing contents of the scene.
Ogre::Pass::setLightMask
void setLightMask(uint32 mask)
Sets the light mask which can be matched to specific light flags to be handled by this pass.
Ogre::Pass::getGeometryProgramParameters
GpuProgramParametersSharedPtr getGeometryProgramParameters(void) const
Gets the geometry program parameters used by this pass.
Ogre::Pass::setHashFunction
static void setHashFunction(HashFunc *hashFunc)
Set the hash function used for all passes.
Definition: OgrePass.h:1739
Ogre::Pass::getCullingMode
CullingMode getCullingMode(void) const
Returns the culling mode for geometry rendered with this pass.
Ogre::Pass::hasVertexProgram
bool hasVertexProgram(void) const
Returns true if this pass uses a programmable vertex pipeline.
Definition: OgrePass.h:277
Ogre::Pass::getLightMask
uint32 getLightMask() const
Gets the light mask controlling which lights are used for this pass.
Ogre::Pass::mEmissive
ColourValue mEmissive
Definition: OgrePass.h:110
Ogre::Pass::setVertexProgram
void setVertexProgram(const String &name, bool resetParams=true)
Sets the details of the vertex program to use.
Ogre::Pass::clearDirtyHashList
static void clearDirtyHashList(void)
Static method to reset the list of passes which need their hash values recalculated.
Ogre::Pass::mDepthBiasConstant
float mDepthBiasConstant
Definition: OgrePass.h:140
Ogre::Pass::mTesselationDomainProgramUsage
GpuProgramUsage * mTesselationDomainProgramUsage
Tesselation domain program details.
Definition: OgrePass.h:218
Ogre::Pass::getTextureUnitStateIterator
ConstTextureUnitStateIterator getTextureUnitStateIterator(void) const
Get an iterator over the TextureUnitStates contained in this Pass.
Ogre::Pass::addTextureUnitState
void addTextureUnitState(TextureUnitState *state)
Adds the passed in TextureUnitState, to the existing Pass.
Ogre::Pass::_split
Pass * _split(unsigned short numUnits)
Splits this Pass to one which can be handled in the number of texture units specified.
Ogre::IlluminationStage
IlluminationStage
Categorisation of passes for the purpose of additive lighting.
Definition: OgrePass.h:50
Ogre::Pass::getTextureUnitState
const TextureUnitState * getTextureUnitState(unsigned short index) const
Retrieves a const pointer to a texture unit state.
Ogre::Pass::getLightingEnabled
bool getLightingEnabled(void) const
Returns whether or not dynamic lighting is enabled.
Ogre::Pass::getComputeProgramParameters
GpuProgramParametersSharedPtr getComputeProgramParameters(void) const
Gets the Tesselation Hull program parameters used by this pass.
Ogre::Pass::setAlphaToCoverageEnabled
void setAlphaToCoverageEnabled(bool enabled)
Sets whether to use alpha to coverage (A2C) when blending alpha rejected values.
Ogre::Pass::getShadowCasterVertexProgramParameters
GpuProgramParametersSharedPtr getShadowCasterVertexProgramParameters(void) const
Gets the vertex program parameters used by this pass when rendering shadow casters.
Ogre::SceneBlendFactor
SceneBlendFactor
Blending factors for manually blending objects with the scene.
Definition: OgreBlendMode.h:235
Ogre::Pass::setIlluminationStage
void setIlluminationStage(IlluminationStage is)
Manually set which illumination stage this pass is a member of.
Definition: OgrePass.h:1698
Ogre::Pass::TextureUnitStateIterator
VectorIterator< TextureUnitStates > TextureUnitStateIterator
Definition: OgrePass.h:597
Ogre::Pass::mTesselationHullProgramUsage
GpuProgramUsage * mTesselationHullProgramUsage
Tesselation hull program details.
Definition: OgrePass.h:216
Ogre::Pass::getTesselationHullProgram
const GpuProgramPtr & getTesselationHullProgram(void) const
Gets the Tesselation Hull program used by this pass, only available after _load().
Ogre::Pass::_notifyIndex
void _notifyIndex(unsigned short index)
Internal method to adjust pass index.
Ogre::Pass::setTesselationHullProgram
void setTesselationHullProgram(const String &name, bool resetParams=true)
Support for shader model 5.0, hull and domain shaders.
Ogre::Pass::setDiffuse
void setDiffuse(const ColourValue &diffuse)
Sets the diffuse colour reflectance properties of this pass.
Ogre::Pass::setVertexColourTracking
void setVertexColourTracking(TrackVertexColourType tracking)
Sets which material properties follow the vertex colour.
Ogre::Pass::hasShadowCasterFragmentProgram
bool hasShadowCasterFragmentProgram(void) const
Returns true if this pass uses a shadow caster fragment program.
Definition: OgrePass.h:291
Ogre::Pass::mDepthBiasPerIteration
float mDepthBiasPerIteration
Definition: OgrePass.h:142
Ogre::Pass::getShadowCasterFragmentProgramName
const String & getShadowCasterFragmentProgramName(void) const
Gets the name of the fragment program used by this pass when rendering shadow casters.
Ogre::Pass::mGeometryProgramUsage
GpuProgramUsage * mGeometryProgramUsage
Geometry program details.
Definition: OgrePass.h:214
OgrePrerequisites.h
Ogre::Pass::hasShadowCasterVertexProgram
bool hasShadowCasterVertexProgram(void) const
Returns true if this pass uses a shadow caster vertex program.
Definition: OgrePass.h:289
Ogre::Pass::queueForDeletion
void queueForDeletion(void)
Queue this pass for deletion when appropriate.
Ogre::Pass::setFragmentProgramParameters
void setFragmentProgramParameters(GpuProgramParametersSharedPtr params)
Sets the fragment program parameters.
Ogre::IS_AMBIENT
@ IS_AMBIENT
Part of the rendering which occurs without any kind of direct lighting.
Definition: OgrePass.h:52
Ogre::Pass::getTesselationHullProgramName
const String & getTesselationHullProgramName(void) const
Gets the name of the Tesselation Hull program used by this pass.
Ogre::Pass::getShadowReceiverFragmentProgramName
const String & getShadowReceiverFragmentProgramName(void) const
Gets the name of the fragment program used by this pass when rendering shadow receivers.
Ogre::Pass::createTextureUnitState
TextureUnitState * createTextureUnitState(const String &textureName, unsigned short texCoordSet=0)
Inserts a new TextureUnitState object into the Pass.
Ogre::Pass::mAmbient
ColourValue mAmbient
Needs to be dirtied when next loaded.
Definition: OgrePass.h:107
Ogre::Pass::setSelfIllumination
void setSelfIllumination(const ColourValue &selfIllum)
Sets the amount of self-illumination an object has.
Ogre::Pass::_dirtyHash
void _dirtyHash(void)
Mark the hash as dirty.
Ogre::Pass::getHashFunction
static HashFunc * getHashFunction(void)
Get the hash function used for all passes.
Definition: OgrePass.h:1743
OgreLight.h
Ogre::TextureUnitState::ContentType
ContentType
Enum identifying the type of content this texture unit contains.
Definition: OgreTextureUnitState.h:488
Ogre::Pass::~Pass
virtual ~Pass()
Ogre::Pass::getAmbient
const ColourValue & getAmbient(void) const
Gets the ambient colour reflectance of the pass.
Ogre::AliasTextureNamePairList
map< String, String >::type AliasTextureNamePairList
Alias / Texture name pair (first = alias, second = texture name)
Definition: OgreCommon.h:553
Ogre::Pass::processPendingPassUpdates
static void processPendingPassUpdates(void)
Process all dirty and pending deletion passes.
Ogre::Pass::mPassIterationCount
size_t mPassIterationCount
Number of pass iterations to perform.
Definition: OgrePass.h:224
Ogre::Pass::mPointSpritesEnabled
bool mPointSpritesEnabled
Definition: OgrePass.h:229
Ogre::Pass::getPolygonMode
PolygonMode getPolygonMode(void) const
Returns the type of light shading to be used.
Ogre::Pass::mUserObjectBindings
UserObjectBindings mUserObjectBindings
User objects binding.
Definition: OgrePass.h:244
Ogre::Pass::mComputeProgramUsage
GpuProgramUsage * mComputeProgramUsage
Compute program details.
Definition: OgrePass.h:220
Ogre::Pass::mLightsPerIteration
unsigned short mLightsPerIteration
Iterate per how many lights?
Definition: OgrePass.h:173
Ogre::Pass::setShadowReceiverVertexProgram
void setShadowReceiverVertexProgram(const String &name)
Sets the details of the vertex program to use when rendering as a shadow receiver.
Ogre::Pass::getVertexProgram
const GpuProgramPtr & getVertexProgram(void) const
Gets the vertex program used by this pass, only available after _load().
Ogre::Pass::getTransparentSortingEnabled
bool getTransparentSortingEnabled(void) const
Returns whether or not transparent sorting is enabled.
Ogre::Pass::mTransparentSorting
bool mTransparentSorting
Transparent depth sorting.
Definition: OgrePass.h:153
_OgreExport
#define _OgreExport
Definition: OgrePlatform.h:257
Ogre::Pass::setIterationDepthBias
void setIterationDepthBias(float biasPerIteration)
Sets a factor which derives an additional depth bias from the number of times a pass is iterated.
Ogre::Pass::mIteratePerLight
bool mIteratePerLight
Run this pass once per light?
Definition: OgrePass.h:171
Ogre::Pass::setIteratePerLight
void setIteratePerLight(bool enabled, bool onlyForOneLightType=true, Light::LightTypes lightType=Light::LT_POINT)
Sets whether or not this pass should iterate per light or number of lights which can affect the objec...
Ogre::Pass::mAlphaToCoverageEnabled
bool mAlphaToCoverageEnabled
Definition: OgrePass.h:150
OgreCommon.h
Ogre::Pass::setLightCountPerIteration
void setLightCountPerIteration(unsigned short c)
If light iteration is enabled, determine the number of lights per iteration.
Ogre::Pass::setPointAttenuation
void setPointAttenuation(bool enabled, Real constant=0.0f, Real linear=1.0f, Real quadratic=0.0f)
Sets how points are attenuated with distance.
Ogre::Pass::setAlphaRejectValue
void setAlphaRejectValue(unsigned char val)
Gets the alpha reject value.
Ogre::Pass::getDirtyHashList
static const PassSet & getDirtyHashList(void)
Static method to retrieve all the Passes which need their hash values recalculated.
Definition: OgrePass.h:1565
Ogre::Pass::getTesselationDomainProgramName
const String & getTesselationDomainProgramName(void) const
Gets the name of the Domain Evaluation program used by this pass.
Ogre::Pass::mShadowContentTypeLookup
ContentTypeLookup mShadowContentTypeLookup
Definition: OgrePass.h:235
Ogre::IlluminationPass::originalPass
Pass * originalPass
The original pass which spawned this one.
Definition: OgrePass.h:1867
Ogre::Pass::setFragmentProgram
void setFragmentProgram(const String &name, bool resetParams=true)
Sets the details of the fragment program to use.
Ogre::Pass::setEmissive
void setEmissive(Real red, Real green, Real blue)
Sets the amount of self-illumination an object has.
Definition: OgrePass.h:411
Ogre::Pass::setPointMaxSize
void setPointMaxSize(Real max)
Set the maximum point size, when point attenuation is in use.
Ogre::CullingMode
CullingMode
Hardware culling modes based on vertex winding.
Definition: OgreCommon.h:136
Ogre::Pass::getColourWriteEnabled
bool getColourWriteEnabled(void) const
Determines if colour buffer writing is enabled for this pass.
Ogre::Pass::TextureUnitStates
vector< TextureUnitState * >::type TextureUnitStates
Storage of texture unit states.
Definition: OgrePass.h:198
Ogre::Pass::getPassIterationCount
size_t getPassIterationCount(void) const
Gets the pass iteration count value.
Definition: OgrePass.h:1607
Ogre::Pass::setTesselationHullProgramParameters
void setTesselationHullProgramParameters(GpuProgramParametersSharedPtr params)
Sets the Tesselation Hull program parameters.
Ogre::Pass::Pass
Pass(Technique *parent, unsigned short index)
Default constructor.
Ogre::Pass::mVertexProgramUsage
GpuProgramUsage * mVertexProgramUsage
Vertex program details.
Definition: OgrePass.h:202
Ogre::Pass::setSelfIllumination
void setSelfIllumination(Real red, Real green, Real blue)
Sets the amount of self-illumination an object has.
Ogre::Pass::setLightClipPlanesEnabled
void setLightClipPlanesEnabled(bool enabled)
Gets whether or not this pass will be clipped by user clips planes bounding the area covered by the l...
Definition: OgrePass.h:1671
Ogre::Pass::getShadowCasterFragmentProgramParameters
GpuProgramParametersSharedPtr getShadowCasterFragmentProgramParameters(void) const
Gets the fragment program parameters used by this pass when rendering shadow casters.
Ogre::Pass::getTesselationDomainProgramParameters
GpuProgramParametersSharedPtr getTesselationDomainProgramParameters(void) const
Gets the Tesselation Domain program parameters used by this pass.
Ogre::Pass::getPointMinSize
Real getPointMinSize(void) const
Get the minimum point size, when point attenuation is in use.
Ogre::Pass::getFragmentProgramName
const String & getFragmentProgramName(void) const
Gets the name of the fragment program used by this pass.
Ogre::Pass::isTransparent
bool isTransparent(void) const
Returns true if this pass has some element of transparency.
Ogre::TrackVertexColourType
int TrackVertexColourType
An enumeration describing which material properties should track the vertex colours.
Definition: OgreCommon.h:276
Ogre::ColourValue::White
static const ColourValue White
Definition: OgreColourValue.h:62
Ogre::Pass::getLightClipPlanesEnabled
bool getLightClipPlanesEnabled() const
Gets whether or not this pass will be clipped by user clips planes bounding the area covered by the l...
Definition: OgrePass.h:1675
Ogre::Pass::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 this pass.
Ogre::Pass::mFogOverride
bool mFogOverride
Definition: OgrePass.h:189
Ogre::Pass::removeTextureUnitState
void removeTextureUnitState(unsigned short index)
Removes the indexed texture unit state from this pass.
Ogre::Pass::hasShadowReceiverVertexProgram
bool hasShadowReceiverVertexProgram(void) const
Returns true if this pass uses a shadow receiver vertex program.
Definition: OgrePass.h:293
Ogre::SharedPtr< GpuProgramParameters >
Ogre::Pass::mSpecular
ColourValue mSpecular
Definition: OgrePass.h:109
Ogre::Light::LT_POINT
@ LT_POINT
Point light sources give off light equally in all directions, so require only position not direction.
Definition: OgreLight.h:85
Ogre::IS_PER_LIGHT
@ IS_PER_LIGHT
Part of the rendering which occurs per light.
Definition: OgrePass.h:54
Ogre::Pass::_prepare
void _prepare(void)
Internal method for preparing to load this pass.
Ogre::Pass::mPolygonMode
PolygonMode mPolygonMode
Polygon mode.
Definition: OgrePass.h:183
Ogre::Pass::getPointMaxSize
Real getPointMaxSize(void) const
Get the maximum point size, when point attenuation is in use.
Ogre::Pass::getFogMode
FogMode getFogMode(void) const
Returns the fog mode for this pass.
Ogre::Pass::getRunOnlyForOneLightType
bool getRunOnlyForOneLightType(void) const
Does this pass run only for a single light type (if getIteratePerLight is true).
Definition: OgrePass.h:1182
Ogre::Pass::setStartLight
void setStartLight(unsigned short startLight)
Sets the light index that this pass will start at in the light list.
Ogre::Pass::getIndex
unsigned short getIndex(void) const
Gets the index of this Pass in the parent Technique.
Definition: OgrePass.h:300
Ogre::Pass::Pass
Pass(Technique *parent, unsigned short index, const Pass &oth)
Copy constructor.
Ogre::Pass::_load
void _load(void)
Internal method for loading this pass.
Ogre::Pass::setMaxSimultaneousLights
void setMaxSimultaneousLights(unsigned short maxLights)
Sets the maximum number of lights to be used by this pass.
Ogre::Pass::setSpecular
void setSpecular(const ColourValue &specular)
Sets the specular colour reflectance properties of this pass.
Ogre::Pass::mShadowReceiverFragmentProgramUsage
GpuProgramUsage * mShadowReceiverFragmentProgramUsage
Fragment program details.
Definition: OgrePass.h:212
Ogre::FOG_NONE
@ FOG_NONE
No fog. Duh.
Definition: OgreCommon.h:124
Ogre::Pass::mShadowReceiverVertexProgramUsage
GpuProgramUsage * mShadowReceiverVertexProgramUsage
Vertex program details.
Definition: OgrePass.h:208
Ogre::IlluminationPass::stage
IlluminationStage stage
Definition: OgrePass.h:1861
Ogre::Pass::getDiffuse
const ColourValue & getDiffuse(void) const
Gets the diffuse colour reflectance of the pass.
Ogre::Pass::setPointMinSize
void setPointMinSize(Real min)
Set the minimum point size, when point attenuation is in use.
Ogre::Pass::getShadowReceiverFragmentProgramParameters
GpuProgramParametersSharedPtr getShadowReceiverFragmentProgramParameters(void) const
Gets the fragment program parameters used by this pass when rendering shadow receivers.
Ogre::Pass::mLightMask
uint32 mLightMask
With a specific light mask?
Definition: OgrePass.h:178
Ogre::Pass::getSceneBlendingOperation
SceneBlendOperation getSceneBlendingOperation() const
Returns the current blending operation.
Ogre::Pass::setPointSize
void setPointSize(Real ps)
Sets the point size of this pass.
Ogre::Pass::mDiffuse
ColourValue mDiffuse
Definition: OgrePass.h:108
OgreBlendMode.h
Ogre::Pass::setDepthCheckEnabled
void setDepthCheckEnabled(bool enabled)
Sets whether or not this pass renders with depth-buffer checking on or not.
Ogre::Pass::getIlluminationStage
IlluminationStage getIlluminationStage() const
Get the manually assigned illumination stage, if any.
Definition: OgrePass.h:1700
OgreColourValue.h
Ogre::ColourValue
Class representing colour.
Definition: OgreColourValue.h:58
Ogre::Pass::getShadowCasterVertexProgramName
const String & getShadowCasterVertexProgramName(void) const
Gets the name of the vertex program used by this pass when rendering shadow casters.
Ogre::Pass::mIndex
unsigned short mIndex
Definition: OgrePass.h:101
OgreGpuProgram.h
Ogre::Pass::getIteratePerLight
bool getIteratePerLight(void) const
Does this pass run once for every light in range?
Definition: OgrePass.h:1180
Ogre::Pass::setLightScissoringEnabled
void setLightScissoringEnabled(bool enabled)
Sets whether or not this pass will be clipped by a scissor rectangle encompassing the lights that are...
Definition: OgrePass.h:1642
Ogre::Pass::setName
void setName(const String &name)
Ogre::Pass::getTextureUnitStateIndex
unsigned short getTextureUnitStateIndex(const TextureUnitState *state) const
Retrieve the index of the Texture Unit State in the pass.
Ogre::Pass::getDestBlendFactorAlpha
SceneBlendFactor getDestBlendFactorAlpha() const
Retrieves the alpha destination blending factor for the material (as set using Materiall::setSeparate...
Ogre::Pass::getNumTextureUnitStates
unsigned short getNumTextureUnitStates(void) const
Returns the number of texture unit settings.
Definition: OgrePass.h:617
Ogre::Pass::ContentTypeLookup
vector< unsigned short >::type ContentTypeLookup
Definition: OgrePass.h:234
Ogre::Pass::setManualCullingMode
void setManualCullingMode(ManualCullingMode mode)
Sets the manual culling mode, performed by CPU rather than hardware.
Ogre::Pass::setDepthFunction
void setDepthFunction(CompareFunction func)
Sets the function used to compare depth values when depth checking is on.
Ogre::IS_DECAL
@ IS_DECAL
Post-lighting rendering.
Definition: OgrePass.h:56
Ogre::Pass::getTesselationHullProgramParameters
GpuProgramParametersSharedPtr getTesselationHullProgramParameters(void) const
Gets the Tesselation Hull program parameters used by this pass.
Ogre::Pass::getPointSpritesEnabled
bool getPointSpritesEnabled(void) const
Returns whether point sprites are enabled when rendering a point list.
Ogre::Pass::mFragmentProgramUsage
GpuProgramUsage * mFragmentProgramUsage
Fragment program details.
Definition: OgrePass.h:210
Ogre::Pass::mRunOnlyForOneLightType
bool mRunOnlyForOneLightType
Should it only be run for a certain light type?
Definition: OgrePass.h:175
Ogre::Pass::getDepthBiasConstant
float getDepthBiasConstant(void) const
Retrieves the const depth bias value as set by setDepthBias.
Ogre::Pass::mIlluminationStage
IlluminationStage mIlluminationStage
Illumination stage?
Definition: OgrePass.h:242
OgreUserObjectBindings.h
Ogre::Pass::mDepthCheck
bool mDepthCheck
Definition: OgrePass.h:137
Ogre::ShadeOptions
ShadeOptions
Light shading modes.
Definition: OgreCommon.h:114
Ogre::Pass::OGRE_STATIC_MUTEX
OGRE_STATIC_MUTEX(msPassGraveyardMutex)
Ogre::Pass::HashFunc::~HashFunc
virtual ~HashFunc()
Need virtual destructor in case subclasses use it.
Definition: OgrePass.h:97
Ogre::Pass::mSeparateBlend
bool mSeparateBlend
Definition: OgrePass.h:123
Ogre::Pass::mFogStart
Real mFogStart
Definition: OgrePass.h:192
Ogre::Pass::getLightScissoringEnabled
bool getLightScissoringEnabled() const
Gets whether or not this pass will be clipped by a scissor rectangle encompassing the lights that are...
Definition: OgrePass.h:1646
Ogre::GpuProgramUsage
This class makes the usage of a vertex and fragment programs (low-level or high-level),...
Definition: OgreGpuProgramUsage.h:74
Ogre::Pass::setDepthWriteEnabled
void setDepthWriteEnabled(bool enabled)
Sets whether or not this pass renders with depth-buffer writing on or not.
Ogre::ManualCullingMode
ManualCullingMode
Manual culling modes based on vertex normals.
Definition: OgreCommon.h:151
Ogre::Pass::setPolygonModeOverrideable
virtual void setPolygonModeOverrideable(bool override)
Sets whether this pass's chosen detail level can be overridden (downgraded) by the camera setting.
Definition: OgrePass.h:945
Ogre::Pass::mLightScissoring
bool mLightScissoring
Scissoring for the light?
Definition: OgrePass.h:238
Ogre::Real
float Real
Software floating point type.
Definition: OgrePrerequisites.h:70
Ogre::Pass::getFogDensity
Real getFogDensity(void) const
Returns the fog density for this pass.
Ogre::Pass::setTextureAnisotropy
void setTextureAnisotropy(unsigned int maxAniso)
Sets the anisotropy level to be used for all textures.
Ogre::Pass::mPointSize
Real mPointSize
Point size, applies when not using per-vertex point size.
Definition: OgrePass.h:226
Ogre::Pass::_unload
void _unload(void)
Internal method for unloading this pass.
Ogre::Pass::setTesselationDomainProgramParameters
void setTesselationDomainProgramParameters(GpuProgramParametersSharedPtr params)
Sets the Tesselation Domain program parameters.
Ogre::Pass::getHash
uint32 getHash(void) const
Gets the 'hash' of this pass, ie a precomputed number to use for sorting.
Definition: OgrePass.h:1500
Ogre::Pass::mParent
Technique * mParent
Definition: OgrePass.h:100
Ogre::Pass::getTextureUnitState
TextureUnitState * getTextureUnitState(const String &name)
Retrieves the Texture Unit State matching name.
Ogre::Pass::setColourWriteEnabled
void setColourWriteEnabled(bool enabled)
Sets whether or not colour buffer writing is enabled for this Pass.
Ogre::Pass::getTesselationDomainProgram
const GpuProgramPtr & getTesselationDomainProgram(void) const
Gets the Tesselation Domain program used by this pass, only available after _load().
Ogre::Pass::mName
String mName
Pass index.
Definition: OgrePass.h:102
Ogre::Pass::getPointSize
Real getPointSize(void) const
Gets the point size of the pass.
Ogre::Pass::isProgrammable
bool isProgrammable(void) const
Returns true if this pass is programmable i.e. includes either a vertex or fragment program.
Definition: OgrePass.h:273
Ogre::Pass::getShadowReceiverVertexProgramName
const String & getShadowReceiverVertexProgramName(void) const
Gets the name of the vertex program used by this pass when rendering shadow receivers.
Ogre::Pass::getFragmentProgramParameters
GpuProgramParametersSharedPtr getFragmentProgramParameters(void) const
Gets the fragment program parameters used by this pass.
Ogre::Pass::mBlendOperation
SceneBlendOperation mBlendOperation
Definition: OgrePass.h:127
Ogre::Pass::mTracking
TrackVertexColourType mTracking
Definition: OgrePass.h:112
Ogre::Pass::getShadowCasterFragmentProgram
const GpuProgramPtr & getShadowCasterFragmentProgram(void) const
Gets the fragment program used by this pass when rendering shadow casters, only available after _load...
Ogre::Pass::setSceneBlending
void setSceneBlending(const SceneBlendType sbt)
Sets the kind of blending this pass has with the existing contents of the scene.
Ogre::Pass::mFogColour
ColourValue mFogColour
Definition: OgrePass.h:191
Ogre::Pass::hasTesselationHullProgram
bool hasTesselationHullProgram(void) const
Returns true if this pass uses a programmable tesselation control pipeline.
Definition: OgrePass.h:283
Ogre::IlluminationPass
Struct recording a pass which can be used for a specific illumination stage.
Definition: OgrePass.h:1860
Ogre::Pass::getDepthCheckEnabled
bool getDepthCheckEnabled(void) const
Returns whether or not this pass renders with depth-buffer checking on or not.
Ogre::Pass::mDestBlendFactorAlpha
SceneBlendFactor mDestBlendFactorAlpha
Definition: OgrePass.h:120
Ogre::Pass::mAlphaRejectVal
unsigned char mAlphaRejectVal
Definition: OgrePass.h:149
Ogre::Pass::getFogColour
const ColourValue & getFogColour(void) const
Returns the fog colour for the scene.
Ogre::Pass::getAlphaRejectValue
unsigned char getAlphaRejectValue(void) const
Gets the alpha reject value.
Definition: OgrePass.h:1086
Ogre::Pass::getPassGraveyard
static const PassSet & getPassGraveyard(void)
Static method to retrieve all the Passes which are pending deletion.
Definition: OgrePass.h:1569
Ogre::Pass::getVertexProgramParameters
GpuProgramParametersSharedPtr getVertexProgramParameters(void) const
Gets the vertex program parameters used by this pass.
Ogre::Pass::mManualCullMode
ManualCullingMode mManualCullMode
Definition: OgrePass.h:161
Ogre::vector
Definition: OgrePrerequisites.h:492
Ogre::Pass::setHashFunction
static void setHashFunction(BuiltinHashFunction builtin)
Sets one of the default hash functions to be used.
Ogre::Pass::getVertexProgramName
const String & getVertexProgramName(void) const
Gets the name of the vertex program used by this pass.
Ogre::Pass::calculateSize
size_t calculateSize(void) const
Ogre::Pass::mSourceBlendFactor
SceneBlendFactor mSourceBlendFactor
Definition: OgrePass.h:117
Ogre::Pass::setDiffuse
void setDiffuse(Real red, Real green, Real blue, Real alpha)
Sets the diffuse colour reflectance properties of this pass.
Ogre::Pass::mAlphaRejectFunc
CompareFunction mAlphaRejectFunc
Definition: OgrePass.h:148
Ogre::Pass::getNormaliseNormals
bool getNormaliseNormals(void) const
Returns true if this pass has auto-normalisation of normals set.
Definition: OgrePass.h:1560
Ogre::Pass::msDirtyHashList
static PassSet msDirtyHashList
List of Passes whose hashes need recalculating.
Definition: OgrePass.h:254
Ogre::Pass::setSpecular
void setSpecular(Real red, Real green, Real blue, Real alpha)
Sets the specular colour reflectance properties of this pass.
Ogre::Pass::setShadowReceiverFragmentProgramParameters
void setShadowReceiverFragmentProgramParameters(GpuProgramParametersSharedPtr params)
Sets the fragment program parameters for rendering as a shadow receiver.
Ogre::Pass::getComputeProgram
const GpuProgramPtr & getComputeProgram(void) const
Gets the Tesselation EHull program used by this pass, only available after _load().
Ogre::Pass::getUserObjectBindings
const UserObjectBindings & getUserObjectBindings() const
Return an instance of user objects binding associated with this class.
Definition: OgrePass.h:1759
Ogre::Pass::setShadowReceiverFragmentProgram
void setShadowReceiverFragmentProgram(const String &name)
This method allows you to specify a fragment program for use when rendering a texture shadow receiver...
Ogre::Pass::setShadingMode
void setShadingMode(ShadeOptions mode)
Sets the type of light shading required.
Ogre::Pass::mTransparentSortingForced
bool mTransparentSortingForced
Transparent depth sorting forced.
Definition: OgrePass.h:155
Ogre::Pass::getDestBlendFactor
SceneBlendFactor getDestBlendFactor() const
Retrieves the destination blending factor for the material (as set using Materiall::setSceneBlending)...
Ogre::Pass::msPassGraveyard
static PassSet msPassGraveyard
The place where passes go to die.
Definition: OgrePass.h:256
Ogre::Pass::removeAllTextureUnitStates
void removeAllTextureUnitStates(void)
Removes all texture unit settings.
Ogre::Pass::getTextureUnitState
const TextureUnitState * getTextureUnitState(const String &name) const
Retrieves the Texture Unit State matching name.
Ogre::PolygonMode
PolygonMode
The polygon mode to use when rasterising.
Definition: OgreCommon.h:180
Ogre::Pass::mStartLight
unsigned short mStartLight
Starting light index.
Definition: OgrePass.h:169
Ogre::Pass::getStartLight
unsigned short getStartLight(void) const
Gets the light index that this pass will start at in the light list.
Ogre::Pass::setTransparentSortingEnabled
void setTransparentSortingEnabled(bool enabled)
Sets whether or not transparent sorting is enabled.
Ogre::Pass::setSceneBlending
void setSceneBlending(const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor)
Allows very fine control of blending this Pass with the existing contents of the scene.
Ogre::Pass::getPointAttenuationQuadratic
Real getPointAttenuationQuadratic(void) const
Returns the quadratic coefficient of point attenuation.
Ogre::IlluminationPass::destroyOnShutdown
bool destroyOnShutdown
Whether this pass is one which should be deleted itself.
Definition: OgrePass.h:1865
Ogre::ConstVectorIterator
Concrete IteratorWrapper for const access to the underlying container.
Definition: OgreIteratorWrapper.h:217
Ogre::Pass::setNormaliseNormals
void setNormaliseNormals(bool normalise)
If set to true, this forces normals to be normalised dynamically by the hardware for this pass.
Definition: OgrePass.h:1557
Ogre::Pass::_recalculateHash
void _recalculateHash(void)
Internal method for recalculating the hash.
Ogre::Pass::mPolygonModeOverrideable
bool mPolygonModeOverrideable
Definition: OgrePass.h:186
Ogre::Pass::setEmissive
void setEmissive(const ColourValue &emissive)
Sets the amount of self-illumination an object has.
Definition: OgrePass.h:431
Ogre::Pass::getDepthWriteEnabled
bool getDepthWriteEnabled(void) const
Returns whether or not this pass renders with depth-buffer writing on or not.
Ogre::Pass::mSourceBlendFactorAlpha
SceneBlendFactor mSourceBlendFactorAlpha
Definition: OgrePass.h:119
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::SceneBlendOperation
SceneBlendOperation
Blending operations controls how objects are blended into the scene.
Definition: OgreBlendMode.h:254
Ogre::Pass::OGRE_MUTEX
OGRE_MUTEX(mTexUnitChangeMutex)
Ogre::Pass::getSourceBlendFactorAlpha
SceneBlendFactor getSourceBlendFactorAlpha() const
Retrieves the alpha source blending factor for the material (as set using Materiall::setSeparateScene...
Ogre::Pass::isPointAttenuationEnabled
bool isPointAttenuationEnabled(void) const
Returns whether points are attenuated with distance.
Ogre::Pass::msHashFunc
static HashFunc * msHashFunc
The Pass hash functor.
Definition: OgrePass.h:258
Ogre::Pass::mTextureUnitStates
TextureUnitStates mTextureUnitStates
Definition: OgrePass.h:199

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