OGRE: OgrePass.h Source File - OGRE Documentation

# 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
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Wed Nov 3 2010 19:24:52