api/1.9/_ogre_scene_manager_8h_source.html

 /*-------------------------------------------------------------------------

 This source file is a part of OGRE

 (Object-oriented Graphics Rendering Engine)


 For the latest info, see http://www.ogre3d.org/


 Copyright (c) 2000-2014 Torus Knot Software Ltd

 Permission is hereby granted, free of charge, to any person obtaining a copy

 of this software and associated documentation files (the "Software"), to deal

 in the Software without restriction, including without limitation the rights

 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 copies of the Software, and to permit persons to whom the Software is

 furnished to do so, subject to the following conditions:


 The above copyright notice and this permission notice shall be included in

 all copies or substantial portions of the Software.


 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 THE SOFTWARE


 You may alternatively use this source under the terms of a specific version of

 the OGRE Unrestricted License provided you have obtained such a license from

 Torus Knot Software Ltd.

 -------------------------------------------------------------------------*/

 #ifndef __SceneManager_H__

 #define __SceneManager_H__


 // Precompiler options

 #include "OgrePrerequisites.h"


 #include "OgreString.h"

 #include "OgreSceneNode.h"

 #include "OgrePlane.h"

 #include "OgreQuaternion.h"

 #include "OgreColourValue.h"

 #include "OgreCommon.h"

 #include "OgreSceneQuery.h"

 #include "OgreAutoParamDataSource.h"

 #include "OgreAnimationState.h"

 #include "OgreRenderQueue.h"

 #include "OgreRenderQueueSortingGrouping.h"

 #include "OgreRectangle2D.h"

 #include "OgrePixelFormat.h"

 #include "OgreResourceGroupManager.h"

 #include "OgreTexture.h"

 #include "OgreShadowCameraSetup.h"

 #include "OgreShadowTextureManager.h"

 #include "OgreCamera.h"

 #include "OgreInstancedGeometry.h"

 #include "OgreLodListener.h"

 #include "OgreInstanceManager.h"

 #include "OgreRenderSystem.h"

 #include "OgreHeaderPrefix.h"

 #include "OgreNameGenerator.h"


 namespace Ogre {

     struct ViewPoint

     {

         Vector3 position;

         Quaternion orientation;

     };


     // Forward declarations

     class DefaultIntersectionSceneQuery;

     class DefaultRaySceneQuery;

     class DefaultSphereSceneQuery;

     class DefaultAxisAlignedBoxSceneQuery;

     class CompositorChain;


     struct _OgreExport VisibleObjectsBoundsInfo

     {

         AxisAlignedBox aabb;

         AxisAlignedBox receiverAabb;

         Real minDistance;

         Real maxDistance;

         Real minDistanceInFrustum;

         Real maxDistanceInFrustum;


         VisibleObjectsBoundsInfo();

         void reset();

         void merge(const AxisAlignedBox& boxBounds, const Sphere& sphereBounds,

             const Camera* cam, bool receiver=true);

         void mergeNonRenderedButInFrustum(const AxisAlignedBox& boxBounds,

             const Sphere& sphereBounds, const Camera* cam);


     };


     class _OgreExport SceneManager : public SceneMgtAlloc

     {

     public:

         static uint32 WORLD_GEOMETRY_TYPE_MASK;

         static uint32 ENTITY_TYPE_MASK;

         static uint32 FX_TYPE_MASK;

         static uint32 STATICGEOMETRY_TYPE_MASK;

         static uint32 LIGHT_TYPE_MASK;

         static uint32 FRUSTUM_TYPE_MASK;

         static uint32 USER_TYPE_MASK_LIMIT;

         struct materialLess

         {

             _OgreExport bool operator()(const Material* x, const Material* y) const;

         };

         struct lightLess

         {

             _OgreExport bool operator()(const Light* a, const Light* b) const;

         };


         enum IlluminationRenderStage

         {

             IRS_NONE,

             IRS_RENDER_TO_TEXTURE,

             IRS_RENDER_RECEIVER_PASS

         };


         enum SpecialCaseRenderQueueMode

         {

             SCRQM_INCLUDE,

             SCRQM_EXCLUDE

         };


         struct SkyDomeGenParameters

         {

             Real skyDomeCurvature;

             Real skyDomeTiling;

             Real skyDomeDistance;

             int skyDomeXSegments;

             int skyDomeYSegments;

             int skyDomeYSegments_keep;

         };


         struct SkyPlaneGenParameters

         {

             Real skyPlaneScale;

             Real skyPlaneTiling;

             Real skyPlaneBow;

             int skyPlaneXSegments;

             int skyPlaneYSegments;

         };


         struct SkyBoxGenParameters

         {

             Real skyBoxDistance;

         };


         class Listener

         {

         public:

             Listener() {}

             virtual ~Listener() {}


             virtual void preUpdateSceneGraph(SceneManager* source, Camera* camera)

                         { (void)source; (void)camera; }


             virtual void postUpdateSceneGraph(SceneManager* source, Camera* camera)

                         { (void)source; (void)camera; }


             virtual void preFindVisibleObjects(SceneManager* source,

                 IlluminationRenderStage irs, Viewport* v)

                         { (void)source; (void)irs; (void)v; }


             virtual void postFindVisibleObjects(SceneManager* source,

                 IlluminationRenderStage irs, Viewport* v)

                         { (void)source; (void)irs; (void)v; }


             virtual void shadowTexturesUpdated(size_t numberOfShadowTextures)

                         { (void)numberOfShadowTextures; }


             virtual void shadowTextureCasterPreViewProj(Light* light,

                 Camera* camera, size_t iteration)

                         { (void)light; (void)camera; (void)iteration; }


             virtual void shadowTextureReceiverPreViewProj(Light* light,

                 Frustum* frustum)

                         { (void)light; (void)frustum; }


             virtual bool sortLightsAffectingFrustum(LightList& lightList)

                         { (void)lightList; return false; }


             virtual void sceneManagerDestroyed(SceneManager* source)

                         { (void)source; }

         };


         class _OgreExport SceneMgrQueuedRenderableVisitor : public QueuedRenderableVisitor

         {

         protected:

             const Pass* mUsedPass;

         public:

             SceneMgrQueuedRenderableVisitor()

                 :transparentShadowCastersMode(false) {}

             ~SceneMgrQueuedRenderableVisitor() {}

             void visit(Renderable* r);

             bool visit(const Pass* p);

             void visit(RenderablePass* rp);


             SceneManager* targetSceneMgr;

             bool transparentShadowCastersMode;

             bool autoLights;

             const LightList* manualLightList;

             bool scissoring;


         };

         friend class SceneMgrQueuedRenderableVisitor;


     protected:


         virtual SceneNode* createSceneNodeImpl(void);

         virtual SceneNode* createSceneNodeImpl(const String& name);


         String mName;


         RenderQueue* mRenderQueue;

         bool mLastRenderQueueInvocationCustom;


         ColourValue mAmbientLight;


         RenderSystem *mDestRenderSystem;


         typedef map<String, Camera* >::type CameraList;


         CameraList mCameras;


         typedef map<String, StaticGeometry* >::type StaticGeometryList;

         StaticGeometryList mStaticGeometryList;

         typedef map<String, InstancedGeometry* >::type InstancedGeometryList;

         InstancedGeometryList mInstancedGeometryList;


         typedef map<String, InstanceManager*>::type InstanceManagerMap;

         InstanceManagerMap  mInstanceManagerMap;


         typedef map<String, SceneNode*>::type SceneNodeList;


         SceneNodeList mSceneNodes;


         Camera* mCameraInProgress;

         Viewport* mCurrentViewport;


         SceneNode* mSceneRoot;


         typedef set<SceneNode*>::type AutoTrackingSceneNodes;

         AutoTrackingSceneNodes mAutoTrackingSceneNodes;


         // Sky params

         // Sky plane

         Entity* mSkyPlaneEntity;

         Entity* mSkyDomeEntity[5];

         ManualObject* mSkyBoxObj;


         SceneNode* mSkyPlaneNode;

         SceneNode* mSkyDomeNode;

         SceneNode* mSkyBoxNode;


         // Sky plane

         bool mSkyPlaneEnabled;

         uint8 mSkyPlaneRenderQueue;

         Plane mSkyPlane;

         SkyPlaneGenParameters mSkyPlaneGenParameters;

         // Sky box

         bool mSkyBoxEnabled;

         uint8 mSkyBoxRenderQueue;

         Quaternion mSkyBoxOrientation;

         SkyBoxGenParameters mSkyBoxGenParameters;

         // Sky dome

         bool mSkyDomeEnabled;

         uint8 mSkyDomeRenderQueue;

         Quaternion mSkyDomeOrientation;

         SkyDomeGenParameters mSkyDomeGenParameters;


         // Fog

         FogMode mFogMode;

         ColourValue mFogColour;

         Real mFogStart;

         Real mFogEnd;

         Real mFogDensity;


         typedef set<uint8>::type SpecialCaseRenderQueueList;

         SpecialCaseRenderQueueList mSpecialCaseQueueList;

         SpecialCaseRenderQueueMode mSpecialCaseQueueMode;

         uint8 mWorldGeometryRenderQueue;


         unsigned long mLastFrameNumber;

         Matrix4 mTempXform[256];

         bool mResetIdentityView;

         bool mResetIdentityProj;


         bool mNormaliseNormalsOnScale;

         bool mFlipCullingOnNegativeScale;

         CullingMode mPassCullingMode;


     protected:


         typedef map< const Camera*, VisibleObjectsBoundsInfo>::type CamVisibleObjectsMap;

         CamVisibleObjectsMap mCamVisibleObjectsMap;


         typedef map< const Camera*, const Light* >::type ShadowCamLightMapping;

         ShadowCamLightMapping mShadowCamLightMapping;


         size_t mShadowTextureCountPerType[3];


         vector<size_t>::type mShadowTextureIndexLightList;


         struct _OgreExport LightInfo

         {

             Light* light;

             int type;

             Real range;

             Vector3 position;

             uint32 lightMask;


             bool operator== (const LightInfo& rhs) const

             {

                 return light == rhs.light && type == rhs.type &&

                     range == rhs.range && position == rhs.position && lightMask == rhs.lightMask;

             }


             bool operator!= (const LightInfo& rhs) const

             {

                 return !(*this == rhs);

             }

         };


         typedef vector<LightInfo>::type LightInfoList;


         LightList mLightsAffectingFrustum;

         LightInfoList mCachedLightInfos;

         LightInfoList mTestLightInfos; // potentially new list

         ulong mLightsDirtyCounter;

         LightList mShadowTextureCurrentCasterLightList;


         typedef map<String, MovableObject*>::type MovableObjectMap;

         struct MovableObjectCollection

         {

                     MovableObjectMap map;

                     OGRE_MUTEX(mutex);

         };

         typedef map<String, MovableObjectCollection*>::type MovableObjectCollectionMap;

         MovableObjectCollectionMap mMovableObjectCollectionMap;

         NameGenerator mMovableNameGenerator;

         MovableObjectCollection* getMovableObjectCollection(const String& typeName);

         const MovableObjectCollection* getMovableObjectCollection(const String& typeName) const;

         OGRE_MUTEX(mMovableObjectCollectionMapMutex);


         virtual void initRenderQueue(void);

         Pass* mShadowCasterPlainBlackPass;

         Pass* mShadowReceiverPass;

         virtual const Pass* deriveShadowCasterPass(const Pass* pass);

         virtual const Pass* deriveShadowReceiverPass(const Pass* pass);


         virtual bool validatePassForRendering(const Pass* pass);


         virtual bool validateRenderableForRendering(const Pass* pass, const Renderable* rend);


         enum BoxPlane

         {

             BP_FRONT = 0,

             BP_BACK = 1,

             BP_LEFT = 2,

             BP_RIGHT = 3,

             BP_UP = 4,

             BP_DOWN = 5

         };


         /* Internal utility method for creating the planes of a skybox.

         */

         virtual MeshPtr createSkyboxPlane(

             BoxPlane bp,

             Real distance,

             const Quaternion& orientation,

             const String& groupName);


         /* Internal utility method for creating the planes of a skydome.

         */

         virtual MeshPtr createSkydomePlane(

             BoxPlane bp,

             Real curvature, Real tiling, Real distance,

             const Quaternion& orientation,

             int xsegments, int ysegments, int ySegmentsToKeep,

             const String& groupName);


         bool mDisplayNodes;


         typedef map<String, Animation*>::type AnimationList;

         AnimationList mAnimationsList;

         OGRE_MUTEX(mAnimationsListMutex);

         AnimationStateSet mAnimationStates;


         virtual void useRenderableViewProjMode(const Renderable* pRend, bool fixedFunction);


         virtual void resetViewProjMode(bool fixedFunction);


         typedef vector<RenderQueueListener*>::type RenderQueueListenerList;

         RenderQueueListenerList mRenderQueueListeners;


         typedef vector<RenderObjectListener*>::type RenderObjectListenerList;

         RenderObjectListenerList mRenderObjectListeners;

         typedef vector<Listener*>::type ListenerList;

         ListenerList mListeners;

         virtual void firePreRenderQueues();

         virtual void firePostRenderQueues();

         virtual bool fireRenderQueueStarted(uint8 id, const String& invocation);

         virtual bool fireRenderQueueEnded(uint8 id, const String& invocation);

         virtual void fireRenderSingleObject(Renderable* rend, const Pass* pass, const AutoParamDataSource* source,

             const LightList* pLightList, bool suppressRenderStateChanges);


         virtual void fireShadowTexturesUpdated(size_t numberOfShadowTextures);

         virtual void fireShadowTexturesPreCaster(Light* light, Camera* camera, size_t iteration);

         virtual void fireShadowTexturesPreReceiver(Light* light, Frustum* f);

         virtual void firePreUpdateSceneGraph(Camera* camera);

         virtual void firePostUpdateSceneGraph(Camera* camera);

         virtual void firePreFindVisibleObjects(Viewport* v);

         virtual void firePostFindVisibleObjects(Viewport* v);

         virtual void fireSceneManagerDestroyed();

         virtual void setViewport(Viewport *vp);


         bool mShowBoundingBoxes;


         virtual void renderVisibleObjectsDefaultSequence(void);

         virtual void renderVisibleObjectsCustomSequence(RenderQueueInvocationSequence* s);

         virtual void prepareRenderQueue(void);


         virtual void renderSingleObject(Renderable* rend, const Pass* pass,

             bool lightScissoringClipping, bool doLightIteration, const LightList* manualLightList = 0);


         virtual AutoParamDataSource* createAutoParamDataSource(void) const

         {

             return OGRE_NEW AutoParamDataSource();

         }


         AutoParamDataSource* mAutoParamDataSource;


         CompositorChain* mActiveCompositorChain;

         bool mLateMaterialResolving;


         ShadowTechnique mShadowTechnique;

         bool mDebugShadows;

         ColourValue mShadowColour;

         Pass* mShadowDebugPass;

         Pass* mShadowStencilPass;

         Pass* mShadowModulativePass;

         bool mShadowMaterialInitDone;

         HardwareIndexBufferSharedPtr mShadowIndexBuffer;

         size_t mShadowIndexBufferSize;

         size_t mShadowIndexBufferUsedSize;

         Rectangle2D* mFullScreenQuad;

         Real mShadowDirLightExtrudeDist;

         IlluminationRenderStage mIlluminationStage;

         ShadowTextureConfigList mShadowTextureConfigList;

         bool mShadowTextureConfigDirty;

         ShadowTextureList mShadowTextures;

         TexturePtr mNullShadowTexture;

         typedef vector<Camera*>::type ShadowTextureCameraList;

         ShadowTextureCameraList mShadowTextureCameras;

         Texture* mCurrentShadowTexture;

         bool mShadowUseInfiniteFarPlane;

         bool mShadowCasterRenderBackFaces;

         bool mShadowAdditiveLightClip;

         struct LightClippingInfo

         {

             RealRect scissorRect;

             PlaneList clipPlanes;

             bool scissorValid;

             unsigned long clipPlanesValid;

             LightClippingInfo() : scissorValid(false), clipPlanesValid(false) {}


         };

         typedef map<Light*, LightClippingInfo>::type LightClippingInfoMap;

         LightClippingInfoMap mLightClippingInfoMap;

         unsigned long mLightClippingInfoMapFrameNumber;


         ShadowCameraSetupPtr mDefaultShadowCameraSetup;


         struct lightsForShadowTextureLess

         {

             _OgreExport bool operator()(const Light* l1, const Light* l2) const;

         };


         virtual void findLightsAffectingFrustum(const Camera* camera);

         virtual void initShadowVolumeMaterials(void);

         virtual void ensureShadowTexturesCreated();

         virtual void destroyShadowTextures(void);


         typedef vector<InstanceManager*>::type      InstanceManagerVec;

         InstanceManagerVec mDirtyInstanceManagers;

         InstanceManagerVec mDirtyInstanceMgrsTmp;


         void updateDirtyInstanceManagers(void);


     public:

         virtual void prepareShadowTextures(Camera* cam, Viewport* vp, const LightList* lightList = 0);


         //A render context, used to store internal data for pausing/resuming rendering

         struct RenderContext

         {

             RenderQueue* renderQueue;

             Viewport* viewport;

             Camera* camera;

             CompositorChain* activeChain;

             RenderSystem::RenderSystemContext* rsContext;

         };


         virtual RenderContext* _pauseRendering();

         virtual void _resumeRendering(RenderContext* context);


     protected:

         virtual void renderShadowVolumesToStencil(const Light* light, const Camera* cam,

             bool calcScissor);

         virtual void setShadowVolumeStencilState(bool secondpass, bool zfail, bool twosided);

         void renderShadowVolumeObjects(ShadowCaster::ShadowRenderableListIterator iShadowRenderables,

             Pass* pass, const LightList *manualLightList, unsigned long flags,

             bool secondpass, bool zfail, bool twosided);

         typedef vector<ShadowCaster*>::type ShadowCasterList;

         ShadowCasterList mShadowCasterList;

         SphereSceneQuery* mShadowCasterSphereQuery;

         AxisAlignedBoxSceneQuery* mShadowCasterAABBQuery;

         Real mDefaultShadowFarDist;

         Real mDefaultShadowFarDistSquared;

         Real mShadowTextureOffset;

         Real mShadowTextureFadeStart;

         Real mShadowTextureFadeEnd;

         bool mShadowTextureSelfShadow;

         Pass* mShadowTextureCustomCasterPass;

         Pass* mShadowTextureCustomReceiverPass;

         String mShadowTextureCustomCasterVertexProgram;

         String mShadowTextureCustomCasterFragmentProgram;

         String mShadowTextureCustomReceiverVertexProgram;

         String mShadowTextureCustomReceiverFragmentProgram;

         GpuProgramParametersSharedPtr mShadowTextureCustomCasterVPParams;

         GpuProgramParametersSharedPtr mShadowTextureCustomCasterFPParams;

         GpuProgramParametersSharedPtr mShadowTextureCustomReceiverVPParams;

         GpuProgramParametersSharedPtr mShadowTextureCustomReceiverFPParams;


         uint32 mVisibilityMask;

         bool mFindVisibleObjects;


         bool mSuppressRenderStateChanges;

         bool mSuppressShadows;


         GpuProgramParametersSharedPtr mInfiniteExtrusionParams;

         GpuProgramParametersSharedPtr mFiniteExtrusionParams;


         class _OgreExport ShadowCasterSceneQueryListener : public SceneQueryListener, public SceneMgtAlloc

         {

         protected:

             SceneManager* mSceneMgr;

             ShadowCasterList* mCasterList;

             bool mIsLightInFrustum;

             const PlaneBoundedVolumeList* mLightClipVolumeList;

             const Camera* mCamera;

             const Light* mLight;

             Real mFarDistSquared;

         public:

             ShadowCasterSceneQueryListener(SceneManager* sm) : mSceneMgr(sm),

                 mCasterList(0), mIsLightInFrustum(false), mLightClipVolumeList(0),

                 mCamera(0) {}

             // Prepare the listener for use with a set of parameters

             void prepare(bool lightInFrustum,

                 const PlaneBoundedVolumeList* lightClipVolumes,

                 const Light* light, const Camera* cam, ShadowCasterList* casterList,

                 Real farDistSquared)

             {

                 mCasterList = casterList;

                 mIsLightInFrustum = lightInFrustum;

                 mLightClipVolumeList = lightClipVolumes;

                 mCamera = cam;

                 mLight = light;

                 mFarDistSquared = farDistSquared;

             }

             bool queryResult(MovableObject* object);

             bool queryResult(SceneQuery::WorldFragment* fragment);

         };


         ShadowCasterSceneQueryListener* mShadowCasterQueryListener;


         virtual const ShadowCasterList& findShadowCastersForLight(const Light* light,

             const Camera* camera);

         virtual void renderBasicQueueGroupObjects(RenderQueueGroup* pGroup,

             QueuedRenderableCollection::OrganisationMode om);

         virtual void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* group,

             QueuedRenderableCollection::OrganisationMode om);

         virtual void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* group,

             QueuedRenderableCollection::OrganisationMode om);

         virtual void renderTextureShadowCasterQueueGroupObjects(RenderQueueGroup* group,

             QueuedRenderableCollection::OrganisationMode om);

         virtual void renderTextureShadowReceiverQueueGroupObjects(RenderQueueGroup* group,

             QueuedRenderableCollection::OrganisationMode om);

         virtual void renderModulativeTextureShadowedQueueGroupObjects(RenderQueueGroup* group,

             QueuedRenderableCollection::OrganisationMode om);


         virtual void renderAdditiveTextureShadowedQueueGroupObjects(RenderQueueGroup* group,

             QueuedRenderableCollection::OrganisationMode om);

         virtual void renderObjects(const QueuedRenderableCollection& objs,

             QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping,

             bool doLightIteration, const LightList* manualLightList = 0);

         virtual void renderTransparentShadowCasterObjects(const QueuedRenderableCollection& objs,

             QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping,

             bool doLightIteration, const LightList* manualLightList = 0);


         virtual void updateRenderQueueSplitOptions(void);

         virtual void updateRenderQueueGroupSplitOptions(RenderQueueGroup* group,

             bool suppressShadows, bool suppressRenderState);


         virtual ClipResult buildAndSetScissor(const LightList& ll, const Camera* cam);

         virtual void buildScissor(const Light* l, const Camera* cam, RealRect& rect);

         virtual void resetScissor();

         virtual ClipResult buildAndSetLightClip(const LightList& ll);

         virtual void buildLightClip(const Light* l, PlaneList& planes);

         virtual void resetLightClip();

         virtual void checkCachedLightClippingInfo();


         SceneMgrQueuedRenderableVisitor* mActiveQueuedRenderableVisitor;

         SceneMgrQueuedRenderableVisitor mDefaultQueuedRenderableVisitor;


         bool mCameraRelativeRendering;

         Matrix4 mCachedViewMatrix;

         Vector3 mCameraRelativePosition;


         uint32 mLastLightHash;

         unsigned short mLastLightLimit;

         uint32 mLastLightHashGpuProgram;

         uint16 mGpuParamsDirty;


         virtual void useLights(const LightList& lights, unsigned short limit);

         virtual void setViewMatrix(const Matrix4& m);

         virtual void useLightsGpuProgram(const Pass* pass, const LightList* lights);

         virtual void bindGpuProgram(GpuProgram* prog);

         virtual void updateGpuProgramParameters(const Pass* p);


         typedef set<LodListener*>::type LodListenerSet;

         LodListenerSet mLodListeners;


         typedef vector<MovableObjectLodChangedEvent>::type MovableObjectLodChangedEventList;

         MovableObjectLodChangedEventList mMovableObjectLodChangedEvents;


         typedef vector<EntityMeshLodChangedEvent>::type EntityMeshLodChangedEventList;

         EntityMeshLodChangedEventList mEntityMeshLodChangedEvents;


         typedef vector<EntityMaterialLodChangedEvent>::type EntityMaterialLodChangedEventList;

         EntityMaterialLodChangedEventList mEntityMaterialLodChangedEvents;


     public:

         SceneManager(const String& instanceName);


         virtual ~SceneManager();


         OGRE_MUTEX(sceneGraphMutex);


         const String& getName(void) const { return mName; }


         virtual const String& getTypeName(void) const = 0;


         virtual Camera* createCamera(const String& name);


         virtual Camera* getCamera(const String& name) const;


         virtual bool hasCamera(const String& name) const;


         virtual void destroyCamera(Camera *cam);


         virtual void destroyCamera(const String& name);


         virtual void destroyAllCameras(void);


         virtual Light* createLight(const String& name);


         virtual Light* createLight();


         virtual Light* getLight(const String& name) const;


         virtual bool hasLight(const String& name) const;


         virtual const PlaneList& getLightClippingPlanes(Light* l);


         virtual const RealRect& getLightScissorRect(Light* l, const Camera* cam);


         virtual void destroyLight(const String& name);


         virtual void destroyLight(Light* light);

         virtual void destroyAllLights(void);


         virtual void _notifyLightsDirty(void);


         ulong _getLightsDirtyCounter(void) const { return mLightsDirtyCounter; }


         virtual const LightList& _getLightsAffectingFrustum(void) const;


         virtual void _populateLightList(const Vector3& position, Real radius, LightList& destList, uint32 lightMask = 0xFFFFFFFF);


         virtual void _populateLightList(const SceneNode* sn, Real radius, LightList& destList, uint32 lightMask = 0xFFFFFFFF);


         virtual SceneNode* createSceneNode(void);


         virtual SceneNode* createSceneNode(const String& name);


         virtual void destroySceneNode(const String& name);


         virtual void destroySceneNode(SceneNode* sn);

         virtual SceneNode* getRootSceneNode(void);


         virtual SceneNode* getSceneNode(const String& name) const;


         virtual bool hasSceneNode(const String& name) const;


         virtual Entity* createEntity(const String& entityName, const String& meshName, const String& groupName = ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME );


         virtual Entity* createEntity(const String& entityName, const MeshPtr& pMesh );


         virtual Entity* createEntity(const String& meshName);


         virtual Entity* createEntity(const MeshPtr& pMesh);


         enum PrefabType {

             PT_PLANE,

             PT_CUBE,

             PT_SPHERE

         };


         virtual Entity* createEntity(const String& entityName, PrefabType ptype);


         virtual Entity* createEntity(PrefabType ptype);

         virtual Entity* getEntity(const String& name) const;

         virtual bool hasEntity(const String& name) const;


         virtual void destroyEntity(Entity* ent);


         virtual void destroyEntity(const String& name);


         virtual void destroyAllEntities(void);


         virtual ManualObject* createManualObject(const String& name);

         virtual ManualObject* createManualObject();

         virtual ManualObject* getManualObject(const String& name) const;

         virtual bool hasManualObject(const String& name) const;


         virtual void destroyManualObject(ManualObject* obj);

         virtual void destroyManualObject(const String& name);

         virtual void destroyAllManualObjects(void);

         virtual BillboardChain* createBillboardChain(const String& name);

         virtual BillboardChain* createBillboardChain();

         virtual BillboardChain* getBillboardChain(const String& name) const;

         virtual bool hasBillboardChain(const String& name) const;


         virtual void destroyBillboardChain(BillboardChain* obj);

         virtual void destroyBillboardChain(const String& name);

         virtual void destroyAllBillboardChains(void);

         virtual RibbonTrail* createRibbonTrail(const String& name);

         virtual RibbonTrail* createRibbonTrail();

         virtual RibbonTrail* getRibbonTrail(const String& name) const;

         virtual bool hasRibbonTrail(const String& name) const;


         virtual void destroyRibbonTrail(RibbonTrail* obj);

         virtual void destroyRibbonTrail(const String& name);

         virtual void destroyAllRibbonTrails(void);


         virtual ParticleSystem* createParticleSystem(const String& name,

             const String& templateName);

         virtual ParticleSystem* createParticleSystem(const String& name,

             size_t quota = 500,

             const String& resourceGroup = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);


         virtual ParticleSystem* createParticleSystem(size_t quota = 500,

             const String& resourceGroup = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);

         virtual ParticleSystem* getParticleSystem(const String& name) const;

         virtual bool hasParticleSystem(const String& name) const;


         virtual void destroyParticleSystem(ParticleSystem* obj);

         virtual void destroyParticleSystem(const String& name);

         virtual void destroyAllParticleSystems(void);


         virtual void clearScene(void);


         void setAmbientLight(const ColourValue& colour);


         const ColourValue& getAmbientLight(void) const;


         virtual void prepareWorldGeometry(const String& filename);


         virtual void prepareWorldGeometry(DataStreamPtr& stream,

             const String& typeName = StringUtil::BLANK);


         virtual void setWorldGeometry(const String& filename);


         virtual void setWorldGeometry(DataStreamPtr& stream,

             const String& typeName = StringUtil::BLANK);


         virtual size_t estimateWorldGeometry(const String& filename)

         { (void)filename; return 0; }


         virtual size_t estimateWorldGeometry(DataStreamPtr& stream,

             const String& typeName = StringUtil::BLANK)

         { (void)stream; (void)typeName; return 0; }


         virtual ViewPoint getSuggestedViewpoint(bool random = false);


         virtual bool setOption( const String& strKey, const void* pValue )

         { (void)strKey; (void)pValue; return false; }


         virtual bool getOption( const String& strKey, void* pDestValue )

         { (void)strKey; (void)pDestValue; return false; }


         virtual bool hasOption( const String& strKey ) const

         { (void)strKey; return false; }


         virtual bool getOptionValues( const String& strKey, StringVector& refValueList )

         { (void)strKey; (void)refValueList; return false; }


         virtual bool getOptionKeys( StringVector& refKeys )

         { (void)refKeys; return false; }


         virtual void _updateSceneGraph(Camera* cam);


         virtual void _findVisibleObjects(Camera* cam, VisibleObjectsBoundsInfo* visibleBounds, bool onlyShadowCasters);


         virtual void _applySceneAnimations(void);


         virtual void _renderVisibleObjects(void);


         virtual void _renderScene(Camera* camera, Viewport* vp, bool includeOverlays);


         virtual void _queueSkiesForRendering(Camera* cam);


         virtual void _setDestinationRenderSystem(RenderSystem* sys);


         virtual void setSkyPlane(

             bool enable,

             const Plane& plane, const String& materialName, Real scale = 1000,

             Real tiling = 10, bool drawFirst = true, Real bow = 0,

             int xsegments = 1, int ysegments = 1,

             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);

         virtual void _setSkyPlane(

             bool enable,

             const Plane& plane, const String& materialName, Real scale = 1000,

             Real tiling = 10, uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, Real bow = 0,

             int xsegments = 1, int ysegments = 1,

             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);


         virtual void setSkyPlaneEnabled(bool enable) { mSkyPlaneEnabled = enable; }


         virtual bool isSkyPlaneEnabled(void) const { return mSkyPlaneEnabled; }


         virtual SceneNode* getSkyPlaneNode(void) const { return mSkyPlaneNode; }


         virtual const SkyPlaneGenParameters& getSkyPlaneGenParameters(void) const { return mSkyPlaneGenParameters; }


         virtual void setSkyBox(

             bool enable, const String& materialName, Real distance = 5000,

             bool drawFirst = true, const Quaternion& orientation = Quaternion::IDENTITY,

             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);


         virtual void _setSkyBox(

             bool enable, const String& materialName, Real distance = 5000,

             uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, const Quaternion& orientation = Quaternion::IDENTITY,

             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);


         virtual void setSkyBoxEnabled(bool enable) { mSkyBoxEnabled = enable; }


         virtual bool isSkyBoxEnabled(void) const { return mSkyBoxEnabled; }


         virtual SceneNode* getSkyBoxNode(void) const { return mSkyBoxNode; }


         virtual const SkyBoxGenParameters& getSkyBoxGenParameters(void) const { return mSkyBoxGenParameters; }


         virtual void setSkyDome(

             bool enable, const String& materialName, Real curvature = 10,

             Real tiling = 8, Real distance = 4000, bool drawFirst = true,

             const Quaternion& orientation = Quaternion::IDENTITY,

             int xsegments = 16, int ysegments = 16, int ysegments_keep = -1,

             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);


         virtual void _setSkyDome(

             bool enable, const String& materialName, Real curvature = 10,

             Real tiling = 8, Real distance = 4000, uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY,

             const Quaternion& orientation = Quaternion::IDENTITY,

             int xsegments = 16, int ysegments = 16, int ysegments_keep = -1,

             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);


         virtual void setSkyDomeEnabled(bool enable) { mSkyDomeEnabled = enable; }


         virtual bool isSkyDomeEnabled(void) const { return mSkyDomeEnabled; }


         virtual SceneNode* getSkyDomeNode(void) const { return mSkyDomeNode; }


         virtual const SkyDomeGenParameters& getSkyDomeGenParameters(void) const { return mSkyDomeGenParameters; }


         void setFog(

             FogMode mode = FOG_NONE, const ColourValue& colour = ColourValue::White,

             Real expDensity = 0.001, Real linearStart = 0.0, Real linearEnd = 1.0);


         virtual FogMode getFogMode(void) const;


         virtual const ColourValue& getFogColour(void) const;


         virtual Real getFogStart(void) const;


         virtual Real getFogEnd(void) const;


         virtual Real getFogDensity(void) const;


         virtual BillboardSet* createBillboardSet(const String& name, unsigned int poolSize = 20);


         virtual BillboardSet* createBillboardSet(unsigned int poolSize = 20);

         virtual BillboardSet* getBillboardSet(const String& name) const;

         virtual bool hasBillboardSet(const String& name) const;


         virtual void destroyBillboardSet(BillboardSet* set);


         virtual void destroyBillboardSet(const String& name);


         virtual void destroyAllBillboardSets(void);


         virtual void setDisplaySceneNodes(bool display);

         virtual bool getDisplaySceneNodes(void) const {return mDisplayNodes;}


         virtual Animation* createAnimation(const String& name, Real length);


         virtual Animation* getAnimation(const String& name) const;

         virtual bool hasAnimation(const String& name) const;


         virtual void destroyAnimation(const String& name);


         virtual void destroyAllAnimations(void);


         virtual AnimationState* createAnimationState(const String& animName);


         virtual AnimationState* getAnimationState(const String& animName) const;

         virtual bool hasAnimationState(const String& name) const;


         virtual void destroyAnimationState(const String& name);


         virtual void destroyAllAnimationStates(void);


         virtual void manualRender(RenderOperation* rend, Pass* pass, Viewport* vp,

             const Matrix4& worldMatrix, const Matrix4& viewMatrix, const Matrix4& projMatrix,

             bool doBeginEndFrame = false) ;


         virtual void manualRender(Renderable* rend, const Pass* pass, Viewport* vp,

             const Matrix4& viewMatrix, const Matrix4& projMatrix, bool doBeginEndFrame = false, bool lightScissoringClipping = true,

             bool doLightIteration = true, const LightList* manualLightList = 0);


         virtual RenderQueue* getRenderQueue(void);


         virtual void addRenderQueueListener(RenderQueueListener* newListener);


         virtual void removeRenderQueueListener(RenderQueueListener* delListener);


         virtual void addRenderObjectListener(RenderObjectListener* newListener);

         virtual void removeRenderObjectListener(RenderObjectListener* delListener);


         virtual void addSpecialCaseRenderQueue(uint8 qid);

         virtual void removeSpecialCaseRenderQueue(uint8 qid);

         virtual void clearSpecialCaseRenderQueues(void);

         virtual void setSpecialCaseRenderQueueMode(SpecialCaseRenderQueueMode mode);

         virtual SpecialCaseRenderQueueMode getSpecialCaseRenderQueueMode(void);

         virtual bool isRenderQueueToBeProcessed(uint8 qid);


         virtual void setWorldGeometryRenderQueue(uint8 qid);

         virtual uint8 getWorldGeometryRenderQueue(void);


         virtual void showBoundingBoxes(bool bShow);


         virtual bool getShowBoundingBoxes() const;


         virtual void _notifyAutotrackingSceneNode(SceneNode* node, bool autoTrack);


         virtual AxisAlignedBoxSceneQuery*

             createAABBQuery(const AxisAlignedBox& box, uint32 mask = 0xFFFFFFFF);

         virtual SphereSceneQuery*

             createSphereQuery(const Sphere& sphere, uint32 mask = 0xFFFFFFFF);

         virtual PlaneBoundedVolumeListSceneQuery*

             createPlaneBoundedVolumeQuery(const PlaneBoundedVolumeList& volumes, uint32 mask = 0xFFFFFFFF);


         virtual RaySceneQuery*

             createRayQuery(const Ray& ray, uint32 mask = 0xFFFFFFFF);

         //PyramidSceneQuery* createPyramidQuery(const Pyramid& p, unsigned long mask = 0xFFFFFFFF);

         virtual IntersectionSceneQuery*

             createIntersectionQuery(uint32 mask = 0xFFFFFFFF);


         virtual void destroyQuery(SceneQuery* query);


         typedef MapIterator<CameraList> CameraIterator;

         typedef MapIterator<AnimationList> AnimationIterator;


         CameraIterator getCameraIterator(void) {

             return CameraIterator(mCameras.begin(), mCameras.end());

         }

         const CameraList& getCameras() const { return mCameras; }

         AnimationIterator getAnimationIterator(void) {

             return AnimationIterator(mAnimationsList.begin(), mAnimationsList.end());

         }

         const AnimationList& getAnimations() const { return mAnimationsList; }

         AnimationStateIterator getAnimationStateIterator(void) {

             return mAnimationStates.getAnimationStateIterator();

         }


         virtual void setShadowTechnique(ShadowTechnique technique);


         virtual ShadowTechnique getShadowTechnique(void) const { return mShadowTechnique; }


         virtual void setShowDebugShadows(bool debug) { mDebugShadows = debug; }

         virtual bool getShowDebugShadows(void ) const { return mDebugShadows; }


         virtual void setShadowColour(const ColourValue& colour);

         virtual const ColourValue& getShadowColour(void) const;

         virtual void setShadowDirectionalLightExtrusionDistance(Real dist);

         virtual Real getShadowDirectionalLightExtrusionDistance(void) const;

         virtual void setShadowFarDistance(Real distance);

         virtual Real getShadowFarDistance(void) const

         { return mDefaultShadowFarDist; }

         virtual Real getShadowFarDistanceSquared(void) const

         { return mDefaultShadowFarDistSquared; }


         virtual void setShadowIndexBufferSize(size_t size);

         virtual size_t getShadowIndexBufferSize(void) const

         { return mShadowIndexBufferSize; }

         virtual void setShadowTextureSize(unsigned short size);


         virtual void setShadowTextureConfig(size_t shadowIndex, unsigned short width,

             unsigned short height, PixelFormat format, unsigned short fsaa = 0, uint16 depthBufferPoolId=1);

         virtual void setShadowTextureConfig(size_t shadowIndex,

             const ShadowTextureConfig& config);


         ConstShadowTextureConfigIterator getShadowTextureConfigIterator() const;


         virtual void setShadowTexturePixelFormat(PixelFormat fmt);

         virtual void setShadowTextureFSAA(unsigned short fsaa);


         virtual void setShadowTextureCount(size_t count);

         size_t getShadowTextureCount(void) const {return mShadowTextureConfigList.size(); }


         void setShadowTextureCountPerLightType(Light::LightTypes type, size_t count)

         { mShadowTextureCountPerType[type] = count; }

         size_t getShadowTextureCountPerLightType(Light::LightTypes type) const

         {return mShadowTextureCountPerType[type]; }


         virtual void setShadowTextureSettings(unsigned short size, unsigned short count,

             PixelFormat fmt = PF_X8R8G8B8, unsigned short fsaa = 0, uint16 depthBufferPoolId=1);


         virtual const TexturePtr& getShadowTexture(size_t shadowIndex);


         virtual void setShadowDirLightTextureOffset(Real offset) { mShadowTextureOffset = offset;}

         virtual Real getShadowDirLightTextureOffset(void)  const { return mShadowTextureOffset; }

         virtual void setShadowTextureFadeStart(Real fadeStart)

         { mShadowTextureFadeStart = fadeStart; }

         virtual void setShadowTextureFadeEnd(Real fadeEnd)

         { mShadowTextureFadeEnd = fadeEnd; }


         virtual void setShadowTextureSelfShadow(bool selfShadow);


         virtual bool getShadowTextureSelfShadow(void) const

         { return mShadowTextureSelfShadow; }

         virtual void setShadowTextureCasterMaterial(const String& name);

         virtual void setShadowTextureReceiverMaterial(const String& name);


         virtual void setShadowCasterRenderBackFaces(bool bf) { mShadowCasterRenderBackFaces = bf; }


         virtual bool getShadowCasterRenderBackFaces() const { return mShadowCasterRenderBackFaces; }


         virtual void setShadowCameraSetup(const ShadowCameraSetupPtr& shadowSetup);


         virtual const ShadowCameraSetupPtr& getShadowCameraSetup() const;


         virtual void setShadowUseInfiniteFarPlane(bool enable) {

             mShadowUseInfiniteFarPlane = enable; }


         virtual bool isShadowTechniqueStencilBased(void) const

         { return (mShadowTechnique & SHADOWDETAILTYPE_STENCIL) != 0; }

         virtual bool isShadowTechniqueTextureBased(void) const

         { return (mShadowTechnique & SHADOWDETAILTYPE_TEXTURE) != 0; }

         virtual bool isShadowTechniqueModulative(void) const

         { return (mShadowTechnique & SHADOWDETAILTYPE_MODULATIVE) != 0; }

         virtual bool isShadowTechniqueAdditive(void) const

         { return (mShadowTechnique & SHADOWDETAILTYPE_ADDITIVE) != 0; }

         virtual bool isShadowTechniqueIntegrated(void) const

         { return (mShadowTechnique & SHADOWDETAILTYPE_INTEGRATED) != 0; }

         virtual bool isShadowTechniqueInUse(void) const

         { return mShadowTechnique != SHADOWTYPE_NONE; }

         virtual void setShadowUseLightClipPlanes(bool enabled) { mShadowAdditiveLightClip = enabled; }

         virtual bool getShadowUseLightClipPlanes() const { return mShadowAdditiveLightClip; }


         virtual void _setActiveCompositorChain(CompositorChain* chain) { mActiveCompositorChain = chain; }


         virtual void setLateMaterialResolving(bool isLate) { mLateMaterialResolving = isLate; }


         virtual bool isLateMaterialResolving() const { return mLateMaterialResolving; }


         virtual CompositorChain* _getActiveCompositorChain() const { return mActiveCompositorChain; }


         virtual void addListener(Listener* s);

         virtual void removeListener(Listener* s);


         virtual StaticGeometry* createStaticGeometry(const String& name);

         virtual StaticGeometry* getStaticGeometry(const String& name) const;

         virtual bool hasStaticGeometry(const String& name) const;

         virtual void destroyStaticGeometry(StaticGeometry* geom);

         virtual void destroyStaticGeometry(const String& name);

         virtual void destroyAllStaticGeometry(void);


         virtual InstancedGeometry* createInstancedGeometry(const String& name);

         virtual InstancedGeometry* getInstancedGeometry(const String& name) const;

         virtual void destroyInstancedGeometry(InstancedGeometry* geom);

         virtual void destroyInstancedGeometry(const String& name);

         virtual void destroyAllInstancedGeometry(void);


         virtual InstanceManager* createInstanceManager( const String &customName, const String &meshName,

                                                         const String &groupName,

                                                         InstanceManager::InstancingTechnique technique,

                                                         size_t numInstancesPerBatch, uint16 flags=0,

                                                         unsigned short subMeshIdx=0 );


         virtual InstanceManager* getInstanceManager( const String &managerName ) const;


     virtual bool hasInstanceManager( const String &managerName ) const;


         virtual void destroyInstanceManager( const String &name );

         virtual void destroyInstanceManager( InstanceManager *instanceManager );


         virtual void destroyAllInstanceManagers(void);


         virtual size_t getNumInstancesPerBatch( const String &meshName, const String &groupName,

                                                 const String &materialName,

                                                 InstanceManager::InstancingTechnique technique,

                                                 size_t numInstancesPerBatch, uint16 flags=0,

                                                 unsigned short subMeshIdx=0 );


         virtual InstancedEntity* createInstancedEntity( const String &materialName,

                                                         const String &managerName );


         virtual void destroyInstancedEntity( InstancedEntity *instancedEntity );


         void _addDirtyInstanceManager( InstanceManager *dirtyManager );


         virtual MovableObject* createMovableObject(const String& name,

             const String& typeName, const NameValuePairList* params = 0);

         virtual MovableObject* createMovableObject(const String& typeName, const NameValuePairList* params = 0);

         virtual void destroyMovableObject(const String& name, const String& typeName);

         virtual void destroyMovableObject(MovableObject* m);

         virtual void destroyAllMovableObjectsByType(const String& typeName);

         virtual void destroyAllMovableObjects(void);

         virtual MovableObject* getMovableObject(const String& name, const String& typeName) const;

         virtual bool hasMovableObject(const String& name, const String& typeName) const;

         typedef MapIterator<MovableObjectMap> MovableObjectIterator;

         virtual MovableObjectIterator getMovableObjectIterator(const String& typeName);

         virtual void injectMovableObject(MovableObject* m);

         virtual void extractMovableObject(const String& name, const String& typeName);

         virtual void extractMovableObject(MovableObject* m);

         virtual void extractAllMovableObjectsByType(const String& typeName);


         virtual void setVisibilityMask(uint32 vmask) { mVisibilityMask = vmask; }


         virtual uint32 getVisibilityMask(void) { return mVisibilityMask; }


         uint32 _getCombinedVisibilityMask(void) const;


         virtual void setFindVisibleObjects(bool find) { mFindVisibleObjects = find; }


         virtual bool getFindVisibleObjects(void) { return mFindVisibleObjects; }


         virtual void setNormaliseNormalsOnScale(bool n) { mNormaliseNormalsOnScale = n; }


         virtual bool getNormaliseNormalsOnScale() const { return mNormaliseNormalsOnScale; }


         virtual void setFlipCullingOnNegativeScale(bool n) { mFlipCullingOnNegativeScale = n; }


         virtual bool getFlipCullingOnNegativeScale() const { return mFlipCullingOnNegativeScale; }


         virtual void _injectRenderWithPass(Pass *pass, Renderable *rend, bool shadowDerivation = true,

             bool doLightIteration = false, const LightList* manualLightList = 0);


         virtual void _suppressRenderStateChanges(bool suppress);


         virtual bool _areRenderStateChangesSuppressed(void) const

         { return mSuppressRenderStateChanges; }


         virtual const Pass* _setPass(const Pass* pass,

             bool evenIfSuppressed = false, bool shadowDerivation = true);


         virtual void _markGpuParamsDirty(uint16 mask);


         virtual void _suppressShadows(bool suppress);


         virtual bool _areShadowsSuppressed(void) const

         { return mSuppressShadows; }


         virtual void _renderQueueGroupObjects(RenderQueueGroup* group,

             QueuedRenderableCollection::OrganisationMode om);


         void setQueuedRenderableVisitor(SceneMgrQueuedRenderableVisitor* visitor);


         SceneMgrQueuedRenderableVisitor* getQueuedRenderableVisitor(void) const;


         RenderSystem *getDestinationRenderSystem();


         Viewport* getCurrentViewport(void) const { return mCurrentViewport; }


         const VisibleObjectsBoundsInfo& getVisibleObjectsBoundsInfo(const Camera* cam) const;


         const VisibleObjectsBoundsInfo& getShadowCasterBoundsInfo(const Light* light, size_t iteration = 0) const;


         virtual void setCameraRelativeRendering(bool rel) { mCameraRelativeRendering = rel; }


         virtual bool getCameraRelativeRendering() const { return mCameraRelativeRendering; }


         void addLodListener(LodListener *listener);


         void removeLodListener(LodListener *listener);


         void _notifyMovableObjectLodChanged(MovableObjectLodChangedEvent& evt);


         void _notifyEntityMeshLodChanged(EntityMeshLodChangedEvent& evt);


         void _notifyEntityMaterialLodChanged(EntityMaterialLodChangedEvent& evt);


         void _handleLodEvents();


         IlluminationRenderStage _getCurrentRenderStage() {return mIlluminationStage;}

     };


     class _OgreExport DefaultIntersectionSceneQuery :

         public IntersectionSceneQuery

     {

     public:

         DefaultIntersectionSceneQuery(SceneManager* creator);

         ~DefaultIntersectionSceneQuery();


         void execute(IntersectionSceneQueryListener* listener);

     };


     class _OgreExport DefaultRaySceneQuery : public RaySceneQuery

     {

     public:

         DefaultRaySceneQuery(SceneManager* creator);

         ~DefaultRaySceneQuery();


         void execute(RaySceneQueryListener* listener);

     };

     class _OgreExport DefaultSphereSceneQuery : public SphereSceneQuery

     {

     public:

         DefaultSphereSceneQuery(SceneManager* creator);

         ~DefaultSphereSceneQuery();


         void execute(SceneQueryListener* listener);

     };

     class _OgreExport DefaultPlaneBoundedVolumeListSceneQuery : public PlaneBoundedVolumeListSceneQuery

     {

     public:

         DefaultPlaneBoundedVolumeListSceneQuery(SceneManager* creator);

         ~DefaultPlaneBoundedVolumeListSceneQuery();


         void execute(SceneQueryListener* listener);

     };

     class _OgreExport DefaultAxisAlignedBoxSceneQuery : public AxisAlignedBoxSceneQuery

     {

     public:

         DefaultAxisAlignedBoxSceneQuery(SceneManager* creator);

         ~DefaultAxisAlignedBoxSceneQuery();


         void execute(SceneQueryListener* listener);

     };


     typedef uint16 SceneTypeMask;


     enum SceneType

     {

         ST_GENERIC = 1,

         ST_EXTERIOR_CLOSE = 2,

         ST_EXTERIOR_FAR = 4,

         ST_EXTERIOR_REAL_FAR = 8,

         ST_INTERIOR = 16

     };


     struct SceneManagerMetaData

     {

         String typeName;

         String description;

         SceneTypeMask sceneTypeMask;

         bool worldGeometrySupported;

     };


     class _OgreExport SceneManagerFactory : public SceneMgtAlloc

     {

     protected:

         mutable SceneManagerMetaData mMetaData;

         mutable bool mMetaDataInit;

         virtual void initMetaData(void) const = 0;

     public:

         SceneManagerFactory() : mMetaDataInit(true) {}

         virtual ~SceneManagerFactory() {}

         virtual const SceneManagerMetaData& getMetaData(void) const

         {

             if (mMetaDataInit)

             {

                 initMetaData();

                 mMetaDataInit = false;

             }

             return mMetaData;

         }

         virtual SceneManager* createInstance(const String& instanceName) = 0;

         virtual void destroyInstance(SceneManager* instance) = 0;


     };


 } // Namespace


 #include "OgreHeaderSuffix.h"


 #endif

Ogre::CompositorChain
Chain of compositor effects applying to one viewport.
Definition: OgreCompositorChain.h:48

Ogre::Ray
Representation of a ray in space, i.e.
Definition: OgreRay.h:46

Ogre::AnimationStateSet
Class encapsulating a set of AnimationState objects.
Definition: OgreAnimationState.h:196

Ogre::SceneManager::IRS_RENDER_TO_TEXTURE
Render to texture stage, used for texture based shadows.
Definition: OgreSceneManager.h:178

Ogre::SceneManager::getCurrentViewport
Viewport * getCurrentViewport(void) const
Gets the current viewport being rendered (advanced use only, only valid during viewport update...
Definition: OgreSceneManager.h:3497

Ogre::SceneManager::mSkyDomeRenderQueue
uint8 mSkyDomeRenderQueue
Definition: OgreSceneManager.h:463

Ogre::SceneManager::mSkyPlaneNode
SceneNode * mSkyPlaneNode
Definition: OgreSceneManager.h:447

Ogre::uint8
unsigned char uint8
Definition: OgrePlatform.h:346

Ogre::Camera
A viewpoint from which the scene will be rendered.
Definition: OgreCamera.h:86

Ogre::SceneManager::mLightsDirtyCounter
ulong mLightsDirtyCounter
Definition: OgreSceneManager.h:536

Ogre::SceneManager::setShadowTextureFadeStart
virtual void setShadowTextureFadeStart(Real fadeStart)
Sets the proportional distance at which texture shadows begin to fade out.
Definition: OgreSceneManager.h:2918

Ogre::SceneQuery::WorldFragment
Represents part of the world geometry that is a result of a SceneQuery.
Definition: OgreSceneQuery.h:109

Ogre::SceneType
SceneType
Classification of a scene to allow a decision of what type of SceenManager to provide back to the app...
Definition: OgreSceneManager.h:3612

Ogre::SceneManager::getOptionValues
virtual bool getOptionValues(const String &strKey, StringVector &refValueList)
Method for getting all possible values for a specific option.
Definition: OgreSceneManager.h:1791

Ogre::SceneManager::FRUSTUM_TYPE_MASK
static uint32 FRUSTUM_TYPE_MASK
Query type mask which will be used for frusta and cameras.
Definition: OgreSceneManager.h:157

Ogre::SceneManager::setNormaliseNormalsOnScale
virtual void setNormaliseNormalsOnScale(bool n)
Set whether to automatically normalise normals on objects whenever they are scaled.
Definition: OgreSceneManager.h:3365

Ogre::ParticleSystem
Class defining particle system based special effects.
Definition: OgreParticleSystem.h:67

Ogre::SceneManager::CamVisibleObjectsMap
map< const Camera *, VisibleObjectsBoundsInfo >::type CamVisibleObjectsMap
Visible objects bounding box list.
Definition: OgreSceneManager.h:497

Ogre::SceneManager::mSuppressShadows
bool mSuppressShadows
Suppress shadows?
Definition: OgreSceneManager.h:879

Ogre::Matrix4
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:78

Ogre::SceneManager::_setActiveCompositorChain
virtual void _setActiveCompositorChain(CompositorChain *chain)
Sets the active compositor chain of the current scene being rendered.
Definition: OgreSceneManager.h:3089

Ogre::SceneManager::SceneMgrQueuedRenderableVisitor::mUsedPass
const Pass * mUsedPass
Pass that was actually used at the grouping level.
Definition: OgreSceneManager.h:361

Ogre::SceneManager::mSceneRoot
SceneNode * mSceneRoot
Root scene node.
Definition: OgreSceneManager.h:435

Ogre::SceneManager::mSkyBoxRenderQueue
uint8 mSkyBoxRenderQueue
Definition: OgreSceneManager.h:458

Ogre::SceneManager::_getLightsDirtyCounter
ulong _getLightsDirtyCounter(void) const
Advance method to gets the lights dirty counter.
Definition: OgreSceneManager.h:1191

Ogre::ST_EXTERIOR_CLOSE
Definition: OgreSceneManager.h:3615

Ogre::SceneManagerFactory::SceneManagerFactory
SceneManagerFactory()
Definition: OgreSceneManager.h:3645

Ogre::SceneManager::mShadowUseInfiniteFarPlane
bool mShadowUseInfiniteFarPlane
Definition: OgreSceneManager.h:751

Ogre::InstanceManager::InstancingTechnique
InstancingTechnique
Definition: OgreInstanceManager.h:66

Ogre::Real
float Real
Software floating point type.
Definition: OgrePrerequisites.h:70

Ogre::SceneManager::mMovableObjectLodChangedEvents
MovableObjectLodChangedEventList mMovableObjectLodChangedEvents
Definition: OgreSceneManager.h:1017

Ogre::SceneManager::mFiniteExtrusionParams
GpuProgramParametersSharedPtr mFiniteExtrusionParams
Definition: OgreSceneManager.h:883

Ogre::SceneManager::Listener::shadowTextureCasterPreViewProj
virtual void shadowTextureCasterPreViewProj(Light *light, Camera *camera, size_t iteration)
This event occurs just before the view & projection matrices are set for rendering into a shadow text...
Definition: OgreSceneManager.h:303

Ogre::uint32
unsigned int uint32
Definition: OgrePlatform.h:344

Ogre::SceneManager::Listener::preFindVisibleObjects
virtual void preFindVisibleObjects(SceneManager *source, IlluminationRenderStage irs, Viewport *v)
Called prior to searching for visible objects in this SceneManager.
Definition: OgreSceneManager.h:255

Ogre::SceneManager::setShadowUseInfiniteFarPlane
virtual void setShadowUseInfiniteFarPlane(bool enable)
Sets whether we should use an inifinite camera far plane when rendering stencil shadows.
Definition: OgreSceneManager.h:3056

Ogre::SceneManager::mDefaultQueuedRenderableVisitor
SceneMgrQueuedRenderableVisitor mDefaultQueuedRenderableVisitor
Storage for default renderable visitor.
Definition: OgreSceneManager.h:984

Ogre::SceneManager::Listener::sceneManagerDestroyed
virtual void sceneManagerDestroyed(SceneManager *source)
Event notifying the listener of the SceneManager's destruction.
Definition: OgreSceneManager.h:350

Ogre::SceneManager::Listener::preUpdateSceneGraph
virtual void preUpdateSceneGraph(SceneManager *source, Camera *camera)
Called prior to updating the scene graph in this SceneManager.
Definition: OgreSceneManager.h:234

Ogre::SceneManager::ShadowCasterSceneQueryListener::mLight
const Light * mLight
Definition: OgreSceneManager.h:894

_OgreExport
#define _OgreExport
Definition: OgrePlatform.h:260

Ogre::SceneManager::AnimationIterator
MapIterator< AnimationList > AnimationIterator
Definition: OgreSceneManager.h:2649

Ogre::SceneManager::isShadowTechniqueStencilBased
virtual bool isShadowTechniqueStencilBased(void) const
Is there a stencil shadow based shadowing technique in use?
Definition: OgreSceneManager.h:3060

Ogre::InstancedGeometry
Pre-transforms and batches up meshes for efficient use as instanced geometry in a scene...
Definition: OgreInstancedGeometry.h:105

Ogre::SceneManager::SceneMgrQueuedRenderableVisitor::transparentShadowCastersMode
bool transparentShadowCastersMode
Are we in transparent shadow caster mode?
Definition: OgreSceneManager.h:373

Ogre::RenderablePass
Struct associating a single Pass with a single Renderable.
Definition: OgreRenderQueueSortingGrouping.h:51

Ogre::SceneManager::LightClippingInfo::clipPlanes
PlaneList clipPlanes
Definition: OgreSceneManager.h:758

Ogre::SceneManager::ENTITY_TYPE_MASK
static uint32 ENTITY_TYPE_MASK
Query type mask which will be used for entities.
Definition: OgreSceneManager.h:149

Ogre::SceneManager::lightsForShadowTextureLess
Default sorting routine which sorts lights which cast shadows to the front of a list, sub-sorting by distance.
Definition: OgreSceneManager.h:779

OgreSceneQuery.h

Ogre::SceneManager::SkyDomeGenParameters::skyDomeTiling
Real skyDomeTiling
Definition: OgreSceneManager.h:198

Ogre::SceneManager::mFogMode
FogMode mFogMode
Definition: OgreSceneManager.h:468

Ogre::ulong
unsigned long ulong
Definition: OgrePrerequisites.h:115

Ogre::NameGenerator
Utility class to generate a sequentially numbered series of names.
Definition: OgreNameGenerator.h:56

Ogre::SceneManager::mShadowTextureCustomCasterFPParams
GpuProgramParametersSharedPtr mShadowTextureCustomCasterFPParams
Definition: OgreSceneManager.h:868

Ogre::SceneManagerMetaData::typeName
String typeName
A globally unique string identifying the scene manager type.
Definition: OgreSceneManager.h:3625

Ogre::SceneManager::mSkyPlane
Plane mSkyPlane
Definition: OgreSceneManager.h:454

Ogre::NameValuePairList
map< String, String >::type NameValuePairList
Name / value parameter pair (first = name, second = value)
Definition: OgreCommon.h:550

Ogre::StaticGeometry
Pre-transforms and batches up meshes for efficient use as static geometry in a scene.
Definition: OgreStaticGeometry.h:121

Ogre::Plane
Defines a plane in 3D space.
Definition: OgrePlane.h:61

Ogre::FogMode
FogMode
Fog modes.
Definition: OgreCommon.h:121

Ogre::HashedVector< Light * >

OGRE_MUTEX
#define OGRE_MUTEX(name)
Definition: OgreThreadDefinesBoost.h:47

OgreSceneNode.h

Ogre::SceneManager::InstanceManagerVec
vector< InstanceManager * >::type InstanceManagerVec
Definition: OgreSceneManager.h:799

Ogre::SceneManager::mShadowTextureCameras
ShadowTextureCameraList mShadowTextureCameras
Definition: OgreSceneManager.h:749

Ogre::RenderObjectListener
Abstract interface which classes must implement if they wish to receive events from the scene manager...
Definition: OgreRenderObjectListener.h:43

Ogre::RenderQueueGroup
A grouping level underneath RenderQueue which groups renderables to be issued at coarsely the same ti...
Definition: OgreRenderQueueSortingGrouping.h:465

Ogre::SceneManager::mShadowTextureFadeStart
Real mShadowTextureFadeStart
Proportion of texture offset in view direction e.g. 0.4.
Definition: OgreSceneManager.h:858

Ogre::SceneManager::mGpuParamsDirty
uint16 mGpuParamsDirty
Gpu params that need rebinding (mask of GpuParamVariability)
Definition: OgreSceneManager.h:996

OgreHeaderSuffix.h

Ogre::SceneManager::SkyDomeGenParameters::skyDomeDistance
Real skyDomeDistance
Definition: OgreSceneManager.h:199

Ogre::SceneManager::mLastLightHash
uint32 mLastLightHash
Last light sets.
Definition: OgreSceneManager.h:992

Ogre::VisibleObjectsBoundsInfo::maxDistanceInFrustum
Real maxDistanceInFrustum
The farthest object in the frustum regardless of visibility / shadow caster flags.
Definition: OgreSceneManager.h:99

Ogre::ManualObject
Class providing a much simplified interface to generating manual objects with custom geometry...
Definition: OgreManualObject.h:106

Ogre::SceneManager::MovableObjectMap
map< String, MovableObject * >::type MovableObjectMap
Definition: OgreSceneManager.h:539

Ogre::SceneManager::SkyPlaneGenParameters::skyPlaneXSegments
int skyPlaneXSegments
Definition: OgreSceneManager.h:210

Ogre::SHADOWTYPE_NONE
No shadows.
Definition: OgreCommon.h:193

Ogre::SceneManager::RenderContext::activeChain
CompositorChain * activeChain
Definition: OgreSceneManager.h:818

Ogre::SceneManager::mDefaultShadowFarDist
Real mDefaultShadowFarDist
Definition: OgreSceneManager.h:855

Ogre::SceneManager::mCurrentViewport
Viewport * mCurrentViewport
Current Viewport.
Definition: OgreSceneManager.h:432

Ogre::SceneManager::mStaticGeometryList
StaticGeometryList mStaticGeometryList
Definition: OgreSceneManager.h:412

Ogre::SceneManager::mShadowTextureCustomReceiverFragmentProgram
String mShadowTextureCustomReceiverFragmentProgram
Definition: OgreSceneManager.h:866

Ogre::SceneManager::mSkyDomeGenParameters
SkyDomeGenParameters mSkyDomeGenParameters
Definition: OgreSceneManager.h:465

Ogre::VisibleObjectsBoundsInfo::receiverAabb
AxisAlignedBox receiverAabb
The axis-aligned bounds of the visible shadow receiver objects.
Definition: OgreSceneManager.h:91

Ogre::ColourValue
Class representing colour.
Definition: OgreColourValue.h:57

Ogre::SHADOWDETAILTYPE_ADDITIVE
Mask for additive shadows (not for direct use, use SHADOWTYPE_ enum instead)
Definition: OgreCommon.h:196

Ogre::TRect< Real >

Ogre::SceneManager::InstanceManagerMap
map< String, InstanceManager * >::type InstanceManagerMap
Definition: OgreSceneManager.h:416

Ogre::SceneManager::LightClippingInfo::scissorRect
RealRect scissorRect
Definition: OgreSceneManager.h:757

Ogre::ColourValue::White
static const ColourValue White
Definition: OgreColourValue.h:62

Ogre::SceneManagerMetaData::sceneTypeMask
SceneTypeMask sceneTypeMask
A mask describing which sorts of scenes this manager can handle.
Definition: OgreSceneManager.h:3629

Ogre::SceneManager::PrefabType
PrefabType
Prefab shapes available without loading a model.
Definition: OgreSceneManager.h:1371

Ogre::SceneManager::FX_TYPE_MASK
static uint32 FX_TYPE_MASK
Query type mask which will be used for effects like billboardsets / particle systems.
Definition: OgreSceneManager.h:151

Ogre::SceneManager::Listener::Listener
Listener()
Definition: OgreSceneManager.h:225

Ogre::SceneManager::mShadowTextures
ShadowTextureList mShadowTextures
Definition: OgreSceneManager.h:746

OgreRenderQueueSortingGrouping.h

Ogre::Frustum
A frustum represents a pyramid, capped at the near and far end which is used to represent either a vi...
Definition: OgreFrustum.h:85

Ogre::SceneQuery
A class for performing queries on a scene.
Definition: OgreSceneQuery.h:74

Ogre::SceneManager
Manages the organisation and rendering of a 'scene' i.e.
Definition: OgreSceneManager.h:143

Ogre::SceneManager::SCRQM_INCLUDE
Render only the queues in the special case list.
Definition: OgreSceneManager.h:190

Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME
static String AUTODETECT_RESOURCE_GROUP_NAME
Special resource group name which causes resource group to be automatically determined based on searc...
Definition: OgreResourceGroupManager.h:270

Ogre::SceneManager::mShadowMaterialInitDone
bool mShadowMaterialInitDone
Definition: OgreSceneManager.h:737

Ogre::SceneManager::materialLess
Comparator for material map, for sorting materials into render order (e.g.
Definition: OgreSceneManager.h:162

Ogre::SceneManager::ShadowCasterSceneQueryListener::mSceneMgr
SceneManager * mSceneMgr
Definition: OgreSceneManager.h:889

Ogre::SceneManager::LightInfoList
vector< LightInfo >::type LightInfoList
Definition: OgreSceneManager.h:531

Ogre::SceneManager::mShadowAdditiveLightClip
bool mShadowAdditiveLightClip
Definition: OgreSceneManager.h:753

Ogre::GpuProgram
Defines a program which runs on the GPU such as a vertex or fragment program.
Definition: OgreGpuProgram.h:69

Ogre::SceneManager::mLastRenderQueueInvocationCustom
bool mLastRenderQueueInvocationCustom
Definition: OgreSceneManager.h:397

Ogre::SceneManager::mShadowIndexBufferSize
size_t mShadowIndexBufferSize
Definition: OgreSceneManager.h:739

Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME
static String DEFAULT_RESOURCE_GROUP_NAME
Default resource group name.
Definition: OgreResourceGroupManager.h:266

Ogre::SceneManager::ShadowCasterSceneQueryListener::mIsLightInFrustum
bool mIsLightInFrustum
Definition: OgreSceneManager.h:891

Ogre::SceneManager::mLastFrameNumber
unsigned long mLastFrameNumber
Definition: OgreSceneManager.h:479

Ogre::Light::LightTypes
LightTypes
Defines the type of light.
Definition: OgreLight.h:82

Ogre::SceneManager::getSkyPlaneNode
virtual SceneNode * getSkyPlaneNode(void) const
Get the sky plane node, if enabled.
Definition: OgreSceneManager.h:1984

Ogre::SceneManager::LightClippingInfo
Struct for caching light clipping information for re-use in a frame.
Definition: OgreSceneManager.h:755

Ogre::SceneManager::mIlluminationStage
IlluminationRenderStage mIlluminationStage
Definition: OgreSceneManager.h:743

Ogre::SceneManager::mSkyDomeEnabled
bool mSkyDomeEnabled
Definition: OgreSceneManager.h:462

Ogre::SceneManager::LightClippingInfo::scissorValid
bool scissorValid
Definition: OgreSceneManager.h:759

Ogre::SceneManager::mShadowTextureOffset
Real mShadowTextureOffset
Definition: OgreSceneManager.h:857

Ogre::SceneManager::isShadowTechniqueAdditive
virtual bool isShadowTechniqueAdditive(void) const
Is there an additive shadowing technique in use?
Definition: OgreSceneManager.h:3069

Ogre::SceneManager::ShadowCasterSceneQueryListener::mCasterList
ShadowCasterList * mCasterList
Definition: OgreSceneManager.h:890

Ogre::SceneManager::mAnimationsList
AnimationList mAnimationsList
Definition: OgreSceneManager.h:639

Ogre::SceneManager::SceneMgrQueuedRenderableVisitor::scissoring
bool scissoring
Scissoring if requested?
Definition: OgreSceneManager.h:379

Ogre::SceneManager::getShadowCasterRenderBackFaces
virtual bool getShadowCasterRenderBackFaces() const
Gets whether or not shadow casters should be rendered into shadow textures using their back faces rat...
Definition: OgreSceneManager.h:3006

Ogre::SceneManager::LightInfo::light
Light * light
Definition: OgreSceneManager.h:513

Ogre::SceneManager::InstancedGeometryList
map< String, InstancedGeometry * >::type InstancedGeometryList
Definition: OgreSceneManager.h:413

Ogre::Material
Class encapsulates rendering properties of an object.
Definition: OgreMaterial.h:88

OgreNameGenerator.h

Ogre::SceneManagerMetaData::worldGeometrySupported
bool worldGeometrySupported
Flag indicating whether world geometry is supported.
Definition: OgreSceneManager.h:3631

Ogre::SceneManager::ShadowCasterSceneQueryListener
Inner class to use as callback for shadow caster scene query.
Definition: OgreSceneManager.h:886

Ogre::SphereSceneQuery
Specialises the SceneQuery class for querying within a sphere.
Definition: OgreSceneQuery.h:287

Ogre::SceneManager::MovableObjectCollection
Simple structure to hold MovableObject map and a mutex to go with it.
Definition: OgreSceneManager.h:541

Ogre::SceneManager::mSkyBoxGenParameters
SkyBoxGenParameters mSkyBoxGenParameters
Definition: OgreSceneManager.h:460

Ogre::SceneManager::LightInfo::lightMask
uint32 lightMask
Sets to zero if directional light.
Definition: OgreSceneManager.h:517

Ogre::SceneManager::LightClippingInfo::clipPlanesValid
unsigned long clipPlanesValid
Definition: OgreSceneManager.h:760

Ogre::AxisAlignedBox
A 3D box aligned with the x/y/z axes.
Definition: OgreAxisAlignedBox.h:54

Ogre::QueuedRenderableCollection::OrganisationMode
OrganisationMode
Organisation modes required for this collection.
Definition: OgreRenderQueueSortingGrouping.h:124

Ogre::AnimationState
Represents the state of an animation and the weight of its influence.
Definition: OgreAnimationState.h:54

Ogre::SceneManager::mRenderQueue
RenderQueue * mRenderQueue
Queue of objects for rendering.
Definition: OgreSceneManager.h:396

Ogre::RENDER_QUEUE_SKIES_EARLY
First queue (after backgrounds), used for skyboxes if rendered first.
Definition: OgreRenderQueue.h:58

Ogre::ShadowTextureList
vector< TexturePtr >::type ShadowTextureList
Definition: OgreShadowTextureManager.h:49

Ogre::SceneManager::getShadowFarDistanceSquared
virtual Real getShadowFarDistanceSquared(void) const
Definition: OgreSceneManager.h:2764

Ogre::SceneManager::ListenerList
vector< Listener * >::type ListenerList
Definition: OgreSceneManager.h:657

Ogre::SceneManager::SkyDomeGenParameters::skyDomeYSegments_keep
int skyDomeYSegments_keep
Definition: OgreSceneManager.h:202

Ogre::SceneManager::isSkyDomeEnabled
virtual bool isSkyDomeEnabled(void) const
Return whether a skydome is enabled.
Definition: OgreSceneManager.h:2203

Ogre::SceneManager::Listener::sortLightsAffectingFrustum
virtual bool sortLightsAffectingFrustum(LightList &lightList)
Hook to allow the listener to override the ordering of lights for the entire frustum.
Definition: OgreSceneManager.h:346

Ogre::SceneManager::mShadowTextureConfigDirty
bool mShadowTextureConfigDirty
Definition: OgreSceneManager.h:745

Ogre::SceneManager::isLateMaterialResolving
virtual bool isLateMaterialResolving() const
Gets whether using late material resolving or not.
Definition: OgreSceneManager.h:3100

OgrePixelFormat.h

Ogre::SceneManager::IlluminationRenderStage
IlluminationRenderStage
Describes the stage of rendering when performing complex illumination.
Definition: OgreSceneManager.h:173

Ogre::SceneManager::SkyBoxGenParameters::skyBoxDistance
Real skyBoxDistance
Definition: OgreSceneManager.h:216

Ogre::SceneManager::mDefaultShadowFarDistSquared
Real mDefaultShadowFarDistSquared
Definition: OgreSceneManager.h:856

Ogre::SceneManager::getShadowUseLightClipPlanes
virtual bool getShadowUseLightClipPlanes() const
Gets whether when using a built-in additive shadow mode, user clip planes should be used to restrict ...
Definition: OgreSceneManager.h:3084

Ogre::SceneManager::Listener
Class that allows listening in on the various stages of SceneManager processing, so that custom behav...
Definition: OgreSceneManager.h:222

Ogre::SceneManager::ShadowCasterList
vector< ShadowCaster * >::type ShadowCasterList
Definition: OgreSceneManager.h:851

Ogre::SceneManager::mSkyPlaneEnabled
bool mSkyPlaneEnabled
Definition: OgreSceneManager.h:452

Ogre::SceneManager::mDefaultShadowCameraSetup
ShadowCameraSetupPtr mDefaultShadowCameraSetup
default shadow camera setup
Definition: OgreSceneManager.h:769

Ogre::SceneManager::setOption
virtual bool setOption(const String &strKey, const void *pValue)
Method for setting a specific option of the Scene Manager.
Definition: OgreSceneManager.h:1746

Ogre::SceneManager::ShadowCasterSceneQueryListener::prepare
void prepare(bool lightInFrustum, const PlaneBoundedVolumeList *lightClipVolumes, const Light *light, const Camera *cam, ShadowCasterList *casterList, Real farDistSquared)
Definition: OgreSceneManager.h:901

Ogre::SceneManager::getShadowIndexBufferSize
virtual size_t getShadowIndexBufferSize(void) const
Get the size of the shadow index buffer.
Definition: OgreSceneManager.h:2794

Ogre::SceneManager::PT_CUBE
Definition: OgreSceneManager.h:1373

Ogre::SceneManagerFactory::mMetaData
SceneManagerMetaData mMetaData
Definition: OgreSceneManager.h:3640

Ogre::SceneManager::LightInfo::type
int type
Just a pointer for comparison, the light might destroyed for some reason.
Definition: OgreSceneManager.h:514

OgreRectangle2D.h

Ogre::SceneManager::mSpecialCaseQueueMode
SpecialCaseRenderQueueMode mSpecialCaseQueueMode
Definition: OgreSceneManager.h:476

OgreTexture.h

Ogre::SceneManager::setShadowTextureFadeEnd
virtual void setShadowTextureFadeEnd(Real fadeEnd)
Sets the proportional distance at which texture shadows finish to fading out.
Definition: OgreSceneManager.h:2927

Ogre::SceneManager::getAnimationIterator
AnimationIterator getAnimationIterator(void)
Returns a specialised MapIterator over all animations in the scene.
Definition: OgreSceneManager.h:2660

Ogre::DefaultSphereSceneQuery
Default implementation of SphereSceneQuery.
Definition: OgreSceneManager.h:3575

Ogre::SceneManager::CameraList
map< String, Camera * >::type CameraList
Definition: OgreSceneManager.h:405

Ogre::SceneManager::mInfiniteExtrusionParams
GpuProgramParametersSharedPtr mInfiniteExtrusionParams
Definition: OgreSceneManager.h:882

Ogre::SceneManager::getShadowTextureCount
size_t getShadowTextureCount(void) const
Get the number of the textures allocated for texture based shadows.
Definition: OgreSceneManager.h:2857

Ogre::MovableObject
Abstract class defining a movable object in a scene.
Definition: OgreMovableObject.h:60

Ogre::SceneManager::SceneNodeList
map< String, SceneNode * >::type SceneNodeList
Definition: OgreSceneManager.h:419

Ogre::SceneManager::RenderContext::renderQueue
RenderQueue * renderQueue
Definition: OgreSceneManager.h:815

Ogre::SceneNode
Class representing a node in the scene graph.
Definition: OgreSceneNode.h:58

Ogre::SceneManager::EntityMaterialLodChangedEventList
vector< EntityMaterialLodChangedEvent >::type EntityMaterialLodChangedEventList
List of entity material LOD changed events.
Definition: OgreSceneManager.h:1024

Ogre::SceneManager::mMovableObjectCollectionMap
MovableObjectCollectionMap mMovableObjectCollectionMap
Definition: OgreSceneManager.h:547

Ogre::SceneManager::mSkyPlaneGenParameters
SkyPlaneGenParameters mSkyPlaneGenParameters
Definition: OgreSceneManager.h:455

Ogre::SceneManager::SceneMgrQueuedRenderableVisitor
Inner helper class to implement the visitor pattern for rendering objects in a queue.
Definition: OgreSceneManager.h:357

Ogre::SceneManager::SkyPlaneGenParameters::skyPlaneBow
Real skyPlaneBow
Definition: OgreSceneManager.h:209

Ogre::SceneManager::mShadowCasterPlainBlackPass
Pass * mShadowCasterPlainBlackPass
A pass designed to let us render shadow colour on white for texture shadows.
Definition: OgreSceneManager.h:568

OgreLodListener.h

Ogre::SceneManager::mSuppressRenderStateChanges
bool mSuppressRenderStateChanges
Suppress render state changes?
Definition: OgreSceneManager.h:877

Ogre::SceneManager::SkyPlaneGenParameters::skyPlaneYSegments
int skyPlaneYSegments
Definition: OgreSceneManager.h:211

Ogre::SceneManager::getSkyDomeNode
virtual SceneNode * getSkyDomeNode(void) const
Get the sky dome node, if enabled.
Definition: OgreSceneManager.h:2206

Ogre::Pass
Class defining a single pass of a Technique (of a Material), i.e.
Definition: OgrePass.h:80

Ogre::SceneManager::USER_TYPE_MASK_LIMIT
static uint32 USER_TYPE_MASK_LIMIT
User type mask limit.
Definition: OgreSceneManager.h:159

OgreAnimationState.h

Ogre::SceneManager::mLastLightHashGpuProgram
uint32 mLastLightHashGpuProgram
Definition: OgreSceneManager.h:994

Ogre::CullingMode
CullingMode
Hardware culling modes based on vertex winding.
Definition: OgreCommon.h:135

Ogre::Renderable
Abstract class defining the interface all renderable objects must implement.
Definition: OgreRenderable.h:63

Ogre::ViewPoint::position
Vector3 position
Definition: OgreSceneManager.h:72

Ogre::Quaternion
Implementation of a Quaternion, i.e.
Definition: OgreQuaternion.h:57

OgrePrerequisites.h

Ogre::MapIterator
Concrete IteratorWrapper for nonconst access to the underlying key-value container.
Definition: OgreIteratorWrapper.h:319

OgreCommon.h

Ogre::FOG_NONE
No fog. Duh.
Definition: OgreCommon.h:124

Ogre::PlaneBoundedVolumeList
vector< PlaneBoundedVolume >::type PlaneBoundedVolumeList
Definition: OgrePlaneBoundedVolume.h:128

Ogre::BillboardSet
A collection of billboards (faces which are always facing the given direction) with the same (default...
Definition: OgreBillboardSet.h:110

Ogre::SceneManager::SceneMgrQueuedRenderableVisitor::manualLightList
const LightList * manualLightList
Manual light list.
Definition: OgreSceneManager.h:377

Ogre::BillboardChain
Allows the rendering of a chain of connected billboards.
Definition: OgreBillboardChain.h:77

Ogre::SceneManager::isSkyPlaneEnabled
virtual bool isSkyPlaneEnabled(void) const
Return whether a key plane is enabled.
Definition: OgreSceneManager.h:1981

Ogre::map
Definition: OgrePrerequisites.h:536

Ogre::SceneManager::SceneMgrQueuedRenderableVisitor::autoLights
bool autoLights
Automatic light handling?
Definition: OgreSceneManager.h:375

Ogre::SceneManager::mTestLightInfos
LightInfoList mTestLightInfos
Definition: OgreSceneManager.h:535

OgreInstanceManager.h

Ogre::RenderQueueInvocationSequence
Class to hold a linear sequence of RenderQueueInvocation objects.
Definition: OgreRenderQueueInvocation.h:173

Ogre::SceneManager::getNormaliseNormalsOnScale
virtual bool getNormaliseNormalsOnScale() const
Get whether to automatically normalise normals on objects whenever they are scaled.
Definition: OgreSceneManager.h:3370

Ogre::SceneManager::mAnimationStates
AnimationStateSet mAnimationStates
Definition: OgreSceneManager.h:641

Ogre::HardwareIndexBufferSharedPtr
Shared pointer implementation used to share index buffers.
Definition: OgreHardwareIndexBuffer.h:79

Ogre::SceneManager::getSkyPlaneGenParameters
virtual const SkyPlaneGenParameters & getSkyPlaneGenParameters(void) const
Get the parameters used to construct the SkyPlane, if any.
Definition: OgreSceneManager.h:1987

Ogre::SceneManager::isShadowTechniqueModulative
virtual bool isShadowTechniqueModulative(void) const
Is there a modulative shadowing technique in use?
Definition: OgreSceneManager.h:3066

Ogre::SceneManager::MovableObjectCollection::map
MovableObjectMap map
Definition: OgreSceneManager.h:543

Ogre::Light
Representation of a dynamic light source in the scene.
Definition: OgreLight.h:73

Ogre::DefaultIntersectionSceneQuery
Default implementation of IntersectionSceneQuery.
Definition: OgreSceneManager.h:3553

Ogre::SceneManager::mFogDensity
Real mFogDensity
Definition: OgreSceneManager.h:472

Ogre::SceneManager::getSkyBoxGenParameters
virtual const SkyBoxGenParameters & getSkyBoxGenParameters(void) const
Get the parameters used to generate the current SkyBox, if any.
Definition: OgreSceneManager.h:2082

Ogre::SceneManager::getShadowTextureSelfShadow
virtual bool getShadowTextureSelfShadow(void) const
Gets whether or not texture shadows attempt to self-shadow.
Definition: OgreSceneManager.h:2945

Ogre::SceneManager::AnimationList
map< String, Animation * >::type AnimationList
Storage of animations, lookup by name.
Definition: OgreSceneManager.h:638

Ogre::QueuedRenderableCollection
Lowest level collection of renderables.
Definition: OgreRenderQueueSortingGrouping.h:113

Ogre::SceneManager::isShadowTechniqueIntegrated
virtual bool isShadowTechniqueIntegrated(void) const
Is the shadow technique integrated into primary materials?
Definition: OgreSceneManager.h:3072

Ogre::SceneManager::mShadowTextureCustomReceiverVPParams
GpuProgramParametersSharedPtr mShadowTextureCustomReceiverVPParams
Definition: OgreSceneManager.h:869

Ogre::SceneManager::setShadowUseLightClipPlanes
virtual void setShadowUseLightClipPlanes(bool enabled)
Sets whether when using a built-in additive shadow mode, user clip planes should be used to restrict ...
Definition: OgreSceneManager.h:3080

Ogre::Rectangle2D
Allows the rendering of a simple 2D rectangle This class renders a simple 2D rectangle; this rectangl...
Definition: OgreRectangle2D.h:49

Ogre::PlaneList
vector< Plane >::type PlaneList
Definition: OgrePlane.h:160

Ogre::EntityMaterialLodChangedEvent
Struct containing information about a material LOD change event for entities.
Definition: OgreLodListener.h:73

Ogre::SceneManager::SceneMgrQueuedRenderableVisitor::SceneMgrQueuedRenderableVisitor
SceneMgrQueuedRenderableVisitor()
Definition: OgreSceneManager.h:363

Ogre::SceneManager::mName
String mName
Instance name.
Definition: OgreSceneManager.h:393

Ogre::SceneManager::mListeners
ListenerList mListeners
Definition: OgreSceneManager.h:658

Ogre::SceneManager::getCameraRelativeRendering
virtual bool getCameraRelativeRendering() const
Get whether to use camera-relative co-ordinates when rendering, ie to always place the camera at the ...
Definition: OgreSceneManager.h:3524

Ogre::SceneManager::mAutoParamDataSource
AutoParamDataSource * mAutoParamDataSource
Utility class for calculating automatic parameters for gpu programs.
Definition: OgreSceneManager.h:726

Ogre::SceneManager::_getCurrentRenderStage
IlluminationRenderStage _getCurrentRenderStage()
Definition: OgreSceneManager.h:3549

Ogre::SHADOWDETAILTYPE_INTEGRATED
Mask for integrated shadows (not for direct use, use SHADOWTYPE_ enum instead)
Definition: OgreCommon.h:202

Ogre::SceneManager::getDisplaySceneNodes
virtual bool getDisplaySceneNodes(void) const
Returns true if all scene nodes axis are to be displayed.
Definition: OgreSceneManager.h:2330

Ogre::Quaternion::IDENTITY
static const Quaternion IDENTITY
Definition: OgreQuaternion.h:316

Ogre::ShadowTechnique
ShadowTechnique
An enumeration of broad shadow techniques.
Definition: OgreCommon.h:190

Ogre::VisibleObjectsBoundsInfo::minDistance
Real minDistance
The closest a visible object is to the camera.
Definition: OgreSceneManager.h:93

Ogre::SceneManager::mFogColour
ColourValue mFogColour
Definition: OgreSceneManager.h:469

Ogre::SceneManager::mShadowTextureCustomCasterVPParams
GpuProgramParametersSharedPtr mShadowTextureCustomCasterVPParams
Definition: OgreSceneManager.h:867

Ogre::SceneManager::IRS_NONE
No special illumination stage.
Definition: OgreSceneManager.h:176

Ogre::SceneManager::mSkyDomeOrientation
Quaternion mSkyDomeOrientation
Definition: OgreSceneManager.h:464

Ogre::SceneManager::RenderContext::rsContext
RenderSystem::RenderSystemContext * rsContext
Definition: OgreSceneManager.h:819

Ogre::SceneManager::RenderContext::viewport
Viewport * viewport
Definition: OgreSceneManager.h:816

Ogre::SceneManager::Listener::postUpdateSceneGraph
virtual void postUpdateSceneGraph(SceneManager *source, Camera *camera)
Called after updating the scene graph in this SceneManager.
Definition: OgreSceneManager.h:243

Ogre::SceneManager::getShadowDirLightTextureOffset
virtual Real getShadowDirLightTextureOffset(void) const
Gets the proportional distance which a texture shadow which is generated from a directional light wil...
Definition: OgreSceneManager.h:2910

Ogre::SceneManager::getVisibilityMask
virtual uint32 getVisibilityMask(void)
Gets a mask which is bitwise 'and'ed with objects own visibility masks to determine if the object is ...
Definition: OgreSceneManager.h:3337

Ogre::SceneManager::getOptionKeys
virtual bool getOptionKeys(StringVector &refKeys)
Method for getting all the implementation-specific options of the scene manager.
Definition: OgreSceneManager.h:1800

Ogre::SceneManager::mShadowTextureFadeEnd
Real mShadowTextureFadeEnd
As a proportion e.g. 0.6.
Definition: OgreSceneManager.h:859

Ogre::SceneManager::SpecialCaseRenderQueueMode
SpecialCaseRenderQueueMode
Enumeration of the possible modes allowed for processing the special case render queue list...
Definition: OgreSceneManager.h:187

Ogre::SHADOWDETAILTYPE_TEXTURE
Mask for texture shadows (not for direct use, use SHADOWTYPE_ enum instead)
Definition: OgreCommon.h:208

Ogre::SceneManager::mPassCullingMode
CullingMode mPassCullingMode
Definition: OgreSceneManager.h:486

Ogre::RaySceneQueryListener
Alternative listener class for dealing with RaySceneQuery.
Definition: OgreSceneQuery.h:335

Ogre::SceneManager::mSkyBoxObj
ManualObject * mSkyBoxObj
Definition: OgreSceneManager.h:445

Ogre::SceneManager::ShadowCasterSceneQueryListener::mLightClipVolumeList
const PlaneBoundedVolumeList * mLightClipVolumeList
Definition: OgreSceneManager.h:892

Ogre::SceneManager::SkyPlaneGenParameters::skyPlaneScale
Real skyPlaneScale
Definition: OgreSceneManager.h:207

Ogre::InstancedEntity
Definition: OgreInstancedEntity.h:77

Ogre::SceneManager::hasOption
virtual bool hasOption(const String &strKey) const
Method for verifying whether the scene manager has an implementation-specific option.
Definition: OgreSceneManager.h:1774

Ogre::SceneManager::SkyDomeGenParameters::skyDomeXSegments
int skyDomeXSegments
Definition: OgreSceneManager.h:200

Ogre::SceneManager::StaticGeometryList
map< String, StaticGeometry * >::type StaticGeometryList
Definition: OgreSceneManager.h:411

Ogre::SceneManager::isShadowTechniqueInUse
virtual bool isShadowTechniqueInUse(void) const
Is there any shadowing technique in use?
Definition: OgreSceneManager.h:3075

Ogre::SceneManager::ShadowCasterSceneQueryListener::mFarDistSquared
Real mFarDistSquared
Definition: OgreSceneManager.h:895

Ogre::SceneManager::mShadowTextureCustomReceiverVertexProgram
String mShadowTextureCustomReceiverVertexProgram
Definition: OgreSceneManager.h:865

Ogre::SceneManager::setShowDebugShadows
virtual void setShowDebugShadows(bool debug)
Enables / disables the rendering of debug information for shadows.
Definition: OgreSceneManager.h:2709

Ogre::SceneManager::mShadowIndexBuffer
HardwareIndexBufferSharedPtr mShadowIndexBuffer
Definition: OgreSceneManager.h:738

Ogre::SceneManager::mShadowCamLightMapping
ShadowCamLightMapping mShadowCamLightMapping
Definition: OgreSceneManager.h:502

Ogre::SHADOWDETAILTYPE_STENCIL
Mask for stencil shadows (not for direct use, use SHADOWTYPE_ enum instead)
Definition: OgreCommon.h:205

Ogre::SceneManager::mDirtyInstanceMgrsTmp
InstanceManagerVec mDirtyInstanceMgrsTmp
Definition: OgreSceneManager.h:801

Ogre::SceneManager::mMovableNameGenerator
NameGenerator mMovableNameGenerator
Definition: OgreSceneManager.h:548

Ogre::SceneManager::PT_PLANE
Definition: OgreSceneManager.h:1372

Ogre::SceneManager::mShadowCasterSphereQuery
SphereSceneQuery * mShadowCasterSphereQuery
Definition: OgreSceneManager.h:853

Ogre::SceneManager::mFindVisibleObjects
bool mFindVisibleObjects
Definition: OgreSceneManager.h:874

Ogre::SceneManager::mCameraRelativePosition
Vector3 mCameraRelativePosition
Definition: OgreSceneManager.h:989

Ogre::IntersectionSceneQueryListener
Alternative listener class for dealing with IntersectionSceneQuery.
Definition: OgreSceneQuery.h:461

Ogre::SceneManager::mLightClippingInfoMapFrameNumber
unsigned long mLightClippingInfoMapFrameNumber
Definition: OgreSceneManager.h:766

Ogre::SceneManager::mLateMaterialResolving
bool mLateMaterialResolving
Definition: OgreSceneManager.h:729

Ogre::VisibleObjectsBoundsInfo::minDistanceInFrustum
Real minDistanceInFrustum
The closest a object in the frustum regardless of visibility / shadow caster flags.
Definition: OgreSceneManager.h:97

Ogre::SceneManager::mActiveQueuedRenderableVisitor
SceneMgrQueuedRenderableVisitor * mActiveQueuedRenderableVisitor
The active renderable visitor class - subclasses could override this.
Definition: OgreSceneManager.h:982

Ogre::PixelFormat
PixelFormat
The pixel format used for images, textures, and render surfaces.
Definition: OgrePixelFormat.h:43

Ogre::SceneManager::_areRenderStateChangesSuppressed
virtual bool _areRenderStateChangesSuppressed(void) const
Are render state changes suppressed?
Definition: OgreSceneManager.h:3418

Ogre::ShadowTextureConfig
Structure containing the configuration for one shadow texture.
Definition: OgreShadowTextureManager.h:52

Ogre::SceneManager::mCameras
CameraList mCameras
Central list of cameras - for easy memory management and lookup.
Definition: OgreSceneManager.h:409

Ogre::PF_X8R8G8B8
32-bit pixel format, 8 bits for red, 8 bits for green, 8 bits for blue like PF_A8R8G8B8, but alpha will get discarded
Definition: OgrePixelFormat.h:84

Ogre::SceneManager::estimateWorldGeometry
virtual size_t estimateWorldGeometry(const String &filename)
Estimate the number of loading stages required to load the named world geometry.
Definition: OgreSceneManager.h:1698

Ogre::SceneManager::mShadowCasterList
ShadowCasterList mShadowCasterList
Definition: OgreSceneManager.h:852

Ogre::SceneManager::mRenderQueueListeners
RenderQueueListenerList mRenderQueueListeners
Definition: OgreSceneManager.h:653

OgrePlane.h

Ogre::SceneManager::MovableObjectLodChangedEventList
vector< MovableObjectLodChangedEvent >::type MovableObjectLodChangedEventList
List of movable object LOD changed events.
Definition: OgreSceneManager.h:1016

Ogre::SceneManager::mShadowDirLightExtrudeDist
Real mShadowDirLightExtrudeDist
Definition: OgreSceneManager.h:742

Ogre::SceneManager::SkyPlaneGenParameters
Definition: OgreSceneManager.h:205

Ogre::Sphere
A sphere primitive, mostly used for bounds checking.
Definition: OgreSphere.h:51

Ogre::SceneManager::setVisibilityMask
virtual void setVisibilityMask(uint32 vmask)
Sets a mask which is bitwise 'and'ed with objects own visibility masks to determine if the object is ...
Definition: OgreSceneManager.h:3332

Ogre::SceneManager::mDestRenderSystem
RenderSystem * mDestRenderSystem
The rendering system to send the scene to.
Definition: OgreSceneManager.h:403

Ogre::Entity
Defines an instance of a discrete, movable object based on a Mesh.
Definition: OgreEntity.h:82

Ogre::ConstVectorIterator
Concrete IteratorWrapper for const access to the underlying container.
Definition: OgreIteratorWrapper.h:217

Ogre::SceneManager::mShadowTechnique
ShadowTechnique mShadowTechnique
Definition: OgreSceneManager.h:731

Ogre::SceneManager::getCameraIterator
CameraIterator getCameraIterator(void)
Returns a specialised MapIterator over all cameras in the scene.
Definition: OgreSceneManager.h:2653

Ogre::SceneManager::lightLess
Comparator for sorting lights relative to a point.
Definition: OgreSceneManager.h:167

OgreShadowTextureManager.h

Ogre::SceneManager::SpecialCaseRenderQueueList
set< uint8 >::type SpecialCaseRenderQueueList
Definition: OgreSceneManager.h:474

Ogre::SceneManager::mShadowTextureCustomReceiverPass
Pass * mShadowTextureCustomReceiverPass
Definition: OgreSceneManager.h:862

Ogre::AllocatedObject
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
Definition: OgreMemoryAllocatedObject.h:58

Ogre::SceneManager::mShadowTextureCurrentCasterLightList
LightList mShadowTextureCurrentCasterLightList
Definition: OgreSceneManager.h:537

Ogre::SceneManager::mShadowStencilPass
Pass * mShadowStencilPass
Definition: OgreSceneManager.h:735

Ogre::RenderQueueListener
Abstract interface which classes must implement if they wish to receive events from the render queue...
Definition: OgreRenderQueueListener.h:56

Ogre::SceneManager::isSkyBoxEnabled
virtual bool isSkyBoxEnabled(void) const
Return whether a skybox is enabled.
Definition: OgreSceneManager.h:2076

Ogre::RibbonTrail
Subclass of BillboardChain which automatically leaves a trail behind one or more Node instances...
Definition: OgreRibbonTrail.h:71

OgreHeaderPrefix.h

Ogre::MovableObjectLodChangedEvent
Struct containing information about a LOD change event for movable objects.
Definition: OgreLodListener.h:44

Ogre::ST_GENERIC
Definition: OgreSceneManager.h:3614

Ogre::set
Definition: OgrePrerequisites.h:522

Ogre::RenderSystem::RenderSystemContext
Definition: OgreRenderSystem.h:904

Ogre::SceneManager::Listener::shadowTexturesUpdated
virtual void shadowTexturesUpdated(size_t numberOfShadowTextures)
Event raised after all shadow textures have been rendered into for all queues / targets but before an...
Definition: OgreSceneManager.h:287

Ogre::vector
Definition: OgrePrerequisites.h:494

Ogre::SceneManager::getFlipCullingOnNegativeScale
virtual bool getFlipCullingOnNegativeScale() const
Get whether to automatically flip the culling mode on objects whenever they are negatively scaled...
Definition: OgreSceneManager.h:3385

Ogre::SceneManager::mInstanceManagerMap
InstanceManagerMap mInstanceManagerMap
Definition: OgreSceneManager.h:417

Ogre::SceneManager::mSkyBoxEnabled
bool mSkyBoxEnabled
Definition: OgreSceneManager.h:457

Ogre::SceneManager::mFlipCullingOnNegativeScale
bool mFlipCullingOnNegativeScale
Definition: OgreSceneManager.h:485

Ogre::SceneManager::ShadowCasterSceneQueryListener::ShadowCasterSceneQueryListener
ShadowCasterSceneQueryListener(SceneManager *sm)
Definition: OgreSceneManager.h:897

Ogre::SceneManager::setSkyPlaneEnabled
virtual void setSkyPlaneEnabled(bool enable)
Enables / disables a 'sky plane'.
Definition: OgreSceneManager.h:1978

Ogre::SHADOWDETAILTYPE_MODULATIVE
Mask for modulative shadows (not for direct use, use SHADOWTYPE_ enum instead)
Definition: OgreCommon.h:199

Ogre::SceneManagerFactory::mMetaDataInit
bool mMetaDataInit
Definition: OgreSceneManager.h:3641

Ogre::SceneManager::CameraIterator
MapIterator< CameraList > CameraIterator
Definition: OgreSceneManager.h:2648

Ogre::SceneManager::getShadowTextureCountPerLightType
size_t getShadowTextureCountPerLightType(Light::LightTypes type) const
Get the number of shadow textures is assigned for the given light type.
Definition: OgreSceneManager.h:2871

Ogre::SceneManager::mShadowTextureCustomCasterFragmentProgram
String mShadowTextureCustomCasterFragmentProgram
Definition: OgreSceneManager.h:864

Ogre::SceneManager::mShadowCasterQueryListener
ShadowCasterSceneQueryListener * mShadowCasterQueryListener
Definition: OgreSceneManager.h:917

Ogre::SceneManager::mNullShadowTexture
TexturePtr mNullShadowTexture
Definition: OgreSceneManager.h:747

Ogre::SceneManager::mSkyBoxNode
SceneNode * mSkyBoxNode
Definition: OgreSceneManager.h:449

Ogre::SceneManager::mShadowTextureCustomCasterVertexProgram
String mShadowTextureCustomCasterVertexProgram
Definition: OgreSceneManager.h:863

Ogre::SceneManager::getFindVisibleObjects
virtual bool getFindVisibleObjects(void)
Gets whether the SceneManager should search for visible objects, or whether they are being manually h...
Definition: OgreSceneManager.h:3355

Ogre::SceneManager::estimateWorldGeometry
virtual size_t estimateWorldGeometry(DataStreamPtr &stream, const String &typeName=StringUtil::BLANK)
Estimate the number of loading stages required to load the named world geometry.
Definition: OgreSceneManager.h:1713

Ogre::StringVector
vector< String >::type StringVector
Definition: OgreStringVector.h:45

OgreInstancedGeometry.h

Ogre::SceneManager::getSkyDomeGenParameters
virtual const SkyDomeGenParameters & getSkyDomeGenParameters(void) const
Get the parameters used to generate the current SkyDome, if any.
Definition: OgreSceneManager.h:2209

Ogre::SceneManager::Listener::~Listener
virtual ~Listener()
Definition: OgreSceneManager.h:226

Ogre::SceneManager::SkyPlaneGenParameters::skyPlaneTiling
Real skyPlaneTiling
Definition: OgreSceneManager.h:208

Ogre::SceneManager::mCachedLightInfos
LightInfoList mCachedLightInfos
Definition: OgreSceneManager.h:534

Ogre::QueuedRenderableVisitor
Visitor interface for items in a QueuedRenderableCollection.
Definition: OgreRenderQueueSortingGrouping.h:69

Ogre::SceneManager::getShadowFarDistance
virtual Real getShadowFarDistance(void) const
Gets the default maximum distance away from the camera that shadows will be visible.
Definition: OgreSceneManager.h:2762

Ogre::SceneManager::setShadowDirLightTextureOffset
virtual void setShadowDirLightTextureOffset(Real offset)
Sets the proportional distance which a texture shadow which is generated from a directional light wil...
Definition: OgreSceneManager.h:2906

Ogre::Vector3
Standard 3-dimensional vector.
Definition: OgreVector3.h:51

Ogre::SceneManager::mFogStart
Real mFogStart
Definition: OgreSceneManager.h:470

Ogre::SceneManager::ShadowTextureCameraList
vector< Camera * >::type ShadowTextureCameraList
Definition: OgreSceneManager.h:748

Ogre::SceneManager::mLastLightLimit
unsigned short mLastLightLimit
Definition: OgreSceneManager.h:993

Ogre::SceneManager::mShadowTextureCustomCasterPass
Pass * mShadowTextureCustomCasterPass
Definition: OgreSceneManager.h:861

OgreRenderQueue.h

Ogre::SceneManager::MovableObjectCollectionMap
map< String, MovableObjectCollection * >::type MovableObjectCollectionMap
Definition: OgreSceneManager.h:546

Ogre::SceneManager::mCachedViewMatrix
Matrix4 mCachedViewMatrix
Definition: OgreSceneManager.h:988

Ogre::SceneManager::mFogEnd
Real mFogEnd
Definition: OgreSceneManager.h:471

Ogre::VisibleObjectsBoundsInfo::aabb
AxisAlignedBox aabb
The axis-aligned bounds of the visible objects.
Definition: OgreSceneManager.h:89

Ogre::SceneManager::mCameraRelativeRendering
bool mCameraRelativeRendering
Whether to use camera-relative rendering.
Definition: OgreSceneManager.h:987

Ogre::SceneManager::setCameraRelativeRendering
virtual void setCameraRelativeRendering(bool rel)
Set whether to use camera-relative co-ordinates when rendering, ie to always place the camera at the ...
Definition: OgreSceneManager.h:3519

Ogre::SceneManager::mResetIdentityProj
bool mResetIdentityProj
Definition: OgreSceneManager.h:482

Ogre::ViewPoint::orientation
Quaternion orientation
Definition: OgreSceneManager.h:73

Ogre::SceneManager::mCameraInProgress
Camera * mCameraInProgress
Camera in progress.
Definition: OgreSceneManager.h:430

Ogre::SceneManager::mAmbientLight
ColourValue mAmbientLight
Current ambient light, cached for RenderSystem.
Definition: OgreSceneManager.h:400

OgreResourceGroupManager.h

Ogre::StringUtil::BLANK
static const String BLANK
Constant blank string, useful for returning by ref where local does not exist.
Definition: OgreString.h:196

Ogre::EntityMeshLodChangedEvent
Struct containing information about a mesh LOD change event for entities.
Definition: OgreLodListener.h:54

OgreQuaternion.h

Ogre::SceneManager::getCameras
const CameraList & getCameras() const
Returns a const version of the camera list.
Definition: OgreSceneManager.h:2658

Ogre::ST_INTERIOR
Definition: OgreSceneManager.h:3618

Ogre::SceneManager::setSkyDomeEnabled
virtual void setSkyDomeEnabled(bool enable)
Enables / disables a 'sky dome'.
Definition: OgreSceneManager.h:2200

Ogre::SceneManager::ShadowCasterSceneQueryListener::mCamera
const Camera * mCamera
Definition: OgreSceneManager.h:893

Ogre::SceneManager::mSkyBoxOrientation
Quaternion mSkyBoxOrientation
Definition: OgreSceneManager.h:459

Ogre::SceneManager::mLightClippingInfoMap
LightClippingInfoMap mLightClippingInfoMap
Definition: OgreSceneManager.h:765

Ogre::DefaultRaySceneQuery
Default implementation of RaySceneQuery.
Definition: OgreSceneManager.h:3565

Ogre::Viewport
An abstraction of a viewport, i.e.
Definition: OgreViewport.h:57

Ogre::RenderOperation
'New' rendering operation using vertex buffers.
Definition: OgreRenderOperation.h:45

Ogre::SceneManager::mShadowCasterRenderBackFaces
bool mShadowCasterRenderBackFaces
Definition: OgreSceneManager.h:752

Ogre::SceneManager::mCamVisibleObjectsMap
CamVisibleObjectsMap mCamVisibleObjectsMap
Definition: OgreSceneManager.h:498

Ogre::SceneManager::mRenderObjectListeners
RenderObjectListenerList mRenderObjectListeners
Definition: OgreSceneManager.h:656

Ogre::SceneManager::mVisibilityMask
uint32 mVisibilityMask
Visibility mask used to show / hide objects.
Definition: OgreSceneManager.h:873

Ogre::SceneManager::mSceneNodes
SceneNodeList mSceneNodes
Central list of SceneNodes - for easy memory management.
Definition: OgreSceneManager.h:427

Ogre::SceneTypeMask
uint16 SceneTypeMask
Bitmask containing scene types.
Definition: OgreSceneManager.h:3607

Ogre::SceneManager::mShadowTextureConfigList
ShadowTextureConfigList mShadowTextureConfigList
Definition: OgreSceneManager.h:744

OgreCamera.h

Ogre::SceneManager::mAutoTrackingSceneNodes
AutoTrackingSceneNodes mAutoTrackingSceneNodes
Definition: OgreSceneManager.h:439

Ogre::LodListener
A interface class defining a listener which can be used to receive notifications of LOD events...
Definition: OgreLodListener.h:117

Ogre::SceneManager::WORLD_GEOMETRY_TYPE_MASK
static uint32 WORLD_GEOMETRY_TYPE_MASK
Query type mask which will be used for world geometry.
Definition: OgreSceneManager.h:147

Ogre::SceneManager::mShadowTextureIndexLightList
vector< size_t >::type mShadowTextureIndexLightList
Array defining shadow texture index in light list.
Definition: OgreSceneManager.h:508

Ogre::SceneManager::mSkyPlaneEntity
Entity * mSkyPlaneEntity
Definition: OgreSceneManager.h:443

Ogre::SceneManager::mSkyDomeNode
SceneNode * mSkyDomeNode
Definition: OgreSceneManager.h:448

Ogre::SceneManager::MovableObjectIterator
MapIterator< MovableObjectMap > MovableObjectIterator
Definition: OgreSceneManager.h:3285

Ogre::ShadowTextureConfigList
vector< ShadowTextureConfig >::type ShadowTextureConfigList
Definition: OgreShadowTextureManager.h:64

Ogre::SceneManager::mShadowReceiverPass
Pass * mShadowReceiverPass
A pass designed to let us render shadow receivers for texture shadows.
Definition: OgreSceneManager.h:570

Ogre::SceneManager::RenderObjectListenerList
vector< RenderObjectListener * >::type RenderObjectListenerList
Definition: OgreSceneManager.h:655

Ogre::SceneManager::getAnimationStateIterator
AnimationStateIterator getAnimationStateIterator(void)
Returns a specialised MapIterator over all animation states in the scene.
Definition: OgreSceneManager.h:2667

Ogre::SceneManager::mCurrentShadowTexture
Texture * mCurrentShadowTexture
Definition: OgreSceneManager.h:750

Ogre::SceneManager::mFullScreenQuad
Rectangle2D * mFullScreenQuad
Definition: OgreSceneManager.h:741

Ogre::DefaultAxisAlignedBoxSceneQuery
Default implementation of AxisAlignedBoxSceneQuery.
Definition: OgreSceneManager.h:3595

Ogre::SceneManager::getOption
virtual bool getOption(const String &strKey, void *pDestValue)
Method for getting the value of an implementation-specific Scene Manager option.
Definition: OgreSceneManager.h:1762

OGRE_NEW
#define OGRE_NEW
Definition: OgreMemoryAllocatorConfig.h:473

Ogre::SceneManager::Listener::shadowTextureReceiverPreViewProj
virtual void shadowTextureReceiverPreViewProj(Light *light, Frustum *frustum)
This event occurs just before the view & projection matrices are set for re-rendering a shadow receiv...
Definition: OgreSceneManager.h:320

OgreShadowCameraSetup.h

Ogre::SceneManager::mSpecialCaseQueueList
SpecialCaseRenderQueueList mSpecialCaseQueueList
Definition: OgreSceneManager.h:475

Ogre::RenderQueue
Class to manage the scene object rendering queue.
Definition: OgreRenderQueue.h:92

OgreString.h

Ogre::AxisAlignedBoxSceneQuery
Specialises the SceneQuery class for querying within an axis aligned box.
Definition: OgreSceneQuery.h:270

Ogre::SceneManager::SkyDomeGenParameters::skyDomeYSegments
int skyDomeYSegments
Definition: OgreSceneManager.h:201

Ogre::SceneManager::LightClippingInfoMap
map< Light *, LightClippingInfo >::type LightClippingInfoMap
Definition: OgreSceneManager.h:764

Ogre::SceneManager::RenderQueueListenerList
vector< RenderQueueListener * >::type RenderQueueListenerList
Definition: OgreSceneManager.h:652

Ogre::SceneManager::isShadowTechniqueTextureBased
virtual bool isShadowTechniqueTextureBased(void) const
Is there a texture shadow based shadowing technique in use?
Definition: OgreSceneManager.h:3063

Ogre::InstanceManager
This is the main starting point for the new instancing system.
Definition: OgreInstanceManager.h:63

Ogre::SceneManager::setShadowTextureCountPerLightType
void setShadowTextureCountPerLightType(Light::LightTypes type, size_t count)
Set the number of shadow textures a light type uses.
Definition: OgreSceneManager.h:2868

Ogre::SceneManager::RenderContext::camera
Camera * camera
Definition: OgreSceneManager.h:817

Ogre::SceneManager::mInstancedGeometryList
InstancedGeometryList mInstancedGeometryList
Definition: OgreSceneManager.h:414

Ogre::SceneManager::_getActiveCompositorChain
virtual CompositorChain * _getActiveCompositorChain() const
Gets the active compositor chain of the current scene being rendered.
Definition: OgreSceneManager.h:3103

Ogre::SceneManager::mNormaliseNormalsOnScale
bool mNormaliseNormalsOnScale
Definition: OgreSceneManager.h:484

Ogre::SceneManager::mLightsAffectingFrustum
LightList mLightsAffectingFrustum
Definition: OgreSceneManager.h:533

Ogre::ST_EXTERIOR_REAL_FAR
Definition: OgreSceneManager.h:3617

Ogre::SceneManagerFactory::~SceneManagerFactory
virtual ~SceneManagerFactory()
Definition: OgreSceneManager.h:3646

Ogre::SharedPtr< Mesh >

Ogre::SceneManager::getAnimations
const AnimationList & getAnimations() const
Returns a const version of the animation list.
Definition: OgreSceneManager.h:2665

Ogre::SceneManager::mWorldGeometryRenderQueue
uint8 mWorldGeometryRenderQueue
Definition: OgreSceneManager.h:477

Ogre::SceneManager::LodListenerSet
set< LodListener * >::type LodListenerSet
Set of registered LOD listeners.
Definition: OgreSceneManager.h:1012

Ogre::SceneManager::mShadowColour
ColourValue mShadowColour
Definition: OgreSceneManager.h:733

Ogre::PlaneBoundedVolumeListSceneQuery
Specialises the SceneQuery class for querying within a plane-bounded volume.
Definition: OgreSceneQuery.h:304

Ogre::SceneManager::setFlipCullingOnNegativeScale
virtual void setFlipCullingOnNegativeScale(bool n)
Set whether to automatically flip the culling mode on objects whenever they are negatively scaled...
Definition: OgreSceneManager.h:3380

Ogre::SceneManager::mShadowCasterAABBQuery
AxisAlignedBoxSceneQuery * mShadowCasterAABBQuery
Definition: OgreSceneManager.h:854

Ogre::DefaultPlaneBoundedVolumeListSceneQuery
Default implementation of PlaneBoundedVolumeListSceneQuery.
Definition: OgreSceneManager.h:3585

Ogre::ClipResult
ClipResult
Generic result of clipping.
Definition: OgreCommon.h:740

Ogre::ViewPoint
Structure for holding a position & orientation pair.
Definition: OgreSceneManager.h:70

Ogre::String
_StringBase String
Definition: OgrePrerequisites.h:442

Ogre::VisibleObjectsBoundsInfo::maxDistance
Real maxDistance
The farthest a visible objects is from the camera.
Definition: OgreSceneManager.h:95

Ogre::ST_EXTERIOR_FAR
Definition: OgreSceneManager.h:3616

Ogre::SceneManager::mSkyPlaneRenderQueue
uint8 mSkyPlaneRenderQueue
Definition: OgreSceneManager.h:453

Ogre::SceneManager::mShadowIndexBufferUsedSize
size_t mShadowIndexBufferUsedSize
Definition: OgreSceneManager.h:740

Ogre::SceneManager::setShadowCasterRenderBackFaces
virtual void setShadowCasterRenderBackFaces(bool bf)
Sets whether or not shadow casters should be rendered into shadow textures using their back faces rat...
Definition: OgreSceneManager.h:3001

OgreRenderSystem.h

Ogre::SceneManager::setFindVisibleObjects
virtual void setFindVisibleObjects(bool find)
Sets whether the SceneManager should search for visible objects, or whether they are being manually h...
Definition: OgreSceneManager.h:3350

Ogre::SceneManager::LightInfo::range
Real range
Use int instead of Light::LightTypes to avoid header file dependence.
Definition: OgreSceneManager.h:515

Ogre::IntersectionSceneQuery
Separate SceneQuery class to query for pairs of objects which are possibly intersecting one another...
Definition: OgreSceneQuery.h:512

Ogre::uint16
unsigned short uint16
Definition: OgrePlatform.h:345

Ogre::SceneManager::ShadowCamLightMapping
map< const Camera *, const Light * >::type ShadowCamLightMapping
ShadowCamera to light mapping.
Definition: OgreSceneManager.h:501

Ogre::SceneManager::getSkyBoxNode
virtual SceneNode * getSkyBoxNode(void) const
Get the skybox node, if enabled.
Definition: OgreSceneManager.h:2079

Ogre::SceneManager::mActiveCompositorChain
CompositorChain * mActiveCompositorChain
Definition: OgreSceneManager.h:728

Ogre::SceneManager::Listener::postFindVisibleObjects
virtual void postFindVisibleObjects(SceneManager *source, IlluminationRenderStage irs, Viewport *v)
Called after searching for visible objects in this SceneManager.
Definition: OgreSceneManager.h:269

Ogre::SceneQueryListener
This optional class allows you to receive per-result callbacks from SceneQuery executions instead of ...
Definition: OgreSceneQuery.h:187

Ogre::SceneManager::mShadowTextureSelfShadow
bool mShadowTextureSelfShadow
As a proportion e.g. 0.9.
Definition: OgreSceneManager.h:860

Ogre::VectorIterator
Concrete IteratorWrapper for nonconst access to the underlying container.
Definition: OgreIteratorWrapper.h:186

Ogre::SceneManager::LightInfo::position
Vector3 position
Sets to zero if directional light.
Definition: OgreSceneManager.h:516

Ogre::SceneManager::mResetIdentityView
bool mResetIdentityView
Definition: OgreSceneManager.h:481

Ogre::SceneManager::SceneMgrQueuedRenderableVisitor::targetSceneMgr
SceneManager * targetSceneMgr
Target SM to send renderables to.
Definition: OgreSceneManager.h:371

Ogre::RenderSystem
Defines the functionality of a 3D API.
Definition: OgreRenderSystem.h:125

Ogre::SceneManager::RenderContext
Definition: OgreSceneManager.h:813

Ogre::SceneManager::_areShadowsSuppressed
virtual bool _areShadowsSuppressed(void) const
Are shadows suppressed?
Definition: OgreSceneManager.h:3460

Ogre::Texture
Abstract class representing a Texture resource.
Definition: OgreTexture.h:102

Ogre::SceneManager::mShadowModulativePass
Pass * mShadowModulativePass
Definition: OgreSceneManager.h:736

Ogre::SceneManager::setLateMaterialResolving
virtual void setLateMaterialResolving(bool isLate)
Sets whether to use late material resolving or not.
Definition: OgreSceneManager.h:3096

Ogre::Animation
An animation sequence.
Definition: OgreAnimation.h:92

Ogre::SceneManager::createAutoParamDataSource
virtual AutoParamDataSource * createAutoParamDataSource(void) const
Internal method for creating the AutoParamDataSource instance.
Definition: OgreSceneManager.h:720

Ogre::VisibleObjectsBoundsInfo
Structure collecting together information about the visible objects that have been discovered in a sc...
Definition: OgreSceneManager.h:86

Ogre::SceneManager::SkyDomeGenParameters
Definition: OgreSceneManager.h:195

OgreColourValue.h

Ogre::SceneManager::mLodListeners
LodListenerSet mLodListeners
Definition: OgreSceneManager.h:1013

Ogre::SceneManager::LightClippingInfo::LightClippingInfo
LightClippingInfo()
Definition: OgreSceneManager.h:761

Ogre::RaySceneQuery
Specialises the SceneQuery class for querying along a ray.
Definition: OgreSceneQuery.h:376

Ogre::SceneManager::mShowBoundingBoxes
bool mShowBoundingBoxes
Flag that indicates if all of the scene node's bounding boxes should be shown as a wireframe...
Definition: OgreSceneManager.h:691

Ogre::SceneManagerMetaData
Structure containing information about a scene manager.
Definition: OgreSceneManager.h:3622

Ogre::SceneManager::mDirtyInstanceManagers
InstanceManagerVec mDirtyInstanceManagers
Definition: OgreSceneManager.h:800

OgreAutoParamDataSource.h

Ogre::SceneManagerFactory::getMetaData
virtual const SceneManagerMetaData & getMetaData(void) const
Get information about the SceneManager type created by this factory.
Definition: OgreSceneManager.h:3648

Ogre::SceneManager::SkyDomeGenParameters::skyDomeCurvature
Real skyDomeCurvature
Definition: OgreSceneManager.h:197

Ogre::SceneManager::SceneMgrQueuedRenderableVisitor::~SceneMgrQueuedRenderableVisitor
~SceneMgrQueuedRenderableVisitor()
Definition: OgreSceneManager.h:365

Ogre::SceneManager::LightInfo
Cached light information, used to tracking light's changes.
Definition: OgreSceneManager.h:511

Ogre::SceneManager::getName
const String & getName(void) const
Return the instance name of this SceneManager.
Definition: OgreSceneManager.h:1065

Ogre::SceneManager::AutoTrackingSceneNodes
set< SceneNode * >::type AutoTrackingSceneNodes
Autotracking scene nodes.
Definition: OgreSceneManager.h:438

Ogre::SceneManager::SkyBoxGenParameters
Definition: OgreSceneManager.h:214

Ogre::SceneManager::STATICGEOMETRY_TYPE_MASK
static uint32 STATICGEOMETRY_TYPE_MASK
Query type mask which will be used for StaticGeometry.
Definition: OgreSceneManager.h:153

Ogre::SceneManager::LIGHT_TYPE_MASK
static uint32 LIGHT_TYPE_MASK
Query type mask which will be used for lights.
Definition: OgreSceneManager.h:155

Ogre::SceneManager::mDebugShadows
bool mDebugShadows
Definition: OgreSceneManager.h:732

Ogre::SceneManager::getShadowTechnique
virtual ShadowTechnique getShadowTechnique(void) const
Gets the current shadow technique.
Definition: OgreSceneManager.h:2706

Ogre::SceneManager::EntityMeshLodChangedEventList
vector< EntityMeshLodChangedEvent >::type EntityMeshLodChangedEventList
List of entity mesh LOD changed events.
Definition: OgreSceneManager.h:1020

Ogre::SceneManagerMetaData::description
String description
A text description of the scene manager.
Definition: OgreSceneManager.h:3627

Ogre::operator==
bool operator==(STLAllocator< T, P > const &, STLAllocator< T2, P > const &)
determine equality, can memory from another allocator be released by this allocator, (ISO C++)
Definition: OgreMemorySTLAllocator.h:184

Ogre::SceneManagerFactory
Class which will create instances of a given SceneManager.
Definition: OgreSceneManager.h:3637

Ogre::AutoParamDataSource
This utility class is used to hold the information used to generate the matrices and other informatio...
Definition: OgreAutoParamDataSource.h:60

Ogre::SceneManager::mShadowDebugPass
Pass * mShadowDebugPass
Definition: OgreSceneManager.h:734

Ogre::SceneManager::setSkyBoxEnabled
virtual void setSkyBoxEnabled(bool enable)
Enables / disables a 'sky box'.
Definition: OgreSceneManager.h:2073

Ogre::SceneManager::mEntityMeshLodChangedEvents
EntityMeshLodChangedEventList mEntityMeshLodChangedEvents
Definition: OgreSceneManager.h:1021

Ogre::SceneManager::getShowDebugShadows
virtual bool getShowDebugShadows(void) const
Are debug shadows shown?
Definition: OgreSceneManager.h:2711

Ogre::operator!=
bool operator!=(STLAllocator< T, P > const &, STLAllocator< T2, P > const &)
determine equality, can memory from another allocator be released by this allocator, (ISO C++)
Definition: OgreMemorySTLAllocator.h:202

Ogre::SceneManager::mDisplayNodes
bool mDisplayNodes
Flag indicating whether SceneNodes will be rendered as a set of 3 axes.
Definition: OgreSceneManager.h:635

Ogre::SceneManager::mShadowTextureCustomReceiverFPParams
GpuProgramParametersSharedPtr mShadowTextureCustomReceiverFPParams
Definition: OgreSceneManager.h:870

Ogre::SceneManager::mEntityMaterialLodChangedEvents
EntityMaterialLodChangedEventList mEntityMaterialLodChangedEvents
Definition: OgreSceneManager.h:1025

Ogre::SceneManager::BoxPlane
BoxPlane
Definition: OgreSceneManager.h:607