# OgreSceneManager.h

Go to the documentation of this file.

    00001 /*-------------------------------------------------------------------------
    00002 This source file is a part of OGRE
    00003 (Object-oriented Graphics Rendering Engine)
    00004
    00005 For the latest info, see http://www.ogre3d.org/
    00006
    00007 Copyright (c) 2000-2009 Torus Knot Software Ltd
    00008 Permission is hereby granted, free of charge, to any person obtaining a copy
    00009 of this software and associated documentation files (the "Software"), to deal
    00010 in the Software without restriction, including without limitation the rights
    00011 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    00012 copies of the Software, and to permit persons to whom the Software is
    00013 furnished to do so, subject to the following conditions:
    00014
    00015 The above copyright notice and this permission notice shall be included in
    00016 all copies or substantial portions of the Software.
    00017
    00018 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    00019 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    00020 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    00021 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    00022 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    00023 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    00024 THE SOFTWARE
    00025
    00026 You may alternatively use this source under the terms of a specific version of
    00027 the OGRE Unrestricted License provided you have obtained such a license from
    00028 Torus Knot Software Ltd.
    00029 -------------------------------------------------------------------------*/
    00030 #ifndef __SceneManager_H__
    00031 #define __SceneManager_H__
    00032
    00033 // Precompiler options
    00034 #include "OgrePrerequisites.h"
    00035
    00036 #include "OgreString.h"
    00037 #include "OgreSceneNode.h"
    00038 #include "OgrePlane.h"
    00039 #include "OgreQuaternion.h"
    00040 #include "OgreColourValue.h"
    00041 #include "OgreCommon.h"
    00042 #include "OgreSceneQuery.h"
    00043 #include "OgreAutoParamDataSource.h"
    00044 #include "OgreAnimationState.h"
    00045 #include "OgreRenderQueue.h"
    00046 #include "OgreRenderQueueSortingGrouping.h"
    00047 #include "OgreRectangle2D.h"
    00048 #include "OgrePixelFormat.h"
    00049 #include "OgreResourceGroupManager.h"
    00050 #include "OgreTexture.h"
    00051 #include "OgreShadowCameraSetup.h"
    00052 #include "OgreShadowTextureManager.h"
    00053 #include "OgreCamera.h"
    00054 #include "OgreInstancedGeometry.h"
    00055 #include "OgreLodListener.h"
    00056 #include "OgreRenderSystem.h"
    00057 namespace Ogre {
    00066     struct ViewPoint
    00067     {
    00068         Vector3 position;
    00069         Quaternion orientation;
    00070     };
    00071
    00072     // Forward declarations
    00073     class DefaultIntersectionSceneQuery;
    00074     class DefaultRaySceneQuery;
    00075     class DefaultSphereSceneQuery;
    00076     class DefaultAxisAlignedBoxSceneQuery;
    00077     class CompositorChain;
    00078
    00082     struct _OgreExport VisibleObjectsBoundsInfo
    00083     {
    00085         AxisAlignedBox aabb;
    00087         AxisAlignedBox receiverAabb;
    00089         Real minDistance;
    00091         Real maxDistance;
    00093         Real minDistanceInFrustum;
    00095         Real maxDistanceInFrustum;
    00096
    00097         VisibleObjectsBoundsInfo();
    00098         void reset();
    00099         void merge(const AxisAlignedBox& boxBounds, const Sphere& sphereBounds,
    00100             const Camera* cam, bool receiver=true);
    00104         void mergeNonRenderedButInFrustum(const AxisAlignedBox& boxBounds,
    00105             const Sphere& sphereBounds, const Camera* cam);
    00106
    00107
    00108     };
    00109
    00139     class _OgreExport SceneManager : public SceneMgtAlloc
    00140     {
    00141     public:
    00143         static uint32 WORLD_GEOMETRY_TYPE_MASK;
    00145         static uint32 ENTITY_TYPE_MASK;
    00147         static uint32 FX_TYPE_MASK;
    00149         static uint32 STATICGEOMETRY_TYPE_MASK;
    00151         static uint32 LIGHT_TYPE_MASK;
    00153         static uint32 FRUSTUM_TYPE_MASK;
    00155         static uint32 USER_TYPE_MASK_LIMIT;
    00158         struct materialLess
    00159         {
    00160             _OgreExport bool operator()(const Material* x, const Material* y) const;
    00161         };
    00163         struct lightLess
    00164         {
    00165             _OgreExport bool operator()(const Light* a, const Light* b) const;
    00166         };
    00167
    00169         enum IlluminationRenderStage
    00170         {
    00172             IRS_NONE,
    00174             IRS_RENDER_TO_TEXTURE,
    00176             IRS_RENDER_RECEIVER_PASS
    00177         };
    00178
    00183         enum SpecialCaseRenderQueueMode
    00184         {
    00186             SCRQM_INCLUDE,
    00188             SCRQM_EXCLUDE
    00189         };
    00190
    00191         struct SkyDomeGenParameters
    00192         {
    00193             Real skyDomeCurvature;
    00194             Real skyDomeTiling;
    00195             Real skyDomeDistance;
    00196             int skyDomeXSegments;
    00197             int skyDomeYSegments;
    00198             int skyDomeYSegments_keep;
    00199         };
    00200
    00201         struct SkyPlaneGenParameters
    00202         {
    00203             Real skyPlaneScale;
    00204             Real skyPlaneTiling;
    00205             Real skyPlaneBow;
    00206             int skyPlaneXSegments;
    00207             int skyPlaneYSegments;
    00208         };
    00209
    00210         struct SkyBoxGenParameters
    00211         {
    00212             Real skyBoxDistance;
    00213         };
    00214
    00218         class Listener
    00219         {
    00220         public:
    00221             Listener() {}
    00222             virtual ~Listener() {}
    00223
    00233             virtual void preFindVisibleObjects(SceneManager* source,
    00234                 IlluminationRenderStage irs, Viewport* v)
    00235                         { (void)source; (void)irs; (void)v; }
    00236
    00247             virtual void postFindVisibleObjects(SceneManager* source,
    00248                 IlluminationRenderStage irs, Viewport* v)
    00249                         { (void)source; (void)irs; (void)v; }
    00250
    00265             virtual void shadowTexturesUpdated(size_t numberOfShadowTextures)
    00266                         { (void)numberOfShadowTextures; }
    00267
    00281             virtual void shadowTextureCasterPreViewProj(Light* light,
    00282                 Camera* camera, size_t iteration)
    00283                         { (void)light; (void)camera; (void)iteration; }
    00284
    00298             virtual void shadowTextureReceiverPreViewProj(Light* light,
    00299                 Frustum* frustum)
    00300                         { (void)light; (void)frustum; }
    00301
    00324             virtual bool sortLightsAffectingFrustum(LightList& lightList)
    00325                         { (void)lightList; return false; }
    00326
    00328             virtual void sceneManagerDestroyed(SceneManager* source)
    00329                         { (void)source; }
    00330         };
    00331
    00335         class _OgreExport SceneMgrQueuedRenderableVisitor : public QueuedRenderableVisitor
    00336         {
    00337         protected:
    00339             const Pass* mUsedPass;
    00340         public:
    00341             SceneMgrQueuedRenderableVisitor()
    00342                 :transparentShadowCastersMode(false) {}
    00343             ~SceneMgrQueuedRenderableVisitor() {}
    00344             void visit(Renderable* r);
    00345             bool visit(const Pass* p);
    00346             void visit(RenderablePass* rp);
    00347
    00349             SceneManager* targetSceneMgr;
    00351             bool transparentShadowCastersMode;
    00353             bool autoLights;
    00355             const LightList* manualLightList;
    00357             bool scissoring;
    00358
    00359         };
    00361         friend class SceneMgrQueuedRenderableVisitor;
    00362
    00363     protected:
    00364
    00366         virtual SceneNode* createSceneNodeImpl(void);
    00368         virtual SceneNode* createSceneNodeImpl(const String& name);
    00369
    00371         String mName;
    00372
    00374         RenderQueue* mRenderQueue;
    00375         bool mLastRenderQueueInvocationCustom;
    00376
    00378         ColourValue mAmbientLight;
    00379
    00381         RenderSystem *mDestRenderSystem;
    00382
    00383         typedef map<String, Camera* >::type CameraList;
    00384
    00387         CameraList mCameras;
    00388
    00389         typedef map<String, StaticGeometry* >::type StaticGeometryList;
    00390         StaticGeometryList mStaticGeometryList;
    00391         typedef map<String, InstancedGeometry* >::type InstancedGeometryList;
    00392         InstancedGeometryList mInstancedGeometryList;
    00393
    00394         typedef map<String, SceneNode*>::type SceneNodeList;
    00395
    00402         SceneNodeList mSceneNodes;
    00403
    00405         Camera* mCameraInProgress;
    00407         Viewport* mCurrentViewport;
    00408
    00410         SceneNode* mSceneRoot;
    00411
    00413         typedef set<SceneNode*>::type AutoTrackingSceneNodes;
    00414         AutoTrackingSceneNodes mAutoTrackingSceneNodes;
    00415
    00416         // Sky params
    00417         // Sky plane
    00418         Entity* mSkyPlaneEntity;
    00419         Entity* mSkyDomeEntity[5];
    00420         ManualObject* mSkyBoxObj;
    00421
    00422         SceneNode* mSkyPlaneNode;
    00423         SceneNode* mSkyDomeNode;
    00424         SceneNode* mSkyBoxNode;
    00425
    00426         // Sky plane
    00427         bool mSkyPlaneEnabled;
    00428         uint8 mSkyPlaneRenderQueue;
    00429         Plane mSkyPlane;
    00430         SkyPlaneGenParameters mSkyPlaneGenParameters;
    00431         // Sky box
    00432         bool mSkyBoxEnabled;
    00433         uint8 mSkyBoxRenderQueue;
    00434         Quaternion mSkyBoxOrientation;
    00435         SkyBoxGenParameters mSkyBoxGenParameters;
    00436         // Sky dome
    00437         bool mSkyDomeEnabled;
    00438         uint8 mSkyDomeRenderQueue;
    00439         Quaternion mSkyDomeOrientation;
    00440         SkyDomeGenParameters mSkyDomeGenParameters;
    00441
    00442         // Fog
    00443         FogMode mFogMode;
    00444         ColourValue mFogColour;
    00445         Real mFogStart;
    00446         Real mFogEnd;
    00447         Real mFogDensity;
    00448
    00449         typedef set<uint8>::type SpecialCaseRenderQueueList;
    00450         SpecialCaseRenderQueueList mSpecialCaseQueueList;
    00451         SpecialCaseRenderQueueMode mSpecialCaseQueueMode;
    00452         uint8 mWorldGeometryRenderQueue;
    00453
    00454         unsigned long mLastFrameNumber;
    00455         Matrix4 mTempXform[256];
    00456         bool mResetIdentityView;
    00457         bool mResetIdentityProj;
    00458
    00459         bool mNormaliseNormalsOnScale;
    00460         bool mFlipCullingOnNegativeScale;
    00461         CullingMode mPassCullingMode;
    00462
    00463     protected:
    00464
    00472         typedef map< const Camera*, VisibleObjectsBoundsInfo>::type CamVisibleObjectsMap;
    00473         CamVisibleObjectsMap mCamVisibleObjectsMap;
    00474
    00476         typedef map< const Camera*, const Light* >::type ShadowCamLightMapping;
    00477         ShadowCamLightMapping mShadowCamLightMapping;
    00478
    00480         size_t mShadowTextureCountPerType[3];
    00481
    00483         vector<size_t>::type mShadowTextureIndexLightList;
    00484
    00486         struct _OgreExport LightInfo
    00487         {
    00488             Light* light;       // Just a pointer for comparison, the light might destroyed for some reason
    00489             int type;           // Use int instead of Light::LightTypes to avoid header file dependence
    00490             Real range;         // Sets to zero if directional light
    00491             Vector3 position;   // Sets to zero if directional light
    00492             uint32 lightMask;   // Light mask
    00493
    00494             bool operator== (const LightInfo& rhs) const
    00495             {
    00496                 return light == rhs.light && type == rhs.type &&
    00497                     range == rhs.range && position == rhs.position && lightMask == rhs.lightMask;
    00498             }
    00499
    00500             bool operator!= (const LightInfo& rhs) const
    00501             {
    00502                 return !(*this == rhs);
    00503             }
    00504         };
    00505
    00506         typedef vector<LightInfo>::type LightInfoList;
    00507
    00508         LightList mLightsAffectingFrustum;
    00509         LightInfoList mCachedLightInfos;
    00510         LightInfoList mTestLightInfos; // potentially new list
    00511         ulong mLightsDirtyCounter;
    00512         LightList mShadowTextureCurrentCasterLightList;
    00513
    00514         typedef map<String, MovableObject*>::type MovableObjectMap;
    00516         struct MovableObjectCollection
    00517         {
    00518             MovableObjectMap map;
    00519             OGRE_MUTEX(mutex)
    00520         };
    00521         typedef map<String, MovableObjectCollection*>::type MovableObjectCollectionMap;
    00522         MovableObjectCollectionMap mMovableObjectCollectionMap;
    00523         NameGenerator mMovableNameGenerator;
    00528         MovableObjectCollection* getMovableObjectCollection(const String& typeName);
    00533         const MovableObjectCollection* getMovableObjectCollection(const String& typeName) const;
    00535         OGRE_MUTEX(mMovableObjectCollectionMapMutex)
    00536
    00537
    00541         virtual void initRenderQueue(void);
    00543         Pass* mShadowCasterPlainBlackPass;
    00545         Pass* mShadowReceiverPass;
    00555         virtual const Pass* deriveShadowCasterPass(const Pass* pass);
    00564         virtual const Pass* deriveShadowReceiverPass(const Pass* pass);
    00565
    00572         virtual bool validatePassForRendering(const Pass* pass);
    00573
    00580         virtual bool validateRenderableForRendering(const Pass* pass, const Renderable* rend);
    00581
    00582         enum BoxPlane
    00583         {
    00584             BP_FRONT = 0,
    00585             BP_BACK = 1,
    00586             BP_LEFT = 2,
    00587             BP_RIGHT = 3,
    00588             BP_UP = 4,
    00589             BP_DOWN = 5
    00590         };
    00591
    00592         /* Internal utility method for creating the planes of a skybox.
    00593         */
    00594         virtual MeshPtr createSkyboxPlane(
    00595             BoxPlane bp,
    00596             Real distance,
    00597             const Quaternion& orientation,
    00598             const String& groupName);
    00599
    00600         /* Internal utility method for creating the planes of a skydome.
    00601         */
    00602         virtual MeshPtr createSkydomePlane(
    00603             BoxPlane bp,
    00604             Real curvature, Real tiling, Real distance,
    00605             const Quaternion& orientation,
    00606             int xsegments, int ysegments, int ySegmentsToKeep,
    00607             const String& groupName);
    00608
    00609         // Flag indicating whether SceneNodes will be rendered as a set of 3 axes
    00610         bool mDisplayNodes;
    00611
    00613         typedef map<String, Animation*>::type AnimationList;
    00614         AnimationList mAnimationsList;
    00615         OGRE_MUTEX(mAnimationsListMutex)
    00616         AnimationStateSet mAnimationStates;
    00617
    00618
    00621         virtual void useRenderableViewProjMode(const Renderable* pRend, bool fixedFunction);
    00622
    00625         virtual void resetViewProjMode(bool fixedFunction);
    00626
    00627         typedef vector<RenderQueueListener*>::type RenderQueueListenerList;
    00628         RenderQueueListenerList mRenderQueueListeners;
    00629
    00630         typedef vector<RenderObjectListener*>::type RenderObjectListenerList;
    00631         RenderObjectListenerList mRenderObjectListeners;
    00632         typedef vector<Listener*>::type ListenerList;
    00633         ListenerList mListeners;
    00635         virtual void firePreRenderQueues();
    00637         virtual void firePostRenderQueues();
    00639         virtual bool fireRenderQueueStarted(uint8 id, const String& invocation);
    00641         virtual bool fireRenderQueueEnded(uint8 id, const String& invocation);
    00643         virtual void fireRenderSingleObject(Renderable* rend, const Pass* pass, const AutoParamDataSource* source,
    00644             const LightList* pLightList, bool suppressRenderStateChanges);
    00645
    00647         virtual void fireShadowTexturesUpdated(size_t numberOfShadowTextures);
    00649         virtual void fireShadowTexturesPreCaster(Light* light, Camera* camera, size_t iteration);
    00651         virtual void fireShadowTexturesPreReceiver(Light* light, Frustum* f);
    00653         virtual void firePreFindVisibleObjects(Viewport* v);
    00655         virtual void firePostFindVisibleObjects(Viewport* v);
    00657         virtual void fireSceneManagerDestroyed();
    00659         virtual void setViewport(Viewport *vp);
    00660
    00662         bool mShowBoundingBoxes;
    00663
    00665         virtual void renderVisibleObjectsDefaultSequence(void);
    00667         virtual void renderVisibleObjectsCustomSequence(RenderQueueInvocationSequence* s);
    00669         virtual void prepareRenderQueue(void);
    00670
    00671
    00687         virtual void renderSingleObject(Renderable* rend, const Pass* pass,
    00688             bool lightScissoringClipping, bool doLightIteration, const LightList* manualLightList = 0);
    00689
    00691         virtual AutoParamDataSource* createAutoParamDataSource(void) const
    00692         {
    00693             return OGRE_NEW AutoParamDataSource();
    00694         }
    00695
    00697         AutoParamDataSource* mAutoParamDataSource;
    00698
    00699         CompositorChain* mActiveCompositorChain;
    00700         bool mLateMaterialResolving;
    00701
    00702         ShadowTechnique mShadowTechnique;
    00703         bool mDebugShadows;
    00704         ColourValue mShadowColour;
    00705         Pass* mShadowDebugPass;
    00706         Pass* mShadowStencilPass;
    00707         Pass* mShadowModulativePass;
    00708         bool mShadowMaterialInitDone;
    00709         HardwareIndexBufferSharedPtr mShadowIndexBuffer;
    00710         size_t mShadowIndexBufferSize;
    00711         Rectangle2D* mFullScreenQuad;
    00712         Real mShadowDirLightExtrudeDist;
    00713         IlluminationRenderStage mIlluminationStage;
    00714         ShadowTextureConfigList mShadowTextureConfigList;
    00715         bool mShadowTextureConfigDirty;
    00716         ShadowTextureList mShadowTextures;
    00717         TexturePtr mNullShadowTexture;
    00718         typedef vector<Camera*>::type ShadowTextureCameraList;
    00719         ShadowTextureCameraList mShadowTextureCameras;
    00720         Texture* mCurrentShadowTexture;
    00721         bool mShadowUseInfiniteFarPlane;
    00722         bool mShadowCasterRenderBackFaces;
    00723         bool mShadowAdditiveLightClip;
    00725         struct LightClippingInfo
    00726         {
    00727             RealRect scissorRect;
    00728             PlaneList clipPlanes;
    00729             bool scissorValid;
    00730             unsigned long clipPlanesValid;
    00731             LightClippingInfo() : scissorValid(false), clipPlanesValid(false) {}
    00732
    00733         };
    00734         typedef map<Light*, LightClippingInfo>::type LightClippingInfoMap;
    00735         LightClippingInfoMap mLightClippingInfoMap;
    00736         unsigned long mLightClippingInfoMapFrameNumber;
    00737
    00739         ShadowCameraSetupPtr mDefaultShadowCameraSetup;
    00740
    00749         struct lightsForShadowTextureLess
    00750         {
    00751             _OgreExport bool operator()(const Light* l1, const Light* l2) const;
    00752         };
    00753
    00754
    00761         virtual void findLightsAffectingFrustum(const Camera* camera);
    00763         virtual void initShadowVolumeMaterials(void);
    00765         virtual void ensureShadowTexturesCreated();
    00767         virtual void destroyShadowTextures(void);
    00768
    00769     public:
    00773         virtual void prepareShadowTextures(Camera* cam, Viewport* vp, const LightList* lightList = 0);
    00774
    00775         //A render context, used to store internal data for pausing/resuming rendering
    00776         struct RenderContext
    00777         {
    00778             RenderQueue* renderQueue;
    00779             Viewport* viewport;
    00780             Camera* camera;
    00781             CompositorChain* activeChain;
    00782             RenderSystem::RenderSystemContext* rsContext;
    00783         };
    00784
    00788         virtual RenderContext* _pauseRendering();
    00792         virtual void _resumeRendering(RenderContext* context);
    00793
    00794     protected:
    00802         virtual void renderShadowVolumesToStencil(const Light* light, const Camera* cam,
    00803             bool calcScissor);
    00809         virtual void setShadowVolumeStencilState(bool secondpass, bool zfail, bool twosided);
    00811         void renderShadowVolumeObjects(ShadowCaster::ShadowRenderableListIterator iShadowRenderables,
    00812             Pass* pass, const LightList *manualLightList, unsigned long flags,
    00813             bool secondpass, bool zfail, bool twosided);
    00814         typedef vector<ShadowCaster*>::type ShadowCasterList;
    00815         ShadowCasterList mShadowCasterList;
    00816         SphereSceneQuery* mShadowCasterSphereQuery;
    00817         AxisAlignedBoxSceneQuery* mShadowCasterAABBQuery;
    00818         Real mDefaultShadowFarDist;
    00819         Real mDefaultShadowFarDistSquared;
    00820         Real mShadowTextureOffset; // proportion of texture offset in view direction e.g. 0.4
    00821         Real mShadowTextureFadeStart; // as a proportion e.g. 0.6
    00822         Real mShadowTextureFadeEnd; // as a proportion e.g. 0.9
    00823         bool mShadowTextureSelfShadow;
    00824         Pass* mShadowTextureCustomCasterPass;
    00825         Pass* mShadowTextureCustomReceiverPass;
    00826         String mShadowTextureCustomCasterVertexProgram;
    00827         String mShadowTextureCustomReceiverVertexProgram;
    00828         String mShadowTextureCustomReceiverFragmentProgram;
    00829         GpuProgramParametersSharedPtr mShadowTextureCustomCasterVPParams;
    00830         GpuProgramParametersSharedPtr mShadowTextureCustomReceiverVPParams;
    00831         GpuProgramParametersSharedPtr mShadowTextureCustomReceiverFPParams;
    00832
    00834         uint32 mVisibilityMask;
    00835         bool mFindVisibleObjects;
    00836
    00838         bool mSuppressRenderStateChanges;
    00840         bool mSuppressShadows;
    00841
    00842
    00843         GpuProgramParametersSharedPtr mInfiniteExtrusionParams;
    00844         GpuProgramParametersSharedPtr mFiniteExtrusionParams;
    00845
    00847         class _OgreExport ShadowCasterSceneQueryListener : public SceneQueryListener, public SceneMgtAlloc
    00848         {
    00849         protected:
    00850             SceneManager* mSceneMgr;
    00851             ShadowCasterList* mCasterList;
    00852             bool mIsLightInFrustum;
    00853             const PlaneBoundedVolumeList* mLightClipVolumeList;
    00854             const Camera* mCamera;
    00855             const Light* mLight;
    00856             Real mFarDistSquared;
    00857         public:
    00858             ShadowCasterSceneQueryListener(SceneManager* sm) : mSceneMgr(sm),
    00859                 mCasterList(0), mIsLightInFrustum(false), mLightClipVolumeList(0),
    00860                 mCamera(0) {}
    00861             // Prepare the listener for use with a set of parameters
    00862             void prepare(bool lightInFrustum,
    00863                 const PlaneBoundedVolumeList* lightClipVolumes,
    00864                 const Light* light, const Camera* cam, ShadowCasterList* casterList,
    00865                 Real farDistSquared)
    00866             {
    00867                 mCasterList = casterList;
    00868                 mIsLightInFrustum = lightInFrustum;
    00869                 mLightClipVolumeList = lightClipVolumes;
    00870                 mCamera = cam;
    00871                 mLight = light;
    00872                 mFarDistSquared = farDistSquared;
    00873             }
    00874             bool queryResult(MovableObject* object);
    00875             bool queryResult(SceneQuery::WorldFragment* fragment);
    00876         };
    00877
    00878         ShadowCasterSceneQueryListener* mShadowCasterQueryListener;
    00879
    00886         virtual const ShadowCasterList& findShadowCastersForLight(const Light* light,
    00887             const Camera* camera);
    00889         virtual void renderBasicQueueGroupObjects(RenderQueueGroup* pGroup,
    00890             QueuedRenderableCollection::OrganisationMode om);
    00892         virtual void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* group,
    00893             QueuedRenderableCollection::OrganisationMode om);
    00895         virtual void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* group,
    00896             QueuedRenderableCollection::OrganisationMode om);
    00898         virtual void renderTextureShadowCasterQueueGroupObjects(RenderQueueGroup* group,
    00899             QueuedRenderableCollection::OrganisationMode om);
    00901         virtual void renderTextureShadowReceiverQueueGroupObjects(RenderQueueGroup* group,
    00902             QueuedRenderableCollection::OrganisationMode om);
    00904         virtual void renderModulativeTextureShadowedQueueGroupObjects(RenderQueueGroup* group,
    00905             QueuedRenderableCollection::OrganisationMode om);
    00906
    00908         virtual void renderAdditiveTextureShadowedQueueGroupObjects(RenderQueueGroup* group,
    00909             QueuedRenderableCollection::OrganisationMode om);
    00911         virtual void renderObjects(const QueuedRenderableCollection& objs,
    00912             QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping,
    00913             bool doLightIteration, const LightList* manualLightList = 0);
    00919         virtual void renderTransparentShadowCasterObjects(const QueuedRenderableCollection& objs,
    00920             QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping,
    00921             bool doLightIteration, const LightList* manualLightList = 0);
    00922
    00925         virtual void updateRenderQueueSplitOptions(void);
    00928         virtual void updateRenderQueueGroupSplitOptions(RenderQueueGroup* group,
    00929             bool suppressShadows, bool suppressRenderState);
    00930
    00932         virtual ClipResult buildAndSetScissor(const LightList& ll, const Camera* cam);
    00934         virtual void buildScissor(const Light* l, const Camera* cam, RealRect& rect);
    00935         virtual void resetScissor();
    00937         virtual ClipResult buildAndSetLightClip(const LightList& ll);
    00938         virtual void buildLightClip(const Light* l, PlaneList& planes);
    00939         virtual void resetLightClip();
    00940         virtual void checkCachedLightClippingInfo();
    00941
    00943         SceneMgrQueuedRenderableVisitor* mActiveQueuedRenderableVisitor;
    00945         SceneMgrQueuedRenderableVisitor mDefaultQueuedRenderableVisitor;
    00946
    00948         bool mCameraRelativeRendering;
    00949         Matrix4 mCachedViewMatrix;
    00950         Vector3 mCameraRelativePosition;
    00951
    00953         uint32 mLastLightHash;
    00954         unsigned short mLastLightLimit;
    00955         uint32 mLastLightHashGpuProgram;
    00957         uint16 mGpuParamsDirty;
    00958
    00959         virtual void useLights(const LightList& lights, unsigned short limit);
    00960         virtual void setViewMatrix(const Matrix4& m);
    00961         virtual void useLightsGpuProgram(const Pass* pass, const LightList* lights);
    00962         virtual void bindGpuProgram(GpuProgram* prog);
    00963         virtual void updateGpuProgramParameters(const Pass* p);
    00964
    00965
    00966
    00967
    00968
    00969
    00970
    00971
    00973         typedef set<LodListener*>::type LodListenerSet;
    00974         LodListenerSet mLodListeners;
    00975
    00977         typedef vector<MovableObjectLodChangedEvent>::type MovableObjectLodChangedEventList;
    00978         MovableObjectLodChangedEventList mMovableObjectLodChangedEvents;
    00979
    00981         typedef vector<EntityMeshLodChangedEvent>::type EntityMeshLodChangedEventList;
    00982         EntityMeshLodChangedEventList mEntityMeshLodChangedEvents;
    00983
    00985         typedef vector<EntityMaterialLodChangedEvent>::type EntityMaterialLodChangedEventList;
    00986         EntityMaterialLodChangedEventList mEntityMaterialLodChangedEvents;
    00987
    00988     public:
    00991         SceneManager(const String& instanceName);
    00992
    00995         virtual ~SceneManager();
    00996
    00997
    01023         OGRE_MUTEX(sceneGraphMutex)
    01024
    01025
    01026         const String& getName(void) const { return mName; }
    01027
    01034         virtual const String& getTypeName(void) const = 0;
    01035
    01043         virtual Camera* createCamera(const String& name);
    01044
    01048         virtual Camera* getCamera(const String& name) const;
    01049
    01052         virtual bool hasCamera(const String& name) const;
    01053
    01062         virtual void destroyCamera(Camera *cam);
    01063
    01069         virtual void destroyCamera(const String& name);
    01070
    01079         virtual void destroyAllCameras(void);
    01080
    01091         virtual Light* createLight(const String& name);
    01092
    01094         virtual Light* createLight();
    01095
    01099         virtual Light* getLight(const String& name) const;
    01100
    01103         virtual bool hasLight(const String& name) const;
    01104
    01107         virtual const PlaneList& getLightClippingPlanes(Light* l);
    01108
    01111         virtual const RealRect& getLightScissorRect(Light* l, const Camera* cam);
    01112
    01117         virtual void destroyLight(const String& name);
    01118
    01123         virtual void destroyLight(Light* light);
    01126         virtual void destroyAllLights(void);
    01127
    01138         virtual void _notifyLightsDirty(void);
    01139
    01152         ulong _getLightsDirtyCounter(void) const { return mLightsDirtyCounter; }
    01153
    01160         virtual const LightList& _getLightsAffectingFrustum(void) const;
    01161
    01184         virtual void _populateLightList(const Vector3& position, Real radius, LightList& destList, uint32 lightMask = 0xFFFFFFFF);
    01185
    01214         virtual void _populateLightList(const SceneNode* sn, Real radius, LightList& destList, uint32 lightMask = 0xFFFFFFFF);
    01215
    01232         virtual SceneNode* createSceneNode(void);
    01233
    01248         virtual SceneNode* createSceneNode(const String& name);
    01249
    01256         virtual void destroySceneNode(const String& name);
    01257
    01264         virtual void destroySceneNode(SceneNode* sn);
    01280         virtual SceneNode* getRootSceneNode(void);
    01281
    01289         virtual SceneNode* getSceneNode(const String& name) const;
    01290
    01293         virtual bool hasSceneNode(const String& name) const;
    01294
    01295
    01303         virtual Entity* createEntity(const String& entityName, const String& meshName, const String& groupName = ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME );
    01304
    01310         virtual Entity* createEntity(const String& meshName);
    01317         enum PrefabType {
    01318             PT_PLANE,
    01319             PT_CUBE,
    01320             PT_SPHERE
    01321         };
    01322
    01329         virtual Entity* createEntity(const String& entityName, PrefabType ptype);
    01330
    01334         virtual Entity* createEntity(PrefabType ptype);
    01338         virtual Entity* getEntity(const String& name) const;
    01341         virtual bool hasEntity(const String& name) const;
    01342
    01351         virtual void destroyEntity(Entity* ent);
    01352
    01361         virtual void destroyEntity(const String& name);
    01362
    01372         virtual void destroyAllEntities(void);
    01373
    01379         virtual ManualObject* createManualObject(const String& name);
    01383         virtual ManualObject* createManualObject();
    01387         virtual ManualObject* getManualObject(const String& name) const;
    01390         virtual bool hasManualObject(const String& name) const;
    01391
    01394         virtual void destroyManualObject(ManualObject* obj);
    01397         virtual void destroyManualObject(const String& name);
    01400         virtual void destroyAllManualObjects(void);
    01406         virtual BillboardChain* createBillboardChain(const String& name);
    01410         virtual BillboardChain* createBillboardChain();
    01414         virtual BillboardChain* getBillboardChain(const String& name) const;
    01417         virtual bool hasBillboardChain(const String& name) const;
    01418
    01421         virtual void destroyBillboardChain(BillboardChain* obj);
    01424         virtual void destroyBillboardChain(const String& name);
    01427         virtual void destroyAllBillboardChains(void);
    01433         virtual RibbonTrail* createRibbonTrail(const String& name);
    01437         virtual RibbonTrail* createRibbonTrail();
    01441         virtual RibbonTrail* getRibbonTrail(const String& name) const;
    01444         virtual bool hasRibbonTrail(const String& name) const;
    01445
    01448         virtual void destroyRibbonTrail(RibbonTrail* obj);
    01451         virtual void destroyRibbonTrail(const String& name);
    01454         virtual void destroyAllRibbonTrails(void);
    01455
    01476         virtual ParticleSystem* createParticleSystem(const String& name,
    01477             const String& templateName);
    01497         virtual ParticleSystem* createParticleSystem(const String& name,
    01498             size_t quota = 500,
    01499             const String& resourceGroup = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
    01500
    01518         virtual ParticleSystem* createParticleSystem(size_t quota = 500,
    01519             const String& resourceGroup = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
    01523         virtual ParticleSystem* getParticleSystem(const String& name) const;
    01526         virtual bool hasParticleSystem(const String& name) const;
    01527
    01530         virtual void destroyParticleSystem(ParticleSystem* obj);
    01533         virtual void destroyParticleSystem(const String& name);
    01536         virtual void destroyAllParticleSystems(void);
    01537
    01543         virtual void clearScene(void);
    01544
    01557         void setAmbientLight(const ColourValue& colour);
    01558
    01561         const ColourValue& getAmbientLight(void) const;
    01562
    01578         virtual void prepareWorldGeometry(const String& filename);
    01579
    01597         virtual void prepareWorldGeometry(DataStreamPtr& stream,
    01598             const String& typeName = StringUtil::BLANK);
    01599
    01612         virtual void setWorldGeometry(const String& filename);
    01613
    01629         virtual void setWorldGeometry(DataStreamPtr& stream,
    01630             const String& typeName = StringUtil::BLANK);
    01631
    01644         virtual size_t estimateWorldGeometry(const String& filename)
    01645         { (void)filename; return 0; }
    01646
    01659         virtual size_t estimateWorldGeometry(DataStreamPtr& stream,
    01660             const String& typeName = StringUtil::BLANK)
    01661         { (void)stream; (void)typeName; return 0; }
    01662
    01677         virtual ViewPoint getSuggestedViewpoint(bool random = false);
    01678
    01692         virtual bool setOption( const String& strKey, const void* pValue )
    01693         { (void)strKey; (void)pValue; return false; }
    01694
    01708         virtual bool getOption( const String& strKey, void* pDestValue )
    01709         { (void)strKey; (void)pDestValue; return false; }
    01710
    01720         virtual bool hasOption( const String& strKey ) const
    01721         { (void)strKey; return false; }
    01722
    01737         virtual bool getOptionValues( const String& strKey, StringVector& refValueList )
    01738         { (void)strKey; (void)refValueList; return false; }
    01739
    01746         virtual bool getOptionKeys( StringVector& refKeys )
    01747         { (void)refKeys; return false; }
    01748
    01757         virtual void _updateSceneGraph(Camera* cam);
    01758
    01770         virtual void _findVisibleObjects(Camera* cam, VisibleObjectsBoundsInfo* visibleBounds, bool onlyShadowCasters);
    01771
    01776         virtual void _applySceneAnimations(void);
    01777
    01780         virtual void _renderVisibleObjects(void);
    01781
    01795         virtual void _renderScene(Camera* camera, Viewport* vp, bool includeOverlays);
    01796
    01800         virtual void _queueSkiesForRendering(Camera* cam);
    01801
    01802
    01803
    01812         virtual void _setDestinationRenderSystem(RenderSystem* sys);
    01813
    01867         virtual void setSkyPlane(
    01868             bool enable,
    01869             const Plane& plane, const String& materialName, Real scale = 1000,
    01870             Real tiling = 10, bool drawFirst = true, Real bow = 0,
    01871             int xsegments = 1, int ysegments = 1,
    01872             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
    01916         virtual void _setSkyPlane(
    01917             bool enable,
    01918             const Plane& plane, const String& materialName, Real scale = 1000,
    01919             Real tiling = 10, uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, Real bow = 0,
    01920             int xsegments = 1, int ysegments = 1,
    01921             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
    01922
    01924         virtual bool isSkyPlaneEnabled(void) const { return mSkyPlaneEnabled; }
    01925
    01927         virtual SceneNode* getSkyPlaneNode(void) const { return mSkyPlaneNode; }
    01928
    01930         virtual const SkyPlaneGenParameters& getSkyPlaneGenParameters(void) const { return mSkyPlaneGenParameters; }
    01931
    01973         virtual void setSkyBox(
    01974             bool enable, const String& materialName, Real distance = 5000,
    01975             bool drawFirst = true, const Quaternion& orientation = Quaternion::IDENTITY,
    01976             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
    01977
    02010         virtual void _setSkyBox(
    02011             bool enable, const String& materialName, Real distance = 5000,
    02012             uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, const Quaternion& orientation = Quaternion::IDENTITY,
    02013             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
    02014
    02016         virtual bool isSkyBoxEnabled(void) const { return mSkyBoxEnabled; }
    02017
    02019         virtual SceneNode* getSkyBoxNode(void) const { return mSkyBoxNode; }
    02020
    02022         virtual const SkyBoxGenParameters& getSkyBoxGenParameters(void) const { return mSkyBoxGenParameters; }
    02023
    02079         virtual void setSkyDome(
    02080             bool enable, const String& materialName, Real curvature = 10,
    02081             Real tiling = 8, Real distance = 4000, bool drawFirst = true,
    02082             const Quaternion& orientation = Quaternion::IDENTITY,
    02083             int xsegments = 16, int ysegments = 16, int ysegments_keep = -1,
    02084             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
    02085
    02132         virtual void _setSkyDome(
    02133             bool enable, const String& materialName, Real curvature = 10,
    02134             Real tiling = 8, Real distance = 4000, uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY,
    02135             const Quaternion& orientation = Quaternion::IDENTITY,
    02136             int xsegments = 16, int ysegments = 16, int ysegments_keep = -1,
    02137             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
    02138
    02140         virtual bool isSkyDomeEnabled(void) const { return mSkyDomeEnabled; }
    02141
    02143         virtual SceneNode* getSkyDomeNode(void) const { return mSkyDomeNode; }
    02144
    02146         virtual const SkyDomeGenParameters& getSkyDomeGenParameters(void) const { return mSkyDomeGenParameters; }
    02147
    02172         void setFog(
    02173             FogMode mode = FOG_NONE, const ColourValue& colour = ColourValue::White,
    02174             Real expDensity = 0.001, Real linearStart = 0.0, Real linearEnd = 1.0);
    02175
    02178         virtual FogMode getFogMode(void) const;
    02179
    02182         virtual const ColourValue& getFogColour(void) const;
    02183
    02186         virtual Real getFogStart(void) const;
    02187
    02190         virtual Real getFogEnd(void) const;
    02191
    02194         virtual Real getFogDensity(void) const;
    02195
    02196
    02214         virtual BillboardSet* createBillboardSet(const String& name, unsigned int poolSize = 20);
    02215
    02222         virtual BillboardSet* createBillboardSet(unsigned int poolSize = 20);
    02226         virtual BillboardSet* getBillboardSet(const String& name) const;
    02229         virtual bool hasBillboardSet(const String& name) const;
    02230
    02237         virtual void destroyBillboardSet(BillboardSet* set);
    02238
    02245         virtual void destroyBillboardSet(const String& name);
    02246
    02256         virtual void destroyAllBillboardSets(void);
    02257
    02265         virtual void setDisplaySceneNodes(bool display);
    02267         virtual bool getDisplaySceneNodes(void) const {return mDisplayNodes;}
    02268
    02289         virtual Animation* createAnimation(const String& name, Real length);
    02290
    02294         virtual Animation* getAnimation(const String& name) const;
    02297         virtual bool hasAnimation(const String& name) const;
    02298
    02304         virtual void destroyAnimation(const String& name);
    02305
    02307         virtual void destroyAllAnimations(void);
    02308
    02336         virtual AnimationState* createAnimationState(const String& animName);
    02337
    02341         virtual AnimationState* getAnimationState(const String& animName) const;
    02344         virtual bool hasAnimationState(const String& name) const;
    02345
    02351         virtual void destroyAnimationState(const String& name);
    02352
    02354         virtual void destroyAllAnimationStates(void);
    02355
    02379         virtual void manualRender(RenderOperation* rend, Pass* pass, Viewport* vp,
    02380             const Matrix4& worldMatrix, const Matrix4& viewMatrix, const Matrix4& projMatrix,
    02381             bool doBeginEndFrame = false) ;
    02382
    02403         virtual void manualRender(Renderable* rend, const Pass* pass, Viewport* vp,
    02404             const Matrix4& viewMatrix, const Matrix4& projMatrix, bool doBeginEndFrame = false, bool lightScissoringClipping = true,
    02405             bool doLightIteration = true, const LightList* manualLightList = 0);
    02406
    02417         virtual RenderQueue* getRenderQueue(void);
    02418
    02422         virtual void addRenderQueueListener(RenderQueueListener* newListener);
    02423
    02425         virtual void removeRenderQueueListener(RenderQueueListener* delListener);
    02426
    02429         virtual void addRenderObjectListener(RenderObjectListener* newListener);
    02431         virtual void removeRenderObjectListener(RenderObjectListener* delListener);
    02432
    02446         virtual void addSpecialCaseRenderQueue(uint8 qid);
    02452         virtual void removeSpecialCaseRenderQueue(uint8 qid);
    02456         virtual void clearSpecialCaseRenderQueues(void);
    02461         virtual void setSpecialCaseRenderQueueMode(SpecialCaseRenderQueueMode mode);
    02463         virtual SpecialCaseRenderQueueMode getSpecialCaseRenderQueueMode(void);
    02470         virtual bool isRenderQueueToBeProcessed(uint8 qid);
    02471
    02487         virtual void setWorldGeometryRenderQueue(uint8 qid);
    02498         virtual uint8 getWorldGeometryRenderQueue(void);
    02499
    02501         virtual void showBoundingBoxes(bool bShow);
    02502
    02504         virtual bool getShowBoundingBoxes() const;
    02505
    02507         virtual void _notifyAutotrackingSceneNode(SceneNode* node, bool autoTrack);
    02508
    02509
    02522         virtual AxisAlignedBoxSceneQuery*
    02523             createAABBQuery(const AxisAlignedBox& box, unsigned long mask = 0xFFFFFFFF);
    02536         virtual SphereSceneQuery*
    02537             createSphereQuery(const Sphere& sphere, unsigned long mask = 0xFFFFFFFF);
    02550         virtual PlaneBoundedVolumeListSceneQuery*
    02551             createPlaneBoundedVolumeQuery(const PlaneBoundedVolumeList& volumes, unsigned long mask = 0xFFFFFFFF);
    02552
    02553
    02566         virtual RaySceneQuery*
    02567             createRayQuery(const Ray& ray, unsigned long mask = 0xFFFFFFFF);
    02568         //PyramidSceneQuery* createPyramidQuery(const Pyramid& p, unsigned long mask = 0xFFFFFFFF);
    02580         virtual IntersectionSceneQuery*
    02581             createIntersectionQuery(unsigned long mask = 0xFFFFFFFF);
    02582
    02584         virtual void destroyQuery(SceneQuery* query);
    02585
    02586         typedef MapIterator<CameraList> CameraIterator;
    02587         typedef MapIterator<AnimationList> AnimationIterator;
    02588
    02591         CameraIterator getCameraIterator(void) {
    02592             return CameraIterator(mCameras.begin(), mCameras.end());
    02593         }
    02596         const CameraList& getCameras() const { return mCameras; }
    02598         AnimationIterator getAnimationIterator(void) {
    02599             return AnimationIterator(mAnimationsList.begin(), mAnimationsList.end());
    02600         }
    02603         const AnimationList& getAnimations() const { return mAnimationsList; }
    02605         AnimationStateIterator getAnimationStateIterator(void) {
    02606             return mAnimationStates.getAnimationStateIterator();
    02607         }
    02608
    02641         virtual void setShadowTechnique(ShadowTechnique technique);
    02642
    02644         virtual ShadowTechnique getShadowTechnique(void) const { return mShadowTechnique; }
    02645
    02647         virtual void setShowDebugShadows(bool debug) { mDebugShadows = debug; }
    02649         virtual bool getShowDebugShadows(void ) const { return mDebugShadows; }
    02650
    02657         virtual void setShadowColour(const ColourValue& colour);
    02664         virtual const ColourValue& getShadowColour(void) const;
    02676         virtual void setShadowDirectionalLightExtrusionDistance(Real dist);
    02679         virtual Real getShadowDirectionalLightExtrusionDistance(void) const;
    02696         virtual void setShadowFarDistance(Real distance);
    02700         virtual Real getShadowFarDistance(void) const
    02701         { return mDefaultShadowFarDist; }
    02702         virtual Real getShadowFarDistanceSquared(void) const
    02703         { return mDefaultShadowFarDistSquared; }
    02704
    02730         virtual void setShadowIndexBufferSize(size_t size);
    02732         virtual size_t getShadowIndexBufferSize(void) const
    02733         { return mShadowIndexBufferSize; }
    02742         virtual void setShadowTextureSize(unsigned short size);
    02743
    02750         virtual void setShadowTextureConfig(size_t shadowIndex, unsigned short width,
    02751             unsigned short height, PixelFormat format);
    02757         virtual void setShadowTextureConfig(size_t shadowIndex,
    02758             const ShadowTextureConfig& config);
    02759
    02761         ConstShadowTextureConfigIterator getShadowTextureConfigIterator() const;
    02762
    02774         virtual void setShadowTexturePixelFormat(PixelFormat fmt);
    02782         virtual void setShadowTextureCount(size_t count);
    02784         size_t getShadowTextureCount(void) const {return mShadowTextureConfigList.size(); }
    02785
    02795         void setShadowTextureCountPerLightType(Light::LightTypes type, size_t count)
    02796         { mShadowTextureCountPerType[type] = count; }
    02798         size_t getShadowTextureCountPerLightType(Light::LightTypes type) const
    02799         {return mShadowTextureCountPerType[type]; }
    02800
    02809         virtual void setShadowTextureSettings(unsigned short size, unsigned short count,
    02810             PixelFormat fmt = PF_X8R8G8B8);
    02811
    02818         virtual const TexturePtr& getShadowTexture(size_t shadowIndex);
    02819
    02834         virtual void setShadowDirLightTextureOffset(Real offset) { mShadowTextureOffset = offset;}
    02838         virtual Real getShadowDirLightTextureOffset(void)  const { return mShadowTextureOffset; }
    02846         virtual void setShadowTextureFadeStart(Real fadeStart)
    02847         { mShadowTextureFadeStart = fadeStart; }
    02855         virtual void setShadowTextureFadeEnd(Real fadeEnd)
    02856         { mShadowTextureFadeEnd = fadeEnd; }
    02857
    02870         virtual void setShadowTextureSelfShadow(bool selfShadow);
    02871
    02873         virtual bool getShadowTextureSelfShadow(void) const
    02874         { return mShadowTextureSelfShadow; }
    02895         virtual void setShadowTextureCasterMaterial(const String& name);
    02917         virtual void setShadowTextureReceiverMaterial(const String& name);
    02918
    02929         virtual void setShadowCasterRenderBackFaces(bool bf) { mShadowCasterRenderBackFaces = bf; }
    02930
    02934         virtual bool getShadowCasterRenderBackFaces() const { return mShadowCasterRenderBackFaces; }
    02935
    02940         virtual void setShadowCameraSetup(const ShadowCameraSetupPtr& shadowSetup);
    02941
    02946         virtual const ShadowCameraSetupPtr& getShadowCameraSetup() const;
    02947
    02984         virtual void setShadowUseInfiniteFarPlane(bool enable) {
    02985             mShadowUseInfiniteFarPlane = enable; }
    02986
    02988         virtual bool isShadowTechniqueStencilBased(void) const
    02989         { return (mShadowTechnique & SHADOWDETAILTYPE_STENCIL) != 0; }
    02991         virtual bool isShadowTechniqueTextureBased(void) const
    02992         { return (mShadowTechnique & SHADOWDETAILTYPE_TEXTURE) != 0; }
    02994         virtual bool isShadowTechniqueModulative(void) const
    02995         { return (mShadowTechnique & SHADOWDETAILTYPE_MODULATIVE) != 0; }
    02997         virtual bool isShadowTechniqueAdditive(void) const
    02998         { return (mShadowTechnique & SHADOWDETAILTYPE_ADDITIVE) != 0; }
    03000         virtual bool isShadowTechniqueIntegrated(void) const
    03001         { return (mShadowTechnique & SHADOWDETAILTYPE_INTEGRATED) != 0; }
    03003         virtual bool isShadowTechniqueInUse(void) const
    03004         { return mShadowTechnique != SHADOWTYPE_NONE; }
    03008         virtual void setShadowUseLightClipPlanes(bool enabled) { mShadowAdditiveLightClip = enabled; }
    03012         virtual bool getShadowUseLightClipPlanes() const { return mShadowAdditiveLightClip; }
    03013
    03017         virtual void _setActiveCompositorChain(CompositorChain* chain) { mActiveCompositorChain = chain; }
    03018
    03024         virtual void setLateMaterialResolving(bool isLate) { mLateMaterialResolving = isLate; }
    03025
    03028         virtual bool isLateMaterialResolving() const { return mLateMaterialResolving; }
    03029
    03031         virtual CompositorChain* _getActiveCompositorChain() const { return mActiveCompositorChain; }
    03032
    03035         virtual void addListener(Listener* s);
    03038         virtual void removeListener(Listener* s);
    03039
    03049         virtual StaticGeometry* createStaticGeometry(const String& name);
    03053         virtual StaticGeometry* getStaticGeometry(const String& name) const;
    03055         virtual bool hasStaticGeometry(const String& name) const;
    03057         virtual void destroyStaticGeometry(StaticGeometry* geom);
    03059         virtual void destroyStaticGeometry(const String& name);
    03061         virtual void destroyAllStaticGeometry(void);
    03062
    03072         virtual InstancedGeometry* createInstancedGeometry(const String& name);
    03074         virtual InstancedGeometry* getInstancedGeometry(const String& name) const;
    03076         virtual void destroyInstancedGeometry(InstancedGeometry* geom);
    03078         virtual void destroyInstancedGeometry(const String& name);
    03080         virtual void destroyAllInstancedGeometry(void);
    03081
    03082
    03093         virtual MovableObject* createMovableObject(const String& name,
    03094             const String& typeName, const NameValuePairList* params = 0);
    03104         virtual MovableObject* createMovableObject(const String& typeName, const NameValuePairList* params = 0);
    03110         virtual void destroyMovableObject(const String& name, const String& typeName);
    03116         virtual void destroyMovableObject(MovableObject* m);
    03118         virtual void destroyAllMovableObjectsByType(const String& typeName);
    03120         virtual void destroyAllMovableObjects(void);
    03124         virtual MovableObject* getMovableObject(const String& name, const String& typeName) const;
    03126         virtual bool hasMovableObject(const String& name, const String& typeName) const;
    03127         typedef MapIterator<MovableObjectMap> MovableObjectIterator;
    03133         virtual MovableObjectIterator getMovableObjectIterator(const String& typeName);
    03145         virtual void injectMovableObject(MovableObject* m);
    03152         virtual void extractMovableObject(const String& name, const String& typeName);
    03159         virtual void extractMovableObject(MovableObject* m);
    03166         virtual void extractAllMovableObjectsByType(const String& typeName);
    03167
    03174         virtual void setVisibilityMask(uint32 vmask) { mVisibilityMask = vmask; }
    03175
    03179         virtual uint32 getVisibilityMask(void) { return mVisibilityMask; }
    03180
    03184         uint32 _getCombinedVisibilityMask(void) const;
    03185
    03192         virtual void setFindVisibleObjects(bool find) { mFindVisibleObjects = find; }
    03193
    03197         virtual bool getFindVisibleObjects(void) { return mFindVisibleObjects; }
    03198
    03207         virtual void setNormaliseNormalsOnScale(bool n) { mNormaliseNormalsOnScale = n; }
    03208
    03212         virtual bool getNormaliseNormalsOnScale() const { return mNormaliseNormalsOnScale; }
    03213
    03222         virtual void setFlipCullingOnNegativeScale(bool n) { mFlipCullingOnNegativeScale = n; }
    03223
    03227         virtual bool getFlipCullingOnNegativeScale() const { return mFlipCullingOnNegativeScale; }
    03228
    03234         virtual void _injectRenderWithPass(Pass *pass, Renderable *rend, bool shadowDerivation = true,
    03235             bool doLightIteration = false, const LightList* manualLightList = 0);
    03236
    03255         virtual void _suppressRenderStateChanges(bool suppress);
    03256
    03260         virtual bool _areRenderStateChangesSuppressed(void) const
    03261         { return mSuppressRenderStateChanges; }
    03262
    03275         virtual const Pass* _setPass(const Pass* pass,
    03276             bool evenIfSuppressed = false, bool shadowDerivation = true);
    03277
    03278
    03288         virtual void _suppressShadows(bool suppress);
    03289
    03293         virtual bool _areShadowsSuppressed(void) const
    03294         { return mSuppressShadows; }
    03295
    03299         virtual void _renderQueueGroupObjects(RenderQueueGroup* group,
    03300             QueuedRenderableCollection::OrganisationMode om);
    03301
    03317         void setQueuedRenderableVisitor(SceneMgrQueuedRenderableVisitor* visitor);
    03318
    03320         SceneMgrQueuedRenderableVisitor* getQueuedRenderableVisitor(void) const;
    03321
    03322
    03326         RenderSystem *getDestinationRenderSystem();
    03327
    03330         Viewport* getCurrentViewport(void) const { return mCurrentViewport; }
    03331
    03333         const VisibleObjectsBoundsInfo& getVisibleObjectsBoundsInfo(const Camera* cam) const;
    03334
    03336         const VisibleObjectsBoundsInfo& getShadowCasterBoundsInfo(const Light* light, size_t iteration = 0) const;
    03337
    03352         virtual void setCameraRelativeRendering(bool rel) { mCameraRelativeRendering = rel; }
    03353
    03357         virtual bool getCameraRelativeRendering() const { return mCameraRelativeRendering; }
    03358
    03359
    03361         void addLodListener(LodListener *listener);
    03362
    03368         void removeLodListener(LodListener *listener);
    03369
    03371         void _notifyMovableObjectLodChanged(MovableObjectLodChangedEvent& evt);
    03372
    03374         void _notifyEntityMeshLodChanged(EntityMeshLodChangedEvent& evt);
    03375
    03377         void _notifyEntityMaterialLodChanged(EntityMaterialLodChangedEvent& evt);
    03378
    03380         void _handleLodEvents();
    03381     };
    03382
    03384     class _OgreExport DefaultIntersectionSceneQuery :
    03385         public IntersectionSceneQuery
    03386     {
    03387     public:
    03388         DefaultIntersectionSceneQuery(SceneManager* creator);
    03389         ~DefaultIntersectionSceneQuery();
    03390
    03392         void execute(IntersectionSceneQueryListener* listener);
    03393     };
    03394
    03396     class _OgreExport DefaultRaySceneQuery : public RaySceneQuery
    03397     {
    03398     public:
    03399         DefaultRaySceneQuery(SceneManager* creator);
    03400         ~DefaultRaySceneQuery();
    03401
    03403         void execute(RaySceneQueryListener* listener);
    03404     };
    03406     class _OgreExport DefaultSphereSceneQuery : public SphereSceneQuery
    03407     {
    03408     public:
    03409         DefaultSphereSceneQuery(SceneManager* creator);
    03410         ~DefaultSphereSceneQuery();
    03411
    03413         void execute(SceneQueryListener* listener);
    03414     };
    03416     class _OgreExport DefaultPlaneBoundedVolumeListSceneQuery : public PlaneBoundedVolumeListSceneQuery
    03417     {
    03418     public:
    03419         DefaultPlaneBoundedVolumeListSceneQuery(SceneManager* creator);
    03420         ~DefaultPlaneBoundedVolumeListSceneQuery();
    03421
    03423         void execute(SceneQueryListener* listener);
    03424     };
    03426     class _OgreExport DefaultAxisAlignedBoxSceneQuery : public AxisAlignedBoxSceneQuery
    03427     {
    03428     public:
    03429         DefaultAxisAlignedBoxSceneQuery(SceneManager* creator);
    03430         ~DefaultAxisAlignedBoxSceneQuery();
    03431
    03433         void execute(SceneQueryListener* listener);
    03434     };
    03435
    03436
    03438     typedef uint16 SceneTypeMask;
    03439
    03443     enum SceneType
    03444     {
    03445         ST_GENERIC = 1,
    03446         ST_EXTERIOR_CLOSE = 2,
    03447         ST_EXTERIOR_FAR = 4,
    03448         ST_EXTERIOR_REAL_FAR = 8,
    03449         ST_INTERIOR = 16
    03450     };
    03451
    03453     struct SceneManagerMetaData
    03454     {
    03456         String typeName;
    03458         String description;
    03460         SceneTypeMask sceneTypeMask;
    03462         bool worldGeometrySupported;
    03463     };
    03464
    03465
    03466
    03468     class _OgreExport SceneManagerFactory : public SceneMgtAlloc
    03469     {
    03470     protected:
    03471         mutable SceneManagerMetaData mMetaData;
    03472         mutable bool mMetaDataInit;
    03474         virtual void initMetaData(void) const = 0;
    03475     public:
    03476         SceneManagerFactory() : mMetaDataInit(true) {}
    03477         virtual ~SceneManagerFactory() {}
    03479         virtual const SceneManagerMetaData& getMetaData(void) const
    03480         {
    03481             if (mMetaDataInit)
    03482             {
    03483                 initMetaData();
    03484                 mMetaDataInit = false;
    03485             }
    03486             return mMetaData;
    03487         }
    03492         virtual SceneManager* createInstance(const String& instanceName) = 0;
    03494         virtual void destroyInstance(SceneManager* instance) = 0;
    03495
    03496     };
    03497
    03502 } // Namespace
    03503
    03504
    03505
    03506 #endif

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