OgrePass.h

Go to the documentation of this file.
00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OGRE
00004 (Object-oriented Graphics Rendering Engine)
00005 For the latest info, see http://www.ogre3d.org
00006 
00007 Copyright (c) 2000-2009 Torus Knot Software Ltd
00008 
00009 Permission is hereby granted, free of charge, to any person obtaining a copy
00010 of this software and associated documentation files (the "Software"), to deal
00011 in the Software without restriction, including without limitation the rights
00012 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
00013 copies of the Software, and to permit persons to whom the Software is
00014 furnished to do so, subject to the following conditions:
00015 
00016 The above copyright notice and this permission notice shall be included in
00017 all copies or substantial portions of the Software.
00018 
00019 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00020 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00021 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
00022 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00023 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00024 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
00025 THE SOFTWARE.
00026 -----------------------------------------------------------------------------
00027 */
00028 #ifndef __Pass_H__
00029 #define __Pass_H__
00030 
00031 #include "OgrePrerequisites.h"
00032 #include "OgreGpuProgram.h"
00033 #include "OgreColourValue.h"
00034 #include "OgreBlendMode.h"
00035 #include "OgreCommon.h"
00036 #include "OgreLight.h"
00037 #include "OgreTextureUnitState.h"
00038 #include "OgreUserObjectBindings.h"
00039 
00040 namespace Ogre {
00041 
00048 
00049     enum IlluminationStage
00050     {
00052         IS_AMBIENT,
00054         IS_PER_LIGHT,
00056         IS_DECAL, 
00058         IS_UNKNOWN
00059     };
00060 
00080     class _OgreExport Pass : public PassAlloc
00081     {
00082     public:
00093         struct HashFunc
00094         {
00095             virtual uint32 operator()(const Pass* p) const = 0;
00097             virtual ~HashFunc() {}
00098         };
00099     protected:
00100         Technique* mParent;
00101         unsigned short mIndex; // pass index
00102         String mName; // optional name for the pass
00103         uint32 mHash; // pass hash
00104         bool mHashDirtyQueued; // needs to be dirtied when next loaded
00105         //-------------------------------------------------------------------------
00106         // Colour properties, only applicable in fixed-function passes
00107         ColourValue mAmbient;
00108         ColourValue mDiffuse;
00109         ColourValue mSpecular;
00110         ColourValue mEmissive;
00111         Real mShininess;
00112         TrackVertexColourType mTracking;
00113         //-------------------------------------------------------------------------
00114 
00115         //-------------------------------------------------------------------------
00116         // Blending factors
00117         SceneBlendFactor mSourceBlendFactor;
00118         SceneBlendFactor mDestBlendFactor;
00119         SceneBlendFactor mSourceBlendFactorAlpha;
00120         SceneBlendFactor mDestBlendFactorAlpha;
00121 
00122         // Used to determine if separate alpha blending should be used for color and alpha channels
00123         bool mSeparateBlend;
00124 
00125         //-------------------------------------------------------------------------
00126         // Blending operations
00127         SceneBlendOperation mBlendOperation;
00128         SceneBlendOperation mAlphaBlendOperation;
00129 
00130         // Determines if we should use separate blending operations for color and alpha channels
00131         bool mSeparateBlendOperation;
00132 
00133         //-------------------------------------------------------------------------
00134 
00135         //-------------------------------------------------------------------------
00136         // Depth buffer settings
00137         bool mDepthCheck;
00138         bool mDepthWrite;
00139         CompareFunction mDepthFunc;
00140         float mDepthBiasConstant;
00141         float mDepthBiasSlopeScale;
00142         float mDepthBiasPerIteration;
00143 
00144         // Colour buffer settings
00145         bool mColourWrite;
00146 
00147         // Alpha reject settings
00148         CompareFunction mAlphaRejectFunc;
00149         unsigned char mAlphaRejectVal;
00150         bool mAlphaToCoverageEnabled;
00151 
00152         // Transparent depth sorting
00153         bool mTransparentSorting;
00154         // Transparent depth sorting forced
00155         bool mTransparentSortingForced;
00156         //-------------------------------------------------------------------------
00157 
00158         //-------------------------------------------------------------------------
00159         // Culling mode
00160         CullingMode mCullMode;
00161         ManualCullingMode mManualCullMode;
00162         //-------------------------------------------------------------------------
00163 
00165         bool mLightingEnabled;
00167         unsigned short mMaxSimultaneousLights;
00169         unsigned short mStartLight;
00171         bool mIteratePerLight;
00173         unsigned short mLightsPerIteration;
00174         // Should it only be run for a certain light type?
00175         bool mRunOnlyForOneLightType;
00176         Light::LightTypes mOnlyLightType;
00177 
00179         ShadeOptions mShadeOptions;
00181         PolygonMode mPolygonMode;
00183         bool mNormaliseNormals;
00184         bool mPolygonModeOverrideable;
00185         //-------------------------------------------------------------------------
00186         // Fog
00187         bool mFogOverride;
00188         FogMode mFogMode;
00189         ColourValue mFogColour;
00190         Real mFogStart;
00191         Real mFogEnd;
00192         Real mFogDensity;
00193         //-------------------------------------------------------------------------
00194 
00196         typedef vector<TextureUnitState*>::type TextureUnitStates;
00197         TextureUnitStates mTextureUnitStates;
00198 
00199         // Vertex program details
00200         GpuProgramUsage *mVertexProgramUsage;
00201         // Vertex program details
00202         GpuProgramUsage *mShadowCasterVertexProgramUsage;
00203         // Vertex program details
00204         GpuProgramUsage *mShadowReceiverVertexProgramUsage;
00205         // Fragment program details
00206         GpuProgramUsage *mFragmentProgramUsage;
00207         // Fragment program details
00208         GpuProgramUsage *mShadowReceiverFragmentProgramUsage;
00209         // Geometry program details
00210         GpuProgramUsage *mGeometryProgramUsage;
00211         // Is this pass queued for deletion?
00212         bool mQueuedForDeletion;
00213         // number of pass iterations to perform
00214         size_t mPassIterationCount;
00215         // point size, applies when not using per-vertex point size
00216         Real mPointSize;
00217         Real mPointMinSize;
00218         Real mPointMaxSize;
00219         bool mPointSpritesEnabled;
00220         bool mPointAttenuationEnabled;
00221         // constant, linear, quadratic coeffs
00222         Real mPointAttenuationCoeffs[3];
00223         // TU Content type lookups
00224         typedef vector<unsigned short>::type ContentTypeLookup;
00225         mutable ContentTypeLookup mShadowContentTypeLookup;
00226         mutable bool mContentTypeLookupBuilt;
00228         bool mLightScissoring;
00230         bool mLightClipPlanes;
00232         IlluminationStage mIlluminationStage;
00233         // User objects binding.
00234         UserObjectBindings  mUserObjectBindings;
00235         
00236 
00237         // Used to get scene blending flags from a blending type
00238         void _getBlendFlags(SceneBlendType type, SceneBlendFactor& source, SceneBlendFactor& dest);
00239 
00240     public:
00241         typedef set<Pass*>::type PassSet;
00242     protected:
00244         static PassSet msDirtyHashList;
00246         static PassSet msPassGraveyard;
00248         static HashFunc* msHashFunc;
00249     public:
00250         OGRE_STATIC_MUTEX(msDirtyHashListMutex)
00251         OGRE_STATIC_MUTEX(msPassGraveyardMutex)
00252         OGRE_MUTEX(mTexUnitChangeMutex)
00253         OGRE_MUTEX(mGpuProgramChangeMutex)
00255         Pass(Technique* parent, unsigned short index);
00257         Pass(Technique* parent, unsigned short index, const Pass& oth );
00259         Pass& operator=(const Pass& oth);
00260         virtual ~Pass();
00261 
00263         bool isProgrammable(void) const { return mVertexProgramUsage || mFragmentProgramUsage || mGeometryProgramUsage; }
00265         bool hasVertexProgram(void) const { return mVertexProgramUsage != NULL; }
00267         bool hasFragmentProgram(void) const { return mFragmentProgramUsage != NULL; }
00269         bool hasGeometryProgram(void) const { return mGeometryProgramUsage != NULL; }
00271         bool hasShadowCasterVertexProgram(void) const { return mShadowCasterVertexProgramUsage != NULL; }
00273         bool hasShadowReceiverVertexProgram(void) const { return mShadowReceiverVertexProgramUsage != NULL; }
00275         bool hasShadowReceiverFragmentProgram(void) const { return mShadowReceiverFragmentProgramUsage != NULL; }
00276 
00277 
00279         unsigned short getIndex(void) const { return mIndex; }
00280         /* Set the name of the pass
00281         @remarks
00282         The name of the pass is optional.  Its useful in material scripts where a material could inherit
00283         from another material and only want to modify a particular pass.
00284         */
00285         void setName(const String& name);
00287         const String& getName(void) const { return mName; }
00288 
00300         void setAmbient(Real red, Real green, Real blue);
00301 
00314         void setAmbient(const ColourValue& ambient);
00315 
00326         void setDiffuse(Real red, Real green, Real blue, Real alpha);
00327 
00338         void setDiffuse(const ColourValue& diffuse);
00339 
00352         void setSpecular(Real red, Real green, Real blue, Real alpha);
00353 
00366         void setSpecular(const ColourValue& specular);
00367 
00373         void setShininess(Real val);
00374 
00384         void setSelfIllumination(Real red, Real green, Real blue);
00385 
00395         void setSelfIllumination(const ColourValue& selfIllum);
00396 
00399         void setVertexColourTracking(TrackVertexColourType tracking);
00400 
00406         Real getPointSize(void) const;
00407 
00423         void setPointSize(Real ps);
00424 
00430         void setPointSpritesEnabled(bool enabled);
00431 
00435         bool getPointSpritesEnabled(void) const;
00436 
00453         void setPointAttenuation(bool enabled,
00454             Real constant = 0.0f, Real linear = 1.0f, Real quadratic = 0.0f);
00455 
00457         bool isPointAttenuationEnabled(void) const;
00458 
00460         Real getPointAttenuationConstant(void) const;
00462         Real getPointAttenuationLinear(void) const;
00464         Real getPointAttenuationQuadratic(void) const;
00465 
00467         void setPointMinSize(Real min);
00469         Real getPointMinSize(void) const;
00473         void setPointMaxSize(Real max);
00477         Real getPointMaxSize(void) const;
00478 
00481         const ColourValue& getAmbient(void) const;
00482 
00485         const ColourValue& getDiffuse(void) const;
00486 
00489         const ColourValue& getSpecular(void) const;
00490 
00493         const ColourValue& getSelfIllumination(void) const;
00494 
00497         Real getShininess(void) const;
00498 
00501         TrackVertexColourType getVertexColourTracking(void) const;
00502 
00507         TextureUnitState* createTextureUnitState(void);
00518         TextureUnitState* createTextureUnitState( const String& textureName, unsigned short texCoordSet = 0);
00524         void addTextureUnitState(TextureUnitState* state);
00527         TextureUnitState* getTextureUnitState(unsigned short index);
00531         TextureUnitState* getTextureUnitState(const String& name);
00534         const TextureUnitState* getTextureUnitState(unsigned short index) const;
00538         const TextureUnitState* getTextureUnitState(const String& name) const;
00539 
00546         unsigned short getTextureUnitStateIndex(const TextureUnitState* state) const;
00547 
00548         typedef VectorIterator<TextureUnitStates> TextureUnitStateIterator;
00550         TextureUnitStateIterator getTextureUnitStateIterator(void);
00551 
00552         typedef ConstVectorIterator<TextureUnitStates> ConstTextureUnitStateIterator;
00554         ConstTextureUnitStateIterator getTextureUnitStateIterator(void) const;
00555 
00560         void removeTextureUnitState(unsigned short index);
00561 
00564         void removeAllTextureUnitStates(void);
00565 
00568         unsigned short getNumTextureUnitStates(void) const
00569         {
00570             return static_cast<unsigned short>(mTextureUnitStates.size());
00571         }
00572 
00589         void setSceneBlending( const SceneBlendType sbt );
00590 
00609         void setSeparateSceneBlending( const SceneBlendType sbt, const SceneBlendType sbta );
00610 
00633         void setSceneBlending( const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor);
00634 
00661         void setSeparateSceneBlending( const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor, const SceneBlendFactor sourceFactorAlpha, const SceneBlendFactor destFactorAlpha );
00662 
00664         bool hasSeparateSceneBlending() const;
00665 
00668         SceneBlendFactor getSourceBlendFactor() const;
00669 
00672         SceneBlendFactor getDestBlendFactor() const;
00673 
00676         SceneBlendFactor getSourceBlendFactorAlpha() const;
00677 
00680         SceneBlendFactor getDestBlendFactorAlpha() const;
00681 
00692         void setSceneBlendingOperation(SceneBlendOperation op);
00693 
00707         void setSeparateSceneBlendingOperation(SceneBlendOperation op, SceneBlendOperation alphaOp);
00708 
00710         bool hasSeparateSceneBlendingOperations() const;
00711 
00713         SceneBlendOperation getSceneBlendingOperation() const;
00714 
00716         SceneBlendOperation getSceneBlendingOperationAlpha() const;
00717 
00719         bool isTransparent(void) const;
00720 
00732         void setDepthCheckEnabled(bool enabled);
00733 
00738         bool getDepthCheckEnabled(void) const;
00739 
00750         void setDepthWriteEnabled(bool enabled);
00751 
00756         bool getDepthWriteEnabled(void) const;
00757 
00765         void setDepthFunction( CompareFunction func );
00770         CompareFunction getDepthFunction(void) const;
00771 
00782         void setColourWriteEnabled(bool enabled);
00784         bool getColourWriteEnabled(void) const;
00785 
00799         void setCullingMode( CullingMode mode );
00800 
00803         CullingMode getCullingMode(void) const;
00804 
00818         void setManualCullingMode( ManualCullingMode mode );
00819 
00824         ManualCullingMode getManualCullingMode(void) const;
00825 
00834         void setLightingEnabled(bool enabled);
00835 
00838         bool getLightingEnabled(void) const;
00839 
00848         void setMaxSimultaneousLights(unsigned short maxLights);
00850         unsigned short getMaxSimultaneousLights(void) const;
00851 
00862         void setStartLight(unsigned short startLight);
00864         unsigned short getStartLight(void) const;
00865 
00870         void setShadingMode( ShadeOptions mode );
00871 
00874         ShadeOptions getShadingMode(void) const;
00875 
00880         void setPolygonMode( PolygonMode mode );
00881 
00884         PolygonMode getPolygonMode(void) const;
00885 
00891         virtual void setPolygonModeOverrideable(bool override)
00892         {
00893             mPolygonModeOverrideable = override;
00894         }
00895 
00899         virtual bool getPolygonModeOverrideable(void) const
00900         {
00901             return mPolygonModeOverrideable;
00902         }
00932         void setFog(
00933             bool overrideScene,
00934             FogMode mode = FOG_NONE,
00935             const ColourValue& colour = ColourValue::White,
00936             Real expDensity = 0.001, Real linearStart = 0.0, Real linearEnd = 1.0 );
00937 
00940         bool getFogOverride(void) const;
00941 
00946         FogMode getFogMode(void) const;
00947 
00950         const ColourValue& getFogColour(void) const;
00951 
00956         Real getFogStart(void) const;
00957 
00962         Real getFogEnd(void) const;
00963 
00968         Real getFogDensity(void) const;
00969 
00989         void setDepthBias(float constantBias, float slopeScaleBias = 0.0f);
00990 
00992         float getDepthBiasConstant(void) const;
00994         float getDepthBiasSlopeScale(void) const;
01001         void setIterationDepthBias(float biasPerIteration);
01005         float getIterationDepthBias() const;
01006 
01016         void setAlphaRejectSettings(CompareFunction func, unsigned char value, bool alphaToCoverageEnabled = false);
01017 
01020         void setAlphaRejectFunction(CompareFunction func);
01021 
01024         void setAlphaRejectValue(unsigned char val);
01025 
01028         CompareFunction getAlphaRejectFunction(void) const { return mAlphaRejectFunc; }
01029 
01032         unsigned char getAlphaRejectValue(void) const { return mAlphaRejectVal; }
01033 
01041         void setAlphaToCoverageEnabled(bool enabled);
01042 
01045         bool isAlphaToCoverageEnabled() const { return mAlphaToCoverageEnabled; }
01046 
01059         void setTransparentSortingEnabled(bool enabled);
01060 
01063         bool getTransparentSortingEnabled(void) const;
01064 
01074         void setTransparentSortingForced(bool enabled);
01075 
01078         bool getTransparentSortingForced(void) const;
01079 
01122         void setIteratePerLight(bool enabled,
01123             bool onlyForOneLightType = true, Light::LightTypes lightType = Light::LT_POINT);
01124 
01126         bool getIteratePerLight(void) const { return mIteratePerLight; }
01128         bool getRunOnlyForOneLightType(void) const { return mRunOnlyForOneLightType; }
01131         Light::LightTypes getOnlyLightType() const { return mOnlyLightType; }
01132 
01142         void setLightCountPerIteration(unsigned short c);
01146         unsigned short getLightCountPerIteration(void) const;
01147         
01149         Technique* getParent(void) const { return mParent; }
01150 
01152         const String& getResourceGroup(void) const;
01153 
01170         void setVertexProgram(const String& name, bool resetParams = true);
01177         void setVertexProgramParameters(GpuProgramParametersSharedPtr params);
01179         const String& getVertexProgramName(void) const;
01181         GpuProgramParametersSharedPtr getVertexProgramParameters(void) const;
01183         const GpuProgramPtr& getVertexProgram(void) const;
01184 
01185 
01215         void setShadowCasterVertexProgram(const String& name);
01222         void setShadowCasterVertexProgramParameters(GpuProgramParametersSharedPtr params);
01224         const String& getShadowCasterVertexProgramName(void) const;
01226         GpuProgramParametersSharedPtr getShadowCasterVertexProgramParameters(void) const;
01229         const GpuProgramPtr& getShadowCasterVertexProgram(void) const;
01230 
01256         void setShadowReceiverVertexProgram(const String& name);
01263         void setShadowReceiverVertexProgramParameters(GpuProgramParametersSharedPtr params);
01264 
01285         void setShadowReceiverFragmentProgram(const String& name);
01292         void setShadowReceiverFragmentProgramParameters(GpuProgramParametersSharedPtr params);
01293 
01295         const String& getShadowReceiverVertexProgramName(void) const;
01297         GpuProgramParametersSharedPtr getShadowReceiverVertexProgramParameters(void) const;
01300         const GpuProgramPtr& getShadowReceiverVertexProgram(void) const;
01301 
01303         const String& getShadowReceiverFragmentProgramName(void) const;
01305         GpuProgramParametersSharedPtr getShadowReceiverFragmentProgramParameters(void) const;
01308         const GpuProgramPtr& getShadowReceiverFragmentProgram(void) const;
01309 
01326         void setFragmentProgram(const String& name, bool resetParams = true);
01331         void setFragmentProgramParameters(GpuProgramParametersSharedPtr params);
01333         const String& getFragmentProgramName(void) const;
01335         GpuProgramParametersSharedPtr getFragmentProgramParameters(void) const;
01337         const GpuProgramPtr& getFragmentProgram(void) const;
01338 
01355         void setGeometryProgram(const String& name, bool resetParams = true);
01360         void setGeometryProgramParameters(GpuProgramParametersSharedPtr params);
01362         const String& getGeometryProgramName(void) const;
01364         GpuProgramParametersSharedPtr getGeometryProgramParameters(void) const;
01366         const GpuProgramPtr& getGeometryProgram(void) const;
01367 
01379         Pass* _split(unsigned short numUnits);
01380 
01382         void _notifyIndex(unsigned short index);
01383 
01385         void _prepare(void);
01387         void _unprepare(void);
01389         void _load(void);
01391         void _unload(void);
01392         // Is this loaded?
01393         bool isLoaded(void) const;
01394 
01401         uint32 getHash(void) const { return mHash; }
01403         void _dirtyHash(void);
01410         void _recalculateHash(void);
01412         void _notifyNeedsRecompile(void);
01413 
01418         void _updateAutoParams(const AutoParamDataSource* source, uint16 variabilityMask) const;
01419 
01426         unsigned short _getTextureUnitWithContentTypeIndex(
01427             TextureUnitState::ContentType contentType, unsigned short index) const;
01428 
01437         void setTextureFiltering(TextureFilterOptions filterType);
01446         void setTextureAnisotropy(unsigned int maxAniso);
01458         void setNormaliseNormals(bool normalise) { mNormaliseNormals = normalise; }
01459 
01461         bool getNormaliseNormals(void) const {return mNormaliseNormals; }
01462 
01466         static const PassSet& getDirtyHashList(void)
01467         { return msDirtyHashList; }
01470         static const PassSet& getPassGraveyard(void)
01471         { return msPassGraveyard; }
01479         static void clearDirtyHashList(void);
01480 
01482         static void processPendingPassUpdates(void);
01483 
01485         void queueForDeletion(void);
01486 
01489         bool isAmbientOnly(void) const;
01490 
01504         void setPassIterationCount(const size_t count) { mPassIterationCount = count; }
01505 
01508         size_t getPassIterationCount(void) const { return mPassIterationCount; }
01509 
01521         bool applyTextureAliases(const AliasTextureNamePairList& aliasList, const bool apply = true) const;
01522 
01543         void setLightScissoringEnabled(bool enabled) { mLightScissoring = enabled; }
01547         bool getLightScissoringEnabled() const { return mLightScissoring; }
01548 
01572         void setLightClipPlanesEnabled(bool enabled) { mLightClipPlanes = enabled; }
01576         bool getLightClipPlanesEnabled() const { return mLightClipPlanes; }
01577 
01599         void setIlluminationStage(IlluminationStage is) { mIlluminationStage = is; }
01601         IlluminationStage getIlluminationStage() const { return mIlluminationStage; }
01605         enum BuiltinHashFunction
01606         {
01608             MIN_TEXTURE_CHANGE,
01613             MIN_GPU_PROGRAM_CHANGE
01614         };
01627         static void setHashFunction(BuiltinHashFunction builtin);
01628 
01640         static void setHashFunction(HashFunc* hashFunc) { msHashFunc = hashFunc; }
01641 
01644         static HashFunc* getHashFunction(void) { return msHashFunc; }
01645 
01648         static HashFunc* getBuiltinHashFunction(BuiltinHashFunction builtin);
01649 
01654         UserObjectBindings& getUserObjectBindings() { return mUserObjectBindings; }
01655 
01660         const UserObjectBindings& getUserObjectBindings() const { return mUserObjectBindings; }
01661     };
01662 
01672     struct IlluminationPass : public PassAlloc
01673     {
01674         IlluminationStage stage;
01676         Pass* pass;
01678         bool destroyOnShutdown;
01680         Pass* originalPass;
01681 
01682         IlluminationPass() {}
01683     };
01684 
01685     typedef vector<IlluminationPass*>::type IlluminationPassList;
01686 
01690 }
01691 
01692 #endif

Copyright © 2008 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Wed Nov 3 2010 19:24:52