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
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Tue Nov 4 11:02:33 2008