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