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 
00325     protected:
00326 
00328         virtual SceneNode* createSceneNodeImpl(void);
00330         virtual SceneNode* createSceneNodeImpl(const String& name);
00331 
00333         String mName;
00334 
00336         RenderQueue* mRenderQueue;
00337 
00339         ColourValue mAmbientLight;
00340 
00342         RenderSystem *mDestRenderSystem;
00343 
00344         typedef std::map<String, Camera* > CameraList;
00345 
00348         CameraList mCameras;
00349 
00350         typedef std::map<String, StaticGeometry* > StaticGeometryList;
00351         StaticGeometryList mStaticGeometryList;
00352         typedef std::map<String, InstancedGeometry* > InstancedGeometryList;
00353         InstancedGeometryList mInstancedGeometryList;
00354 
00355         typedef std::map<String, SceneNode*> SceneNodeList;
00356 
00363         SceneNodeList mSceneNodes;
00364 
00366         Camera* mCameraInProgress;
00368         Viewport* mCurrentViewport;
00369 
00371         SceneNode* mSceneRoot;
00372 
00374         typedef std::set<SceneNode*> AutoTrackingSceneNodes;
00375         AutoTrackingSceneNodes mAutoTrackingSceneNodes;
00376 
00377         // Sky params
00378         // Sky plane
00379         Entity* mSkyPlaneEntity;
00380         Entity* mSkyDomeEntity[5];
00381         ManualObject* mSkyBoxObj;
00382 
00383         SceneNode* mSkyPlaneNode;
00384         SceneNode* mSkyDomeNode;
00385         SceneNode* mSkyBoxNode;
00386 
00387         // Sky plane
00388         bool mSkyPlaneEnabled;
00389         uint8 mSkyPlaneRenderQueue;
00390         Plane mSkyPlane;
00391         SkyPlaneGenParameters mSkyPlaneGenParameters;
00392         // Sky box
00393         bool mSkyBoxEnabled;
00394         uint8 mSkyBoxRenderQueue;
00395         Quaternion mSkyBoxOrientation;
00396         SkyBoxGenParameters mSkyBoxGenParameters;
00397         // Sky dome
00398         bool mSkyDomeEnabled;
00399         uint8 mSkyDomeRenderQueue;
00400         Quaternion mSkyDomeOrientation;
00401         SkyDomeGenParameters mSkyDomeGenParameters;
00402 
00403         // Fog
00404         FogMode mFogMode;
00405         ColourValue mFogColour;
00406         Real mFogStart;
00407         Real mFogEnd;
00408         Real mFogDensity;
00409 
00410         typedef std::set<uint8> SpecialCaseRenderQueueList;
00411         SpecialCaseRenderQueueList mSpecialCaseQueueList;
00412         SpecialCaseRenderQueueMode mSpecialCaseQueueMode;
00413         uint8 mWorldGeometryRenderQueue;
00414         
00415         unsigned long mLastFrameNumber;
00416         Matrix4 mTempXform[256];
00417         bool mResetIdentityView;
00418         bool mResetIdentityProj;
00419 
00420         bool mNormaliseNormalsOnScale;
00421         bool mFlipCullingOnNegativeScale;
00422         CullingMode mPassCullingMode;
00423 
00424     protected:
00425 
00433         typedef std::map< const Camera*, VisibleObjectsBoundsInfo> CamVisibleObjectsMap;
00434         CamVisibleObjectsMap mCamVisibleObjectsMap; 
00435 
00437         typedef std::map< const Camera*, const Light* > ShadowCamLightMapping;
00438         ShadowCamLightMapping mShadowCamLightMapping;
00439 
00441         size_t mShadowTextureCountPerType[3];
00442 
00444         std::vector<size_t> mShadowTextureIndexLightList;
00445 
00447         struct _OgreExport LightInfo
00448         {
00449             Light* light;       // Just a pointer for comparison, the light might destroyed for some reason
00450             int type;           // Use int instead of Light::LightTypes to avoid header file dependence
00451             Real range;         // Sets to zero if directional light
00452             Vector3 position;   // Sets to zero if directional light
00453 
00454             bool operator== (const LightInfo& rhs) const
00455             {
00456                 return light == rhs.light && type == rhs.type &&
00457                     range == rhs.range && position == rhs.position;
00458             }
00459 
00460             bool operator!= (const LightInfo& rhs) const
00461             {
00462                 return !(*this == rhs);
00463             }
00464         };
00465 
00466         typedef std::vector<LightInfo> LightInfoList;
00467 
00468         LightList mLightsAffectingFrustum;
00469         LightInfoList mCachedLightInfos;
00470         LightInfoList mTestLightInfos; // potentially new list
00471         ulong mLightsDirtyCounter;
00472 
00473         typedef std::map<String, MovableObject*> MovableObjectMap;
00475         struct MovableObjectCollection
00476         {
00477             MovableObjectMap map;
00478             OGRE_MUTEX(mutex)
00479         };
00480         typedef std::map<String, MovableObjectCollection*> MovableObjectCollectionMap;
00481         MovableObjectCollectionMap mMovableObjectCollectionMap;
00486         MovableObjectCollection* getMovableObjectCollection(const String& typeName);
00491         const MovableObjectCollection* getMovableObjectCollection(const String& typeName) const;
00493         OGRE_MUTEX(mMovableObjectCollectionMapMutex)
00494 
00495         
00499         virtual void initRenderQueue(void);
00501         Pass* mShadowCasterPlainBlackPass;
00503         Pass* mShadowReceiverPass;
00513         virtual const Pass* deriveShadowCasterPass(const Pass* pass);
00522         virtual const Pass* deriveShadowReceiverPass(const Pass* pass);
00523     
00530         virtual bool validatePassForRendering(const Pass* pass);
00531 
00538         virtual bool validateRenderableForRendering(const Pass* pass, const Renderable* rend);
00539 
00540         enum BoxPlane
00541         {
00542             BP_FRONT = 0,
00543             BP_BACK = 1,
00544             BP_LEFT = 2,
00545             BP_RIGHT = 3,
00546             BP_UP = 4,
00547             BP_DOWN = 5
00548         };
00549 
00550         /* Internal utility method for creating the planes of a skybox.
00551         */
00552         virtual MeshPtr createSkyboxPlane(
00553             BoxPlane bp,
00554             Real distance,
00555             const Quaternion& orientation,
00556             const String& groupName);
00557 
00558         /* Internal utility method for creating the planes of a skydome.
00559         */
00560         virtual MeshPtr createSkydomePlane(
00561             BoxPlane bp,
00562             Real curvature, Real tiling, Real distance,
00563             const Quaternion& orientation,
00564             int xsegments, int ysegments, int ySegmentsToKeep, 
00565             const String& groupName);
00566 
00567         // Flag indicating whether SceneNodes will be rendered as a set of 3 axes
00568         bool mDisplayNodes;
00569 
00571         typedef std::map<String, Animation*> AnimationList;
00572         AnimationList mAnimationsList;
00573         OGRE_MUTEX(mAnimationsListMutex)
00574         AnimationStateSet mAnimationStates;
00575 
00576 
00579         virtual void useRenderableViewProjMode(const Renderable* pRend);
00580         
00583         virtual void resetViewProjMode(void);
00584 
00585         typedef std::vector<RenderQueueListener*> RenderQueueListenerList;
00586         RenderQueueListenerList mRenderQueueListeners;
00587 
00588         typedef std::vector<Listener*> ListenerList;
00589         ListenerList mListeners;
00591         virtual bool fireRenderQueueStarted(uint8 id, const String& invocation);
00593         virtual bool fireRenderQueueEnded(uint8 id, const String& invocation);
00594 
00596         virtual void fireShadowTexturesUpdated(size_t numberOfShadowTextures);
00598         virtual void fireShadowTexturesPreCaster(Light* light, Camera* camera, size_t iteration);
00600         virtual void fireShadowTexturesPreReceiver(Light* light, Frustum* f);
00602         virtual void firePreFindVisibleObjects(Viewport* v);
00604         virtual void firePostFindVisibleObjects(Viewport* v);
00606         virtual void setViewport(Viewport *vp);
00607 
00609         bool mShowBoundingBoxes;      
00610 
00612         virtual void renderVisibleObjectsDefaultSequence(void);
00614         virtual void renderVisibleObjectsCustomSequence(RenderQueueInvocationSequence* s);
00616         virtual void prepareRenderQueue(void);
00617 
00618 
00634         virtual void renderSingleObject(Renderable* rend, const Pass* pass, 
00635             bool lightScissoringClipping, bool doLightIteration, const LightList* manualLightList = 0);
00636 
00638         virtual AutoParamDataSource* createAutoParamDataSource(void) const
00639         {
00640             return OGRE_NEW AutoParamDataSource();
00641         }
00642 
00644         AutoParamDataSource* mAutoParamDataSource;
00645 
00646         ShadowTechnique mShadowTechnique;
00647         bool mDebugShadows;
00648         ColourValue mShadowColour;
00649         Pass* mShadowDebugPass;
00650         Pass* mShadowStencilPass;
00651         Pass* mShadowModulativePass;
00652         bool mShadowMaterialInitDone;
00653         HardwareIndexBufferSharedPtr mShadowIndexBuffer;
00654         size_t mShadowIndexBufferSize;
00655         Rectangle2D* mFullScreenQuad;
00656         Real mShadowDirLightExtrudeDist;
00657         IlluminationRenderStage mIlluminationStage;
00658         ShadowTextureConfigList mShadowTextureConfigList;
00659         bool mShadowTextureConfigDirty;
00660         ShadowTextureList mShadowTextures;
00661         TexturePtr mNullShadowTexture;
00662         typedef std::vector<Camera*> ShadowTextureCameraList;
00663         ShadowTextureCameraList mShadowTextureCameras;
00664         Texture* mCurrentShadowTexture;
00665         bool mShadowUseInfiniteFarPlane;
00666         bool mShadowCasterRenderBackFaces;
00667         bool mShadowAdditiveLightClip;
00669         struct LightClippingInfo
00670         {
00671             RealRect scissorRect;
00672             PlaneList clipPlanes;
00673             bool scissorValid;
00674             unsigned long clipPlanesValid;
00675             LightClippingInfo() : scissorValid(false), clipPlanesValid(false) {}
00676 
00677         };
00678         typedef std::map<Light*, LightClippingInfo> LightClippingInfoMap;
00679         LightClippingInfoMap mLightClippingInfoMap;
00680         unsigned long mLightClippingInfoMapFrameNumber;
00681 
00683         ShadowCameraSetupPtr mDefaultShadowCameraSetup;
00684 
00693         struct lightsForShadowTextureLess
00694         {
00695             _OgreExport bool operator()(const Light* l1, const Light* l2) const;
00696         };
00697 
00698 
00705         virtual void findLightsAffectingFrustum(const Camera* camera);
00707         virtual void initShadowVolumeMaterials(void);
00709         virtual void ensureShadowTexturesCreated();
00711         virtual void destroyShadowTextures(void);
00713         virtual void prepareShadowTextures(Camera* cam, Viewport* vp);
00714 
00722         virtual void renderShadowVolumesToStencil(const Light* light, const Camera* cam, 
00723             bool calcScissor);
00729         virtual void setShadowVolumeStencilState(bool secondpass, bool zfail, bool twosided);
00731         void renderShadowVolumeObjects(ShadowCaster::ShadowRenderableListIterator iShadowRenderables,
00732             Pass* pass, const LightList *manualLightList, unsigned long flags,
00733             bool secondpass, bool zfail, bool twosided);
00734         typedef std::vector<ShadowCaster*> ShadowCasterList;
00735         ShadowCasterList mShadowCasterList;
00736         SphereSceneQuery* mShadowCasterSphereQuery;
00737         AxisAlignedBoxSceneQuery* mShadowCasterAABBQuery;
00738         Real mDefaultShadowFarDist;
00739         Real mDefaultShadowFarDistSquared;
00740         Real mShadowTextureOffset; // proportion of texture offset in view direction e.g. 0.4
00741         Real mShadowTextureFadeStart; // as a proportion e.g. 0.6
00742         Real mShadowTextureFadeEnd; // as a proportion e.g. 0.9
00743         bool mShadowTextureSelfShadow;
00744         Pass* mShadowTextureCustomCasterPass;
00745         Pass* mShadowTextureCustomReceiverPass;
00746         String mShadowTextureCustomCasterVertexProgram;
00747         String mShadowTextureCustomReceiverVertexProgram;
00748         String mShadowTextureCustomReceiverFragmentProgram;
00749         GpuProgramParametersSharedPtr mShadowTextureCustomCasterVPParams;
00750         GpuProgramParametersSharedPtr mShadowTextureCustomReceiverVPParams;
00751         GpuProgramParametersSharedPtr mShadowTextureCustomReceiverFPParams;
00752 
00754         uint32 mVisibilityMask;
00755         bool mFindVisibleObjects;
00756 
00758         bool mSuppressRenderStateChanges;
00760         bool mSuppressShadows;
00761 
00762 
00763         GpuProgramParametersSharedPtr mInfiniteExtrusionParams;
00764         GpuProgramParametersSharedPtr mFiniteExtrusionParams;
00765 
00767         class _OgreExport ShadowCasterSceneQueryListener : public SceneQueryListener, public SceneMgtAlloc
00768         {
00769         protected:
00770             SceneManager* mSceneMgr;
00771             ShadowCasterList* mCasterList;
00772             bool mIsLightInFrustum;
00773             const PlaneBoundedVolumeList* mLightClipVolumeList;
00774             const Camera* mCamera;
00775             const Light* mLight;
00776             Real mFarDistSquared;
00777         public:
00778             ShadowCasterSceneQueryListener(SceneManager* sm) : mSceneMgr(sm),
00779                 mCasterList(0), mIsLightInFrustum(false), mLightClipVolumeList(0), 
00780                 mCamera(0) {}
00781             // Prepare the listener for use with a set of parameters  
00782             void prepare(bool lightInFrustum, 
00783                 const PlaneBoundedVolumeList* lightClipVolumes, 
00784                 const Light* light, const Camera* cam, ShadowCasterList* casterList, 
00785                 Real farDistSquared) 
00786             {
00787                 mCasterList = casterList;
00788                 mIsLightInFrustum = lightInFrustum;
00789                 mLightClipVolumeList = lightClipVolumes;
00790                 mCamera = cam;
00791                 mLight = light;
00792                 mFarDistSquared = farDistSquared;
00793             }
00794             bool queryResult(MovableObject* object);
00795             bool queryResult(SceneQuery::WorldFragment* fragment);
00796         };
00797 
00798         ShadowCasterSceneQueryListener* mShadowCasterQueryListener;
00799 
00806         virtual const ShadowCasterList& findShadowCastersForLight(const Light* light, 
00807             const Camera* camera);
00809         virtual void renderBasicQueueGroupObjects(RenderQueueGroup* pGroup, 
00810             QueuedRenderableCollection::OrganisationMode om);
00812         virtual void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* group, 
00813             QueuedRenderableCollection::OrganisationMode om);
00815         virtual void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* group, 
00816             QueuedRenderableCollection::OrganisationMode om);
00818         virtual void renderTextureShadowCasterQueueGroupObjects(RenderQueueGroup* group, 
00819             QueuedRenderableCollection::OrganisationMode om);
00821         virtual void renderTextureShadowReceiverQueueGroupObjects(RenderQueueGroup* group, 
00822             QueuedRenderableCollection::OrganisationMode om);
00824         virtual void renderModulativeTextureShadowedQueueGroupObjects(RenderQueueGroup* group, 
00825             QueuedRenderableCollection::OrganisationMode om);
00826 
00828         virtual void renderAdditiveTextureShadowedQueueGroupObjects(RenderQueueGroup* group, 
00829             QueuedRenderableCollection::OrganisationMode om);
00831         virtual void renderObjects(const QueuedRenderableCollection& objs, 
00832             QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping,
00833             bool doLightIteration, const LightList* manualLightList = 0);
00839         virtual void renderTransparentShadowCasterObjects(const QueuedRenderableCollection& objs, 
00840             QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping,
00841             bool doLightIteration, const LightList* manualLightList = 0);
00842 
00845         virtual void updateRenderQueueSplitOptions(void);
00848         virtual void updateRenderQueueGroupSplitOptions(RenderQueueGroup* group, 
00849             bool suppressShadows, bool suppressRenderState);
00850 
00852         virtual ClipResult buildAndSetScissor(const LightList& ll, const Camera* cam);
00854         virtual void buildScissor(const Light* l, const Camera* cam, RealRect& rect);
00855         virtual void resetScissor();
00857         virtual ClipResult buildAndSetLightClip(const LightList& ll);
00858         virtual void buildLightClip(const Light* l, PlaneList& planes);
00859         virtual void resetLightClip();
00860         virtual void checkCachedLightClippingInfo();
00861 
00865         class _OgreExport SceneMgrQueuedRenderableVisitor : public QueuedRenderableVisitor
00866         {
00867         protected:
00869             const Pass* mUsedPass;
00870         public:
00871             SceneMgrQueuedRenderableVisitor() 
00872                 :transparentShadowCastersMode(false) {}
00873             ~SceneMgrQueuedRenderableVisitor() {}
00874             void visit(Renderable* r);
00875             bool visit(const Pass* p);
00876             void visit(RenderablePass* rp);
00877 
00879             SceneManager* targetSceneMgr;
00881             bool transparentShadowCastersMode;
00883             bool autoLights;
00885             const LightList* manualLightList;
00887             bool scissoring;
00888 
00889         };
00891         friend class SceneMgrQueuedRenderableVisitor;
00893         SceneMgrQueuedRenderableVisitor* mActiveQueuedRenderableVisitor;
00895         SceneMgrQueuedRenderableVisitor mDefaultQueuedRenderableVisitor;
00896 
00898         bool mCameraRelativeRendering;
00899         Matrix4 mCachedViewMatrix;
00900         Vector3 mCameraRelativePosition;
00901 
00902     public:
00905         SceneManager(const String& instanceName);
00906 
00909         virtual ~SceneManager();
00910 
00911 
00937         OGRE_MUTEX(sceneGraphMutex)
00938 
00939         
00940         const String& getName(void) const { return mName; }
00941 
00948         virtual const String& getTypeName(void) const = 0;
00949 
00957         virtual Camera* createCamera(const String& name);
00958 
00962         virtual Camera* getCamera(const String& name) const;
00963 
00966         virtual bool hasCamera(const String& name) const;
00967 
00976         virtual void destroyCamera(Camera *cam);
00977 
00983         virtual void destroyCamera(const String& name);
00984 
00993         virtual void destroyAllCameras(void);
00994 
01005         virtual Light* createLight(const String& name);
01006 
01010         virtual Light* getLight(const String& name) const;
01011 
01014         virtual bool hasLight(const String& name) const;
01015 
01018         virtual const PlaneList& getLightClippingPlanes(Light* l);
01019 
01022         virtual const RealRect& getLightScissorRect(Light* l, const Camera* cam);
01023 
01028         virtual void destroyLight(const String& name);
01029 
01034         virtual void destroyLight(Light* light);
01037         virtual void destroyAllLights(void);
01038 
01049         virtual void _notifyLightsDirty(void);
01050 
01063         ulong _getLightsDirtyCounter(void) const { return mLightsDirtyCounter; }
01064 
01071         virtual const LightList& _getLightsAffectingFrustum(void) const;
01072 
01094         virtual void _populateLightList(const Vector3& position, Real radius, LightList& destList);
01095 
01096 
01113         virtual SceneNode* createSceneNode(void);
01114 
01129         virtual SceneNode* createSceneNode(const String& name);
01130 
01137         virtual void destroySceneNode(const String& name);
01138 
01145         virtual void destroySceneNode(SceneNode* sn);
01161         virtual SceneNode* getRootSceneNode(void);
01162 
01170         virtual SceneNode* getSceneNode(const String& name) const;
01171 
01174         virtual bool hasSceneNode(const String& name) const;
01175 
01176 
01184         virtual Entity* createEntity(const String& entityName, const String& meshName);
01185 
01192         enum PrefabType {
01193             PT_PLANE,
01194             PT_CUBE,
01195             PT_SPHERE
01196         };
01197 
01204         virtual Entity* createEntity(const String& entityName, PrefabType ptype);
01208         virtual Entity* getEntity(const String& name) const;
01211         virtual bool hasEntity(const String& name) const;
01212 
01221         virtual void destroyEntity(Entity* ent);
01222 
01231         virtual void destroyEntity(const String& name);
01232 
01242         virtual void destroyAllEntities(void);
01243 
01249         virtual ManualObject* createManualObject(const String& name);
01253         virtual ManualObject* getManualObject(const String& name) const;
01256         virtual bool hasManualObject(const String& name) const;
01257 
01260         virtual void destroyManualObject(ManualObject* obj);
01263         virtual void destroyManualObject(const String& name);
01266         virtual void destroyAllManualObjects(void);
01272         virtual BillboardChain* createBillboardChain(const String& name);
01276         virtual BillboardChain* getBillboardChain(const String& name) const;
01279         virtual bool hasBillboardChain(const String& name) const;
01280 
01283         virtual void destroyBillboardChain(BillboardChain* obj);
01286         virtual void destroyBillboardChain(const String& name);
01289         virtual void destroyAllBillboardChains(void);       
01295         virtual RibbonTrail* createRibbonTrail(const String& name);
01299         virtual RibbonTrail* getRibbonTrail(const String& name) const;
01302         virtual bool hasRibbonTrail(const String& name) const;
01303 
01306         virtual void destroyRibbonTrail(RibbonTrail* obj);
01309         virtual void destroyRibbonTrail(const String& name);
01312         virtual void destroyAllRibbonTrails(void);      
01313 
01334         virtual ParticleSystem* createParticleSystem(const String& name,
01335             const String& templateName);
01355         virtual ParticleSystem* createParticleSystem(const String& name,
01356             size_t quota = 500, 
01357             const String& resourceGroup = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
01361         virtual ParticleSystem* getParticleSystem(const String& name) const;
01364         virtual bool hasParticleSystem(const String& name) const;
01365 
01368         virtual void destroyParticleSystem(ParticleSystem* obj);
01371         virtual void destroyParticleSystem(const String& name);
01374         virtual void destroyAllParticleSystems(void);       
01375 
01381         virtual void clearScene(void);
01382 
01395         void setAmbientLight(const ColourValue& colour);
01396 
01399         const ColourValue& getAmbientLight(void) const;
01400 
01416         virtual void prepareWorldGeometry(const String& filename);
01417 
01435         virtual void prepareWorldGeometry(DataStreamPtr& stream, 
01436             const String& typeName = StringUtil::BLANK);
01437 
01450         virtual void setWorldGeometry(const String& filename);
01451 
01467         virtual void setWorldGeometry(DataStreamPtr& stream, 
01468             const String& typeName = StringUtil::BLANK);
01469 
01482         virtual size_t estimateWorldGeometry(const String& filename) { return 0; }
01483 
01496         virtual size_t estimateWorldGeometry(DataStreamPtr& stream, 
01497             const String& typeName = StringUtil::BLANK) { return 0; }
01512         virtual ViewPoint getSuggestedViewpoint(bool random = false);
01513 
01527         virtual bool setOption( const String& strKey, const void* pValue ) { return false; }
01528 
01542         virtual bool getOption( const String& strKey, void* pDestValue ) { return false; }
01543 
01553         virtual bool hasOption( const String& strKey ) const { return false; }
01568         virtual bool getOptionValues( const String& strKey, StringVector& refValueList ) { return false; }
01569 
01576         virtual bool getOptionKeys( StringVector& refKeys ) { return false; }
01577 
01586         virtual void _updateSceneGraph(Camera* cam);
01587 
01599         virtual void _findVisibleObjects(Camera* cam, VisibleObjectsBoundsInfo* visibleBounds, bool onlyShadowCasters);
01600 
01605         virtual void _applySceneAnimations(void);
01606 
01609         virtual void _renderVisibleObjects(void);
01610 
01624         virtual void _renderScene(Camera* camera, Viewport* vp, bool includeOverlays);
01625 
01629         virtual void _queueSkiesForRendering(Camera* cam);
01630 
01631 
01632 
01641         virtual void _setDestinationRenderSystem(RenderSystem* sys);
01642 
01696         virtual void setSkyPlane(
01697             bool enable,
01698             const Plane& plane, const String& materialName, Real scale = 1000,
01699             Real tiling = 10, bool drawFirst = true, Real bow = 0, 
01700             int xsegments = 1, int ysegments = 1, 
01701             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
01745         virtual void _setSkyPlane(
01746             bool enable,
01747             const Plane& plane, const String& materialName, Real scale = 1000,
01748             Real tiling = 10, uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, Real bow = 0, 
01749             int xsegments = 1, int ysegments = 1, 
01750             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
01751 
01753         virtual bool isSkyPlaneEnabled(void) const { return mSkyPlaneEnabled; }
01754 
01756         virtual SceneNode* getSkyPlaneNode(void) const { return mSkyPlaneNode; }
01757 
01759         virtual const SkyPlaneGenParameters& getSkyPlaneGenParameters(void) const { return mSkyPlaneGenParameters; }
01760 
01802         virtual void setSkyBox(
01803             bool enable, const String& materialName, Real distance = 5000,
01804             bool drawFirst = true, const Quaternion& orientation = Quaternion::IDENTITY,
01805             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
01806 
01839         virtual void _setSkyBox(
01840             bool enable, const String& materialName, Real distance = 5000,
01841             uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, const Quaternion& orientation = Quaternion::IDENTITY,
01842             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
01843 
01845         virtual bool isSkyBoxEnabled(void) const { return mSkyBoxEnabled; }
01846 
01848         virtual SceneNode* getSkyBoxNode(void) const { return mSkyBoxNode; }
01849 
01851         virtual const SkyBoxGenParameters& getSkyBoxGenParameters(void) const { return mSkyBoxGenParameters; }
01852 
01908         virtual void setSkyDome(
01909             bool enable, const String& materialName, Real curvature = 10,
01910             Real tiling = 8, Real distance = 4000, bool drawFirst = true,
01911             const Quaternion& orientation = Quaternion::IDENTITY,
01912             int xsegments = 16, int ysegments = 16, int ysegments_keep = -1,
01913             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
01914 
01961         virtual void _setSkyDome(
01962             bool enable, const String& materialName, Real curvature = 10,
01963             Real tiling = 8, Real distance = 4000, uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY,
01964             const Quaternion& orientation = Quaternion::IDENTITY,
01965             int xsegments = 16, int ysegments = 16, int ysegments_keep = -1,
01966             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
01967 
01969         virtual bool isSkyDomeEnabled(void) const { return mSkyDomeEnabled; }
01970 
01972         virtual SceneNode* getSkyDomeNode(void) const { return mSkyDomeNode; }
01973 
01975         virtual const SkyDomeGenParameters& getSkyDomeGenParameters(void) const { return mSkyDomeGenParameters; }
01976 
02001         void setFog(
02002             FogMode mode = FOG_NONE, const ColourValue& colour = ColourValue::White,
02003             Real expDensity = 0.001, Real linearStart = 0.0, Real linearEnd = 1.0);
02004 
02007         virtual FogMode getFogMode(void) const;
02008 
02011         virtual const ColourValue& getFogColour(void) const;
02012 
02015         virtual Real getFogStart(void) const;
02016 
02019         virtual Real getFogEnd(void) const;
02020 
02023         virtual Real getFogDensity(void) const;
02024 
02025 
02043         virtual BillboardSet* createBillboardSet(const String& name, unsigned int poolSize = 20);
02044 
02048         virtual BillboardSet* getBillboardSet(const String& name) const;
02051         virtual bool hasBillboardSet(const String& name) const;
02052 
02059         virtual void destroyBillboardSet(BillboardSet* set);
02060 
02067         virtual void destroyBillboardSet(const String& name);
02068 
02078         virtual void destroyAllBillboardSets(void);
02079 
02087         virtual void setDisplaySceneNodes(bool display);
02089         virtual bool getDisplaySceneNodes(void) const {return mDisplayNodes;}
02090 
02111         virtual Animation* createAnimation(const String& name, Real length);
02112 
02116         virtual Animation* getAnimation(const String& name) const;
02119         virtual bool hasAnimation(const String& name) const;
02120 
02126         virtual void destroyAnimation(const String& name);
02127 
02129         virtual void destroyAllAnimations(void);
02130 
02158         virtual AnimationState* createAnimationState(const String& animName);
02159 
02163         virtual AnimationState* getAnimationState(const String& animName) const;
02166         virtual bool hasAnimationState(const String& name) const;
02167 
02173         virtual void destroyAnimationState(const String& name);
02174 
02176         virtual void destroyAllAnimationStates(void);
02177 
02201         virtual void manualRender(RenderOperation* rend, Pass* pass, Viewport* vp, 
02202             const Matrix4& worldMatrix, const Matrix4& viewMatrix, const Matrix4& projMatrix, 
02203             bool doBeginEndFrame = false) ;
02204 
02215         virtual RenderQueue* getRenderQueue(void);
02216 
02220         virtual void addRenderQueueListener(RenderQueueListener* newListener);
02221 
02223         virtual void removeRenderQueueListener(RenderQueueListener* delListener);
02224 
02238         virtual void addSpecialCaseRenderQueue(uint8 qid);
02244         virtual void removeSpecialCaseRenderQueue(uint8 qid);
02248         virtual void clearSpecialCaseRenderQueues(void);
02253         virtual void setSpecialCaseRenderQueueMode(SpecialCaseRenderQueueMode mode);
02255         virtual SpecialCaseRenderQueueMode getSpecialCaseRenderQueueMode(void);
02262         virtual bool isRenderQueueToBeProcessed(uint8 qid);
02263 
02279         virtual void setWorldGeometryRenderQueue(uint8 qid);
02290         virtual uint8 getWorldGeometryRenderQueue(void);
02291 
02293         virtual void showBoundingBoxes(bool bShow);
02294 
02296         virtual bool getShowBoundingBoxes() const;
02297 
02299         virtual void _notifyAutotrackingSceneNode(SceneNode* node, bool autoTrack);
02300 
02301         
02314         virtual AxisAlignedBoxSceneQuery* 
02315             createAABBQuery(const AxisAlignedBox& box, unsigned long mask = 0xFFFFFFFF);
02328         virtual SphereSceneQuery* 
02329             createSphereQuery(const Sphere& sphere, unsigned long mask = 0xFFFFFFFF);
02342         virtual PlaneBoundedVolumeListSceneQuery* 
02343             createPlaneBoundedVolumeQuery(const PlaneBoundedVolumeList& volumes, unsigned long mask = 0xFFFFFFFF);
02344 
02345 
02358         virtual RaySceneQuery* 
02359             createRayQuery(const Ray& ray, unsigned long mask = 0xFFFFFFFF);
02360         //PyramidSceneQuery* createPyramidQuery(const Pyramid& p, unsigned long mask = 0xFFFFFFFF);
02372         virtual IntersectionSceneQuery* 
02373             createIntersectionQuery(unsigned long mask = 0xFFFFFFFF);
02374 
02376         virtual void destroyQuery(SceneQuery* query);
02377 
02378         typedef MapIterator<CameraList> CameraIterator;
02379         typedef MapIterator<AnimationList> AnimationIterator;
02380 
02383         CameraIterator getCameraIterator(void) {
02384             return CameraIterator(mCameras.begin(), mCameras.end());
02385         }
02387         AnimationIterator getAnimationIterator(void) {
02388             return AnimationIterator(mAnimationsList.begin(), mAnimationsList.end());
02389         }
02391         AnimationStateIterator getAnimationStateIterator(void) {
02392             return mAnimationStates.getAnimationStateIterator();
02393         }
02394 
02427         virtual void setShadowTechnique(ShadowTechnique technique);
02428         
02430         virtual ShadowTechnique getShadowTechnique(void) const { return mShadowTechnique; }
02431 
02433         virtual void setShowDebugShadows(bool debug) { mDebugShadows = debug; }
02435         virtual bool getShowDebugShadows(void ) const { return mDebugShadows; }
02436 
02443         virtual void setShadowColour(const ColourValue& colour);
02450         virtual const ColourValue& getShadowColour(void) const;
02462         virtual void setShadowDirectionalLightExtrusionDistance(Real dist); 
02465         virtual Real getShadowDirectionalLightExtrusionDistance(void) const;
02482         virtual void setShadowFarDistance(Real distance);
02486         virtual Real getShadowFarDistance(void) const
02487         { return mDefaultShadowFarDist; }
02488         virtual Real getShadowFarDistanceSquared(void) const
02489         { return mDefaultShadowFarDistSquared; }
02490 
02516         virtual void setShadowIndexBufferSize(size_t size);
02518         virtual size_t getShadowIndexBufferSize(void) const
02519         { return mShadowIndexBufferSize; }
02528         virtual void setShadowTextureSize(unsigned short size);
02529 
02536         virtual void setShadowTextureConfig(size_t shadowIndex, unsigned short width, 
02537             unsigned short height, PixelFormat format);
02543         virtual void setShadowTextureConfig(size_t shadowIndex, 
02544             const ShadowTextureConfig& config);
02545 
02547         ConstShadowTextureConfigIterator getShadowTextureConfigIterator() const;
02548 
02560         virtual void setShadowTexturePixelFormat(PixelFormat fmt);
02568         virtual void setShadowTextureCount(size_t count);
02570         size_t getShadowTextureCount(void) const {return mShadowTextureConfigList.size(); }
02571 
02581         void setShadowTextureCountPerLightType(Light::LightTypes type, size_t count)
02582         { mShadowTextureCountPerType[type] = count; }
02584         size_t getShadowTextureCountPerLightType(Light::LightTypes type) const
02585         {return mShadowTextureCountPerType[type]; }
02586 
02595         virtual void setShadowTextureSettings(unsigned short size, unsigned short count, 
02596             PixelFormat fmt = PF_X8R8G8B8);
02597 
02604         virtual const TexturePtr& getShadowTexture(size_t shadowIndex);
02605 
02620         virtual void setShadowDirLightTextureOffset(Real offset) { mShadowTextureOffset = offset;}
02624         virtual Real getShadowDirLightTextureOffset(void)  const { return mShadowTextureOffset; }
02632         virtual void setShadowTextureFadeStart(Real fadeStart) 
02633         { mShadowTextureFadeStart = fadeStart; }
02641         virtual void setShadowTextureFadeEnd(Real fadeEnd) 
02642         { mShadowTextureFadeEnd = fadeEnd; }
02643 
02656         virtual void setShadowTextureSelfShadow(bool selfShadow); 
02657 
02659         virtual bool getShadowTextureSelfShadow(void) const 
02660         { return mShadowTextureSelfShadow; }
02681         virtual void setShadowTextureCasterMaterial(const String& name);
02703         virtual void setShadowTextureReceiverMaterial(const String& name);
02704 
02715         virtual void setShadowCasterRenderBackFaces(bool bf) { mShadowCasterRenderBackFaces = bf; }
02716 
02720         virtual bool getShadowCasterRenderBackFaces() const { return mShadowCasterRenderBackFaces; }
02721 
02726         virtual void setShadowCameraSetup(const ShadowCameraSetupPtr& shadowSetup);
02727 
02732         virtual const ShadowCameraSetupPtr& getShadowCameraSetup() const;
02733 
02770         virtual void setShadowUseInfiniteFarPlane(bool enable) {
02771             mShadowUseInfiniteFarPlane = enable; }
02772 
02774         virtual bool isShadowTechniqueStencilBased(void) const 
02775         { return (mShadowTechnique & SHADOWDETAILTYPE_STENCIL) != 0; }
02777         virtual bool isShadowTechniqueTextureBased(void) const 
02778         { return (mShadowTechnique & SHADOWDETAILTYPE_TEXTURE) != 0; }
02780         virtual bool isShadowTechniqueModulative(void) const 
02781         { return (mShadowTechnique & SHADOWDETAILTYPE_MODULATIVE) != 0; }
02783         virtual bool isShadowTechniqueAdditive(void) const 
02784         { return (mShadowTechnique & SHADOWDETAILTYPE_ADDITIVE) != 0; }
02786         virtual bool isShadowTechniqueIntegrated(void) const 
02787         { return (mShadowTechnique & SHADOWDETAILTYPE_INTEGRATED) != 0; }
02789         virtual bool isShadowTechniqueInUse(void) const 
02790         { return mShadowTechnique != SHADOWTYPE_NONE; }
02794         virtual void setShadowUseLightClipPlanes(bool enabled) { mShadowAdditiveLightClip = enabled; }
02798         virtual bool getShadowUseLightClipPlanes() const { return mShadowAdditiveLightClip; }
02799 
02802         virtual void addListener(Listener* s);
02805         virtual void removeListener(Listener* s);
02806 
02816         virtual StaticGeometry* createStaticGeometry(const String& name);
02820         virtual StaticGeometry* getStaticGeometry(const String& name) const;
02822         virtual bool hasStaticGeometry(const String& name) const;
02824         virtual void destroyStaticGeometry(StaticGeometry* geom);
02826         virtual void destroyStaticGeometry(const String& name);
02828         virtual void destroyAllStaticGeometry(void);
02829 
02839         virtual InstancedGeometry* createInstancedGeometry(const String& name);
02841         virtual InstancedGeometry* getInstancedGeometry(const String& name) const;
02843         virtual void destroyInstancedGeometry(InstancedGeometry* geom);
02845         virtual void destroyInstancedGeometry(const String& name);
02847         virtual void destroyAllInstancedGeometry(void);
02848 
02849 
02860         virtual MovableObject* createMovableObject(const String& name, 
02861             const String& typeName, const NameValuePairList* params = 0);
02867         virtual void destroyMovableObject(const String& name, const String& typeName);
02873         virtual void destroyMovableObject(MovableObject* m);
02875         virtual void destroyAllMovableObjectsByType(const String& typeName);
02877         virtual void destroyAllMovableObjects(void);
02881         virtual MovableObject* getMovableObject(const String& name, const String& typeName) const;
02883         virtual bool hasMovableObject(const String& name, const String& typeName) const;
02884         typedef MapIterator<MovableObjectMap> MovableObjectIterator;
02890         virtual MovableObjectIterator getMovableObjectIterator(const String& typeName);
02902         virtual void injectMovableObject(MovableObject* m);
02909         virtual void extractMovableObject(const String& name, const String& typeName);
02916         virtual void extractMovableObject(MovableObject* m);
02923         virtual void extractAllMovableObjectsByType(const String& typeName);
02924 
02931         virtual void setVisibilityMask(uint32 vmask) { mVisibilityMask = vmask; }
02932 
02936         virtual uint32 getVisibilityMask(void) { return mVisibilityMask; }
02937 
02941         uint32 _getCombinedVisibilityMask(void) const;
02942 
02949         virtual void setFindVisibleObjects(bool find) { mFindVisibleObjects = find; }
02950 
02954         virtual bool getFindVisibleObjects(void) { return mFindVisibleObjects; }
02955 
02964         virtual void setNormaliseNormalsOnScale(bool n) { mNormaliseNormalsOnScale = n; }
02965 
02969         virtual bool getNormaliseNormalsOnScale() const { return mNormaliseNormalsOnScale; }
02970 
02979         virtual void setFlipCullingOnNegativeScale(bool n) { mFlipCullingOnNegativeScale = n; }
02980 
02984         virtual bool getFlipCullingOnNegativeScale() const { return mFlipCullingOnNegativeScale; }
02985 
02991         virtual void _injectRenderWithPass(Pass *pass, Renderable *rend, bool shadowDerivation = true);
02992 
03011         virtual void _suppressRenderStateChanges(bool suppress);
03012         
03016         virtual bool _areRenderStateChangesSuppressed(void) const
03017         { return mSuppressRenderStateChanges; }
03018 
03031         virtual const Pass* _setPass(const Pass* pass, 
03032             bool evenIfSuppressed = false, bool shadowDerivation = true);
03033 
03034 
03044         virtual void _suppressShadows(bool suppress); 
03045 
03049         virtual bool _areShadowsSuppressed(void) const
03050         { return mSuppressShadows; }
03051 
03055         virtual void _renderQueueGroupObjects(RenderQueueGroup* group, 
03056             QueuedRenderableCollection::OrganisationMode om);
03057 
03073         void setQueuedRenderableVisitor(SceneMgrQueuedRenderableVisitor* visitor);
03074 
03076         SceneMgrQueuedRenderableVisitor* getQueuedRenderableVisitor(void) const;
03077 
03078 
03082         RenderSystem *getDestinationRenderSystem();
03083 
03086         Viewport* getCurrentViewport(void) const { return mCurrentViewport; }
03087 
03089         const VisibleObjectsBoundsInfo& getVisibleObjectsBoundsInfo(const Camera* cam) const;
03090 
03092         const VisibleObjectsBoundsInfo& getShadowCasterBoundsInfo(const Light* light, size_t iteration = 0) const;
03093 
03108         virtual void setCameraRelativeRendering(bool rel) { mCameraRelativeRendering = rel; }
03109 
03113         virtual bool getCameraRelativeRendering() const { return mCameraRelativeRendering; }
03114     };
03115 
03117     class _OgreExport DefaultIntersectionSceneQuery : 
03118         public IntersectionSceneQuery
03119     {
03120     public:
03121         DefaultIntersectionSceneQuery(SceneManager* creator);
03122         ~DefaultIntersectionSceneQuery();
03123 
03125         void execute(IntersectionSceneQueryListener* listener);
03126     };
03127 
03129     class _OgreExport DefaultRaySceneQuery : public RaySceneQuery
03130     {
03131     public:
03132         DefaultRaySceneQuery(SceneManager* creator);
03133         ~DefaultRaySceneQuery();
03134 
03136         void execute(RaySceneQueryListener* listener);
03137     };
03139     class _OgreExport DefaultSphereSceneQuery : public SphereSceneQuery
03140     {
03141     public:
03142         DefaultSphereSceneQuery(SceneManager* creator);
03143         ~DefaultSphereSceneQuery();
03144 
03146         void execute(SceneQueryListener* listener);
03147     };
03149     class _OgreExport DefaultPlaneBoundedVolumeListSceneQuery : public PlaneBoundedVolumeListSceneQuery
03150     {
03151     public:
03152         DefaultPlaneBoundedVolumeListSceneQuery(SceneManager* creator);
03153         ~DefaultPlaneBoundedVolumeListSceneQuery();
03154 
03156         void execute(SceneQueryListener* listener);
03157     };
03159     class _OgreExport DefaultAxisAlignedBoxSceneQuery : public AxisAlignedBoxSceneQuery
03160     {
03161     public:
03162         DefaultAxisAlignedBoxSceneQuery(SceneManager* creator);
03163         ~DefaultAxisAlignedBoxSceneQuery();
03164 
03166         void execute(SceneQueryListener* listener);
03167     };
03168     
03169 
03171     typedef uint16 SceneTypeMask;
03172 
03176     enum SceneType
03177     {
03178         ST_GENERIC = 1,
03179         ST_EXTERIOR_CLOSE = 2,
03180         ST_EXTERIOR_FAR = 4,
03181         ST_EXTERIOR_REAL_FAR = 8,
03182         ST_INTERIOR = 16
03183     };
03184 
03186     struct SceneManagerMetaData
03187     {
03189         String typeName;
03191         String description;
03193         SceneTypeMask sceneTypeMask;
03195         bool worldGeometrySupported;
03196     };
03197 
03198 
03199 
03201     class _OgreExport SceneManagerFactory : public SceneMgtAlloc
03202     {
03203     protected:
03204         mutable SceneManagerMetaData mMetaData;
03205         mutable bool mMetaDataInit;
03207         virtual void initMetaData(void) const = 0;
03208     public:
03209         SceneManagerFactory() : mMetaDataInit(true) {}
03210         virtual ~SceneManagerFactory() {}
03212         virtual const SceneManagerMetaData& getMetaData(void) const 
03213         {
03214             if (mMetaDataInit)
03215             {
03216                 initMetaData();
03217                 mMetaDataInit = false;
03218             }
03219             return mMetaData; 
03220         }
03225         virtual SceneManager* createInstance(const String& instanceName) = 0;
03227         virtual void destroyInstance(SceneManager* instance) = 0;
03228 
03229     };
03230 
03231 
03232 
03233 } // Namespace
03234 
03235 
03236 
03237 #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 Thu Aug 28 20:53:52 2008