Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

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-2006 Torus Knot Software Ltd
00008 Also see acknowledgements in Readme.html
00009 
00010 This library is free software; you can redistribute it and/or modify it
00011 under the terms of the GNU Lesser General Public License (LGPL) as 
00012 published by the Free Software Foundation; either version 2.1 of the 
00013 License, or (at your option) any later version.
00014 
00015 This library is distributed in the hope that it will be useful, but 
00016 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
00017 or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public 
00018 License for more details.
00019 
00020 You should have received a copy of the GNU Lesser General Public License 
00021 along with this library; if not, write to the Free Software Foundation, 
00022 Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA or go to
00023 http://www.gnu.org/copyleft/lesser.txt
00024 
00025 You may alternatively use this source under the terms of a specific version of
00026 the OGRE Unrestricted License provided you have obtained such a license from
00027 Torus Knot Software Ltd.
00028 -------------------------------------------------------------------------*/
00029 #ifndef __SceneManager_H__
00030 #define __SceneManager_H__
00031 
00032 // Precompiler options
00033 #include "OgrePrerequisites.h"
00034 
00035 #include "OgreString.h"
00036 #include "OgreSceneNode.h"
00037 #include "OgrePlane.h"
00038 #include "OgreQuaternion.h"
00039 #include "OgreColourValue.h"
00040 #include "OgreCommon.h"
00041 #include "OgreSceneQuery.h"
00042 #include "OgreAutoParamDataSource.h"
00043 #include "OgreAnimationState.h"
00044 #include "OgreRenderQueue.h"
00045 #include "OgreRenderQueueSortingGrouping.h"
00046 #include "OgreRectangle2D.h"
00047 #include "OgrePixelFormat.h"
00048 #include "OgreResourceGroupManager.h"
00049 #include "OgreTexture.h"
00050 #include "OgreShadowCameraSetup.h"
00051 #include "OgreShadowTextureManager.h"
00052 #include "OgreCamera.h"
00053 #include "OgreInstancedGeometry.h"
00054 
00055 namespace Ogre {
00056 
00058     struct ViewPoint
00059     {
00060         Vector3 position;
00061         Quaternion orientation;
00062     };
00063 
00064     // Forward declarations
00065     class DefaultIntersectionSceneQuery;
00066     class DefaultRaySceneQuery;
00067     class DefaultSphereSceneQuery;
00068     class DefaultAxisAlignedBoxSceneQuery;
00069 
00073     struct VisibleObjectsBoundsInfo
00074     {
00076         AxisAlignedBox aabb;
00078         AxisAlignedBox receiverAabb;
00080         Real minDistance;
00082         Real maxDistance;
00083 
00084         VisibleObjectsBoundsInfo()
00085         {
00086             reset();
00087         }
00088 
00089         void reset()
00090         {
00091             aabb.setNull();
00092             receiverAabb.setNull();
00093             minDistance = std::numeric_limits<Real>::infinity();
00094             maxDistance = 0;
00095         }
00096 
00097         void merge(const AxisAlignedBox& boxBounds, const Sphere& sphereBounds, 
00098             const Camera* cam, bool receiver=true)
00099         {
00100             aabb.merge(boxBounds);
00101             if (receiver)
00102                 receiverAabb.merge(boxBounds);
00103             Real camDistToCenter = 
00104                 (cam->getDerivedPosition() - sphereBounds.getCenter()).length();
00105             minDistance = (std::min)(minDistance, (std::max)((Real)0, camDistToCenter - sphereBounds.getRadius()));
00106             maxDistance = (std::max)(maxDistance, camDistToCenter + sphereBounds.getRadius());
00107         }
00108 
00109 
00110     };
00111 
00141     class _OgreExport SceneManager : public SceneMgtAlloc
00142     {
00143     public:
00145         static uint32 WORLD_GEOMETRY_TYPE_MASK;
00147         static uint32 ENTITY_TYPE_MASK;
00149         static uint32 FX_TYPE_MASK;
00151         static uint32 STATICGEOMETRY_TYPE_MASK;
00153         static uint32 LIGHT_TYPE_MASK;
00155         static uint32 FRUSTUM_TYPE_MASK;
00157         static uint32 USER_TYPE_MASK_LIMIT;
00160         struct materialLess
00161         {
00162             _OgreExport bool operator()(const Material* x, const Material* y) const;
00163         };
00165         struct lightLess
00166         {
00167             _OgreExport bool operator()(const Light* a, const Light* b) const;
00168         };
00169 
00171         enum IlluminationRenderStage
00172         {
00174             IRS_NONE,
00176             IRS_RENDER_TO_TEXTURE,
00178             IRS_RENDER_RECEIVER_PASS
00179         };
00180 
00185         enum SpecialCaseRenderQueueMode
00186         {
00188             SCRQM_INCLUDE,
00190             SCRQM_EXCLUDE
00191         };
00192 
00193         struct SkyDomeGenParameters
00194         {
00195             Real skyDomeCurvature;
00196             Real skyDomeTiling;
00197             Real skyDomeDistance;
00198             int skyDomeXSegments; 
00199             int skyDomeYSegments;
00200             int skyDomeYSegments_keep;
00201         };
00202 
00203         struct SkyPlaneGenParameters
00204         {
00205             Real skyPlaneScale;
00206             Real skyPlaneTiling; 
00207             Real skyPlaneBow; 
00208             int skyPlaneXSegments; 
00209             int skyPlaneYSegments; 
00210         };
00211 
00212         struct SkyBoxGenParameters
00213         {
00214             Real skyBoxDistance;
00215         };
00216 
00220         class Listener
00221         {
00222         public:
00223             Listener() {}
00224             virtual ~Listener() {}
00225 
00235             virtual void preFindVisibleObjects(SceneManager* source, 
00236                 IlluminationRenderStage irs, Viewport* v) = 0;
00247             virtual void postFindVisibleObjects(SceneManager* source, 
00248                 IlluminationRenderStage irs, Viewport* v) = 0;
00249 
00264             virtual void shadowTexturesUpdated(size_t numberOfShadowTextures) = 0;
00265 
00279             virtual void shadowTextureCasterPreViewProj(Light* light, 
00280                 Camera* camera, size_t iteration) = 0;
00294             virtual void shadowTextureReceiverPreViewProj(Light* light, 
00295                 Frustum* frustum) = 0;
00296 
00319             virtual bool sortLightsAffectingFrustum(LightList& lightList) { return false; }
00320 
00321 
00322 
00323         };
00324 
00328         class _OgreExport SceneMgrQueuedRenderableVisitor : public QueuedRenderableVisitor
00329         {
00330         protected:
00332             const Pass* mUsedPass;
00333         public:
00334             SceneMgrQueuedRenderableVisitor() 
00335                 :transparentShadowCastersMode(false) {}
00336             ~SceneMgrQueuedRenderableVisitor() {}
00337             void visit(Renderable* r);
00338             bool visit(const Pass* p);
00339             void visit(RenderablePass* rp);
00340 
00342             SceneManager* targetSceneMgr;
00344             bool transparentShadowCastersMode;
00346             bool autoLights;
00348             const LightList* manualLightList;
00350             bool scissoring;
00351 
00352         };
00354         friend class SceneMgrQueuedRenderableVisitor;
00355 
00356     protected:
00357 
00359         virtual SceneNode* createSceneNodeImpl(void);
00361         virtual SceneNode* createSceneNodeImpl(const String& name);
00362 
00364         String mName;
00365 
00367         RenderQueue* mRenderQueue;
00368         bool mLastRenderQueueInvocationCustom;
00369 
00371         ColourValue mAmbientLight;
00372 
00374         RenderSystem *mDestRenderSystem;
00375 
00376         typedef std::map<String, Camera* > CameraList;
00377 
00380         CameraList mCameras;
00381 
00382         typedef std::map<String, StaticGeometry* > StaticGeometryList;
00383         StaticGeometryList mStaticGeometryList;
00384         typedef std::map<String, InstancedGeometry* > InstancedGeometryList;
00385         InstancedGeometryList mInstancedGeometryList;
00386 
00387         typedef std::map<String, SceneNode*> SceneNodeList;
00388 
00395         SceneNodeList mSceneNodes;
00396 
00398         Camera* mCameraInProgress;
00400         Viewport* mCurrentViewport;
00401 
00403         SceneNode* mSceneRoot;
00404 
00406         typedef std::set<SceneNode*> AutoTrackingSceneNodes;
00407         AutoTrackingSceneNodes mAutoTrackingSceneNodes;
00408 
00409         // Sky params
00410         // Sky plane
00411         Entity* mSkyPlaneEntity;
00412         Entity* mSkyDomeEntity[5];
00413         ManualObject* mSkyBoxObj;
00414 
00415         SceneNode* mSkyPlaneNode;
00416         SceneNode* mSkyDomeNode;
00417         SceneNode* mSkyBoxNode;
00418 
00419         // Sky plane
00420         bool mSkyPlaneEnabled;
00421         uint8 mSkyPlaneRenderQueue;
00422         Plane mSkyPlane;
00423         SkyPlaneGenParameters mSkyPlaneGenParameters;
00424         // Sky box
00425         bool mSkyBoxEnabled;
00426         uint8 mSkyBoxRenderQueue;
00427         Quaternion mSkyBoxOrientation;
00428         SkyBoxGenParameters mSkyBoxGenParameters;
00429         // Sky dome
00430         bool mSkyDomeEnabled;
00431         uint8 mSkyDomeRenderQueue;
00432         Quaternion mSkyDomeOrientation;
00433         SkyDomeGenParameters mSkyDomeGenParameters;
00434 
00435         // Fog
00436         FogMode mFogMode;
00437         ColourValue mFogColour;
00438         Real mFogStart;
00439         Real mFogEnd;
00440         Real mFogDensity;
00441 
00442         typedef std::set<uint8> SpecialCaseRenderQueueList;
00443         SpecialCaseRenderQueueList mSpecialCaseQueueList;
00444         SpecialCaseRenderQueueMode mSpecialCaseQueueMode;
00445         uint8 mWorldGeometryRenderQueue;
00446         
00447         unsigned long mLastFrameNumber;
00448         Matrix4 mTempXform[256];
00449         bool mResetIdentityView;
00450         bool mResetIdentityProj;
00451 
00452         bool mNormaliseNormalsOnScale;
00453         bool mFlipCullingOnNegativeScale;
00454         CullingMode mPassCullingMode;
00455 
00456     protected:
00457 
00465         typedef std::map< const Camera*, VisibleObjectsBoundsInfo> CamVisibleObjectsMap;
00466         CamVisibleObjectsMap mCamVisibleObjectsMap; 
00467 
00469         typedef std::map< const Camera*, const Light* > ShadowCamLightMapping;
00470         ShadowCamLightMapping mShadowCamLightMapping;
00471 
00473         size_t mShadowTextureCountPerType[3];
00474 
00476         std::vector<size_t> mShadowTextureIndexLightList;
00477 
00479         struct _OgreExport LightInfo
00480         {
00481             Light* light;       // Just a pointer for comparison, the light might destroyed for some reason
00482             int type;           // Use int instead of Light::LightTypes to avoid header file dependence
00483             Real range;         // Sets to zero if directional light
00484             Vector3 position;   // Sets to zero if directional light
00485 
00486             bool operator== (const LightInfo& rhs) const
00487             {
00488                 return light == rhs.light && type == rhs.type &&
00489                     range == rhs.range && position == rhs.position;
00490             }
00491 
00492             bool operator!= (const LightInfo& rhs) const
00493             {
00494                 return !(*this == rhs);
00495             }
00496         };
00497 
00498         typedef std::vector<LightInfo> LightInfoList;
00499 
00500         LightList mLightsAffectingFrustum;
00501         LightInfoList mCachedLightInfos;
00502         LightInfoList mTestLightInfos; // potentially new list
00503         ulong mLightsDirtyCounter;
00504 
00505         typedef std::map<String, MovableObject*> MovableObjectMap;
00507         struct MovableObjectCollection
00508         {
00509             MovableObjectMap map;
00510             OGRE_MUTEX(mutex)
00511         };
00512         typedef std::map<String, MovableObjectCollection*> MovableObjectCollectionMap;
00513         MovableObjectCollectionMap mMovableObjectCollectionMap;
00518         MovableObjectCollection* getMovableObjectCollection(const String& typeName);
00523         const MovableObjectCollection* getMovableObjectCollection(const String& typeName) const;
00525         OGRE_MUTEX(mMovableObjectCollectionMapMutex)
00526 
00527         
00531         virtual void initRenderQueue(void);
00533         Pass* mShadowCasterPlainBlackPass;
00535         Pass* mShadowReceiverPass;
00545         virtual const Pass* deriveShadowCasterPass(const Pass* pass);
00554         virtual const Pass* deriveShadowReceiverPass(const Pass* pass);
00555     
00562         virtual bool validatePassForRendering(const Pass* pass);
00563 
00570         virtual bool validateRenderableForRendering(const Pass* pass, const Renderable* rend);
00571 
00572         enum BoxPlane
00573         {
00574             BP_FRONT = 0,
00575             BP_BACK = 1,
00576             BP_LEFT = 2,
00577             BP_RIGHT = 3,
00578             BP_UP = 4,
00579             BP_DOWN = 5
00580         };
00581 
00582         /* Internal utility method for creating the planes of a skybox.
00583         */
00584         virtual MeshPtr createSkyboxPlane(
00585             BoxPlane bp,
00586             Real distance,
00587             const Quaternion& orientation,
00588             const String& groupName);
00589 
00590         /* Internal utility method for creating the planes of a skydome.
00591         */
00592         virtual MeshPtr createSkydomePlane(
00593             BoxPlane bp,
00594             Real curvature, Real tiling, Real distance,
00595             const Quaternion& orientation,
00596             int xsegments, int ysegments, int ySegmentsToKeep, 
00597             const String& groupName);
00598 
00599         // Flag indicating whether SceneNodes will be rendered as a set of 3 axes
00600         bool mDisplayNodes;
00601 
00603         typedef std::map<String, Animation*> AnimationList;
00604         AnimationList mAnimationsList;
00605         OGRE_MUTEX(mAnimationsListMutex)
00606         AnimationStateSet mAnimationStates;
00607 
00608 
00611         virtual void useRenderableViewProjMode(const Renderable* pRend);
00612         
00615         virtual void resetViewProjMode(void);
00616 
00617         typedef std::vector<RenderQueueListener*> RenderQueueListenerList;
00618         RenderQueueListenerList mRenderQueueListeners;
00619 
00620         typedef std::vector<Listener*> ListenerList;
00621         ListenerList mListeners;
00623         virtual bool fireRenderQueueStarted(uint8 id, const String& invocation);
00625         virtual bool fireRenderQueueEnded(uint8 id, const String& invocation);
00626 
00628         virtual void fireShadowTexturesUpdated(size_t numberOfShadowTextures);
00630         virtual void fireShadowTexturesPreCaster(Light* light, Camera* camera, size_t iteration);
00632         virtual void fireShadowTexturesPreReceiver(Light* light, Frustum* f);
00634         virtual void firePreFindVisibleObjects(Viewport* v);
00636         virtual void firePostFindVisibleObjects(Viewport* v);
00638         virtual void setViewport(Viewport *vp);
00639 
00641         bool mShowBoundingBoxes;      
00642 
00644         virtual void renderVisibleObjectsDefaultSequence(void);
00646         virtual void renderVisibleObjectsCustomSequence(RenderQueueInvocationSequence* s);
00648         virtual void prepareRenderQueue(void);
00649 
00650 
00666         virtual void renderSingleObject(Renderable* rend, const Pass* pass, 
00667             bool lightScissoringClipping, bool doLightIteration, const LightList* manualLightList = 0);
00668 
00670         virtual AutoParamDataSource* createAutoParamDataSource(void) const
00671         {
00672             return OGRE_NEW AutoParamDataSource();
00673         }
00674 
00676         AutoParamDataSource* mAutoParamDataSource;
00677 
00678         ShadowTechnique mShadowTechnique;
00679         bool mDebugShadows;
00680         ColourValue mShadowColour;
00681         Pass* mShadowDebugPass;
00682         Pass* mShadowStencilPass;
00683         Pass* mShadowModulativePass;
00684         bool mShadowMaterialInitDone;
00685         HardwareIndexBufferSharedPtr mShadowIndexBuffer;
00686         size_t mShadowIndexBufferSize;
00687         Rectangle2D* mFullScreenQuad;
00688         Real mShadowDirLightExtrudeDist;
00689         IlluminationRenderStage mIlluminationStage;
00690         ShadowTextureConfigList mShadowTextureConfigList;
00691         bool mShadowTextureConfigDirty;
00692         ShadowTextureList mShadowTextures;
00693         TexturePtr mNullShadowTexture;
00694         typedef std::vector<Camera*> ShadowTextureCameraList;
00695         ShadowTextureCameraList mShadowTextureCameras;
00696         Texture* mCurrentShadowTexture;
00697         bool mShadowUseInfiniteFarPlane;
00698         bool mShadowCasterRenderBackFaces;
00699         bool mShadowAdditiveLightClip;
00701         struct LightClippingInfo
00702         {
00703             RealRect scissorRect;
00704             PlaneList clipPlanes;
00705             bool scissorValid;
00706             unsigned long clipPlanesValid;
00707             LightClippingInfo() : scissorValid(false), clipPlanesValid(false) {}
00708 
00709         };
00710         typedef std::map<Light*, LightClippingInfo> LightClippingInfoMap;
00711         LightClippingInfoMap mLightClippingInfoMap;
00712         unsigned long mLightClippingInfoMapFrameNumber;
00713 
00715         ShadowCameraSetupPtr mDefaultShadowCameraSetup;
00716 
00725         struct lightsForShadowTextureLess
00726         {
00727             _OgreExport bool operator()(const Light* l1, const Light* l2) const;
00728         };
00729 
00730 
00737         virtual void findLightsAffectingFrustum(const Camera* camera);
00739         virtual void initShadowVolumeMaterials(void);
00741         virtual void ensureShadowTexturesCreated();
00743         virtual void destroyShadowTextures(void);
00745         virtual void prepareShadowTextures(Camera* cam, Viewport* vp);
00746 
00754         virtual void renderShadowVolumesToStencil(const Light* light, const Camera* cam, 
00755             bool calcScissor);
00761         virtual void setShadowVolumeStencilState(bool secondpass, bool zfail, bool twosided);
00763         void renderShadowVolumeObjects(ShadowCaster::ShadowRenderableListIterator iShadowRenderables,
00764             Pass* pass, const LightList *manualLightList, unsigned long flags,
00765             bool secondpass, bool zfail, bool twosided);
00766         typedef std::vector<ShadowCaster*> ShadowCasterList;
00767         ShadowCasterList mShadowCasterList;
00768         SphereSceneQuery* mShadowCasterSphereQuery;
00769         AxisAlignedBoxSceneQuery* mShadowCasterAABBQuery;
00770         Real mDefaultShadowFarDist;
00771         Real mDefaultShadowFarDistSquared;
00772         Real mShadowTextureOffset; // proportion of texture offset in view direction e.g. 0.4
00773         Real mShadowTextureFadeStart; // as a proportion e.g. 0.6
00774         Real mShadowTextureFadeEnd; // as a proportion e.g. 0.9
00775         bool mShadowTextureSelfShadow;
00776         Pass* mShadowTextureCustomCasterPass;
00777         Pass* mShadowTextureCustomReceiverPass;
00778         String mShadowTextureCustomCasterVertexProgram;
00779         String mShadowTextureCustomReceiverVertexProgram;
00780         String mShadowTextureCustomReceiverFragmentProgram;
00781         GpuProgramParametersSharedPtr mShadowTextureCustomCasterVPParams;
00782         GpuProgramParametersSharedPtr mShadowTextureCustomReceiverVPParams;
00783         GpuProgramParametersSharedPtr mShadowTextureCustomReceiverFPParams;
00784 
00786         uint32 mVisibilityMask;
00787         bool mFindVisibleObjects;
00788 
00790         bool mSuppressRenderStateChanges;
00792         bool mSuppressShadows;
00793 
00794 
00795         GpuProgramParametersSharedPtr mInfiniteExtrusionParams;
00796         GpuProgramParametersSharedPtr mFiniteExtrusionParams;
00797 
00799         class _OgreExport ShadowCasterSceneQueryListener : public SceneQueryListener, public SceneMgtAlloc
00800         {
00801         protected:
00802             SceneManager* mSceneMgr;
00803             ShadowCasterList* mCasterList;
00804             bool mIsLightInFrustum;
00805             const PlaneBoundedVolumeList* mLightClipVolumeList;
00806             const Camera* mCamera;
00807             const Light* mLight;
00808             Real mFarDistSquared;
00809         public:
00810             ShadowCasterSceneQueryListener(SceneManager* sm) : mSceneMgr(sm),
00811                 mCasterList(0), mIsLightInFrustum(false), mLightClipVolumeList(0), 
00812                 mCamera(0) {}
00813             // Prepare the listener for use with a set of parameters  
00814             void prepare(bool lightInFrustum, 
00815                 const PlaneBoundedVolumeList* lightClipVolumes, 
00816                 const Light* light, const Camera* cam, ShadowCasterList* casterList, 
00817                 Real farDistSquared) 
00818             {
00819                 mCasterList = casterList;
00820                 mIsLightInFrustum = lightInFrustum;
00821                 mLightClipVolumeList = lightClipVolumes;
00822                 mCamera = cam;
00823                 mLight = light;
00824                 mFarDistSquared = farDistSquared;
00825             }
00826             bool queryResult(MovableObject* object);
00827             bool queryResult(SceneQuery::WorldFragment* fragment);
00828         };
00829 
00830         ShadowCasterSceneQueryListener* mShadowCasterQueryListener;
00831 
00838         virtual const ShadowCasterList& findShadowCastersForLight(const Light* light, 
00839             const Camera* camera);
00841         virtual void renderBasicQueueGroupObjects(RenderQueueGroup* pGroup, 
00842             QueuedRenderableCollection::OrganisationMode om);
00844         virtual void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* group, 
00845             QueuedRenderableCollection::OrganisationMode om);
00847         virtual void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* group, 
00848             QueuedRenderableCollection::OrganisationMode om);
00850         virtual void renderTextureShadowCasterQueueGroupObjects(RenderQueueGroup* group, 
00851             QueuedRenderableCollection::OrganisationMode om);
00853         virtual void renderTextureShadowReceiverQueueGroupObjects(RenderQueueGroup* group, 
00854             QueuedRenderableCollection::OrganisationMode om);
00856         virtual void renderModulativeTextureShadowedQueueGroupObjects(RenderQueueGroup* group, 
00857             QueuedRenderableCollection::OrganisationMode om);
00858 
00860         virtual void renderAdditiveTextureShadowedQueueGroupObjects(RenderQueueGroup* group, 
00861             QueuedRenderableCollection::OrganisationMode om);
00863         virtual void renderObjects(const QueuedRenderableCollection& objs, 
00864             QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping,
00865             bool doLightIteration, const LightList* manualLightList = 0);
00871         virtual void renderTransparentShadowCasterObjects(const QueuedRenderableCollection& objs, 
00872             QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping,
00873             bool doLightIteration, const LightList* manualLightList = 0);
00874 
00877         virtual void updateRenderQueueSplitOptions(void);
00880         virtual void updateRenderQueueGroupSplitOptions(RenderQueueGroup* group, 
00881             bool suppressShadows, bool suppressRenderState);
00882 
00884         virtual ClipResult buildAndSetScissor(const LightList& ll, const Camera* cam);
00886         virtual void buildScissor(const Light* l, const Camera* cam, RealRect& rect);
00887         virtual void resetScissor();
00889         virtual ClipResult buildAndSetLightClip(const LightList& ll);
00890         virtual void buildLightClip(const Light* l, PlaneList& planes);
00891         virtual void resetLightClip();
00892         virtual void checkCachedLightClippingInfo();
00893 
00895         SceneMgrQueuedRenderableVisitor* mActiveQueuedRenderableVisitor;
00897         SceneMgrQueuedRenderableVisitor mDefaultQueuedRenderableVisitor;
00898 
00900         bool mCameraRelativeRendering;
00901         Matrix4 mCachedViewMatrix;
00902         Vector3 mCameraRelativePosition;
00903 
00904     public:
00907         SceneManager(const String& instanceName);
00908 
00911         virtual ~SceneManager();
00912 
00913 
00939         OGRE_MUTEX(sceneGraphMutex)
00940 
00941         
00942         const String& getName(void) const { return mName; }
00943 
00950         virtual const String& getTypeName(void) const = 0;
00951 
00959         virtual Camera* createCamera(const String& name);
00960 
00964         virtual Camera* getCamera(const String& name) const;
00965 
00968         virtual bool hasCamera(const String& name) const;
00969 
00978         virtual void destroyCamera(Camera *cam);
00979 
00985         virtual void destroyCamera(const String& name);
00986 
00995         virtual void destroyAllCameras(void);
00996 
01007         virtual Light* createLight(const String& name);
01008 
01012         virtual Light* getLight(const String& name) const;
01013 
01016         virtual bool hasLight(const String& name) const;
01017 
01020         virtual const PlaneList& getLightClippingPlanes(Light* l);
01021 
01024         virtual const RealRect& getLightScissorRect(Light* l, const Camera* cam);
01025 
01030         virtual void destroyLight(const String& name);
01031 
01036         virtual void destroyLight(Light* light);
01039         virtual void destroyAllLights(void);
01040 
01051         virtual void _notifyLightsDirty(void);
01052 
01065         ulong _getLightsDirtyCounter(void) const { return mLightsDirtyCounter; }
01066 
01073         virtual const LightList& _getLightsAffectingFrustum(void) const;
01074 
01096         virtual void _populateLightList(const Vector3& position, Real radius, LightList& destList);
01097 
01098 
01115         virtual SceneNode* createSceneNode(void);
01116 
01131         virtual SceneNode* createSceneNode(const String& name);
01132 
01139         virtual void destroySceneNode(const String& name);
01140 
01147         virtual void destroySceneNode(SceneNode* sn);
01163         virtual SceneNode* getRootSceneNode(void);
01164 
01172         virtual SceneNode* getSceneNode(const String& name) const;
01173 
01176         virtual bool hasSceneNode(const String& name) const;
01177 
01178 
01186         virtual Entity* createEntity(const String& entityName, const String& meshName);
01187 
01194         enum PrefabType {
01195             PT_PLANE,
01196             PT_CUBE,
01197             PT_SPHERE
01198         };
01199 
01206         virtual Entity* createEntity(const String& entityName, PrefabType ptype);
01210         virtual Entity* getEntity(const String& name) const;
01213         virtual bool hasEntity(const String& name) const;
01214 
01223         virtual void destroyEntity(Entity* ent);
01224 
01233         virtual void destroyEntity(const String& name);
01234 
01244         virtual void destroyAllEntities(void);
01245 
01251         virtual ManualObject* createManualObject(const String& name);
01255         virtual ManualObject* getManualObject(const String& name) const;
01258         virtual bool hasManualObject(const String& name) const;
01259 
01262         virtual void destroyManualObject(ManualObject* obj);
01265         virtual void destroyManualObject(const String& name);
01268         virtual void destroyAllManualObjects(void);
01274         virtual BillboardChain* createBillboardChain(const String& name);
01278         virtual BillboardChain* getBillboardChain(const String& name) const;
01281         virtual bool hasBillboardChain(const String& name) const;
01282 
01285         virtual void destroyBillboardChain(BillboardChain* obj);
01288         virtual void destroyBillboardChain(const String& name);
01291         virtual void destroyAllBillboardChains(void);       
01297         virtual RibbonTrail* createRibbonTrail(const String& name);
01301         virtual RibbonTrail* getRibbonTrail(const String& name) const;
01304         virtual bool hasRibbonTrail(const String& name) const;
01305 
01308         virtual void destroyRibbonTrail(RibbonTrail* obj);
01311         virtual void destroyRibbonTrail(const String& name);
01314         virtual void destroyAllRibbonTrails(void);      
01315 
01336         virtual ParticleSystem* createParticleSystem(const String& name,
01337             const String& templateName);
01357         virtual ParticleSystem* createParticleSystem(const String& name,
01358             size_t quota = 500, 
01359             const String& resourceGroup = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
01363         virtual ParticleSystem* getParticleSystem(const String& name) const;
01366         virtual bool hasParticleSystem(const String& name) const;
01367 
01370         virtual void destroyParticleSystem(ParticleSystem* obj);
01373         virtual void destroyParticleSystem(const String& name);
01376         virtual void destroyAllParticleSystems(void);       
01377 
01383         virtual void clearScene(void);
01384 
01397         void setAmbientLight(const ColourValue& colour);
01398 
01401         const ColourValue& getAmbientLight(void) const;
01402 
01418         virtual void prepareWorldGeometry(const String& filename);
01419 
01437         virtual void prepareWorldGeometry(DataStreamPtr& stream, 
01438             const String& typeName = StringUtil::BLANK);
01439 
01452         virtual void setWorldGeometry(const String& filename);
01453 
01469         virtual void setWorldGeometry(DataStreamPtr& stream, 
01470             const String& typeName = StringUtil::BLANK);
01471 
01484         virtual size_t estimateWorldGeometry(const String& filename) { return 0; }
01485 
01498         virtual size_t estimateWorldGeometry(DataStreamPtr& stream, 
01499             const String& typeName = StringUtil::BLANK) { return 0; }
01514         virtual ViewPoint getSuggestedViewpoint(bool random = false);
01515 
01529         virtual bool setOption( const String& strKey, const void* pValue ) { return false; }
01530 
01544         virtual bool getOption( const String& strKey, void* pDestValue ) { return false; }
01545 
01555         virtual bool hasOption( const String& strKey ) const { return false; }
01570         virtual bool getOptionValues( const String& strKey, StringVector& refValueList ) { return false; }
01571 
01578         virtual bool getOptionKeys( StringVector& refKeys ) { return false; }
01579 
01588         virtual void _updateSceneGraph(Camera* cam);
01589 
01601         virtual void _findVisibleObjects(Camera* cam, VisibleObjectsBoundsInfo* visibleBounds, bool onlyShadowCasters);
01602 
01607         virtual void _applySceneAnimations(void);
01608 
01611         virtual void _renderVisibleObjects(void);
01612 
01626         virtual void _renderScene(Camera* camera, Viewport* vp, bool includeOverlays);
01627 
01631         virtual void _queueSkiesForRendering(Camera* cam);
01632 
01633 
01634 
01643         virtual void _setDestinationRenderSystem(RenderSystem* sys);
01644 
01698         virtual void setSkyPlane(
01699             bool enable,
01700             const Plane& plane, const String& materialName, Real scale = 1000,
01701             Real tiling = 10, bool drawFirst = true, Real bow = 0, 
01702             int xsegments = 1, int ysegments = 1, 
01703             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
01747         virtual void _setSkyPlane(
01748             bool enable,
01749             const Plane& plane, const String& materialName, Real scale = 1000,
01750             Real tiling = 10, uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, Real bow = 0, 
01751             int xsegments = 1, int ysegments = 1, 
01752             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
01753 
01755         virtual bool isSkyPlaneEnabled(void) const { return mSkyPlaneEnabled; }
01756 
01758         virtual SceneNode* getSkyPlaneNode(void) const { return mSkyPlaneNode; }
01759 
01761         virtual const SkyPlaneGenParameters& getSkyPlaneGenParameters(void) const { return mSkyPlaneGenParameters; }
01762 
01804         virtual void setSkyBox(
01805             bool enable, const String& materialName, Real distance = 5000,
01806             bool drawFirst = true, const Quaternion& orientation = Quaternion::IDENTITY,
01807             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
01808 
01841         virtual void _setSkyBox(
01842             bool enable, const String& materialName, Real distance = 5000,
01843             uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, const Quaternion& orientation = Quaternion::IDENTITY,
01844             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
01845 
01847         virtual bool isSkyBoxEnabled(void) const { return mSkyBoxEnabled; }
01848 
01850         virtual SceneNode* getSkyBoxNode(void) const { return mSkyBoxNode; }
01851 
01853         virtual const SkyBoxGenParameters& getSkyBoxGenParameters(void) const { return mSkyBoxGenParameters; }
01854 
01910         virtual void setSkyDome(
01911             bool enable, const String& materialName, Real curvature = 10,
01912             Real tiling = 8, Real distance = 4000, bool drawFirst = true,
01913             const Quaternion& orientation = Quaternion::IDENTITY,
01914             int xsegments = 16, int ysegments = 16, int ysegments_keep = -1,
01915             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
01916 
01963         virtual void _setSkyDome(
01964             bool enable, const String& materialName, Real curvature = 10,
01965             Real tiling = 8, Real distance = 4000, uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY,
01966             const Quaternion& orientation = Quaternion::IDENTITY,
01967             int xsegments = 16, int ysegments = 16, int ysegments_keep = -1,
01968             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
01969 
01971         virtual bool isSkyDomeEnabled(void) const { return mSkyDomeEnabled; }
01972 
01974         virtual SceneNode* getSkyDomeNode(void) const { return mSkyDomeNode; }
01975 
01977         virtual const SkyDomeGenParameters& getSkyDomeGenParameters(void) const { return mSkyDomeGenParameters; }
01978 
02003         void setFog(
02004             FogMode mode = FOG_NONE, const ColourValue& colour = ColourValue::White,
02005             Real expDensity = 0.001, Real linearStart = 0.0, Real linearEnd = 1.0);
02006 
02009         virtual FogMode getFogMode(void) const;
02010 
02013         virtual const ColourValue& getFogColour(void) const;
02014 
02017         virtual Real getFogStart(void) const;
02018 
02021         virtual Real getFogEnd(void) const;
02022 
02025         virtual Real getFogDensity(void) const;
02026 
02027 
02045         virtual BillboardSet* createBillboardSet(const String& name, unsigned int poolSize = 20);
02046 
02050         virtual BillboardSet* getBillboardSet(const String& name) const;
02053         virtual bool hasBillboardSet(const String& name) const;
02054 
02061         virtual void destroyBillboardSet(BillboardSet* set);
02062 
02069         virtual void destroyBillboardSet(const String& name);
02070 
02080         virtual void destroyAllBillboardSets(void);
02081 
02089         virtual void setDisplaySceneNodes(bool display);
02091         virtual bool getDisplaySceneNodes(void) const {return mDisplayNodes;}
02092 
02113         virtual Animation* createAnimation(const String& name, Real length);
02114 
02118         virtual Animation* getAnimation(const String& name) const;
02121         virtual bool hasAnimation(const String& name) const;
02122 
02128         virtual void destroyAnimation(const String& name);
02129 
02131         virtual void destroyAllAnimations(void);
02132 
02160         virtual AnimationState* createAnimationState(const String& animName);
02161 
02165         virtual AnimationState* getAnimationState(const String& animName) const;
02168         virtual bool hasAnimationState(const String& name) const;
02169 
02175         virtual void destroyAnimationState(const String& name);
02176 
02178         virtual void destroyAllAnimationStates(void);
02179 
02203         virtual void manualRender(RenderOperation* rend, Pass* pass, Viewport* vp, 
02204             const Matrix4& worldMatrix, const Matrix4& viewMatrix, const Matrix4& projMatrix, 
02205             bool doBeginEndFrame = false) ;
02206 
02217         virtual RenderQueue* getRenderQueue(void);
02218 
02222         virtual void addRenderQueueListener(RenderQueueListener* newListener);
02223 
02225         virtual void removeRenderQueueListener(RenderQueueListener* delListener);
02226 
02240         virtual void addSpecialCaseRenderQueue(uint8 qid);
02246         virtual void removeSpecialCaseRenderQueue(uint8 qid);
02250         virtual void clearSpecialCaseRenderQueues(void);
02255         virtual void setSpecialCaseRenderQueueMode(SpecialCaseRenderQueueMode mode);
02257         virtual SpecialCaseRenderQueueMode getSpecialCaseRenderQueueMode(void);
02264         virtual bool isRenderQueueToBeProcessed(uint8 qid);
02265 
02281         virtual void setWorldGeometryRenderQueue(uint8 qid);
02292         virtual uint8 getWorldGeometryRenderQueue(void);
02293 
02295         virtual void showBoundingBoxes(bool bShow);
02296 
02298         virtual bool getShowBoundingBoxes() const;
02299 
02301         virtual void _notifyAutotrackingSceneNode(SceneNode* node, bool autoTrack);
02302 
02303         
02316         virtual AxisAlignedBoxSceneQuery* 
02317             createAABBQuery(const AxisAlignedBox& box, unsigned long mask = 0xFFFFFFFF);
02330         virtual SphereSceneQuery* 
02331             createSphereQuery(const Sphere& sphere, unsigned long mask = 0xFFFFFFFF);
02344         virtual PlaneBoundedVolumeListSceneQuery* 
02345             createPlaneBoundedVolumeQuery(const PlaneBoundedVolumeList& volumes, unsigned long mask = 0xFFFFFFFF);
02346 
02347 
02360         virtual RaySceneQuery* 
02361             createRayQuery(const Ray& ray, unsigned long mask = 0xFFFFFFFF);
02362         //PyramidSceneQuery* createPyramidQuery(const Pyramid& p, unsigned long mask = 0xFFFFFFFF);
02374         virtual IntersectionSceneQuery* 
02375             createIntersectionQuery(unsigned long mask = 0xFFFFFFFF);
02376 
02378         virtual void destroyQuery(SceneQuery* query);
02379 
02380         typedef MapIterator<CameraList> CameraIterator;
02381         typedef MapIterator<AnimationList> AnimationIterator;
02382 
02385         CameraIterator getCameraIterator(void) {
02386             return CameraIterator(mCameras.begin(), mCameras.end());
02387         }
02389         AnimationIterator getAnimationIterator(void) {
02390             return AnimationIterator(mAnimationsList.begin(), mAnimationsList.end());
02391         }
02393         AnimationStateIterator getAnimationStateIterator(void) {
02394             return mAnimationStates.getAnimationStateIterator();
02395         }
02396 
02429         virtual void setShadowTechnique(ShadowTechnique technique);
02430         
02432         virtual ShadowTechnique getShadowTechnique(void) const { return mShadowTechnique; }
02433 
02435         virtual void setShowDebugShadows(bool debug) { mDebugShadows = debug; }
02437         virtual bool getShowDebugShadows(void ) const { return mDebugShadows; }
02438 
02445         virtual void setShadowColour(const ColourValue& colour);
02452         virtual const ColourValue& getShadowColour(void) const;
02464         virtual void setShadowDirectionalLightExtrusionDistance(Real dist); 
02467         virtual Real getShadowDirectionalLightExtrusionDistance(void) const;
02484         virtual void setShadowFarDistance(Real distance);
02488         virtual Real getShadowFarDistance(void) const
02489         { return mDefaultShadowFarDist; }
02490         virtual Real getShadowFarDistanceSquared(void) const
02491         { return mDefaultShadowFarDistSquared; }
02492 
02518         virtual void setShadowIndexBufferSize(size_t size);
02520         virtual size_t getShadowIndexBufferSize(void) const
02521         { return mShadowIndexBufferSize; }
02530         virtual void setShadowTextureSize(unsigned short size);
02531 
02538         virtual void setShadowTextureConfig(size_t shadowIndex, unsigned short width, 
02539             unsigned short height, PixelFormat format);
02545         virtual void setShadowTextureConfig(size_t shadowIndex, 
02546             const ShadowTextureConfig& config);
02547 
02549         ConstShadowTextureConfigIterator getShadowTextureConfigIterator() const;
02550 
02562         virtual void setShadowTexturePixelFormat(PixelFormat fmt);
02570         virtual void setShadowTextureCount(size_t count);
02572         size_t getShadowTextureCount(void) const {return mShadowTextureConfigList.size(); }
02573 
02583         void setShadowTextureCountPerLightType(Light::LightTypes type, size_t count)
02584         { mShadowTextureCountPerType[type] = count; }
02586         size_t getShadowTextureCountPerLightType(Light::LightTypes type) const
02587         {return mShadowTextureCountPerType[type]; }
02588 
02597         virtual void setShadowTextureSettings(unsigned short size, unsigned short count, 
02598             PixelFormat fmt = PF_X8R8G8B8);
02599 
02606         virtual const TexturePtr& getShadowTexture(size_t shadowIndex);
02607 
02622         virtual void setShadowDirLightTextureOffset(Real offset) { mShadowTextureOffset = offset;}
02626         virtual Real getShadowDirLightTextureOffset(void)  const { return mShadowTextureOffset; }
02634         virtual void setShadowTextureFadeStart(Real fadeStart) 
02635         { mShadowTextureFadeStart = fadeStart; }
02643         virtual void setShadowTextureFadeEnd(Real fadeEnd) 
02644         { mShadowTextureFadeEnd = fadeEnd; }
02645 
02658         virtual void setShadowTextureSelfShadow(bool selfShadow); 
02659 
02661         virtual bool getShadowTextureSelfShadow(void) const 
02662         { return mShadowTextureSelfShadow; }
02683         virtual void setShadowTextureCasterMaterial(const String& name);
02705         virtual void setShadowTextureReceiverMaterial(const String& name);
02706 
02717         virtual void setShadowCasterRenderBackFaces(bool bf) { mShadowCasterRenderBackFaces = bf; }
02718 
02722         virtual bool getShadowCasterRenderBackFaces() const { return mShadowCasterRenderBackFaces; }
02723 
02728         virtual void setShadowCameraSetup(const ShadowCameraSetupPtr& shadowSetup);
02729 
02734         virtual const ShadowCameraSetupPtr& getShadowCameraSetup() const;
02735 
02772         virtual void setShadowUseInfiniteFarPlane(bool enable) {
02773             mShadowUseInfiniteFarPlane = enable; }
02774 
02776         virtual bool isShadowTechniqueStencilBased(void) const 
02777         { return (mShadowTechnique & SHADOWDETAILTYPE_STENCIL) != 0; }
02779         virtual bool isShadowTechniqueTextureBased(void) const 
02780         { return (mShadowTechnique & SHADOWDETAILTYPE_TEXTURE) != 0; }
02782         virtual bool isShadowTechniqueModulative(void) const 
02783         { return (mShadowTechnique & SHADOWDETAILTYPE_MODULATIVE) != 0; }
02785         virtual bool isShadowTechniqueAdditive(void) const 
02786         { return (mShadowTechnique & SHADOWDETAILTYPE_ADDITIVE) != 0; }
02788         virtual bool isShadowTechniqueIntegrated(void) const 
02789         { return (mShadowTechnique & SHADOWDETAILTYPE_INTEGRATED) != 0; }
02791         virtual bool isShadowTechniqueInUse(void) const 
02792         { return mShadowTechnique != SHADOWTYPE_NONE; }
02796         virtual void setShadowUseLightClipPlanes(bool enabled) { mShadowAdditiveLightClip = enabled; }
02800         virtual bool getShadowUseLightClipPlanes() const { return mShadowAdditiveLightClip; }
02801 
02804         virtual void addListener(Listener* s);
02807         virtual void removeListener(Listener* s);
02808 
02818         virtual StaticGeometry* createStaticGeometry(const String& name);
02822         virtual StaticGeometry* getStaticGeometry(const String& name) const;
02824         virtual bool hasStaticGeometry(const String& name) const;
02826         virtual void destroyStaticGeometry(StaticGeometry* geom);
02828         virtual void destroyStaticGeometry(const String& name);
02830         virtual void destroyAllStaticGeometry(void);
02831 
02841         virtual InstancedGeometry* createInstancedGeometry(const String& name);
02843         virtual InstancedGeometry* getInstancedGeometry(const String& name) const;
02845         virtual void destroyInstancedGeometry(InstancedGeometry* geom);
02847         virtual void destroyInstancedGeometry(const String& name);
02849         virtual void destroyAllInstancedGeometry(void);
02850 
02851 
02862         virtual MovableObject* createMovableObject(const String& name, 
02863             const String& typeName, const NameValuePairList* params = 0);
02869         virtual void destroyMovableObject(const String& name, const String& typeName);
02875         virtual void destroyMovableObject(MovableObject* m);
02877         virtual void destroyAllMovableObjectsByType(const String& typeName);
02879         virtual void destroyAllMovableObjects(void);
02883         virtual MovableObject* getMovableObject(const String& name, const String& typeName) const;
02885         virtual bool hasMovableObject(const String& name, const String& typeName) const;
02886         typedef MapIterator<MovableObjectMap> MovableObjectIterator;
02892         virtual MovableObjectIterator getMovableObjectIterator(const String& typeName);
02904         virtual void injectMovableObject(MovableObject* m);
02911         virtual void extractMovableObject(const String& name, const String& typeName);
02918         virtual void extractMovableObject(MovableObject* m);
02925         virtual void extractAllMovableObjectsByType(const String& typeName);
02926 
02933         virtual void setVisibilityMask(uint32 vmask) { mVisibilityMask = vmask; }
02934 
02938         virtual uint32 getVisibilityMask(void) { return mVisibilityMask; }
02939 
02943         uint32 _getCombinedVisibilityMask(void) const;
02944 
02951         virtual void setFindVisibleObjects(bool find) { mFindVisibleObjects = find; }
02952 
02956         virtual bool getFindVisibleObjects(void) { return mFindVisibleObjects; }
02957 
02966         virtual void setNormaliseNormalsOnScale(bool n) { mNormaliseNormalsOnScale = n; }
02967 
02971         virtual bool getNormaliseNormalsOnScale() const { return mNormaliseNormalsOnScale; }
02972 
02981         virtual void setFlipCullingOnNegativeScale(bool n) { mFlipCullingOnNegativeScale = n; }
02982 
02986         virtual bool getFlipCullingOnNegativeScale() const { return mFlipCullingOnNegativeScale; }
02987 
02993         virtual void _injectRenderWithPass(Pass *pass, Renderable *rend, bool shadowDerivation = true);
02994 
03013         virtual void _suppressRenderStateChanges(bool suppress);
03014         
03018         virtual bool _areRenderStateChangesSuppressed(void) const
03019         { return mSuppressRenderStateChanges; }
03020 
03033         virtual const Pass* _setPass(const Pass* pass, 
03034             bool evenIfSuppressed = false, bool shadowDerivation = true);
03035 
03036 
03046         virtual void _suppressShadows(bool suppress); 
03047 
03051         virtual bool _areShadowsSuppressed(void) const
03052         { return mSuppressShadows; }
03053 
03057         virtual void _renderQueueGroupObjects(RenderQueueGroup* group, 
03058             QueuedRenderableCollection::OrganisationMode om);
03059 
03075         void setQueuedRenderableVisitor(SceneMgrQueuedRenderableVisitor* visitor);
03076 
03078         SceneMgrQueuedRenderableVisitor* getQueuedRenderableVisitor(void) const;
03079 
03080 
03084         RenderSystem *getDestinationRenderSystem();
03085 
03088         Viewport* getCurrentViewport(void) const { return mCurrentViewport; }
03089 
03091         const VisibleObjectsBoundsInfo& getVisibleObjectsBoundsInfo(const Camera* cam) const;
03092 
03094         const VisibleObjectsBoundsInfo& getShadowCasterBoundsInfo(const Light* light, size_t iteration = 0) const;
03095 
03110         virtual void setCameraRelativeRendering(bool rel) { mCameraRelativeRendering = rel; }
03111 
03115         virtual bool getCameraRelativeRendering() const { return mCameraRelativeRendering; }
03116     };
03117 
03119     class _OgreExport DefaultIntersectionSceneQuery : 
03120         public IntersectionSceneQuery
03121     {
03122     public:
03123         DefaultIntersectionSceneQuery(SceneManager* creator);
03124         ~DefaultIntersectionSceneQuery();
03125 
03127         void execute(IntersectionSceneQueryListener* listener);
03128     };
03129 
03131     class _OgreExport DefaultRaySceneQuery : public RaySceneQuery
03132     {
03133     public:
03134         DefaultRaySceneQuery(SceneManager* creator);
03135         ~DefaultRaySceneQuery();
03136 
03138         void execute(RaySceneQueryListener* listener);
03139     };
03141     class _OgreExport DefaultSphereSceneQuery : public SphereSceneQuery
03142     {
03143     public:
03144         DefaultSphereSceneQuery(SceneManager* creator);
03145         ~DefaultSphereSceneQuery();
03146 
03148         void execute(SceneQueryListener* listener);
03149     };
03151     class _OgreExport DefaultPlaneBoundedVolumeListSceneQuery : public PlaneBoundedVolumeListSceneQuery
03152     {
03153     public:
03154         DefaultPlaneBoundedVolumeListSceneQuery(SceneManager* creator);
03155         ~DefaultPlaneBoundedVolumeListSceneQuery();
03156 
03158         void execute(SceneQueryListener* listener);
03159     };
03161     class _OgreExport DefaultAxisAlignedBoxSceneQuery : public AxisAlignedBoxSceneQuery
03162     {
03163     public:
03164         DefaultAxisAlignedBoxSceneQuery(SceneManager* creator);
03165         ~DefaultAxisAlignedBoxSceneQuery();
03166 
03168         void execute(SceneQueryListener* listener);
03169     };
03170     
03171 
03173     typedef uint16 SceneTypeMask;
03174 
03178     enum SceneType
03179     {
03180         ST_GENERIC = 1,
03181         ST_EXTERIOR_CLOSE = 2,
03182         ST_EXTERIOR_FAR = 4,
03183         ST_EXTERIOR_REAL_FAR = 8,
03184         ST_INTERIOR = 16
03185     };
03186 
03188     struct SceneManagerMetaData
03189     {
03191         String typeName;
03193         String description;
03195         SceneTypeMask sceneTypeMask;
03197         bool worldGeometrySupported;
03198     };
03199 
03200 
03201 
03203     class _OgreExport SceneManagerFactory : public SceneMgtAlloc
03204     {
03205     protected:
03206         mutable SceneManagerMetaData mMetaData;
03207         mutable bool mMetaDataInit;
03209         virtual void initMetaData(void) const = 0;
03210     public:
03211         SceneManagerFactory() : mMetaDataInit(true) {}
03212         virtual ~SceneManagerFactory() {}
03214         virtual const SceneManagerMetaData& getMetaData(void) const 
03215         {
03216             if (mMetaDataInit)
03217             {
03218                 initMetaData();
03219                 mMetaDataInit = false;
03220             }
03221             return mMetaData; 
03222         }
03227         virtual SceneManager* createInstance(const String& instanceName) = 0;
03229         virtual void destroyInstance(SceneManager* instance) = 0;
03230 
03231     };
03232 
03233 
03234 
03235 } // Namespace
03236 
03237 
03238 
03239 #endif

Copyright © 2008 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sat Apr 11 13:46:43 2009