OGRE: Ogre::Pass Class Reference - OGRE Documentation

# Ogre::Pass Class Reference

Class defining a single pass of a Technique (of a Material), i.e. More...

`#include <OgrePass.h>`

Inheritance diagram for Ogre::Pass:

[legend]

List of all members.

## Public Types
enum | BuiltinHashFunction { MIN_TEXTURE_CHANGE, MIN_GPU_PROGRAM_CHANGE }
| There are some default hash functions used to order passes so that render state changes are minimised, this enumerates them. More...
typedef std::set< Pass * > | PassSet
typedef VectorIterator < TextureUnitStates > | TextureUnitStateIterator
typedef ConstVectorIterator < TextureUnitStates > | ConstTextureUnitStateIterator
## Public Member Functions
| Pass (Technique *parent, unsigned short index)
| Default constructor.
| Pass (Technique *parent, unsigned short index, const Pass &oth)
| Copy constructor.
Pass & | operator= (const Pass &oth)
| Operator = overload.
virtual | ~Pass ()
bool | isProgrammable (void) const
| Returns true if this pass is programmable i.e. includes either a vertex or fragment program.
bool | hasVertexProgram (void) const
| Returns true if this pass uses a programmable vertex pipeline.
bool | hasFragmentProgram (void) const
| Returns true if this pass uses a programmable fragment pipeline.
bool | hasGeometryProgram (void) const
| Returns true if this pass uses a programmable geometry pipeline.
bool | hasShadowCasterVertexProgram (void) const
| Returns true if this pass uses a shadow caster vertex program.
bool | hasShadowReceiverVertexProgram (void) const
| Returns true if this pass uses a shadow receiver vertex program.
bool | hasShadowReceiverFragmentProgram (void) const
| Returns true if this pass uses a shadow receiver fragment program.
unsigned short | getIndex (void) const
| Gets the index of this Pass in the parent Technique.
void | setName (const String &name)
const String & | getName (void) const
| get the name of the pass
void | setAmbient (Real red, Real green, Real blue)
| Sets the ambient colour reflectance properties of this pass.
void | setAmbient (const ColourValue &ambient)
| Sets the ambient colour reflectance properties of this pass.
void | setDiffuse (Real red, Real green, Real blue, Real alpha)
| Sets the diffuse colour reflectance properties of this pass.
void | setDiffuse (const ColourValue &diffuse)
| Sets the diffuse colour reflectance properties of this pass.
void | setSpecular (Real red, Real green, Real blue, Real alpha)
| Sets the specular colour reflectance properties of this pass.
void | setSpecular (const ColourValue &specular)
| Sets the specular colour reflectance properties of this pass.
void | setShininess (Real val)
| Sets the shininess of the pass, affecting the size of specular highlights.
void | setSelfIllumination (Real red, Real green, Real blue)
| Sets the amount of self-illumination an object has.
void | setSelfIllumination (const ColourValue &selfIllum)
| Sets the amount of self-illumination an object has.
void | setVertexColourTracking (TrackVertexColourType tracking)
| Sets which material properties follow the vertex colour.
Real | getPointSize (void) const
| Gets the point size of the pass.
void | setPointSize (Real ps)
| Sets the point size of this pass.
void | setPointSpritesEnabled (bool enabled)
| Sets whether or not rendering points using OT_POINT_LIST will render point sprites (textured quads) or plain points (dots).
bool | getPointSpritesEnabled (void) const
| Returns whether point sprites are enabled when rendering a point list.
void | setPointAttenuation (bool enabled, Real constant=0.0f, Real linear=1.0f, Real quadratic=0.0f)
| Sets how points are attenuated with distance.
bool | isPointAttenuationEnabled (void) const
| Returns whether points are attenuated with distance.
Real | getPointAttenuationConstant (void) const
| Returns the constant coefficient of point attenuation.
Real | getPointAttenuationLinear (void) const
| Returns the linear coefficient of point attenuation.
Real | getPointAttenuationQuadratic (void) const
| Returns the quadratic coefficient of point attenuation.
void | setPointMinSize (Real min)
| Set the minimum point size, when point attenuation is in use.
Real | getPointMinSize (void) const
| Get the minimum point size, when point attenuation is in use.
void | setPointMaxSize (Real max)
| Set the maximum point size, when point attenuation is in use.
Real | getPointMaxSize (void) const
| Get the maximum point size, when point attenuation is in use.
const ColourValue & | getAmbient (void) const
| Gets the ambient colour reflectance of the pass.
const ColourValue & | getDiffuse (void) const
| Gets the diffuse colour reflectance of the pass.
const ColourValue & | getSpecular (void) const
| Gets the specular colour reflectance of the pass.
const ColourValue & | getSelfIllumination (void) const
| Gets the self illumination colour of the pass.
Real | getShininess (void) const
| Gets the 'shininess' property of the pass (affects specular highlights).
TrackVertexColourType | getVertexColourTracking (void) const
| Gets which material properties follow the vertex colour.
TextureUnitState * | createTextureUnitState (void)
| Inserts a new TextureUnitState object into the Pass.
TextureUnitState * | createTextureUnitState (const String &textureName, unsigned short texCoordSet=0)
| Inserts a new TextureUnitState object into the Pass.
void | addTextureUnitState (TextureUnitState *state)
| Adds the passed in TextureUnitState, to the existing Pass.
TextureUnitState * | getTextureUnitState (unsigned short index)
| Retrieves a pointer to a texture unit state so it may be modified.
TextureUnitState * | getTextureUnitState (const String &name)
| Retrieves the Texture Unit State matching name.
const TextureUnitState * | getTextureUnitState (unsigned short index) const
| Retrieves a const pointer to a texture unit state.
const TextureUnitState * | getTextureUnitState (const String &name) const
| Retrieves the Texture Unit State matching name.
unsigned short | getTextureUnitStateIndex (const TextureUnitState *state) const
| Retrieve the index of the Texture Unit State in the pass.
TextureUnitStateIterator | getTextureUnitStateIterator (void)
| Get an iterator over the TextureUnitStates contained in this Pass.
ConstTextureUnitStateIterator | getTextureUnitStateIterator (void) const
| Get an iterator over the TextureUnitStates contained in this Pass.
void | removeTextureUnitState (unsigned short index)
| Removes the indexed texture unit state from this pass.
void | removeAllTextureUnitStates (void)
| Removes all texture unit settings.
unsigned short | getNumTextureUnitStates (void) const
| Returns the number of texture unit settings.
void | setSceneBlending (const SceneBlendType sbt)
| Sets the kind of blending this pass has with the existing contents of the scene.
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 and alpha channels.
void | setSceneBlending (const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor)
| Allows very fine control of blending this Pass with the existing contents of the scene.
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.
bool | hasSeparateSceneBlending () const
| Return true if this pass uses separate scene blending.
SceneBlendFactor | getSourceBlendFactor () const
| Retrieves the source blending factor for the material (as set using Materiall::setSceneBlending).
SceneBlendFactor | getDestBlendFactor () const
| Retrieves the destination blending factor for the material (as set using Materiall::setSceneBlending).
SceneBlendFactor | getSourceBlendFactorAlpha () const
| Retrieves the alpha source blending factor for the material (as set using Materiall::setSeparateSceneBlending).
SceneBlendFactor | getDestBlendFactorAlpha () const
| Retrieves the alpha destination blending factor for the material (as set using Materiall::setSeparateSceneBlending).
bool | isTransparent (void) const
| Returns true if this pass has some element of transparency.
void | setDepthCheckEnabled (bool enabled)
| Sets whether or not this pass renders with depth-buffer checking on or not.
bool | getDepthCheckEnabled (void) const
| Returns whether or not this pass renders with depth-buffer checking on or not.
void | setDepthWriteEnabled (bool enabled)
| Sets whether or not this pass renders with depth-buffer writing on or not.
bool | getDepthWriteEnabled (void) const
| Returns whether or not this pass renders with depth-buffer writing on or not.
void | setDepthFunction (CompareFunction func)
| Sets the function used to compare depth values when depth checking is on.
CompareFunction | getDepthFunction (void) const
| Returns the function used to compare depth values when depth checking is on.
void | setColourWriteEnabled (bool enabled)
| Sets whether or not colour buffer writing is enabled for this Pass.
bool | getColourWriteEnabled (void) const
| Determines if colour buffer writing is enabled for this pass.
void | setCullingMode (CullingMode mode)
| Sets the culling mode for this pass based on the 'vertex winding'.
CullingMode | getCullingMode (void) const
| Returns the culling mode for geometry rendered with this pass.
void | setManualCullingMode (ManualCullingMode mode)
| Sets the manual culling mode, performed by CPU rather than hardware.
ManualCullingMode | getManualCullingMode (void) const
| Retrieves the manual culling mode for this pass.
void | setLightingEnabled (bool enabled)
| Sets whether or not dynamic lighting is enabled.
bool | getLightingEnabled (void) const
| Returns whether or not dynamic lighting is enabled.
void | setMaxSimultaneousLights (unsigned short maxLights)
| Sets the maximum number of lights to be used by this pass.
unsigned short | getMaxSimultaneousLights (void) const
| Gets the maximum number of lights to be used by this pass.
void | setStartLight (unsigned short startLight)
| Sets the light index that this pass will start at in the light list.
unsigned short | getStartLight (void) const
| Gets the light index that this pass will start at in the light list.
void | setShadingMode (ShadeOptions mode)
| Sets the type of light shading required.
ShadeOptions | getShadingMode (void) const
| Returns the type of light shading to be used.
void | setPolygonMode (PolygonMode mode)
| Sets the type of polygon rendering required.
PolygonMode | getPolygonMode (void) const
| Returns the type of light shading to be used.
virtual void | setPolygonModeOverrideable (bool override)
| Sets whether this pass's chosen detail level can be overridden (downgraded) by the camera setting.
virtual bool | getPolygonModeOverrideable (void) const
| Gets whether this renderable's chosen detail level can be overridden (downgraded) by the camera setting.
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.
bool | getFogOverride (void) const
| Returns true if this pass is to override the scene fog settings.
FogMode | getFogMode (void) const
| Returns the fog mode for this pass.
const ColourValue & | getFogColour (void) const
| Returns the fog colour for the scene.
Real | getFogStart (void) const
| Returns the fog start distance for this pass.
Real | getFogEnd (void) const
| Returns the fog end distance for this pass.
Real | getFogDensity (void) const
| Returns the fog density for this pass.
void | setDepthBias (float constantBias, float slopeScaleBias=0.0f)
| Sets the depth bias to be used for this material.
float | getDepthBiasConstant (void) const
| Retrieves the const depth bias value as set by setDepthBias.
float | getDepthBiasSlopeScale (void) const
| Retrieves the slope-scale depth bias value as set by setDepthBias.
void | setIterationDepthBias (float biasPerIteration)
| Sets a factor which derives an additional depth bias from the number of times a pass is iterated.
float | getIterationDepthBias () const
| Gets a factor which derives an additional depth bias from the number of times a pass is iterated.
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.
void | setAlphaRejectFunction (CompareFunction func)
| Sets the alpha reject function.
void | setAlphaRejectValue (unsigned char val)
| Gets the alpha reject value.
CompareFunction | getAlphaRejectFunction (void) const
| Gets the alpha reject function.
unsigned char | getAlphaRejectValue (void) const
| Gets the alpha reject value.
void | setAlphaToCoverageEnabled (bool enabled)
| Sets whether to use alpha to coverage (A2C) when blending alpha rejected values.
bool | isAlphaToCoverageEnabled () const
| Gets whether to use alpha to coverage (A2C) when blending alpha rejected values.
void | setTransparentSortingEnabled (bool enabled)
| Sets whether or not transparent sorting is enabled.
bool | getTransparentSortingEnabled (void) const
| Returns whether or not transparent sorting is enabled.
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 object being rendered.
bool | getIteratePerLight (void) const
| Does this pass run once for every light in range?
bool | getRunOnlyForOneLightType (void) const
| Does this pass run only for a single light type (if getIteratePerLight is true).
Light::LightTypes | getOnlyLightType () const
| Gets the single light type this pass runs for if getIteratePerLight and getRunOnlyForOneLightType are both true.
void | setLightCountPerIteration (unsigned short c)
| If light iteration is enabled, determine the number of lights per iteration.
unsigned short | getLightCountPerIteration (void) const
| If light iteration is enabled, determine the number of lights per iteration.
Technique * | getParent (void) const
| Gets the parent Technique.
const String & | getResourceGroup (void) const
| Gets the resource group of the ultimate parent Material.
void | setVertexProgram (const String &name, bool resetParams=true)
| Sets the details of the vertex program to use.
void | setVertexProgramParameters (GpuProgramParametersSharedPtr params)
| Sets the vertex program parameters.
const String & | getVertexProgramName (void) const
| Gets the name of the vertex program used by this pass.
GpuProgramParametersSharedPtr | getVertexProgramParameters (void) const
| Gets the vertex program parameters used by this pass.
const GpuProgramPtr & | getVertexProgram (void) const
| Gets the vertex program used by this pass, only available after _load().
void | setShadowCasterVertexProgram (const String &name)
| Sets the details of the vertex program to use when rendering as a shadow caster.
void | setShadowCasterVertexProgramParameters (GpuProgramParametersSharedPtr params)
| Sets the vertex program parameters for rendering as a shadow caster.
const String & | getShadowCasterVertexProgramName (void) const
| Gets the name of the vertex program used by this pass when rendering shadow casters.
GpuProgramParametersSharedPtr | getShadowCasterVertexProgramParameters (void) const
| Gets the vertex program parameters used by this pass when rendering shadow casters.
const GpuProgramPtr & | getShadowCasterVertexProgram (void) const
| Gets the vertex program used by this pass when rendering shadow casters, only available after _load().
void | setShadowReceiverVertexProgram (const String &name)
| Sets the details of the vertex program to use when rendering as a shadow receiver.
void | setShadowReceiverVertexProgramParameters (GpuProgramParametersSharedPtr params)
| Sets the vertex program parameters for rendering as a shadow receiver.
void | setShadowReceiverFragmentProgram (const String &name)
| This method allows you to specify a fragment program for use when rendering a texture shadow receiver.
void | setShadowReceiverFragmentProgramParameters (GpuProgramParametersSharedPtr params)
| Sets the fragment program parameters for rendering as a shadow receiver.
const String & | getShadowReceiverVertexProgramName (void) const
| Gets the name of the vertex program used by this pass when rendering shadow receivers.
GpuProgramParametersSharedPtr | getShadowReceiverVertexProgramParameters (void) const
| Gets the vertex program parameters used by this pass when rendering shadow receivers.
const GpuProgramPtr & | getShadowReceiverVertexProgram (void) const
| Gets the vertex program used by this pass when rendering shadow receivers, only available after _load().
const String & | getShadowReceiverFragmentProgramName (void) const
| Gets the name of the fragment program used by this pass when rendering shadow receivers.
GpuProgramParametersSharedPtr | getShadowReceiverFragmentProgramParameters (void) const
| Gets the fragment program parameters used by this pass when rendering shadow receivers.
const GpuProgramPtr & | getShadowReceiverFragmentProgram (void) const
| Gets the fragment program used by this pass when rendering shadow receivers, only available after _load().
void | setFragmentProgram (const String &name, bool resetParams=true)
| Sets the details of the fragment program to use.
void | setFragmentProgramParameters (GpuProgramParametersSharedPtr params)
| Sets the fragment program parameters.
const String & | getFragmentProgramName (void) const
| Gets the name of the fragment program used by this pass.
GpuProgramParametersSharedPtr | getFragmentProgramParameters (void) const
| Gets the fragment program parameters used by this pass.
const GpuProgramPtr & | getFragmentProgram (void) const
| Gets the fragment program used by this pass, only available after _load().
void | setGeometryProgram (const String &name, bool resetParams=true)
| Sets the details of the geometry program to use.
void | setGeometryProgramParameters (GpuProgramParametersSharedPtr params)
| Sets the geometry program parameters.
const String & | getGeometryProgramName (void) const
| Gets the name of the geometry program used by this pass.
GpuProgramParametersSharedPtr | getGeometryProgramParameters (void) const
| Gets the geometry program parameters used by this pass.
const GpuProgramPtr & | getGeometryProgram (void) const
| Gets the geometry program used by this pass, only available after _load().
Pass * | _split (unsigned short numUnits)
| Splits this Pass to one which can be handled in the number of texture units specified.
void | _notifyIndex (unsigned short index)
| Internal method to adjust pass index.
void | _prepare (void)
| Internal method for preparing to load this pass.
void | _unprepare (void)
| Internal method for undoing the load preparartion for this pass.
void | _load (void)
| Internal method for loading this pass.
void | _unload (void)
| Internal method for unloading this pass.
bool | isLoaded (void) const
uint32 | getHash (void) const
| Gets the 'hash' of this pass, ie a precomputed number to use for sorting.
void | _dirtyHash (void)
| Mark the hash as dirty.
void | _recalculateHash (void)
| Internal method for recalculating the hash.
void | _notifyNeedsRecompile (void)
| Tells the pass that it needs recompilation.
void | _updateAutoParamsNoLights (const AutoParamDataSource *source) const
| Update any automatic parameters (except lights) on this pass.
void | _updateAutoParamsLightsOnly (const AutoParamDataSource *source) const
| Update any automatic light parameters on this pass.
unsigned short | _getTextureUnitWithContentTypeIndex (TextureUnitState::ContentType contentType, unsigned short index) const
| Gets the 'nth' texture which references the given content type.
void | setTextureFiltering (TextureFilterOptions filterType)
| Set texture filtering for every texture unit.
void | setTextureAnisotropy (unsigned int maxAniso)
| Sets the anisotropy level to be used for all textures.
void | setNormaliseNormals (bool normalise)
| If set to true, this forces normals to be normalised dynamically by the hardware for this pass.
bool | getNormaliseNormals (void) const
| Returns true if this pass has auto-normalisation of normals set.
void | queueForDeletion (void)
| Queue this pass for deletion when appropriate.
bool | isAmbientOnly (void) const
| Returns whether this pass is ambient only.
void | setPassIterationCount (const size_t count)
| set the number of iterations that this pass should perform when doing fast multi pass operation.
size_t | getPassIterationCount (void) const
| Gets the pass iteration count value.
bool | applyTextureAliases (const AliasTextureNamePairList &aliasList, const bool apply=true) const
| Applies texture names to Texture Unit State with matching texture name aliases.
void | setLightScissoringEnabled (bool enabled)
| Sets whether or not this pass will be clipped by a scissor rectangle encompassing the lights that are being used in it.
bool | getLightScissoringEnabled () const
| Gets whether or not this pass will be clipped by a scissor rectangle encompassing the lights that are being used in it.
void | setLightClipPlanesEnabled (bool enabled)
| Gets whether or not this pass will be clipped by user clips planes bounding the area covered by the light.
bool | getLightClipPlanesEnabled () const
| Gets whether or not this pass will be clipped by user clips planes bounding the area covered by the light.
void | setIlluminationStage (IlluminationStage is)
| Manually set which illumination stage this pass is a member of.
IlluminationStage | getIlluminationStage () const
| Get the manually assigned illumination stage, if any.
void * | operator new (size_t sz, const char *file, int line, const char *func)
| operator new, with debug line info
void * | operator new (size_t sz)
void * | operator new (size_t sz, void *ptr)
| placement operator new
void * | operator new[] (size_t sz, const char *file, int line, const char *func)
| array operator new, with debug line info
void * | operator new[] (size_t sz)
void | operator delete (void *ptr)
void | operator delete (void *ptr, void *)
void | operator delete (void *ptr, const char *, int, const char *)
void | operator delete[] (void *ptr)
void | operator delete[] (void *ptr, const char *, int, const char *)
## Static Public Member Functions
static const PassSet & | getDirtyHashList (void)
| Static method to retrieve all the Passes which need their hash values recalculated.
static const PassSet & | getPassGraveyard (void)
| Static method to retrieve all the Passes which are pending deletion.
static void | clearDirtyHashList (void)
| Static method to reset the list of passes which need their hash values recalculated.
static void | processPendingPassUpdates (void)
| Process all dirty and pending deletion passes.
static void | setHashFunction (BuiltinHashFunction builtin)
| Sets one of the default hash functions to be used.
static void | setHashFunction (HashFunc *hashFunc)
| Set the hash function used for all passes.
static HashFunc * | getHashFunction (void)
| Get the hash function used for all passes.
## Protected Types
typedef std::vector < TextureUnitState * > | TextureUnitStates
| Storage of texture unit states.
typedef std::vector< unsigned short > | ContentTypeLookup
## Protected Member Functions
void | _getBlendFlags (SceneBlendType type, SceneBlendFactor &source, SceneBlendFactor &dest)
## Protected Attributes
Technique * | mParent
unsigned short | mIndex
String | mName
uint32 | mHash
bool | mHashDirtyQueued
ColourValue | mAmbient
ColourValue | mDiffuse
ColourValue | mSpecular
ColourValue | mEmissive
Real | mShininess
TrackVertexColourType | mTracking
SceneBlendFactor | mSourceBlendFactor
SceneBlendFactor | mDestBlendFactor
SceneBlendFactor | mSourceBlendFactorAlpha
SceneBlendFactor | mDestBlendFactorAlpha
bool | mSeparateBlend
bool | mDepthCheck
bool | mDepthWrite
CompareFunction | mDepthFunc
float | mDepthBiasConstant
float | mDepthBiasSlopeScale
float | mDepthBiasPerIteration
bool | mColourWrite
CompareFunction | mAlphaRejectFunc
unsigned char | mAlphaRejectVal
bool | mAlphaToCoverageEnabled
bool | mTransparentSorting
CullingMode | mCullMode
ManualCullingMode | mManualCullMode
bool | mLightingEnabled
| Lighting enabled?
unsigned short | mMaxSimultaneousLights
| Max simultaneous lights.
unsigned short | mStartLight
| Starting light index.
bool | mIteratePerLight
| Run this pass once per light?
unsigned short | mLightsPerIteration
| Iterate per how many lights?
bool | mRunOnlyForOneLightType
Light::LightTypes | mOnlyLightType
ShadeOptions | mShadeOptions
| Shading options.
PolygonMode | mPolygonMode
| Polygon mode.
bool | mNormaliseNormals
| Normalisation.
bool | mPolygonModeOverrideable
bool | mFogOverride
FogMode | mFogMode
ColourValue | mFogColour
Real | mFogStart
Real | mFogEnd
Real | mFogDensity
TextureUnitStates | mTextureUnitStates
GpuProgramUsage * | mVertexProgramUsage
GpuProgramUsage * | mShadowCasterVertexProgramUsage
GpuProgramUsage * | mShadowReceiverVertexProgramUsage
GpuProgramUsage * | mFragmentProgramUsage
GpuProgramUsage * | mShadowReceiverFragmentProgramUsage
GpuProgramUsage * | mGeometryProgramUsage
bool | mQueuedForDeletion
size_t | mPassIterationCount
Real | mPointSize
Real | mPointMinSize
Real | mPointMaxSize
bool | mPointSpritesEnabled
bool | mPointAttenuationEnabled
Real | mPointAttenuationCoeffs [3]
ContentTypeLookup | mShadowContentTypeLookup
bool | mContentTypeLookupBuilt
bool | mLightScissoring
| Scissoring for the light?
bool | mLightClipPlanes
| User clip planes for light?
IlluminationStage | mIlluminationStage
| Illumination stage?
## Static Protected Attributes
static PassSet | msDirtyHashList
| List of Passes whose hashes need recalculating.
static PassSet | msPassGraveyard
| The place where passes go to die.
static HashFunc * | msHashFunc
| The Pass hash functor.
## Classes
struct | HashFunc
| Definition of a functor for calculating the hashcode of a Pass. More...

## Detailed Description

Class defining a single pass of a Technique (of a Material), i.e.

a single rendering call.

Remarks:
  Rendering can be repeated with many passes for more complex effects. Each pass is either a fixed-function pass (meaning it does not use a vertex or fragment program) or a programmable pass (meaning it does use either a vertex and fragment program, or both).

  Programmable passes are complex to define, because they require custom programs and you have to set all constant inputs to the programs (like the position of lights, any base material colours you wish to use etc), but they do give you much total flexibility over the algorithms used to render your pass, and you can create some effects which are impossible with a fixed-function pass. On the other hand, you can define a fixed-function pass in very little time, and you can use a range of fixed-function effects like environment mapping very easily, plus your pass will be more likely to be compatible with older hardware. There are pros and cons to both, just remember that if you use a programmable pass to create some great effects, allow more time for definition and testing.

Definition at line 74 of file OgrePass.h.

## Member Typedef Documentation

typedef std::vector<TextureUnitState*> Ogre::Pass::TextureUnitStates`[protected]`

Storage of texture unit states.

Definition at line 179 of file OgrePass.h.

typedef std::vector<unsigned short> Ogre::Pass::ContentTypeLookup`[protected]`

Definition at line 207 of file OgrePass.h.

typedef std::set<Pass*> Ogre::Pass::PassSet

Definition at line 221 of file OgrePass.h.

typedef VectorIterator<TextureUnitStates> Ogre::Pass::TextureUnitStateIterator

Definition at line 528 of file OgrePass.h.

typedef ConstVectorIterator<TextureUnitStates> Ogre::Pass::ConstTextureUnitStateIterator

Definition at line 532 of file OgrePass.h.

## Member Enumeration Documentation

enum Ogre::Pass::BuiltinHashFunction

There are some default hash functions used to order passes so that render state changes are minimised, this enumerates them.

Enumerator:

  MIN_TEXTURE_CHANGE | Try to minimise the number of texture changes.
  MIN_GPU_PROGRAM_CHANGE | Try to minimise the number of GPU program changes. Note: Only really useful if you use GPU programs for all of your materials.

Definition at line 1533 of file OgrePass.h.

## Constructor & Destructor Documentation

Ogre::Pass::Pass | ( | Technique * | parent,
|  | unsigned short | index |
| ) |  |  |

Default constructor.

Ogre::Pass::Pass | ( | Technique * | parent,
|  | unsigned short | index,
|  | const Pass & | oth |
| ) |  |  |

Copy constructor.

virtual Ogre::Pass::~Pass | ( |  | ) | `[virtual]`

## Member Function Documentation

void Ogre::Pass::_getBlendFlags | ( | SceneBlendType | type,
|  | SceneBlendFactor & | source,
|  | SceneBlendFactor & | dest |
| ) |  |  | `[protected]`

Pass& Ogre::Pass::operator= | ( | const Pass & | oth | ) |

Operator = overload.

bool Ogre::Pass::isProgrammable | ( | void |  | ) | const

Returns true if this pass is programmable i.e. includes either a vertex or fragment program.

Definition at line 243 of file OgrePass.h.

bool Ogre::Pass::hasVertexProgram | ( | void |  | ) | const

Returns true if this pass uses a programmable vertex pipeline.

Definition at line 245 of file OgrePass.h.

bool Ogre::Pass::hasFragmentProgram | ( | void |  | ) | const

Returns true if this pass uses a programmable fragment pipeline.

Definition at line 247 of file OgrePass.h.

bool Ogre::Pass::hasGeometryProgram | ( | void |  | ) | const

Returns true if this pass uses a programmable geometry pipeline.

Definition at line 249 of file OgrePass.h.

bool Ogre::Pass::hasShadowCasterVertexProgram | ( | void |  | ) | const

Returns true if this pass uses a shadow caster vertex program.

Definition at line 251 of file OgrePass.h.

bool Ogre::Pass::hasShadowReceiverVertexProgram | ( | void |  | ) | const

Returns true if this pass uses a shadow receiver vertex program.

Definition at line 253 of file OgrePass.h.

bool Ogre::Pass::hasShadowReceiverFragmentProgram | ( | void |  | ) | const

Returns true if this pass uses a shadow receiver fragment program.

Definition at line 255 of file OgrePass.h.

unsigned short Ogre::Pass::getIndex | ( | void |  | ) | const

Gets the index of this Pass in the parent Technique.

Definition at line 259 of file OgrePass.h.

void Ogre::Pass::setName | ( | const String & | name | ) |

const String& Ogre::Pass::getName | ( | void |  | ) | const

get the name of the pass

Definition at line 267 of file OgrePass.h.

void Ogre::Pass::setAmbient | ( | Real | red,
|  | Real | green,
|  | Real | blue |
| ) |  |  |

Sets the ambient colour reflectance properties of this pass.

Remarks:
  The base colour of a pass is determined by how much red, green and blue light is reflects (provided texture layer #0 has a blend mode other than LBO_REPLACE). This property determines how much ambient light (directionless global light) is reflected. The default is full white, meaning objects are completely globally illuminated. Reduce this if you want to see diffuse or specular light effects, or change the blend of colours to make the object have a base colour other than white.

Note:
  This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled), or if this is a programmable pass.

void Ogre::Pass::setAmbient | ( | const ColourValue & | ambient | ) |

Sets the ambient colour reflectance properties of this pass.

Remarks:
  The base colour of a pass is determined by how much red, green and blue light is reflects (provided texture layer #0 has a blend mode other than LBO_REPLACE). This property determines how much ambient light (directionless global light) is reflected. The default is full white, meaning objects are completely globally illuminated. Reduce this if you want to see diffuse or specular light effects, or change the blend of colours to make the object have a base colour other than white.

Note:
  This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled), or if this is a programmable pass.

void Ogre::Pass::setDiffuse | ( | Real | red,
|  | Real | green,
|  | Real | blue,
|  | Real | alpha |
| ) |  |  |

Sets the diffuse colour reflectance properties of this pass.

Remarks:
  The base colour of a pass is determined by how much red, green and blue light is reflects (provided texture layer #0 has a blend mode other than LBO_REPLACE). This property determines how much diffuse light (light from instances of the Light class in the scene) is reflected. The default is full white, meaning objects reflect the maximum white light they can from Light objects.

Note:
  This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled), or if this is a programmable pass.

void Ogre::Pass::setDiffuse | ( | const ColourValue & | diffuse | ) |

Sets the diffuse colour reflectance properties of this pass.

Remarks:
  The base colour of a pass is determined by how much red, green and blue light is reflects (provided texture layer #0 has a blend mode other than LBO_REPLACE). This property determines how much diffuse light (light from instances of the Light class in the scene) is reflected. The default is full white, meaning objects reflect the maximum white light they can from Light objects.

Note:
  This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled), or if this is a programmable pass.

void Ogre::Pass::setSpecular | ( | Real | red,
|  | Real | green,
|  | Real | blue,
|  | Real | alpha |
| ) |  |  |

Sets the specular colour reflectance properties of this pass.

Remarks:
  The base colour of a pass is determined by how much red, green and blue light is reflects (provided texture layer #0 has a blend mode other than LBO_REPLACE). This property determines how much specular light (highlights from instances of the Light class in the scene) is reflected. The default is to reflect no specular light.

Note:
  The size of the specular highlights is determined by the separate 'shininess' property.

  This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled), or if this is a programmable pass.

void Ogre::Pass::setSpecular | ( | const ColourValue & | specular | ) |

Sets the specular colour reflectance properties of this pass.

Remarks:
  The base colour of a pass is determined by how much red, green and blue light is reflects (provided texture layer #0 has a blend mode other than LBO_REPLACE). This property determines how much specular light (highlights from instances of the Light class in the scene) is reflected. The default is to reflect no specular light.

Note:
  The size of the specular highlights is determined by the separate 'shininess' property.

  This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled), or if this is a programmable pass.

void Ogre::Pass::setShininess | ( | Real | val | ) |

Sets the shininess of the pass, affecting the size of specular highlights.

Note:
  This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled), or if this is a programmable pass.

void Ogre::Pass::setSelfIllumination | ( | Real | red,
|  | Real | green,
|  | Real | blue |
| ) |  |  |

Sets the amount of self-illumination an object has.

Remarks:
  If an object is self-illuminating, it does not need external sources to light it, ambient or otherwise. It's like the object has it's own personal ambient light. This property is rarely useful since you can already specify per-pass ambient light, but is here for completeness.

Note:
  This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled), or if this is a programmable pass.

void Ogre::Pass::setSelfIllumination | ( | const ColourValue & | selfIllum | ) |

Sets the amount of self-illumination an object has.

Remarks:
  If an object is self-illuminating, it does not need external sources to light it, ambient or otherwise. It's like the object has it's own personal ambient light. This property is rarely useful since you can already specify per-pass ambient light, but is here for completeness.

Note:
  This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled), or if this is a programmable pass.

void Ogre::Pass::setVertexColourTracking | ( | TrackVertexColourType | tracking | ) |

Sets which material properties follow the vertex colour.

Real Ogre::Pass::getPointSize | ( | void |  | ) | const

Gets the point size of the pass.

Remarks:
  This property determines what point size is used to render a point list.

void Ogre::Pass::setPointSize | ( | Real | ps | ) |

Sets the point size of this pass.

Remarks:
  This setting allows you to change the size of points when rendering a point list, or a list of point sprites. The interpretation of this command depends on the Pass::setPointSizeAttenuation option - if it is off (the default), the point size is in screen pixels, if it is on, it expressed as normalised screen coordinates (1.0 is the height of the screen) when the point is at the origin.

Note:
  Some drivers have an upper limit on the size of points they support
  - this can even vary between APIs on the same card! Don't rely on point sizes that cause the point sprites to get very large on screen, since they may get clamped on some cards. Upper sizes can range from 64 to 256 pixels.

void Ogre::Pass::setPointSpritesEnabled | ( | bool | enabled | ) |

Sets whether or not rendering points using OT_POINT_LIST will render point sprites (textured quads) or plain points (dots).

Parameters:

  | enabled | True enables point sprites, false returns to normal point rendering.

bool Ogre::Pass::getPointSpritesEnabled | ( | void |  | ) | const

Returns whether point sprites are enabled when rendering a point list.

void Ogre::Pass::setPointAttenuation | ( | bool | enabled,
|  | Real | constant = `0.0f`,
|  | Real | linear = `1.0f`,
|  | Real | quadratic = `0.0f` |
| ) |  |  |

Sets how points are attenuated with distance.

Remarks:
  When performing point rendering or point sprite rendering, point size can be attenuated with distance. The equation for doing this is attenuation = 1 / (constant + linear * dist + quadratic * d^2).

  For example, to disable distance attenuation (constant screensize) you would set constant to 1, and linear and quadratic to 0. A standard perspective attenuation would be 0, 1, 0 respectively.

Note:
  The resulting size is clamped to the minimum and maximum point size.

Parameters:

  | enabled | Whether point attenuation is enabled
  | constant,linear,quadratic | Parameters to the attenuation function defined above

bool Ogre::Pass::isPointAttenuationEnabled | ( | void |  | ) | const

Returns whether points are attenuated with distance.

Real Ogre::Pass::getPointAttenuationConstant | ( | void |  | ) | const

Returns the constant coefficient of point attenuation.

Real Ogre::Pass::getPointAttenuationLinear | ( | void |  | ) | const

Returns the linear coefficient of point attenuation.

Real Ogre::Pass::getPointAttenuationQuadratic | ( | void |  | ) | const

Returns the quadratic coefficient of point attenuation.

void Ogre::Pass::setPointMinSize | ( | Real | min | ) |

Set the minimum point size, when point attenuation is in use.

Real Ogre::Pass::getPointMinSize | ( | void |  | ) | const

Get the minimum point size, when point attenuation is in use.

void Ogre::Pass::setPointMaxSize | ( | Real | max | ) |

Set the maximum point size, when point attenuation is in use.

Remarks:
  Setting this to 0 indicates the max size supported by the card.

Real Ogre::Pass::getPointMaxSize | ( | void |  | ) | const

Get the maximum point size, when point attenuation is in use.

Remarks:
  0 indicates the max size supported by the card.

const ColourValue& Ogre::Pass::getAmbient | ( | void |  | ) | const

Gets the ambient colour reflectance of the pass.

const ColourValue& Ogre::Pass::getDiffuse | ( | void |  | ) | const

Gets the diffuse colour reflectance of the pass.

const ColourValue& Ogre::Pass::getSpecular | ( | void |  | ) | const

Gets the specular colour reflectance of the pass.

const ColourValue& Ogre::Pass::getSelfIllumination | ( | void |  | ) | const

Gets the self illumination colour of the pass.

Real Ogre::Pass::getShininess | ( | void |  | ) | const

Gets the 'shininess' property of the pass (affects specular highlights).

TrackVertexColourType Ogre::Pass::getVertexColourTracking | ( | void |  | ) | const

Gets which material properties follow the vertex colour.

TextureUnitState* Ogre::Pass::createTextureUnitState | ( | void |  | ) |

Inserts a new TextureUnitState object into the Pass.

Remarks:
  This unit is is added on top of all previous units.

TextureUnitState* Ogre::Pass::createTextureUnitState | ( | const String & | textureName,
|  | unsigned short | texCoordSet = `0` |
| ) |  |  |

Inserts a new TextureUnitState object into the Pass.

Remarks:
  This unit is is added on top of all previous units.

Parameters:

  | name | The basic name of the texture e.g. brickwall.jpg, stonefloor.png
  | texCoordSet | The index of the texture coordinate set to use.

Note:
  Applies to both fixed-function and programmable passes.

void Ogre::Pass::addTextureUnitState | ( | TextureUnitState * | state | ) |

Adds the passed in TextureUnitState, to the existing Pass.

Parameters:

  | state | The Texture Unit State to be attached to this pass. It must not be attached to another pass.

Note:
  Throws an exception if the TextureUnitState is attached to another Pass.

TextureUnitState* Ogre::Pass::getTextureUnitState | ( | unsigned short | index | ) |

Retrieves a pointer to a texture unit state so it may be modified.

TextureUnitState* Ogre::Pass::getTextureUnitState | ( | const String & | name | ) |

Retrieves the Texture Unit State matching name.

Returns 0 if name match is not found.

const TextureUnitState* Ogre::Pass::getTextureUnitState | ( | unsigned short | index | ) | const

Retrieves a const pointer to a texture unit state.

const TextureUnitState* Ogre::Pass::getTextureUnitState | ( | const String & | name | ) | const

Retrieves the Texture Unit State matching name.

Returns 0 if name match is not found.

unsigned short Ogre::Pass::getTextureUnitStateIndex | ( | const TextureUnitState * | state | ) | const

Retrieve the index of the Texture Unit State in the pass.

Parameters:

  | state | The Texture Unit State this is attached to this pass.

Note:
  Throws an exception if the state is not attached to the pass.

TextureUnitStateIterator Ogre::Pass::getTextureUnitStateIterator | ( | void |  | ) |

Get an iterator over the TextureUnitStates contained in this Pass.

ConstTextureUnitStateIterator Ogre::Pass::getTextureUnitStateIterator | ( | void |  | ) | const

Get an iterator over the TextureUnitStates contained in this Pass.

void Ogre::Pass::removeTextureUnitState | ( | unsigned short | index | ) |

Removes the indexed texture unit state from this pass.

Remarks:
  Note that removing a texture which is not the topmost will have a larger performance impact.

void Ogre::Pass::removeAllTextureUnitStates | ( | void |  | ) |

Removes all texture unit settings.

unsigned short Ogre::Pass::getNumTextureUnitStates | ( | void |  | ) | const

Returns the number of texture unit settings.

Definition at line 548 of file OgrePass.h.

void Ogre::Pass::setSceneBlending | ( | const SceneBlendType | sbt | ) |

Sets the kind of blending this pass has with the existing contents of the scene.

Remarks:
  Wheras the texture blending operations seen in the TextureUnitState class are concerned with blending between texture layers, this blending is about combining the output of the Pass as a whole with the existing contents of the rendering target. This blending therefore allows object transparency and other special effects. If all passes in a technique have a scene blend, then the whole technique is considered to be transparent.

  This method allows you to select one of a number of predefined blending types. If you require more control than this, use the alternative version of this method which allows you to specify source and destination blend factors.

Note:
  This method is applicable for both the fixed-function and programmable pipelines.

Parameters:

  | sbt | One of the predefined SceneBlendType blending types

void Ogre::Pass::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 and alpha channels.

Remarks:
  Whereas the texture blending operations seen in the TextureUnitState class are concerned with blending between texture layers, this blending is about combining the output of the Pass as a whole with the existing contents of the rendering target. This blending therefore allows object transparency and other special effects. If all passes in a technique have a scene blend, then the whole technique is considered to be transparent.

  This method allows you to select one of a number of predefined blending types. If you require more control than this, use the alternative version of this method which allows you to specify source and destination blend factors.

Note:
  This method is applicable for both the fixed-function and programmable pipelines.

Parameters:

  | sbt | One of the predefined SceneBlendType blending types for the color channel
  | sbta | One of the predefined SceneBlendType blending types for the alpha channel

void Ogre::Pass::setSceneBlending | ( | const SceneBlendFactor | sourceFactor,
|  | const SceneBlendFactor | destFactor |
| ) |  |  |

Allows very fine control of blending this Pass with the existing contents of the scene.

Remarks:
  Whereas the texture blending operations seen in the TextureUnitState class are concerned with blending between texture layers, this blending is about combining the output of the material as a whole with the existing contents of the rendering target. This blending therefore allows object transparency and other special effects.

  This version of the method allows complete control over the blending operation, by specifying the source and destination blending factors. The result of the blending operation is: final = (texture * sourceFactor) + (pixel * destFactor)

  Each of the factors is specified as one of a number of options, as specified in the SceneBlendFactor enumerated type.

Parameters:

  | sourceFactor | The source factor in the above calculation, i.e. multiplied by the texture colour components.
  | destFactor | The destination factor in the above calculation, i.e. multiplied by the pixel colour components.

Note:
  This method is applicable for both the fixed-function and programmable pipelines.

void Ogre::Pass::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.

Remarks:
  Wheras the texture blending operations seen in the TextureUnitState class are concerned with blending between texture layers, this blending is about combining the output of the material as a whole with the existing contents of the rendering target. This blending therefore allows object transparency and other special effects.

  This version of the method allows complete control over the blending operation, by specifying the source and destination blending factors. The result of the blending operation is: final = (texture * sourceFactor) + (pixel * destFactor)

  Each of the factors is specified as one of a number of options, as specified in the SceneBlendFactor enumerated type.

Parameters:

  | sourceFactor | The source factor in the above calculation, i.e. multiplied by the texture colour components.
  | destFactor | The destination factor in the above calculation, i.e. multiplied by the pixel colour components.
  | sourceFactorAlpha | The alpha source factor in the above calculation, i.e. multiplied by the texture alpha component.
  | destFactorAlpha | The alpha destination factor in the above calculation, i.e. multiplied by the pixel alpha component.

Note:
  This method is applicable for both the fixed-function and programmable pipelines.

bool Ogre::Pass::hasSeparateSceneBlending | ( |  | ) | const

Return true if this pass uses separate scene blending.

SceneBlendFactor Ogre::Pass::getSourceBlendFactor | ( |  | ) | const

Retrieves the source blending factor for the material (as set using Materiall::setSceneBlending).

SceneBlendFactor Ogre::Pass::getDestBlendFactor | ( |  | ) | const

Retrieves the destination blending factor for the material (as set using Materiall::setSceneBlending).

SceneBlendFactor Ogre::Pass::getSourceBlendFactorAlpha | ( |  | ) | const

Retrieves the alpha source blending factor for the material (as set using Materiall::setSeparateSceneBlending).

SceneBlendFactor Ogre::Pass::getDestBlendFactorAlpha | ( |  | ) | const

Retrieves the alpha destination blending factor for the material (as set using Materiall::setSeparateSceneBlending).

bool Ogre::Pass::isTransparent | ( | void |  | ) | const

Returns true if this pass has some element of transparency.

void Ogre::Pass::setDepthCheckEnabled | ( | bool | enabled | ) |

Sets whether or not this pass renders with depth-buffer checking on or not.

Remarks:
  If depth-buffer checking is on, whenever a pixel is about to be written to the frame buffer the depth buffer is checked to see if the pixel is in front of all other pixels written at that point. If not, the pixel is not written.

  If depth checking is off, pixels are written no matter what has been rendered before. Also see setDepthFunction for more advanced depth check configuration.

See also:
  setDepthFunction

bool Ogre::Pass::getDepthCheckEnabled | ( | void |  | ) | const

Returns whether or not this pass renders with depth-buffer checking on or not.

See also:
  setDepthCheckEnabled

void Ogre::Pass::setDepthWriteEnabled | ( | bool | enabled | ) |

Sets whether or not this pass renders with depth-buffer writing on or not.

Remarks:
  If depth-buffer writing is on, whenever a pixel is written to the frame buffer the depth buffer is updated with the depth value of that new pixel, thus affecting future rendering operations if future pixels are behind this one.

  If depth writing is off, pixels are written without updating the depth buffer Depth writing should normally be on but can be turned off when rendering static backgrounds or when rendering a collection of transparent objects at the end of a scene so that they overlap each other correctly.

bool Ogre::Pass::getDepthWriteEnabled | ( | void |  | ) | const

Returns whether or not this pass renders with depth-buffer writing on or not.

See also:
  setDepthWriteEnabled

void Ogre::Pass::setDepthFunction | ( | CompareFunction | func | ) |

Sets the function used to compare depth values when depth checking is on.

Remarks:
  If depth checking is enabled (see setDepthCheckEnabled) a comparison occurs between the depth value of the pixel to be written and the current contents of the buffer. This comparison is normally CMPF_LESS_EQUAL, i.e. the pixel is written if it is closer (or at the same distance) than the current contents. If you wish you can change this comparison using this method.

CompareFunction Ogre::Pass::getDepthFunction | ( | void |  | ) | const

Returns the function used to compare depth values when depth checking is on.

See also:
  setDepthFunction

void Ogre::Pass::setColourWriteEnabled | ( | bool | enabled | ) |

Sets whether or not colour buffer writing is enabled for this Pass.

Remarks:
  For some effects, you might wish to turn off the colour write operation when rendering geometry; this means that only the depth buffer will be updated (provided you have depth buffer writing enabled, which you probably will do, although you may wish to only update the stencil buffer for example - stencil buffer state is managed at the RenderSystem level only, not the Material since you are likely to want to manage it at a higher level).

bool Ogre::Pass::getColourWriteEnabled | ( | void |  | ) | const

Determines if colour buffer writing is enabled for this pass.

void Ogre::Pass::setCullingMode | ( | CullingMode | mode | ) |

Sets the culling mode for this pass based on the 'vertex winding'.

Remarks:
  A typical way for the rendering engine to cull triangles is based on the 'vertex winding' of triangles. Vertex winding refers to the direction in which the vertices are passed or indexed to in the rendering operation as viewed from the camera, and will wither be clockwise or anticlockwise (that's 'counterclockwise' for you Americans out there ;) The default is CULL_CLOCKWISE i.e. that only triangles whose vertices are passed/indexed in anticlockwise order are rendered - this is a common approach and is used in 3D studio models for example. You can alter this culling mode if you wish but it is not advised unless you know what you are doing.

  You may wish to use the CULL_NONE option for mesh data that you cull yourself where the vertex winding is uncertain.

CullingMode Ogre::Pass::getCullingMode | ( | void |  | ) | const

Returns the culling mode for geometry rendered with this pass.

See setCullingMode for more information.

void Ogre::Pass::setManualCullingMode | ( | ManualCullingMode | mode | ) |

Sets the manual culling mode, performed by CPU rather than hardware.

Remarks:
  In some situations you want to use manual culling of triangles rather than sending the triangles to the hardware and letting it cull them. This setting only takes effect on SceneManager's that use it (since it is best used on large groups of planar world geometry rather than on movable geometry since this would be expensive), but if used can cull geometry before it is sent to the hardware.

Note:
  The default for this setting is MANUAL_CULL_BACK.

Parameters:

  | mode | The mode to use - see enum ManualCullingMode for details

ManualCullingMode Ogre::Pass::getManualCullingMode | ( | void |  | ) | const

Retrieves the manual culling mode for this pass.

See also:
  setManualCullingMode

void Ogre::Pass::setLightingEnabled | ( | bool | enabled | ) |

Sets whether or not dynamic lighting is enabled.

Parameters:

  | enabled | If true, dynamic lighting is performed on geometry with normals supplied, geometry without normals will not be displayed.

  If false, no lighting is applied and all geometry will be full brightness.

bool Ogre::Pass::getLightingEnabled | ( | void |  | ) | const

Returns whether or not dynamic lighting is enabled.

void Ogre::Pass::setMaxSimultaneousLights | ( | unsigned short | maxLights | ) |

Sets the maximum number of lights to be used by this pass.

Remarks:
  During rendering, if lighting is enabled (or if the pass uses an automatic program parameter based on a light) the engine will request the nearest lights to the object being rendered in order to work out which ones to use. This parameter sets the limit on the number of lights which should apply to objects rendered with this pass.

unsigned short Ogre::Pass::getMaxSimultaneousLights | ( | void |  | ) | const

Gets the maximum number of lights to be used by this pass.

void Ogre::Pass::setStartLight | ( | unsigned short | startLight | ) |

Sets the light index that this pass will start at in the light list.

Remarks:
  Normally the lights passed to a pass will start from the beginning of the light list for this object. This option allows you to make this pass start from a higher light index, for example if one of your earlier passes could deal with lights 0-3, and this pass dealt with lights 4+. This option also has an interaction with pass iteration, in that if you choose to iterate this pass per light too, the iteration will only begin from light 4.

unsigned short Ogre::Pass::getStartLight | ( | void |  | ) | const

Gets the light index that this pass will start at in the light list.

void Ogre::Pass::setShadingMode | ( | ShadeOptions | mode | ) |

Sets the type of light shading required.

Note:
  The default shading method is Gouraud shading.

ShadeOptions Ogre::Pass::getShadingMode | ( | void |  | ) | const

Returns the type of light shading to be used.

void Ogre::Pass::setPolygonMode | ( | PolygonMode | mode | ) |

Sets the type of polygon rendering required.

Note:
  The default shading method is Solid

PolygonMode Ogre::Pass::getPolygonMode | ( | void |  | ) | const

Returns the type of light shading to be used.

virtual void Ogre::Pass::setPolygonModeOverrideable | ( | bool | override | ) | `[virtual]`

Sets whether this pass's chosen detail level can be overridden (downgraded) by the camera setting.

Parameters:

  | override | true means that a lower camera detail will override this pass's detail level, false means it won't (default true).

Definition at line 835 of file OgrePass.h.

virtual bool Ogre::Pass::getPolygonModeOverrideable | ( | void |  | ) | const`[virtual]`

Gets whether this renderable's chosen detail level can be overridden (downgraded) by the camera setting.

Definition at line 843 of file OgrePass.h.

void Ogre::Pass::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.

Remarks:
  Fogging is an effect that is applied as polys are rendered. Sometimes, you want fog to be applied to an entire scene. Other times, you want it to be applied to a few polygons only. This pass-level specification of fog parameters lets you easily manage both.

  The SceneManager class also has a setFog method which applies scene-level fog. This method lets you change the fog behaviour for this pass compared to the standard scene-level fog.

Parameters:

  | overrideScene | If true, you authorise this pass to override the scene's fog params with it's own settings. If you specify false, so other parameters are necessary, and this is the default behaviour for passes.
  | mode | Only applicable if overrideScene is true. You can disable fog which is turned on for the rest of the scene by specifying FOG_NONE. Otherwise, set a pass-specific fog mode as defined in the enum FogMode.
  | colour | The colour of the fog. Either set this to the same as your viewport background colour, or to blend in with a skydome or skybox.
  | expDensity | The density of the fog in FOG_EXP or FOG_EXP2 mode, as a value between 0 and 1. The default is 0.001.
  | linearStart | Distance in world units at which linear fog starts to encroach. Only applicable if mode is FOG_LINEAR.
  | linearEnd | Distance in world units at which linear fog becomes completely opaque. Only applicable if mode is FOG_LINEAR.

bool Ogre::Pass::getFogOverride | ( | void |  | ) | const

Returns true if this pass is to override the scene fog settings.

FogMode Ogre::Pass::getFogMode | ( | void |  | ) | const

Returns the fog mode for this pass.

Note:
  Only valid if getFogOverride is true.

const ColourValue& Ogre::Pass::getFogColour | ( | void |  | ) | const

Returns the fog colour for the scene.

Real Ogre::Pass::getFogStart | ( | void |  | ) | const

Returns the fog start distance for this pass.

Note:
  Only valid if getFogOverride is true.

Real Ogre::Pass::getFogEnd | ( | void |  | ) | const

Returns the fog end distance for this pass.

Note:
  Only valid if getFogOverride is true.

Real Ogre::Pass::getFogDensity | ( | void |  | ) | const

Returns the fog density for this pass.

Note:
  Only valid if getFogOverride is true.

void Ogre::Pass::setDepthBias | ( | float | constantBias,
|  | float | slopeScaleBias = `0.0f` |
| ) |  |  |

Sets the depth bias to be used for this material.

Remarks:
  When polygons are coplanar, you can get problems with 'depth fighting' where the pixels from the two polys compete for the same screen pixel. This is particularly a problem for decals (polys attached to another surface to represent details such as bulletholes etc.).

  A way to combat this problem is to use a depth bias to adjust the depth buffer value used for the decal such that it is slightly higher than the true value, ensuring that the decal appears on top. There are two aspects to the biasing, a constant bias value and a slope-relative biasing value, which varies according to the maximum depth slope relative to the camera, ie:

      finalBias = maxSlope * slopeScaleBias + constantBias

  Note that slope scale bias, whilst more accurate, may be ignored by old hardware.

Parameters:

  | constantBias | The constant bias value, expressed as a factor of the minimum observable depth
  | slopeScaleBias | The slope-relative bias value, expressed as a factor of the depth slope

float Ogre::Pass::getDepthBiasConstant | ( | void |  | ) | const

Retrieves the const depth bias value as set by setDepthBias.

float Ogre::Pass::getDepthBiasSlopeScale | ( | void |  | ) | const

Retrieves the slope-scale depth bias value as set by setDepthBias.

void Ogre::Pass::setIterationDepthBias | ( | float | biasPerIteration | ) |

Sets a factor which derives an additional depth bias from the number of times a pass is iterated.

Remarks:
  The Final depth bias will be the constant depth bias as set through setDepthBias, plus this value times the iteration number.

float Ogre::Pass::getIterationDepthBias | ( |  | ) | const

Gets a factor which derives an additional depth bias from the number of times a pass is iterated.

void Ogre::Pass::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.

Remarks:
  The default is CMPF_ALWAYS_PASS i.e. alpha is not used to reject pixels.

Parameters:

  | func | The comparison which must pass for the pixel to be written.
  | value | 1 byte value against which alpha values will be tested(0-255)
  | alphaToCoverageEnabled | Whether to enable alpha to coverage support

Note:
  This option applies in both the fixed function and the programmable pipeline.

void Ogre::Pass::setAlphaRejectFunction | ( | CompareFunction | func | ) |

Sets the alpha reject function.

See setAlphaRejectSettings for more information.

void Ogre::Pass::setAlphaRejectValue | ( | unsigned char | val | ) |

Gets the alpha reject value.

See setAlphaRejectSettings for more information.

CompareFunction Ogre::Pass::getAlphaRejectFunction | ( | void |  | ) | const

Gets the alpha reject function.

See setAlphaRejectSettings for more information.

Definition at line 972 of file OgrePass.h.

unsigned char Ogre::Pass::getAlphaRejectValue | ( | void |  | ) | const

Gets the alpha reject value.

See setAlphaRejectSettings for more information.

Definition at line 976 of file OgrePass.h.

void Ogre::Pass::setAlphaToCoverageEnabled | ( | bool | enabled | ) |

Sets whether to use alpha to coverage (A2C) when blending alpha rejected values.

Remarks:
  Alpha to coverage performs multisampling on the edges of alpha-rejected textures to produce a smoother result. It is only supported when multisampling is already enabled on the render target, and when the hardware supports alpha to coverage (see RenderSystemCapabilities).

bool Ogre::Pass::isAlphaToCoverageEnabled | ( |  | ) | const

Gets whether to use alpha to coverage (A2C) when blending alpha rejected values.

Definition at line 989 of file OgrePass.h.

void Ogre::Pass::setTransparentSortingEnabled | ( | bool | enabled | ) |

Sets whether or not transparent sorting is enabled.

Parameters:

  | enabled | If false depth sorting of this material will be disabled.

Remarks:
  By default all transparent materials are sorted such that renderables furthest away from the camera are rendered first. This is usually the desired behaviour but in certain cases this depth sorting may be unnecessary and undesirable. If for example it is necessary to ensure the rendering order does not change from one frame to the next.

Note:
  This will have no effect on non-transparent materials.

bool Ogre::Pass::getTransparentSortingEnabled | ( | void |  | ) | const

Returns whether or not transparent sorting is enabled.

void Ogre::Pass::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 object being rendered.

Remarks:
  The default behaviour for a pass (when this option is 'false'), is for a pass to be rendered only once (or the number of times set in setPassIterationCount), with all the lights which could affect this object set at the same time (up to the maximum lights allowed in the render system, which is typically 8).

  Setting this option to 'true' changes this behaviour, such that instead of trying to issue render this pass once per object, it is run per light, or for a group of 'n' lights each time which can affect this object, the number of times set in setPassIterationCount (default is once). In this case, only light index 0 is ever used, and is a different light every time the pass is issued, up to the total number of lights which is affecting this object. This has 2 advantages:
  - There is no limit on the number of lights which can be supported
  - It's easier to write vertex / fragment programs for this because a single program can be used for any number of lights
  However, this technique is more expensive, and typically you will want an additional ambient pass, because if no lights are affecting the object it will not be rendered at all, which will look odd even if ambient light is zero (imagine if there are lit objects behind it - the objects silhouette would not show up). Therefore, use this option with care, and you would be well advised to provide a less expensive fallback technique for use in the distance.

Note:
  The number of times this pass runs is still limited by the maximum number of lights allowed as set in setMaxSimultaneousLights, so you will never get more passes than this. Also, the iteration is started from the 'start light' as set in Pass::setStartLight, and the number of passes is the number of lights to iterate over divided by the number of lights per iteration (default 1, set by setLightCountPerIteration).

Parameters:

  | enabled | Whether this feature is enabled
  | onlyForOneLightType | If true, the pass will only be run for a single type of light, other light types will be ignored.
  | lightType | The single light type which will be considered for this pass

bool Ogre::Pass::getIteratePerLight | ( | void |  | ) | const

Does this pass run once for every light in range?

Definition at line 1055 of file OgrePass.h.

bool Ogre::Pass::getRunOnlyForOneLightType | ( | void |  | ) | const

Does this pass run only for a single light type (if getIteratePerLight is true).

Definition at line 1057 of file OgrePass.h.

Light::LightTypes Ogre::Pass::getOnlyLightType | ( |  | ) | const

Gets the single light type this pass runs for if getIteratePerLight and getRunOnlyForOneLightType are both true.

Definition at line 1060 of file OgrePass.h.

void Ogre::Pass::setLightCountPerIteration | ( | unsigned short | c | ) |

If light iteration is enabled, determine the number of lights per iteration.

Remarks:
  The default for this setting is 1, so if you enable light iteration (Pass::setIteratePerLight), the pass is rendered once per light. If you set this value higher, the passes will occur once per 'n' lights. The start of the iteration is set by Pass::setStartLight and the end by Pass::setMaxSimultaneousLights.

unsigned short Ogre::Pass::getLightCountPerIteration | ( | void |  | ) | const

If light iteration is enabled, determine the number of lights per iteration.

Technique* Ogre::Pass::getParent | ( | void |  | ) | const

Gets the parent Technique.

Definition at line 1078 of file OgrePass.h.

const String& Ogre::Pass::getResourceGroup | ( | void |  | ) | const

Gets the resource group of the ultimate parent Material.

void Ogre::Pass::setVertexProgram | ( | const String & | name,
|  | bool | resetParams = `true` |
| ) |  |  |

Sets the details of the vertex program to use.

Remarks:
  Only applicable to programmable passes, this sets the details of the vertex program to use in this pass. The program will not be loaded until the parent Material is loaded.

Parameters:

  | name | The name of the program - this must have been created using GpuProgramManager by the time that this Pass is loaded. If this parameter is blank, any vertex program in this pass is disabled.
  | resetParams | If true, this will create a fresh set of parameters from the new program being linked, so if you had previously set parameters you will have to set them again. If you set this to false, you must be absolutely sure that the parameters match perfectly, and in the case of named parameters refers to the indexes underlying them, not just the names.

void Ogre::Pass::setVertexProgramParameters | ( | GpuProgramParametersSharedPtr | params | ) |

Sets the vertex program parameters.

Remarks:
  Only applicable to programmable passes, and this particular call is designed for low-level programs; use the named parameter methods for setting high-level program parameters.

const String& Ogre::Pass::getVertexProgramName | ( | void |  | ) | const

Gets the name of the vertex program used by this pass.

GpuProgramParametersSharedPtr Ogre::Pass::getVertexProgramParameters | ( | void |  | ) | const

Gets the vertex program parameters used by this pass.

const GpuProgramPtr& Ogre::Pass::getVertexProgram | ( | void |  | ) | const

Gets the vertex program used by this pass, only available after _load().

void Ogre::Pass::setShadowCasterVertexProgram | ( | const String & | name | ) |

Sets the details of the vertex program to use when rendering as a shadow caster.

Remarks:
  Texture-based shadows require that the caster is rendered to a texture in a solid colour (the shadow colour in the case of modulative texture shadows). Whilst Ogre can arrange this for the fixed function pipeline, passes which use vertex programs might need the vertex programs still to run in order to preserve any deformation etc that it does. However, lighting calculations must be a lot simpler, with only the ambient colour being used (which the engine will ensure is bound to the shadow colour).

  Therefore, it is up to implementors of vertex programs to provide an alternative vertex program which can be used to render the object to a shadow texture. Do all the same vertex transforms, but set the colour of the vertex to the ambient colour, as bound using the standard auto parameter binding mechanism.

Note:
  Some vertex programs will work without doing this, because Ogre ensures that all lights except for ambient are set black. However, the chances are that your vertex program is doing a lot of unnecessary work in this case, since the other lights are having no effect, and it is good practice to supply an alternative.

  This is only applicable to programmable passes.

  The default behaviour is for Ogre to switch to fixed-function rendering if an explicit vertex program alternative is not set.

void Ogre::Pass::setShadowCasterVertexProgramParameters | ( | GpuProgramParametersSharedPtr | params | ) |

Sets the vertex program parameters for rendering as a shadow caster.

Remarks:
  Only applicable to programmable passes, and this particular call is designed for low-level programs; use the named parameter methods for setting high-level program parameters.

const String& Ogre::Pass::getShadowCasterVertexProgramName | ( | void |  | ) | const

Gets the name of the vertex program used by this pass when rendering shadow casters.

GpuProgramParametersSharedPtr Ogre::Pass::getShadowCasterVertexProgramParameters | ( | void |  | ) | const

Gets the vertex program parameters used by this pass when rendering shadow casters.

const GpuProgramPtr& Ogre::Pass::getShadowCasterVertexProgram | ( | void |  | ) | const

Gets the vertex program used by this pass when rendering shadow casters, only available after _load().

void Ogre::Pass::setShadowReceiverVertexProgram | ( | const String & | name | ) |

Sets the details of the vertex program to use when rendering as a shadow receiver.

Remarks:
  Texture-based shadows require that the shadow receiver is rendered using a projective texture. Whilst Ogre can arrange this for the fixed function pipeline, passes which use vertex programs might need the vertex programs still to run in order to preserve any deformation etc that it does. So in this case, we need a vertex program which does the appropriate vertex transformation, but generates projective texture coordinates.

  Therefore, it is up to implementors of vertex programs to provide an alternative vertex program which can be used to render the object as a shadow receiver. Do all the same vertex transforms, but generate 2 sets of texture coordinates using the auto parameter ACT_TEXTURE_VIEWPROJ_MATRIX, which Ogre will bind to the parameter name / index you supply as the second parameter to this method. 2 texture sets are needed because Ogre needs to use 2 texture units for some shadow effects.

Note:
  This is only applicable to programmable passes.

  The default behaviour is for Ogre to switch to fixed-function rendering if an explict vertex program alternative is not set.

void Ogre::Pass::setShadowReceiverVertexProgramParameters | ( | GpuProgramParametersSharedPtr | params | ) |

Sets the vertex program parameters for rendering as a shadow receiver.

Remarks:
  Only applicable to programmable passes, and this particular call is designed for low-level programs; use the named parameter methods for setting high-level program parameters.

void Ogre::Pass::setShadowReceiverFragmentProgram | ( | const String & | name | ) |

This method allows you to specify a fragment program for use when rendering a texture shadow receiver.

Remarks:
  Texture shadows are applied by rendering the receiver. Modulative texture shadows are performed as a post-render darkening pass, and as such fragment programs are generally not required per-object. Additive texture shadows, however, are applied by accumulating light masked out using a texture shadow (black & white by default, unless you customise this using SceneManager::setCustomShadowCasterMaterial). OGRE can do this for you for most materials, but if you use a custom lighting program (e.g. per pixel lighting) then you'll need to provide a custom version for receiving shadows. You don't need to provide this for shadow casters if you don't use self-shadowing since they will never be shadow receivers too.

  The shadow texture is always bound to texture unit 0 when rendering texture shadow passes. Therefore your custom shadow receiver program may well just need to shift it's texture unit usage up by one unit, and take the shadow texture into account in its calculations.

void Ogre::Pass::setShadowReceiverFragmentProgramParameters | ( | GpuProgramParametersSharedPtr | params | ) |

Sets the fragment program parameters for rendering as a shadow receiver.

Remarks:
  Only applicable to programmable passes, and this particular call is designed for low-level programs; use the named parameter methods for setting high-level program parameters.

const String& Ogre::Pass::getShadowReceiverVertexProgramName | ( | void |  | ) | const

Gets the name of the vertex program used by this pass when rendering shadow receivers.

GpuProgramParametersSharedPtr Ogre::Pass::getShadowReceiverVertexProgramParameters | ( | void |  | ) | const

Gets the vertex program parameters used by this pass when rendering shadow receivers.

const GpuProgramPtr& Ogre::Pass::getShadowReceiverVertexProgram | ( | void |  | ) | const

Gets the vertex program used by this pass when rendering shadow receivers, only available after _load().

const String& Ogre::Pass::getShadowReceiverFragmentProgramName | ( | void |  | ) | const

Gets the name of the fragment program used by this pass when rendering shadow receivers.

GpuProgramParametersSharedPtr Ogre::Pass::getShadowReceiverFragmentProgramParameters | ( | void |  | ) | const

Gets the fragment program parameters used by this pass when rendering shadow receivers.

const GpuProgramPtr& Ogre::Pass::getShadowReceiverFragmentProgram | ( | void |  | ) | const

Gets the fragment program used by this pass when rendering shadow receivers, only available after _load().

void Ogre::Pass::setFragmentProgram | ( | const String & | name,
|  | bool | resetParams = `true` |
| ) |  |  |

Sets the details of the fragment program to use.

Remarks:
  Only applicable to programmable passes, this sets the details of the fragment program to use in this pass. The program will not be loaded until the parent Material is loaded.

Parameters:

  | name | The name of the program - this must have been created using GpuProgramManager by the time that this Pass is loaded. If this parameter is blank, any fragment program in this pass is disabled.
  | resetParams | If true, this will create a fresh set of parameters from the new program being linked, so if you had previously set parameters you will have to set them again. If you set this to false, you must be absolutely sure that the parameters match perfectly, and in the case of named parameters refers to the indexes underlying them, not just the names.

void Ogre::Pass::setFragmentProgramParameters | ( | GpuProgramParametersSharedPtr | params | ) |

Sets the fragment program parameters.

Remarks:
  Only applicable to programmable passes.

const String& Ogre::Pass::getFragmentProgramName | ( | void |  | ) | const

Gets the name of the fragment program used by this pass.

GpuProgramParametersSharedPtr Ogre::Pass::getFragmentProgramParameters | ( | void |  | ) | const

Gets the fragment program parameters used by this pass.

const GpuProgramPtr& Ogre::Pass::getFragmentProgram | ( | void |  | ) | const

Gets the fragment program used by this pass, only available after _load().

void Ogre::Pass::setGeometryProgram | ( | const String & | name,
|  | bool | resetParams = `true` |
| ) |  |  |

Sets the details of the geometry program to use.

Remarks:
  Only applicable to programmable passes, this sets the details of the geometry program to use in this pass. The program will not be loaded until the parent Material is loaded.

Parameters:

  | name | The name of the program - this must have been created using GpuProgramManager by the time that this Pass is loaded. If this parameter is blank, any geometry program in this pass is disabled.
  | resetParams | If true, this will create a fresh set of parameters from the new program being linked, so if you had previously set parameters you will have to set them again. If you set this to false, you must be absolutely sure that the parameters match perfectly, and in the case of named parameters refers to the indexes underlying them, not just the names.

void Ogre::Pass::setGeometryProgramParameters | ( | GpuProgramParametersSharedPtr | params | ) |

Sets the geometry program parameters.

Remarks:
  Only applicable to programmable passes.

const String& Ogre::Pass::getGeometryProgramName | ( | void |  | ) | const

Gets the name of the geometry program used by this pass.

GpuProgramParametersSharedPtr Ogre::Pass::getGeometryProgramParameters | ( | void |  | ) | const

Gets the geometry program parameters used by this pass.

const GpuProgramPtr& Ogre::Pass::getGeometryProgram | ( | void |  | ) | const

Gets the geometry program used by this pass, only available after _load().

Pass* Ogre::Pass::_split | ( | unsigned short | numUnits | ) |

Splits this Pass to one which can be handled in the number of texture units specified.

Remarks:
  Only works on non-programmable passes, programmable passes cannot be split, it's up to the author to ensure that there is a fallback Technique for less capable cards.

Parameters:

  | numUnits | The target number of texture units

Returns:
  A new Pass which contains the remaining units, and a scene_blend setting appropriate to approximate the multitexture. This Pass will be attached to the parent Technique of this Pass.

void Ogre::Pass::_notifyIndex | ( | unsigned short | index | ) |

Internal method to adjust pass index.

void Ogre::Pass::_prepare | ( | void |  | ) |

Internal method for preparing to load this pass.

void Ogre::Pass::_unprepare | ( | void |  | ) |

Internal method for undoing the load preparartion for this pass.

void Ogre::Pass::_load | ( | void |  | ) |

Internal method for loading this pass.

void Ogre::Pass::_unload | ( | void |  | ) |

Internal method for unloading this pass.

bool Ogre::Pass::isLoaded | ( | void |  | ) | const

uint32 Ogre::Pass::getHash | ( | void |  | ) | const

Gets the 'hash' of this pass, ie a precomputed number to use for sorting.

Remarks:
  This hash is used to sort passes, and for this reason the pass is hashed using firstly its index (so that all passes are rendered in order), then by the textures which it's TextureUnitState instances are using.

Definition at line 1330 of file OgrePass.h.

Referenced by Ogre::QueuedRenderableCollection::RadixSortFunctorPass::operator()(), Ogre::QueuedRenderableCollection::DepthSortDescendingLess::operator()(), and Ogre::QueuedRenderableCollection::PassGroupLess::operator()().

void Ogre::Pass::_dirtyHash | ( | void |  | ) |

Mark the hash as dirty.

void Ogre::Pass::_recalculateHash | ( | void |  | ) |

Internal method for recalculating the hash.

Remarks:
  Do not call this unless you are sure the old hash is not still being used by anything. If in doubt, call _dirtyHash if you want to force recalculation of the has next time.

void Ogre::Pass::_notifyNeedsRecompile | ( | void |  | ) |

Tells the pass that it needs recompilation.

void Ogre::Pass::_updateAutoParamsNoLights | ( | const AutoParamDataSource * | source | ) | const

Update any automatic parameters (except lights) on this pass.

void Ogre::Pass::_updateAutoParamsLightsOnly | ( | const AutoParamDataSource * | source | ) | const

Update any automatic light parameters on this pass.

unsigned short Ogre::Pass::_getTextureUnitWithContentTypeIndex | ( | TextureUnitState::ContentType | contentType,
|  | unsigned short | index |
| ) |  |  | const

Gets the 'nth' texture which references the given content type.

Remarks:
  If the 'nth' texture unit which references the content type doesn't exist, then this method returns an arbitrary high-value outside the valid range to index texture units.

void Ogre::Pass::setTextureFiltering | ( | TextureFilterOptions | filterType | ) |

Set texture filtering for every texture unit.

Note:
  This property actually exists on the TextureUnitState class For simplicity, this method allows you to set these properties for every current TeextureUnitState, If you need more precision, retrieve the TextureUnitState instance and set the property there.

See also:
  TextureUnitState::setTextureFiltering

void Ogre::Pass::setTextureAnisotropy | ( | unsigned int | maxAniso | ) |

Sets the anisotropy level to be used for all textures.

Note:
  This property has been moved to the TextureUnitState class, which is accessible via the Technique and Pass. For simplicity, this method allows you to set these properties for every current TeextureUnitState, If you need more precision, retrieve the Technique, Pass and TextureUnitState instances and set the property there.

See also:
  TextureUnitState::setTextureAnisotropy

void Ogre::Pass::setNormaliseNormals | ( | bool | normalise | ) |

If set to true, this forces normals to be normalised dynamically by the hardware for this pass.

Remarks:
  This option can be used to prevent lighting variations when scaling an object - normally because this scaling is hardware based, the normals get scaled too which causes lighting to become inconsistent. By default the SceneManager detects scaled objects and does this for you, but this has an overhead so you might want to turn that off through SceneManager::setNormaliseNormalsOnScale(false) and only do it per-Pass when you need to.

Definition at line 1386 of file OgrePass.h.

bool Ogre::Pass::getNormaliseNormals | ( | void |  | ) | const

Returns true if this pass has auto-normalisation of normals set.

Definition at line 1389 of file OgrePass.h.

static const PassSet& Ogre::Pass::getDirtyHashList | ( | void |  | ) | `[static]`

Static method to retrieve all the Passes which need their hash values recalculated.

Definition at line 1394 of file OgrePass.h.

static const PassSet& Ogre::Pass::getPassGraveyard | ( | void |  | ) | `[static]`

Static method to retrieve all the Passes which are pending deletion.

Definition at line 1398 of file OgrePass.h.

static void Ogre::Pass::clearDirtyHashList | ( | void |  | ) | `[static]`

Static method to reset the list of passes which need their hash values recalculated.

Remarks:
  For performance, the dirty list is not updated progressively as the hashes are recalculated, instead we expect the processor of the dirty hash list to clear the list when they are done.

static void Ogre::Pass::processPendingPassUpdates | ( | void |  | ) | `[static]`

Process all dirty and pending deletion passes.

void Ogre::Pass::queueForDeletion | ( | void |  | ) |

Queue this pass for deletion when appropriate.

bool Ogre::Pass::isAmbientOnly | ( | void |  | ) | const

Returns whether this pass is ambient only.

void Ogre::Pass::setPassIterationCount | ( | const size_t | count | ) |

set the number of iterations that this pass should perform when doing fast multi pass operation.

Remarks:
  Only applicable for programmable passes.

Parameters:

  | count | number of iterations to perform fast multi pass operations. A value greater than 1 will cause the pass to be executed count number of times without changing the render state. This is very usefull for passes that use programmable shaders that have to iterate more than once but don't need a render state change. Using multi pass can dramatically speed up rendering for materials that do things like fur, blur. A value of 1 turns off multi pass operation and the pass does the normal pass operation.

Definition at line 1432 of file OgrePass.h.

size_t Ogre::Pass::getPassIterationCount | ( | void |  | ) | const

Gets the pass iteration count value.

Definition at line 1436 of file OgrePass.h.

bool Ogre::Pass::applyTextureAliases | ( | const AliasTextureNamePairList & | aliasList,
|  | const bool | apply = `true` |
| ) |  |  | const

Applies texture names to Texture Unit State with matching texture name aliases.

All Texture Unit States within the pass are checked. If matching texture aliases are found then true is returned.

Parameters:

  | aliasList | is a map container of texture alias, texture name pairs
  | apply | set true to apply the texture aliases else just test to see if texture alias matches are found.

Returns:
  True if matching texture aliases were found in the pass.

void Ogre::Pass::setLightScissoringEnabled | ( | bool | enabled | ) |

Sets whether or not this pass will be clipped by a scissor rectangle encompassing the lights that are being used in it.

Remarks:
  In order to cut down on fillrate when you have a number of fixed-range lights in the scene, you can enable this option to request that during rendering, only the region of the screen which is covered by the lights is rendered. This region is the screen-space rectangle covering the union of the spheres making up the light ranges. Directional lights are ignored for this.

  This is only likely to be useful for multipass additive lighting algorithms, where the scene has already been 'seeded' with an ambient pass and this pass is just adding light in affected areas.

Note:
  When using SHADOWTYPE_STENCIL_ADDITIVE or SHADOWTYPE_TEXTURE_ADDITIVE, this option is implicitly used for all per-light passes and does not need to be specified. If you are not using shadows or are using a modulative or an integrated shadow technique then this could be useful.

Definition at line 1471 of file OgrePass.h.

bool Ogre::Pass::getLightScissoringEnabled | ( |  | ) | const

Gets whether or not this pass will be clipped by a scissor rectangle encompassing the lights that are being used in it.

Definition at line 1475 of file OgrePass.h.

void Ogre::Pass::setLightClipPlanesEnabled | ( | bool | enabled | ) |

Gets whether or not this pass will be clipped by user clips planes bounding the area covered by the light.

Remarks:
  In order to cut down on the geometry set up to render this pass when you have a single fixed-range light being rendered through it, you can enable this option to request that during triangle setup, clip planes are defined to bound the range of the light. In the case of a point light these planes form a cube, and in the case of a spotlight they form a pyramid. Directional lights are never clipped.

  This option is only likely to be useful for multipass additive lighting algorithms, where the scene has already been 'seeded' with an ambient pass and this pass is just adding light in affected areas. In addition, it will only be honoured if there is exactly one non-directional light being used in this pass. Also, these clip planes override any user clip planes set on Camera.

Note:
  When using SHADOWTYPE_STENCIL_ADDITIVE or SHADOWTYPE_TEXTURE_ADDITIVE, this option is automatically used for all per-light passes if you enable SceneManager::setShadowUseLightClipPlanes and does not need to be specified. It is disabled by default since clip planes have a cost of their own which may not always exceed the benefits they give you.

Definition at line 1500 of file OgrePass.h.

bool Ogre::Pass::getLightClipPlanesEnabled | ( |  | ) | const

Gets whether or not this pass will be clipped by user clips planes bounding the area covered by the light.

Definition at line 1504 of file OgrePass.h.

void Ogre::Pass::setIlluminationStage | ( | IlluminationStage | is | ) |

Manually set which illumination stage this pass is a member of.

Remarks:
  When using an additive lighting mode (SHADOWTYPE_STENCIL_ADDITIVE or SHADOWTYPE_TEXTURE_ADDITIVE), the scene is rendered in 3 discrete stages, ambient (or pre-lighting), per-light (once per light, with shadowing) and decal (or post-lighting). Usually OGRE figures out how to categorise your passes automatically, but there are some effects you cannot achieve without manually controlling the illumination. For example specular effects are muted by the typical sequence because all textures are saved until the IS_DECAL stage which mutes the specular effect. Instead, you could do texturing within the per-light stage if it's possible for your material and thus add the specular on after the decal texturing, and have no post-light rendering.

  If you assign an illumination stage to a pass you have to assign it to all passes in the technique otherwise it will be ignored. Also note that whilst you can have more than one pass in each group, they cannot alternate, ie all ambient passes will be before all per-light passes, which will also be before all decal passes. Within their categories the passes will retain their ordering though.

Definition at line 1527 of file OgrePass.h.

IlluminationStage Ogre::Pass::getIlluminationStage | ( |  | ) | const

Get the manually assigned illumination stage, if any.

Definition at line 1529 of file OgrePass.h.

static void Ogre::Pass::setHashFunction | ( | BuiltinHashFunction | builtin | ) | `[static]`

Sets one of the default hash functions to be used.

Remarks:
  You absolutely must not change the hash function whilst any Pass instances exist in the render queue. The only time you can do this is either before you render anything, or directly after you manuall call RenderQueue::clear(true) to completely destroy the queue structures. The default is MIN_TEXTURE_CHANGE.

Note:
  You can also implement your own hash function, see the alternate version of this method.

See also:
  HashFunc

static void Ogre::Pass::setHashFunction | ( | HashFunc * | hashFunc | ) | `[static]`

Set the hash function used for all passes.

Remarks:
  You absolutely must not change the hash function whilst any Pass instances exist in the render queue. The only time you can do this is either before you render anything, or directly after you manuall call RenderQueue::clear(true) to completely destroy the queue structures.

Note:
  You can also use one of the built-in hash functions, see the alternate version of this method. The default is MIN_TEXTURE_CHANGE.

See also:
  HashFunc

Definition at line 1568 of file OgrePass.h.

static HashFunc* Ogre::Pass::getHashFunction | ( | void |  | ) | `[static]`

Get the hash function used for all passes.

Definition at line 1572 of file OgrePass.h.

template<class Alloc>

void* Ogre::AllocatedObject< Alloc >::operator new | ( | size_t | sz,
|  | const char * | file,
|  | int | line,
|  | const char * | func |
| ) |  |  | `[inherited]`

operator new, with debug line info

Definition at line 62 of file OgreMemoryAllocatedObject.h.

template<class Alloc>

void* Ogre::AllocatedObject< Alloc >::operator new | ( | size_t | sz | ) | `[inherited]`

Definition at line 67 of file OgreMemoryAllocatedObject.h.

template<class Alloc>

void* Ogre::AllocatedObject< Alloc >::operator new | ( | size_t | sz,
|  | void * | ptr |
| ) |  |  | `[inherited]`

placement operator new

Definition at line 73 of file OgreMemoryAllocatedObject.h.

template<class Alloc>

void* Ogre::AllocatedObject< Alloc >::operator new[] | ( | size_t | sz,
|  | const char * | file,
|  | int | line,
|  | const char * | func |
| ) |  |  | `[inherited]`

array operator new, with debug line info

Definition at line 79 of file OgreMemoryAllocatedObject.h.

template<class Alloc>

void* Ogre::AllocatedObject< Alloc >::operator new[] | ( | size_t | sz | ) | `[inherited]`

Definition at line 84 of file OgreMemoryAllocatedObject.h.

template<class Alloc>

void Ogre::AllocatedObject< Alloc >::operator delete | ( | void * | ptr | ) | `[inherited]`

Definition at line 89 of file OgreMemoryAllocatedObject.h.

template<class Alloc>

void Ogre::AllocatedObject< Alloc >::operator delete | ( | void * | ptr,
|  | void * |  |
| ) |  |  | `[inherited]`

Definition at line 95 of file OgreMemoryAllocatedObject.h.

template<class Alloc>

void Ogre::AllocatedObject< Alloc >::operator delete | ( | void * | ptr,
|  | const char * | ,
|  | int | ,
|  | const char * |  |
| ) |  |  | `[inherited]`

Definition at line 101 of file OgreMemoryAllocatedObject.h.

template<class Alloc>

void Ogre::AllocatedObject< Alloc >::operator delete[] | ( | void * | ptr | ) | `[inherited]`

Definition at line 106 of file OgreMemoryAllocatedObject.h.

template<class Alloc>

void Ogre::AllocatedObject< Alloc >::operator delete[] | ( | void * | ptr,
|  | const char * | ,
|  | int | ,
|  | const char * |  |
| ) |  |  | `[inherited]`

Definition at line 112 of file OgreMemoryAllocatedObject.h.

## Member Data Documentation

Technique* Ogre::Pass::mParent`[protected]`

Definition at line 94 of file OgrePass.h.

unsigned short Ogre::Pass::mIndex`[protected]`

Definition at line 95 of file OgrePass.h.

String Ogre::Pass::mName`[protected]`

Definition at line 96 of file OgrePass.h.

uint32 Ogre::Pass::mHash`[protected]`

Definition at line 97 of file OgrePass.h.

bool Ogre::Pass::mHashDirtyQueued`[protected]`

Definition at line 98 of file OgrePass.h.

ColourValue Ogre::Pass::mAmbient`[protected]`

Definition at line 101 of file OgrePass.h.

ColourValue Ogre::Pass::mDiffuse`[protected]`

Definition at line 102 of file OgrePass.h.

ColourValue Ogre::Pass::mSpecular`[protected]`

Definition at line 103 of file OgrePass.h.

ColourValue Ogre::Pass::mEmissive`[protected]`

Definition at line 104 of file OgrePass.h.

Real Ogre::Pass::mShininess`[protected]`

Definition at line 105 of file OgrePass.h.

TrackVertexColourType Ogre::Pass::mTracking`[protected]`

Definition at line 106 of file OgrePass.h.

SceneBlendFactor Ogre::Pass::mSourceBlendFactor`[protected]`

Definition at line 111 of file OgrePass.h.

SceneBlendFactor Ogre::Pass::mDestBlendFactor`[protected]`

Definition at line 112 of file OgrePass.h.

SceneBlendFactor Ogre::Pass::mSourceBlendFactorAlpha`[protected]`

Definition at line 113 of file OgrePass.h.

SceneBlendFactor Ogre::Pass::mDestBlendFactorAlpha`[protected]`

Definition at line 114 of file OgrePass.h.

bool Ogre::Pass::mSeparateBlend`[protected]`

Definition at line 117 of file OgrePass.h.

bool Ogre::Pass::mDepthCheck`[protected]`

Definition at line 122 of file OgrePass.h.

bool Ogre::Pass::mDepthWrite`[protected]`

Definition at line 123 of file OgrePass.h.

CompareFunction Ogre::Pass::mDepthFunc`[protected]`

Definition at line 124 of file OgrePass.h.

float Ogre::Pass::mDepthBiasConstant`[protected]`

Definition at line 125 of file OgrePass.h.

float Ogre::Pass::mDepthBiasSlopeScale`[protected]`

Definition at line 126 of file OgrePass.h.

float Ogre::Pass::mDepthBiasPerIteration`[protected]`

Definition at line 127 of file OgrePass.h.

bool Ogre::Pass::mColourWrite`[protected]`

Definition at line 130 of file OgrePass.h.

CompareFunction Ogre::Pass::mAlphaRejectFunc`[protected]`

Definition at line 133 of file OgrePass.h.

unsigned char Ogre::Pass::mAlphaRejectVal`[protected]`

Definition at line 134 of file OgrePass.h.

bool Ogre::Pass::mAlphaToCoverageEnabled`[protected]`

Definition at line 135 of file OgrePass.h.

bool Ogre::Pass::mTransparentSorting`[protected]`

Definition at line 138 of file OgrePass.h.

CullingMode Ogre::Pass::mCullMode`[protected]`

Definition at line 143 of file OgrePass.h.

ManualCullingMode Ogre::Pass::mManualCullMode`[protected]`

Definition at line 144 of file OgrePass.h.

bool Ogre::Pass::mLightingEnabled`[protected]`

Lighting enabled?

Definition at line 148 of file OgrePass.h.

unsigned short Ogre::Pass::mMaxSimultaneousLights`[protected]`

Max simultaneous lights.

Definition at line 150 of file OgrePass.h.

unsigned short Ogre::Pass::mStartLight`[protected]`

Starting light index.

Definition at line 152 of file OgrePass.h.

bool Ogre::Pass::mIteratePerLight`[protected]`

Run this pass once per light?

Definition at line 154 of file OgrePass.h.

unsigned short Ogre::Pass::mLightsPerIteration`[protected]`

Iterate per how many lights?

Definition at line 156 of file OgrePass.h.

bool Ogre::Pass::mRunOnlyForOneLightType`[protected]`

Definition at line 158 of file OgrePass.h.

Light::LightTypes Ogre::Pass::mOnlyLightType`[protected]`

Definition at line 159 of file OgrePass.h.

ShadeOptions Ogre::Pass::mShadeOptions`[protected]`

Shading options.

Definition at line 162 of file OgrePass.h.

PolygonMode Ogre::Pass::mPolygonMode`[protected]`

Polygon mode.

Definition at line 164 of file OgrePass.h.

bool Ogre::Pass::mNormaliseNormals`[protected]`

Normalisation.

Definition at line 166 of file OgrePass.h.

bool Ogre::Pass::mPolygonModeOverrideable`[protected]`

Definition at line 167 of file OgrePass.h.

bool Ogre::Pass::mFogOverride`[protected]`

Definition at line 170 of file OgrePass.h.

FogMode Ogre::Pass::mFogMode`[protected]`

Definition at line 171 of file OgrePass.h.

ColourValue Ogre::Pass::mFogColour`[protected]`

Definition at line 172 of file OgrePass.h.

Real Ogre::Pass::mFogStart`[protected]`

Definition at line 173 of file OgrePass.h.

Real Ogre::Pass::mFogEnd`[protected]`

Definition at line 174 of file OgrePass.h.

Real Ogre::Pass::mFogDensity`[protected]`

Definition at line 175 of file OgrePass.h.

TextureUnitStates Ogre::Pass::mTextureUnitStates`[protected]`

Definition at line 180 of file OgrePass.h.

GpuProgramUsage* Ogre::Pass::mVertexProgramUsage`[protected]`

Definition at line 183 of file OgrePass.h.

GpuProgramUsage* Ogre::Pass::mShadowCasterVertexProgramUsage`[protected]`

Definition at line 185 of file OgrePass.h.

GpuProgramUsage* Ogre::Pass::mShadowReceiverVertexProgramUsage`[protected]`

Definition at line 187 of file OgrePass.h.

GpuProgramUsage* Ogre::Pass::mFragmentProgramUsage`[protected]`

Definition at line 189 of file OgrePass.h.

GpuProgramUsage* Ogre::Pass::mShadowReceiverFragmentProgramUsage`[protected]`

Definition at line 191 of file OgrePass.h.

GpuProgramUsage* Ogre::Pass::mGeometryProgramUsage`[protected]`

Definition at line 193 of file OgrePass.h.

bool Ogre::Pass::mQueuedForDeletion`[protected]`

Definition at line 195 of file OgrePass.h.

size_t Ogre::Pass::mPassIterationCount`[protected]`

Definition at line 197 of file OgrePass.h.

Real Ogre::Pass::mPointSize`[protected]`

Definition at line 199 of file OgrePass.h.

Real Ogre::Pass::mPointMinSize`[protected]`

Definition at line 200 of file OgrePass.h.

Real Ogre::Pass::mPointMaxSize`[protected]`

Definition at line 201 of file OgrePass.h.

bool Ogre::Pass::mPointSpritesEnabled`[protected]`

Definition at line 202 of file OgrePass.h.

bool Ogre::Pass::mPointAttenuationEnabled`[protected]`

Definition at line 203 of file OgrePass.h.

Real Ogre::Pass::mPointAttenuationCoeffs[3]`[protected]`

Definition at line 205 of file OgrePass.h.

ContentTypeLookup Ogre::Pass::mShadowContentTypeLookup`[mutable, protected]`

Definition at line 208 of file OgrePass.h.

bool Ogre::Pass::mContentTypeLookupBuilt`[mutable, protected]`

Definition at line 209 of file OgrePass.h.

bool Ogre::Pass::mLightScissoring`[protected]`

Scissoring for the light?

Definition at line 211 of file OgrePass.h.

bool Ogre::Pass::mLightClipPlanes`[protected]`

User clip planes for light?

Definition at line 213 of file OgrePass.h.

IlluminationStage Ogre::Pass::mIlluminationStage`[protected]`

Illumination stage?

Definition at line 215 of file OgrePass.h.

PassSet Ogre::Pass::msDirtyHashList`[static, protected]`

List of Passes whose hashes need recalculating.

Definition at line 224 of file OgrePass.h.

PassSet Ogre::Pass::msPassGraveyard`[static, protected]`

The place where passes go to die.

Definition at line 226 of file OgrePass.h.

HashFunc* Ogre::Pass::msHashFunc`[static, protected]`

The Pass hash functor.

Definition at line 228 of file OgrePass.h.

The documentation for this class was generated from the following file:

- OgrePass.h

Copyright © 2008 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Jul 26 11:34:56 2009