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; 00084 Real minDistanceInFrustum; 00086 Real maxDistanceInFrustum; 00087 00088 VisibleObjectsBoundsInfo() 00089 { 00090 reset(); 00091 } 00092 00093 void reset() 00094 { 00095 aabb.setNull(); 00096 receiverAabb.setNull(); 00097 minDistance = minDistanceInFrustum = std::numeric_limits<Real>::infinity(); 00098 maxDistance = maxDistanceInFrustum = 0; 00099 } 00100 00101 void merge(const AxisAlignedBox& boxBounds, const Sphere& sphereBounds, 00102 const Camera* cam, bool receiver=true) 00103 { 00104 aabb.merge(boxBounds); 00105 if (receiver) 00106 receiverAabb.merge(boxBounds); 00107 // use view matrix to determine distance, works with custom view matrices 00108 Vector3 vsSpherePos = cam->getViewMatrix(true) * sphereBounds.getCenter(); 00109 Real camDistToCenter = vsSpherePos.length(); 00110 minDistance = (std::min)(minDistance, (std::max)((Real)0, camDistToCenter - sphereBounds.getRadius())); 00111 maxDistance = (std::max)(maxDistance, camDistToCenter + sphereBounds.getRadius()); 00112 minDistanceInFrustum = (std::min)(minDistanceInFrustum, (std::max)((Real)0, camDistToCenter - sphereBounds.getRadius())); 00113 maxDistanceInFrustum = (std::max)(maxDistanceInFrustum, camDistToCenter + sphereBounds.getRadius()); 00114 } 00115 00119 void mergeNonRenderedButInFrustum(const AxisAlignedBox& boxBounds, 00120 const Sphere& sphereBounds, const Camera* cam) 00121 { 00122 // use view matrix to determine distance, works with custom view matrices 00123 Vector3 vsSpherePos = cam->getViewMatrix(true) * sphereBounds.getCenter(); 00124 Real camDistToCenter = vsSpherePos.length(); 00125 minDistanceInFrustum = (std::min)(minDistanceInFrustum, (std::max)((Real)0, camDistToCenter - sphereBounds.getRadius())); 00126 maxDistanceInFrustum = (std::max)(maxDistanceInFrustum, camDistToCenter + sphereBounds.getRadius()); 00127 00128 } 00129 00130 00131 }; 00132 00162 class _OgreExport SceneManager : public SceneMgtAlloc 00163 { 00164 public: 00166 static uint32 WORLD_GEOMETRY_TYPE_MASK; 00168 static uint32 ENTITY_TYPE_MASK; 00170 static uint32 FX_TYPE_MASK; 00172 static uint32 STATICGEOMETRY_TYPE_MASK; 00174 static uint32 LIGHT_TYPE_MASK; 00176 static uint32 FRUSTUM_TYPE_MASK; 00178 static uint32 USER_TYPE_MASK_LIMIT; 00181 struct materialLess 00182 { 00183 _OgreExport bool operator()(const Material* x, const Material* y) const; 00184 }; 00186 struct lightLess 00187 { 00188 _OgreExport bool operator()(const Light* a, const Light* b) const; 00189 }; 00190 00192 enum IlluminationRenderStage 00193 { 00195 IRS_NONE, 00197 IRS_RENDER_TO_TEXTURE, 00199 IRS_RENDER_RECEIVER_PASS 00200 }; 00201 00206 enum SpecialCaseRenderQueueMode 00207 { 00209 SCRQM_INCLUDE, 00211 SCRQM_EXCLUDE 00212 }; 00213 00214 struct SkyDomeGenParameters 00215 { 00216 Real skyDomeCurvature; 00217 Real skyDomeTiling; 00218 Real skyDomeDistance; 00219 int skyDomeXSegments; 00220 int skyDomeYSegments; 00221 int skyDomeYSegments_keep; 00222 }; 00223 00224 struct SkyPlaneGenParameters 00225 { 00226 Real skyPlaneScale; 00227 Real skyPlaneTiling; 00228 Real skyPlaneBow; 00229 int skyPlaneXSegments; 00230 int skyPlaneYSegments; 00231 }; 00232 00233 struct SkyBoxGenParameters 00234 { 00235 Real skyBoxDistance; 00236 }; 00237 00241 class Listener 00242 { 00243 public: 00244 Listener() {} 00245 virtual ~Listener() {} 00246 00256 virtual void preFindVisibleObjects(SceneManager* source, 00257 IlluminationRenderStage irs, Viewport* v) = 0; 00268 virtual void postFindVisibleObjects(SceneManager* source, 00269 IlluminationRenderStage irs, Viewport* v) = 0; 00270 00285 virtual void shadowTexturesUpdated(size_t numberOfShadowTextures) = 0; 00286 00300 virtual void shadowTextureCasterPreViewProj(Light* light, 00301 Camera* camera, size_t iteration) = 0; 00315 virtual void shadowTextureReceiverPreViewProj(Light* light, 00316 Frustum* frustum) = 0; 00317 00340 virtual bool sortLightsAffectingFrustum(LightList& lightList) { return false; } 00341 00342 00343 00344 }; 00345 00349 class _OgreExport SceneMgrQueuedRenderableVisitor : public QueuedRenderableVisitor 00350 { 00351 protected: 00353 const Pass* mUsedPass; 00354 public: 00355 SceneMgrQueuedRenderableVisitor() 00356 :transparentShadowCastersMode(false) {} 00357 ~SceneMgrQueuedRenderableVisitor() {} 00358 void visit(Renderable* r); 00359 bool visit(const Pass* p); 00360 void visit(RenderablePass* rp); 00361 00363 SceneManager* targetSceneMgr; 00365 bool transparentShadowCastersMode; 00367 bool autoLights; 00369 const LightList* manualLightList; 00371 bool scissoring; 00372 00373 }; 00375 friend class SceneMgrQueuedRenderableVisitor; 00376 00377 protected: 00378 00380 virtual SceneNode* createSceneNodeImpl(void); 00382 virtual SceneNode* createSceneNodeImpl(const String& name); 00383 00385 String mName; 00386 00388 RenderQueue* mRenderQueue; 00389 bool mLastRenderQueueInvocationCustom; 00390 00392 ColourValue mAmbientLight; 00393 00395 RenderSystem *mDestRenderSystem; 00396 00397 typedef std::map<String, Camera* > CameraList; 00398 00401 CameraList mCameras; 00402 00403 typedef std::map<String, StaticGeometry* > StaticGeometryList; 00404 StaticGeometryList mStaticGeometryList; 00405 typedef std::map<String, InstancedGeometry* > InstancedGeometryList; 00406 InstancedGeometryList mInstancedGeometryList; 00407 00408 typedef std::map<String, SceneNode*> SceneNodeList; 00409 00416 SceneNodeList mSceneNodes; 00417 00419 Camera* mCameraInProgress; 00421 Viewport* mCurrentViewport; 00422 00424 SceneNode* mSceneRoot; 00425 00427 typedef std::set<SceneNode*> AutoTrackingSceneNodes; 00428 AutoTrackingSceneNodes mAutoTrackingSceneNodes; 00429 00430 // Sky params 00431 // Sky plane 00432 Entity* mSkyPlaneEntity; 00433 Entity* mSkyDomeEntity[5]; 00434 ManualObject* mSkyBoxObj; 00435 00436 SceneNode* mSkyPlaneNode; 00437 SceneNode* mSkyDomeNode; 00438 SceneNode* mSkyBoxNode; 00439 00440 // Sky plane 00441 bool mSkyPlaneEnabled; 00442 uint8 mSkyPlaneRenderQueue; 00443 Plane mSkyPlane; 00444 SkyPlaneGenParameters mSkyPlaneGenParameters; 00445 // Sky box 00446 bool mSkyBoxEnabled; 00447 uint8 mSkyBoxRenderQueue; 00448 Quaternion mSkyBoxOrientation; 00449 SkyBoxGenParameters mSkyBoxGenParameters; 00450 // Sky dome 00451 bool mSkyDomeEnabled; 00452 uint8 mSkyDomeRenderQueue; 00453 Quaternion mSkyDomeOrientation; 00454 SkyDomeGenParameters mSkyDomeGenParameters; 00455 00456 // Fog 00457 FogMode mFogMode; 00458 ColourValue mFogColour; 00459 Real mFogStart; 00460 Real mFogEnd; 00461 Real mFogDensity; 00462 00463 typedef std::set<uint8> SpecialCaseRenderQueueList; 00464 SpecialCaseRenderQueueList mSpecialCaseQueueList; 00465 SpecialCaseRenderQueueMode mSpecialCaseQueueMode; 00466 uint8 mWorldGeometryRenderQueue; 00467 00468 unsigned long mLastFrameNumber; 00469 Matrix4 mTempXform[256]; 00470 bool mResetIdentityView; 00471 bool mResetIdentityProj; 00472 00473 bool mNormaliseNormalsOnScale; 00474 bool mFlipCullingOnNegativeScale; 00475 CullingMode mPassCullingMode; 00476 00477 protected: 00478 00486 typedef std::map< const Camera*, VisibleObjectsBoundsInfo> CamVisibleObjectsMap; 00487 CamVisibleObjectsMap mCamVisibleObjectsMap; 00488 00490 typedef std::map< const Camera*, const Light* > ShadowCamLightMapping; 00491 ShadowCamLightMapping mShadowCamLightMapping; 00492 00494 size_t mShadowTextureCountPerType[3]; 00495 00497 std::vector<size_t> mShadowTextureIndexLightList; 00498 00500 struct _OgreExport LightInfo 00501 { 00502 Light* light; // Just a pointer for comparison, the light might destroyed for some reason 00503 int type; // Use int instead of Light::LightTypes to avoid header file dependence 00504 Real range; // Sets to zero if directional light 00505 Vector3 position; // Sets to zero if directional light 00506 00507 bool operator== (const LightInfo& rhs) const 00508 { 00509 return light == rhs.light && type == rhs.type && 00510 range == rhs.range && position == rhs.position; 00511 } 00512 00513 bool operator!= (const LightInfo& rhs) const 00514 { 00515 return !(*this == rhs); 00516 } 00517 }; 00518 00519 typedef std::vector<LightInfo> LightInfoList; 00520 00521 LightList mLightsAffectingFrustum; 00522 LightInfoList mCachedLightInfos; 00523 LightInfoList mTestLightInfos; // potentially new list 00524 ulong mLightsDirtyCounter; 00525 00526 typedef std::map<String, MovableObject*> MovableObjectMap; 00528 struct MovableObjectCollection 00529 { 00530 MovableObjectMap map; 00531 OGRE_MUTEX(mutex) 00532 }; 00533 typedef std::map<String, MovableObjectCollection*> MovableObjectCollectionMap; 00534 MovableObjectCollectionMap mMovableObjectCollectionMap; 00539 MovableObjectCollection* getMovableObjectCollection(const String& typeName); 00544 const MovableObjectCollection* getMovableObjectCollection(const String& typeName) const; 00546 OGRE_MUTEX(mMovableObjectCollectionMapMutex) 00547 00548 00552 virtual void initRenderQueue(void); 00554 Pass* mShadowCasterPlainBlackPass; 00556 Pass* mShadowReceiverPass; 00566 virtual const Pass* deriveShadowCasterPass(const Pass* pass); 00575 virtual const Pass* deriveShadowReceiverPass(const Pass* pass); 00576 00583 virtual bool validatePassForRendering(const Pass* pass); 00584 00591 virtual bool validateRenderableForRendering(const Pass* pass, const Renderable* rend); 00592 00593 enum BoxPlane 00594 { 00595 BP_FRONT = 0, 00596 BP_BACK = 1, 00597 BP_LEFT = 2, 00598 BP_RIGHT = 3, 00599 BP_UP = 4, 00600 BP_DOWN = 5 00601 }; 00602 00603 /* Internal utility method for creating the planes of a skybox. 00604 */ 00605 virtual MeshPtr createSkyboxPlane( 00606 BoxPlane bp, 00607 Real distance, 00608 const Quaternion& orientation, 00609 const String& groupName); 00610 00611 /* Internal utility method for creating the planes of a skydome. 00612 */ 00613 virtual MeshPtr createSkydomePlane( 00614 BoxPlane bp, 00615 Real curvature, Real tiling, Real distance, 00616 const Quaternion& orientation, 00617 int xsegments, int ysegments, int ySegmentsToKeep, 00618 const String& groupName); 00619 00620 // Flag indicating whether SceneNodes will be rendered as a set of 3 axes 00621 bool mDisplayNodes; 00622 00624 typedef std::map<String, Animation*> AnimationList; 00625 AnimationList mAnimationsList; 00626 OGRE_MUTEX(mAnimationsListMutex) 00627 AnimationStateSet mAnimationStates; 00628 00629 00632 virtual void useRenderableViewProjMode(const Renderable* pRend); 00633 00636 virtual void resetViewProjMode(void); 00637 00638 typedef std::vector<RenderQueueListener*> RenderQueueListenerList; 00639 RenderQueueListenerList mRenderQueueListeners; 00640 00641 typedef std::vector<Listener*> ListenerList; 00642 ListenerList mListeners; 00644 virtual bool fireRenderQueueStarted(uint8 id, const String& invocation); 00646 virtual bool fireRenderQueueEnded(uint8 id, const String& invocation); 00647 00649 virtual void fireShadowTexturesUpdated(size_t numberOfShadowTextures); 00651 virtual void fireShadowTexturesPreCaster(Light* light, Camera* camera, size_t iteration); 00653 virtual void fireShadowTexturesPreReceiver(Light* light, Frustum* f); 00655 virtual void firePreFindVisibleObjects(Viewport* v); 00657 virtual void firePostFindVisibleObjects(Viewport* v); 00659 virtual void setViewport(Viewport *vp); 00660 00662 bool mShowBoundingBoxes; 00663 00665 virtual void renderVisibleObjectsDefaultSequence(void); 00667 virtual void renderVisibleObjectsCustomSequence(RenderQueueInvocationSequence* s); 00669 virtual void prepareRenderQueue(void); 00670 00671 00687 virtual void renderSingleObject(Renderable* rend, const Pass* pass, 00688 bool lightScissoringClipping, bool doLightIteration, const LightList* manualLightList = 0); 00689 00691 virtual AutoParamDataSource* createAutoParamDataSource(void) const 00692 { 00693 return OGRE_NEW AutoParamDataSource(); 00694 } 00695 00697 AutoParamDataSource* mAutoParamDataSource; 00698 00699 ShadowTechnique mShadowTechnique; 00700 bool mDebugShadows; 00701 ColourValue mShadowColour; 00702 Pass* mShadowDebugPass; 00703 Pass* mShadowStencilPass; 00704 Pass* mShadowModulativePass; 00705 bool mShadowMaterialInitDone; 00706 HardwareIndexBufferSharedPtr mShadowIndexBuffer; 00707 size_t mShadowIndexBufferSize; 00708 Rectangle2D* mFullScreenQuad; 00709 Real mShadowDirLightExtrudeDist; 00710 IlluminationRenderStage mIlluminationStage; 00711 ShadowTextureConfigList mShadowTextureConfigList; 00712 bool mShadowTextureConfigDirty; 00713 ShadowTextureList mShadowTextures; 00714 TexturePtr mNullShadowTexture; 00715 typedef std::vector<Camera*> ShadowTextureCameraList; 00716 ShadowTextureCameraList mShadowTextureCameras; 00717 Texture* mCurrentShadowTexture; 00718 bool mShadowUseInfiniteFarPlane; 00719 bool mShadowCasterRenderBackFaces; 00720 bool mShadowAdditiveLightClip; 00722 struct LightClippingInfo 00723 { 00724 RealRect scissorRect; 00725 PlaneList clipPlanes; 00726 bool scissorValid; 00727 unsigned long clipPlanesValid; 00728 LightClippingInfo() : scissorValid(false), clipPlanesValid(false) {} 00729 00730 }; 00731 typedef std::map<Light*, LightClippingInfo> LightClippingInfoMap; 00732 LightClippingInfoMap mLightClippingInfoMap; 00733 unsigned long mLightClippingInfoMapFrameNumber; 00734 00736 ShadowCameraSetupPtr mDefaultShadowCameraSetup; 00737 00746 struct lightsForShadowTextureLess 00747 { 00748 _OgreExport bool operator()(const Light* l1, const Light* l2) const; 00749 }; 00750 00751 00758 virtual void findLightsAffectingFrustum(const Camera* camera); 00760 virtual void initShadowVolumeMaterials(void); 00762 virtual void ensureShadowTexturesCreated(); 00764 virtual void destroyShadowTextures(void); 00766 virtual void prepareShadowTextures(Camera* cam, Viewport* vp); 00767 00775 virtual void renderShadowVolumesToStencil(const Light* light, const Camera* cam, 00776 bool calcScissor); 00782 virtual void setShadowVolumeStencilState(bool secondpass, bool zfail, bool twosided); 00784 void renderShadowVolumeObjects(ShadowCaster::ShadowRenderableListIterator iShadowRenderables, 00785 Pass* pass, const LightList *manualLightList, unsigned long flags, 00786 bool secondpass, bool zfail, bool twosided); 00787 typedef std::vector<ShadowCaster*> ShadowCasterList; 00788 ShadowCasterList mShadowCasterList; 00789 SphereSceneQuery* mShadowCasterSphereQuery; 00790 AxisAlignedBoxSceneQuery* mShadowCasterAABBQuery; 00791 Real mDefaultShadowFarDist; 00792 Real mDefaultShadowFarDistSquared; 00793 Real mShadowTextureOffset; // proportion of texture offset in view direction e.g. 0.4 00794 Real mShadowTextureFadeStart; // as a proportion e.g. 0.6 00795 Real mShadowTextureFadeEnd; // as a proportion e.g. 0.9 00796 bool mShadowTextureSelfShadow; 00797 Pass* mShadowTextureCustomCasterPass; 00798 Pass* mShadowTextureCustomReceiverPass; 00799 String mShadowTextureCustomCasterVertexProgram; 00800 String mShadowTextureCustomReceiverVertexProgram; 00801 String mShadowTextureCustomReceiverFragmentProgram; 00802 GpuProgramParametersSharedPtr mShadowTextureCustomCasterVPParams; 00803 GpuProgramParametersSharedPtr mShadowTextureCustomReceiverVPParams; 00804 GpuProgramParametersSharedPtr mShadowTextureCustomReceiverFPParams; 00805 00807 uint32 mVisibilityMask; 00808 bool mFindVisibleObjects; 00809 00811 bool mSuppressRenderStateChanges; 00813 bool mSuppressShadows; 00814 00815 00816 GpuProgramParametersSharedPtr mInfiniteExtrusionParams; 00817 GpuProgramParametersSharedPtr mFiniteExtrusionParams; 00818 00820 class _OgreExport ShadowCasterSceneQueryListener : public SceneQueryListener, public SceneMgtAlloc 00821 { 00822 protected: 00823 SceneManager* mSceneMgr; 00824 ShadowCasterList* mCasterList; 00825 bool mIsLightInFrustum; 00826 const PlaneBoundedVolumeList* mLightClipVolumeList; 00827 const Camera* mCamera; 00828 const Light* mLight; 00829 Real mFarDistSquared; 00830 public: 00831 ShadowCasterSceneQueryListener(SceneManager* sm) : mSceneMgr(sm), 00832 mCasterList(0), mIsLightInFrustum(false), mLightClipVolumeList(0), 00833 mCamera(0) {} 00834 // Prepare the listener for use with a set of parameters 00835 void prepare(bool lightInFrustum, 00836 const PlaneBoundedVolumeList* lightClipVolumes, 00837 const Light* light, const Camera* cam, ShadowCasterList* casterList, 00838 Real farDistSquared) 00839 { 00840 mCasterList = casterList; 00841 mIsLightInFrustum = lightInFrustum; 00842 mLightClipVolumeList = lightClipVolumes; 00843 mCamera = cam; 00844 mLight = light; 00845 mFarDistSquared = farDistSquared; 00846 } 00847 bool queryResult(MovableObject* object); 00848 bool queryResult(SceneQuery::WorldFragment* fragment); 00849 }; 00850 00851 ShadowCasterSceneQueryListener* mShadowCasterQueryListener; 00852 00859 virtual const ShadowCasterList& findShadowCastersForLight(const Light* light, 00860 const Camera* camera); 00862 virtual void renderBasicQueueGroupObjects(RenderQueueGroup* pGroup, 00863 QueuedRenderableCollection::OrganisationMode om); 00865 virtual void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* group, 00866 QueuedRenderableCollection::OrganisationMode om); 00868 virtual void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* group, 00869 QueuedRenderableCollection::OrganisationMode om); 00871 virtual void renderTextureShadowCasterQueueGroupObjects(RenderQueueGroup* group, 00872 QueuedRenderableCollection::OrganisationMode om); 00874 virtual void renderTextureShadowReceiverQueueGroupObjects(RenderQueueGroup* group, 00875 QueuedRenderableCollection::OrganisationMode om); 00877 virtual void renderModulativeTextureShadowedQueueGroupObjects(RenderQueueGroup* group, 00878 QueuedRenderableCollection::OrganisationMode om); 00879 00881 virtual void renderAdditiveTextureShadowedQueueGroupObjects(RenderQueueGroup* group, 00882 QueuedRenderableCollection::OrganisationMode om); 00884 virtual void renderObjects(const QueuedRenderableCollection& objs, 00885 QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping, 00886 bool doLightIteration, const LightList* manualLightList = 0); 00892 virtual void renderTransparentShadowCasterObjects(const QueuedRenderableCollection& objs, 00893 QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping, 00894 bool doLightIteration, const LightList* manualLightList = 0); 00895 00898 virtual void updateRenderQueueSplitOptions(void); 00901 virtual void updateRenderQueueGroupSplitOptions(RenderQueueGroup* group, 00902 bool suppressShadows, bool suppressRenderState); 00903 00905 virtual ClipResult buildAndSetScissor(const LightList& ll, const Camera* cam); 00907 virtual void buildScissor(const Light* l, const Camera* cam, RealRect& rect); 00908 virtual void resetScissor(); 00910 virtual ClipResult buildAndSetLightClip(const LightList& ll); 00911 virtual void buildLightClip(const Light* l, PlaneList& planes); 00912 virtual void resetLightClip(); 00913 virtual void checkCachedLightClippingInfo(); 00914 00916 SceneMgrQueuedRenderableVisitor* mActiveQueuedRenderableVisitor; 00918 SceneMgrQueuedRenderableVisitor mDefaultQueuedRenderableVisitor; 00919 00921 bool mCameraRelativeRendering; 00922 Matrix4 mCachedViewMatrix; 00923 Vector3 mCameraRelativePosition; 00924 00925 public: 00928 SceneManager(const String& instanceName); 00929 00932 virtual ~SceneManager(); 00933 00934 00960 OGRE_MUTEX(sceneGraphMutex) 00961 00962 00963 const String& getName(void) const { return mName; } 00964 00971 virtual const String& getTypeName(void) const = 0; 00972 00980 virtual Camera* createCamera(const String& name); 00981 00985 virtual Camera* getCamera(const String& name) const; 00986 00989 virtual bool hasCamera(const String& name) const; 00990 00999 virtual void destroyCamera(Camera *cam); 01000 01006 virtual void destroyCamera(const String& name); 01007 01016 virtual void destroyAllCameras(void); 01017 01028 virtual Light* createLight(const String& name); 01029 01033 virtual Light* getLight(const String& name) const; 01034 01037 virtual bool hasLight(const String& name) const; 01038 01041 virtual const PlaneList& getLightClippingPlanes(Light* l); 01042 01045 virtual const RealRect& getLightScissorRect(Light* l, const Camera* cam); 01046 01051 virtual void destroyLight(const String& name); 01052 01057 virtual void destroyLight(Light* light); 01060 virtual void destroyAllLights(void); 01061 01072 virtual void _notifyLightsDirty(void); 01073 01086 ulong _getLightsDirtyCounter(void) const { return mLightsDirtyCounter; } 01087 01094 virtual const LightList& _getLightsAffectingFrustum(void) const; 01095 01117 virtual void _populateLightList(const Vector3& position, Real radius, LightList& destList); 01118 01119 01136 virtual SceneNode* createSceneNode(void); 01137 01152 virtual SceneNode* createSceneNode(const String& name); 01153 01160 virtual void destroySceneNode(const String& name); 01161 01168 virtual void destroySceneNode(SceneNode* sn); 01184 virtual SceneNode* getRootSceneNode(void); 01185 01193 virtual SceneNode* getSceneNode(const String& name) const; 01194 01197 virtual bool hasSceneNode(const String& name) const; 01198 01199 01207 virtual Entity* createEntity(const String& entityName, const String& meshName); 01208 01215 enum PrefabType { 01216 PT_PLANE, 01217 PT_CUBE, 01218 PT_SPHERE 01219 }; 01220 01227 virtual Entity* createEntity(const String& entityName, PrefabType ptype); 01231 virtual Entity* getEntity(const String& name) const; 01234 virtual bool hasEntity(const String& name) const; 01235 01244 virtual void destroyEntity(Entity* ent); 01245 01254 virtual void destroyEntity(const String& name); 01255 01265 virtual void destroyAllEntities(void); 01266 01272 virtual ManualObject* createManualObject(const String& name); 01276 virtual ManualObject* getManualObject(const String& name) const; 01279 virtual bool hasManualObject(const String& name) const; 01280 01283 virtual void destroyManualObject(ManualObject* obj); 01286 virtual void destroyManualObject(const String& name); 01289 virtual void destroyAllManualObjects(void); 01295 virtual BillboardChain* createBillboardChain(const String& name); 01299 virtual BillboardChain* getBillboardChain(const String& name) const; 01302 virtual bool hasBillboardChain(const String& name) const; 01303 01306 virtual void destroyBillboardChain(BillboardChain* obj); 01309 virtual void destroyBillboardChain(const String& name); 01312 virtual void destroyAllBillboardChains(void); 01318 virtual RibbonTrail* createRibbonTrail(const String& name); 01322 virtual RibbonTrail* getRibbonTrail(const String& name) const; 01325 virtual bool hasRibbonTrail(const String& name) const; 01326 01329 virtual void destroyRibbonTrail(RibbonTrail* obj); 01332 virtual void destroyRibbonTrail(const String& name); 01335 virtual void destroyAllRibbonTrails(void); 01336 01357 virtual ParticleSystem* createParticleSystem(const String& name, 01358 const String& templateName); 01378 virtual ParticleSystem* createParticleSystem(const String& name, 01379 size_t quota = 500, 01380 const String& resourceGroup = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 01384 virtual ParticleSystem* getParticleSystem(const String& name) const; 01387 virtual bool hasParticleSystem(const String& name) const; 01388 01391 virtual void destroyParticleSystem(ParticleSystem* obj); 01394 virtual void destroyParticleSystem(const String& name); 01397 virtual void destroyAllParticleSystems(void); 01398 01404 virtual void clearScene(void); 01405 01418 void setAmbientLight(const ColourValue& colour); 01419 01422 const ColourValue& getAmbientLight(void) const; 01423 01439 virtual void prepareWorldGeometry(const String& filename); 01440 01458 virtual void prepareWorldGeometry(DataStreamPtr& stream, 01459 const String& typeName = StringUtil::BLANK); 01460 01473 virtual void setWorldGeometry(const String& filename); 01474 01490 virtual void setWorldGeometry(DataStreamPtr& stream, 01491 const String& typeName = StringUtil::BLANK); 01492 01505 virtual size_t estimateWorldGeometry(const String& filename) { return 0; } 01506 01519 virtual size_t estimateWorldGeometry(DataStreamPtr& stream, 01520 const String& typeName = StringUtil::BLANK) { return 0; } 01535 virtual ViewPoint getSuggestedViewpoint(bool random = false); 01536 01550 virtual bool setOption( const String& strKey, const void* pValue ) { return false; } 01551 01565 virtual bool getOption( const String& strKey, void* pDestValue ) { return false; } 01566 01576 virtual bool hasOption( const String& strKey ) const { return false; } 01591 virtual bool getOptionValues( const String& strKey, StringVector& refValueList ) { return false; } 01592 01599 virtual bool getOptionKeys( StringVector& refKeys ) { return false; } 01600 01609 virtual void _updateSceneGraph(Camera* cam); 01610 01622 virtual void _findVisibleObjects(Camera* cam, VisibleObjectsBoundsInfo* visibleBounds, bool onlyShadowCasters); 01623 01628 virtual void _applySceneAnimations(void); 01629 01632 virtual void _renderVisibleObjects(void); 01633 01647 virtual void _renderScene(Camera* camera, Viewport* vp, bool includeOverlays); 01648 01652 virtual void _queueSkiesForRendering(Camera* cam); 01653 01654 01655 01664 virtual void _setDestinationRenderSystem(RenderSystem* sys); 01665 01719 virtual void setSkyPlane( 01720 bool enable, 01721 const Plane& plane, const String& materialName, Real scale = 1000, 01722 Real tiling = 10, bool drawFirst = true, Real bow = 0, 01723 int xsegments = 1, int ysegments = 1, 01724 const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 01768 virtual void _setSkyPlane( 01769 bool enable, 01770 const Plane& plane, const String& materialName, Real scale = 1000, 01771 Real tiling = 10, uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, Real bow = 0, 01772 int xsegments = 1, int ysegments = 1, 01773 const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 01774 01776 virtual bool isSkyPlaneEnabled(void) const { return mSkyPlaneEnabled; } 01777 01779 virtual SceneNode* getSkyPlaneNode(void) const { return mSkyPlaneNode; } 01780 01782 virtual const SkyPlaneGenParameters& getSkyPlaneGenParameters(void) const { return mSkyPlaneGenParameters; } 01783 01825 virtual void setSkyBox( 01826 bool enable, const String& materialName, Real distance = 5000, 01827 bool drawFirst = true, const Quaternion& orientation = Quaternion::IDENTITY, 01828 const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 01829 01862 virtual void _setSkyBox( 01863 bool enable, const String& materialName, Real distance = 5000, 01864 uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, const Quaternion& orientation = Quaternion::IDENTITY, 01865 const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 01866 01868 virtual bool isSkyBoxEnabled(void) const { return mSkyBoxEnabled; } 01869 01871 virtual SceneNode* getSkyBoxNode(void) const { return mSkyBoxNode; } 01872 01874 virtual const SkyBoxGenParameters& getSkyBoxGenParameters(void) const { return mSkyBoxGenParameters; } 01875 01931 virtual void setSkyDome( 01932 bool enable, const String& materialName, Real curvature = 10, 01933 Real tiling = 8, Real distance = 4000, bool drawFirst = true, 01934 const Quaternion& orientation = Quaternion::IDENTITY, 01935 int xsegments = 16, int ysegments = 16, int ysegments_keep = -1, 01936 const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 01937 01984 virtual void _setSkyDome( 01985 bool enable, const String& materialName, Real curvature = 10, 01986 Real tiling = 8, Real distance = 4000, uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, 01987 const Quaternion& orientation = Quaternion::IDENTITY, 01988 int xsegments = 16, int ysegments = 16, int ysegments_keep = -1, 01989 const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 01990 01992 virtual bool isSkyDomeEnabled(void) const { return mSkyDomeEnabled; } 01993 01995 virtual SceneNode* getSkyDomeNode(void) const { return mSkyDomeNode; } 01996 01998 virtual const SkyDomeGenParameters& getSkyDomeGenParameters(void) const { return mSkyDomeGenParameters; } 01999 02024 void setFog( 02025 FogMode mode = FOG_NONE, const ColourValue& colour = ColourValue::White, 02026 Real expDensity = 0.001, Real linearStart = 0.0, Real linearEnd = 1.0); 02027 02030 virtual FogMode getFogMode(void) const; 02031 02034 virtual const ColourValue& getFogColour(void) const; 02035 02038 virtual Real getFogStart(void) const; 02039 02042 virtual Real getFogEnd(void) const; 02043 02046 virtual Real getFogDensity(void) const; 02047 02048 02066 virtual BillboardSet* createBillboardSet(const String& name, unsigned int poolSize = 20); 02067 02071 virtual BillboardSet* getBillboardSet(const String& name) const; 02074 virtual bool hasBillboardSet(const String& name) const; 02075 02082 virtual void destroyBillboardSet(BillboardSet* set); 02083 02090 virtual void destroyBillboardSet(const String& name); 02091 02101 virtual void destroyAllBillboardSets(void); 02102 02110 virtual void setDisplaySceneNodes(bool display); 02112 virtual bool getDisplaySceneNodes(void) const {return mDisplayNodes;} 02113 02134 virtual Animation* createAnimation(const String& name, Real length); 02135 02139 virtual Animation* getAnimation(const String& name) const; 02142 virtual bool hasAnimation(const String& name) const; 02143 02149 virtual void destroyAnimation(const String& name); 02150 02152 virtual void destroyAllAnimations(void); 02153 02181 virtual AnimationState* createAnimationState(const String& animName); 02182 02186 virtual AnimationState* getAnimationState(const String& animName) const; 02189 virtual bool hasAnimationState(const String& name) const; 02190 02196 virtual void destroyAnimationState(const String& name); 02197 02199 virtual void destroyAllAnimationStates(void); 02200 02224 virtual void manualRender(RenderOperation* rend, Pass* pass, Viewport* vp, 02225 const Matrix4& worldMatrix, const Matrix4& viewMatrix, const Matrix4& projMatrix, 02226 bool doBeginEndFrame = false) ; 02227 02238 virtual RenderQueue* getRenderQueue(void); 02239 02243 virtual void addRenderQueueListener(RenderQueueListener* newListener); 02244 02246 virtual void removeRenderQueueListener(RenderQueueListener* delListener); 02247 02261 virtual void addSpecialCaseRenderQueue(uint8 qid); 02267 virtual void removeSpecialCaseRenderQueue(uint8 qid); 02271 virtual void clearSpecialCaseRenderQueues(void); 02276 virtual void setSpecialCaseRenderQueueMode(SpecialCaseRenderQueueMode mode); 02278 virtual SpecialCaseRenderQueueMode getSpecialCaseRenderQueueMode(void); 02285 virtual bool isRenderQueueToBeProcessed(uint8 qid); 02286 02302 virtual void setWorldGeometryRenderQueue(uint8 qid); 02313 virtual uint8 getWorldGeometryRenderQueue(void); 02314 02316 virtual void showBoundingBoxes(bool bShow); 02317 02319 virtual bool getShowBoundingBoxes() const; 02320 02322 virtual void _notifyAutotrackingSceneNode(SceneNode* node, bool autoTrack); 02323 02324 02337 virtual AxisAlignedBoxSceneQuery* 02338 createAABBQuery(const AxisAlignedBox& box, unsigned long mask = 0xFFFFFFFF); 02351 virtual SphereSceneQuery* 02352 createSphereQuery(const Sphere& sphere, unsigned long mask = 0xFFFFFFFF); 02365 virtual PlaneBoundedVolumeListSceneQuery* 02366 createPlaneBoundedVolumeQuery(const PlaneBoundedVolumeList& volumes, unsigned long mask = 0xFFFFFFFF); 02367 02368 02381 virtual RaySceneQuery* 02382 createRayQuery(const Ray& ray, unsigned long mask = 0xFFFFFFFF); 02383 //PyramidSceneQuery* createPyramidQuery(const Pyramid& p, unsigned long mask = 0xFFFFFFFF); 02395 virtual IntersectionSceneQuery* 02396 createIntersectionQuery(unsigned long mask = 0xFFFFFFFF); 02397 02399 virtual void destroyQuery(SceneQuery* query); 02400 02401 typedef MapIterator<CameraList> CameraIterator; 02402 typedef MapIterator<AnimationList> AnimationIterator; 02403 02406 CameraIterator getCameraIterator(void) { 02407 return CameraIterator(mCameras.begin(), mCameras.end()); 02408 } 02410 AnimationIterator getAnimationIterator(void) { 02411 return AnimationIterator(mAnimationsList.begin(), mAnimationsList.end()); 02412 } 02414 AnimationStateIterator getAnimationStateIterator(void) { 02415 return mAnimationStates.getAnimationStateIterator(); 02416 } 02417 02450 virtual void setShadowTechnique(ShadowTechnique technique); 02451 02453 virtual ShadowTechnique getShadowTechnique(void) const { return mShadowTechnique; } 02454 02456 virtual void setShowDebugShadows(bool debug) { mDebugShadows = debug; } 02458 virtual bool getShowDebugShadows(void ) const { return mDebugShadows; } 02459 02466 virtual void setShadowColour(const ColourValue& colour); 02473 virtual const ColourValue& getShadowColour(void) const; 02485 virtual void setShadowDirectionalLightExtrusionDistance(Real dist); 02488 virtual Real getShadowDirectionalLightExtrusionDistance(void) const; 02505 virtual void setShadowFarDistance(Real distance); 02509 virtual Real getShadowFarDistance(void) const 02510 { return mDefaultShadowFarDist; } 02511 virtual Real getShadowFarDistanceSquared(void) const 02512 { return mDefaultShadowFarDistSquared; } 02513 02539 virtual void setShadowIndexBufferSize(size_t size); 02541 virtual size_t getShadowIndexBufferSize(void) const 02542 { return mShadowIndexBufferSize; } 02551 virtual void setShadowTextureSize(unsigned short size); 02552 02559 virtual void setShadowTextureConfig(size_t shadowIndex, unsigned short width, 02560 unsigned short height, PixelFormat format); 02566 virtual void setShadowTextureConfig(size_t shadowIndex, 02567 const ShadowTextureConfig& config); 02568 02570 ConstShadowTextureConfigIterator getShadowTextureConfigIterator() const; 02571 02583 virtual void setShadowTexturePixelFormat(PixelFormat fmt); 02591 virtual void setShadowTextureCount(size_t count); 02593 size_t getShadowTextureCount(void) const {return mShadowTextureConfigList.size(); } 02594 02604 void setShadowTextureCountPerLightType(Light::LightTypes type, size_t count) 02605 { mShadowTextureCountPerType[type] = count; } 02607 size_t getShadowTextureCountPerLightType(Light::LightTypes type) const 02608 {return mShadowTextureCountPerType[type]; } 02609 02618 virtual void setShadowTextureSettings(unsigned short size, unsigned short count, 02619 PixelFormat fmt = PF_X8R8G8B8); 02620 02627 virtual const TexturePtr& getShadowTexture(size_t shadowIndex); 02628 02643 virtual void setShadowDirLightTextureOffset(Real offset) { mShadowTextureOffset = offset;} 02647 virtual Real getShadowDirLightTextureOffset(void) const { return mShadowTextureOffset; } 02655 virtual void setShadowTextureFadeStart(Real fadeStart) 02656 { mShadowTextureFadeStart = fadeStart; } 02664 virtual void setShadowTextureFadeEnd(Real fadeEnd) 02665 { mShadowTextureFadeEnd = fadeEnd; } 02666 02679 virtual void setShadowTextureSelfShadow(bool selfShadow); 02680 02682 virtual bool getShadowTextureSelfShadow(void) const 02683 { return mShadowTextureSelfShadow; } 02704 virtual void setShadowTextureCasterMaterial(const String& name); 02726 virtual void setShadowTextureReceiverMaterial(const String& name); 02727 02738 virtual void setShadowCasterRenderBackFaces(bool bf) { mShadowCasterRenderBackFaces = bf; } 02739 02743 virtual bool getShadowCasterRenderBackFaces() const { return mShadowCasterRenderBackFaces; } 02744 02749 virtual void setShadowCameraSetup(const ShadowCameraSetupPtr& shadowSetup); 02750 02755 virtual const ShadowCameraSetupPtr& getShadowCameraSetup() const; 02756 02793 virtual void setShadowUseInfiniteFarPlane(bool enable) { 02794 mShadowUseInfiniteFarPlane = enable; } 02795 02797 virtual bool isShadowTechniqueStencilBased(void) const 02798 { return (mShadowTechnique & SHADOWDETAILTYPE_STENCIL) != 0; } 02800 virtual bool isShadowTechniqueTextureBased(void) const 02801 { return (mShadowTechnique & SHADOWDETAILTYPE_TEXTURE) != 0; } 02803 virtual bool isShadowTechniqueModulative(void) const 02804 { return (mShadowTechnique & SHADOWDETAILTYPE_MODULATIVE) != 0; } 02806 virtual bool isShadowTechniqueAdditive(void) const 02807 { return (mShadowTechnique & SHADOWDETAILTYPE_ADDITIVE) != 0; } 02809 virtual bool isShadowTechniqueIntegrated(void) const 02810 { return (mShadowTechnique & SHADOWDETAILTYPE_INTEGRATED) != 0; } 02812 virtual bool isShadowTechniqueInUse(void) const 02813 { return mShadowTechnique != SHADOWTYPE_NONE; } 02817 virtual void setShadowUseLightClipPlanes(bool enabled) { mShadowAdditiveLightClip = enabled; } 02821 virtual bool getShadowUseLightClipPlanes() const { return mShadowAdditiveLightClip; } 02822 02825 virtual void addListener(Listener* s); 02828 virtual void removeListener(Listener* s); 02829 02839 virtual StaticGeometry* createStaticGeometry(const String& name); 02843 virtual StaticGeometry* getStaticGeometry(const String& name) const; 02845 virtual bool hasStaticGeometry(const String& name) const; 02847 virtual void destroyStaticGeometry(StaticGeometry* geom); 02849 virtual void destroyStaticGeometry(const String& name); 02851 virtual void destroyAllStaticGeometry(void); 02852 02862 virtual InstancedGeometry* createInstancedGeometry(const String& name); 02864 virtual InstancedGeometry* getInstancedGeometry(const String& name) const; 02866 virtual void destroyInstancedGeometry(InstancedGeometry* geom); 02868 virtual void destroyInstancedGeometry(const String& name); 02870 virtual void destroyAllInstancedGeometry(void); 02871 02872 02883 virtual MovableObject* createMovableObject(const String& name, 02884 const String& typeName, const NameValuePairList* params = 0); 02890 virtual void destroyMovableObject(const String& name, const String& typeName); 02896 virtual void destroyMovableObject(MovableObject* m); 02898 virtual void destroyAllMovableObjectsByType(const String& typeName); 02900 virtual void destroyAllMovableObjects(void); 02904 virtual MovableObject* getMovableObject(const String& name, const String& typeName) const; 02906 virtual bool hasMovableObject(const String& name, const String& typeName) const; 02907 typedef MapIterator<MovableObjectMap> MovableObjectIterator; 02913 virtual MovableObjectIterator getMovableObjectIterator(const String& typeName); 02925 virtual void injectMovableObject(MovableObject* m); 02932 virtual void extractMovableObject(const String& name, const String& typeName); 02939 virtual void extractMovableObject(MovableObject* m); 02946 virtual void extractAllMovableObjectsByType(const String& typeName); 02947 02954 virtual void setVisibilityMask(uint32 vmask) { mVisibilityMask = vmask; } 02955 02959 virtual uint32 getVisibilityMask(void) { return mVisibilityMask; } 02960 02964 uint32 _getCombinedVisibilityMask(void) const; 02965 02972 virtual void setFindVisibleObjects(bool find) { mFindVisibleObjects = find; } 02973 02977 virtual bool getFindVisibleObjects(void) { return mFindVisibleObjects; } 02978 02987 virtual void setNormaliseNormalsOnScale(bool n) { mNormaliseNormalsOnScale = n; } 02988 02992 virtual bool getNormaliseNormalsOnScale() const { return mNormaliseNormalsOnScale; } 02993 03002 virtual void setFlipCullingOnNegativeScale(bool n) { mFlipCullingOnNegativeScale = n; } 03003 03007 virtual bool getFlipCullingOnNegativeScale() const { return mFlipCullingOnNegativeScale; } 03008 03014 virtual void _injectRenderWithPass(Pass *pass, Renderable *rend, bool shadowDerivation = true); 03015 03034 virtual void _suppressRenderStateChanges(bool suppress); 03035 03039 virtual bool _areRenderStateChangesSuppressed(void) const 03040 { return mSuppressRenderStateChanges; } 03041 03054 virtual const Pass* _setPass(const Pass* pass, 03055 bool evenIfSuppressed = false, bool shadowDerivation = true); 03056 03057 03067 virtual void _suppressShadows(bool suppress); 03068 03072 virtual bool _areShadowsSuppressed(void) const 03073 { return mSuppressShadows; } 03074 03078 virtual void _renderQueueGroupObjects(RenderQueueGroup* group, 03079 QueuedRenderableCollection::OrganisationMode om); 03080 03096 void setQueuedRenderableVisitor(SceneMgrQueuedRenderableVisitor* visitor); 03097 03099 SceneMgrQueuedRenderableVisitor* getQueuedRenderableVisitor(void) const; 03100 03101 03105 RenderSystem *getDestinationRenderSystem(); 03106 03109 Viewport* getCurrentViewport(void) const { return mCurrentViewport; } 03110 03112 const VisibleObjectsBoundsInfo& getVisibleObjectsBoundsInfo(const Camera* cam) const; 03113 03115 const VisibleObjectsBoundsInfo& getShadowCasterBoundsInfo(const Light* light, size_t iteration = 0) const; 03116 03131 virtual void setCameraRelativeRendering(bool rel) { mCameraRelativeRendering = rel; } 03132 03136 virtual bool getCameraRelativeRendering() const { return mCameraRelativeRendering; } 03137 }; 03138 03140 class _OgreExport DefaultIntersectionSceneQuery : 03141 public IntersectionSceneQuery 03142 { 03143 public: 03144 DefaultIntersectionSceneQuery(SceneManager* creator); 03145 ~DefaultIntersectionSceneQuery(); 03146 03148 void execute(IntersectionSceneQueryListener* listener); 03149 }; 03150 03152 class _OgreExport DefaultRaySceneQuery : public RaySceneQuery 03153 { 03154 public: 03155 DefaultRaySceneQuery(SceneManager* creator); 03156 ~DefaultRaySceneQuery(); 03157 03159 void execute(RaySceneQueryListener* listener); 03160 }; 03162 class _OgreExport DefaultSphereSceneQuery : public SphereSceneQuery 03163 { 03164 public: 03165 DefaultSphereSceneQuery(SceneManager* creator); 03166 ~DefaultSphereSceneQuery(); 03167 03169 void execute(SceneQueryListener* listener); 03170 }; 03172 class _OgreExport DefaultPlaneBoundedVolumeListSceneQuery : public PlaneBoundedVolumeListSceneQuery 03173 { 03174 public: 03175 DefaultPlaneBoundedVolumeListSceneQuery(SceneManager* creator); 03176 ~DefaultPlaneBoundedVolumeListSceneQuery(); 03177 03179 void execute(SceneQueryListener* listener); 03180 }; 03182 class _OgreExport DefaultAxisAlignedBoxSceneQuery : public AxisAlignedBoxSceneQuery 03183 { 03184 public: 03185 DefaultAxisAlignedBoxSceneQuery(SceneManager* creator); 03186 ~DefaultAxisAlignedBoxSceneQuery(); 03187 03189 void execute(SceneQueryListener* listener); 03190 }; 03191 03192 03194 typedef uint16 SceneTypeMask; 03195 03199 enum SceneType 03200 { 03201 ST_GENERIC = 1, 03202 ST_EXTERIOR_CLOSE = 2, 03203 ST_EXTERIOR_FAR = 4, 03204 ST_EXTERIOR_REAL_FAR = 8, 03205 ST_INTERIOR = 16 03206 }; 03207 03209 struct SceneManagerMetaData 03210 { 03212 String typeName; 03214 String description; 03216 SceneTypeMask sceneTypeMask; 03218 bool worldGeometrySupported; 03219 }; 03220 03221 03222 03224 class _OgreExport SceneManagerFactory : public SceneMgtAlloc 03225 { 03226 protected: 03227 mutable SceneManagerMetaData mMetaData; 03228 mutable bool mMetaDataInit; 03230 virtual void initMetaData(void) const = 0; 03231 public: 03232 SceneManagerFactory() : mMetaDataInit(true) {} 03233 virtual ~SceneManagerFactory() {} 03235 virtual const SceneManagerMetaData& getMetaData(void) const 03236 { 03237 if (mMetaDataInit) 03238 { 03239 initMetaData(); 03240 mMetaDataInit = false; 03241 } 03242 return mMetaData; 03243 } 03248 virtual SceneManager* createInstance(const String& instanceName) = 0; 03250 virtual void destroyInstance(SceneManager* instance) = 0; 03251 03252 }; 03253 03254 03255 03256 } // Namespace 03257 03258 03259 03260 #endif
Copyright © 2008 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Sep 27 22:02:25 2009