This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Mon Jul 27 2020 13:40:45
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-2013 Torus Knot Software Ltd 00008 Permission is hereby granted, free of charge, to any person obtaining a copy 00009 of this software and associated documentation files (the "Software"), to deal 00010 in the Software without restriction, including without limitation the rights 00011 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 00012 copies of the Software, and to permit persons to whom the Software is 00013 furnished to do so, subject to the following conditions: 00014 00015 The above copyright notice and this permission notice shall be included in 00016 all copies or substantial portions of the Software. 00017 00018 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00019 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00020 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 00021 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00022 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 00023 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 00024 THE SOFTWARE 00025 00026 You may alternatively use this source under the terms of a specific version of 00027 the OGRE Unrestricted License provided you have obtained such a license from 00028 Torus Knot Software Ltd. 00029 -------------------------------------------------------------------------*/ 00030 #ifndef __SceneManager_H__ 00031 #define __SceneManager_H__ 00032 00033 // Precompiler options 00034 #include "OgrePrerequisites.h" 00035 00036 #include "OgreString.h" 00037 #include "OgreSceneNode.h" 00038 #include "OgrePlane.h" 00039 #include "OgreQuaternion.h" 00040 #include "OgreColourValue.h" 00041 #include "OgreCommon.h" 00042 #include "OgreSceneQuery.h" 00043 #include "OgreAutoParamDataSource.h" 00044 #include "OgreAnimationState.h" 00045 #include "OgreRenderQueue.h" 00046 #include "OgreRenderQueueSortingGrouping.h" 00047 #include "OgreRectangle2D.h" 00048 #include "OgrePixelFormat.h" 00049 #include "OgreResourceGroupManager.h" 00050 #include "OgreTexture.h" 00051 #include "OgreShadowCameraSetup.h" 00052 #include "OgreShadowTextureManager.h" 00053 #include "OgreCamera.h" 00054 #include "OgreInstancedGeometry.h" 00055 #include "OgreLodListener.h" 00056 #include "OgreInstanceManager.h" 00057 #include "OgreRenderSystem.h" 00058 #include "OgreHeaderPrefix.h" 00059 #include "OgreNameGenerator.h" 00060 00061 namespace Ogre { 00070 struct ViewPoint 00071 { 00072 Vector3 position; 00073 Quaternion orientation; 00074 }; 00075 00076 // Forward declarations 00077 class DefaultIntersectionSceneQuery; 00078 class DefaultRaySceneQuery; 00079 class DefaultSphereSceneQuery; 00080 class DefaultAxisAlignedBoxSceneQuery; 00081 class CompositorChain; 00082 00086 struct _OgreExport VisibleObjectsBoundsInfo 00087 { 00089 AxisAlignedBox aabb; 00091 AxisAlignedBox receiverAabb; 00093 Real minDistance; 00095 Real maxDistance; 00097 Real minDistanceInFrustum; 00099 Real maxDistanceInFrustum; 00100 00101 VisibleObjectsBoundsInfo(); 00102 void reset(); 00103 void merge(const AxisAlignedBox& boxBounds, const Sphere& sphereBounds, 00104 const Camera* cam, bool receiver=true); 00108 void mergeNonRenderedButInFrustum(const AxisAlignedBox& boxBounds, 00109 const Sphere& sphereBounds, const Camera* cam); 00110 00111 00112 }; 00113 00143 class _OgreExport SceneManager : public SceneMgtAlloc 00144 { 00145 public: 00147 static uint32 WORLD_GEOMETRY_TYPE_MASK; 00149 static uint32 ENTITY_TYPE_MASK; 00151 static uint32 FX_TYPE_MASK; 00153 static uint32 STATICGEOMETRY_TYPE_MASK; 00155 static uint32 LIGHT_TYPE_MASK; 00157 static uint32 FRUSTUM_TYPE_MASK; 00159 static uint32 USER_TYPE_MASK_LIMIT; 00162 struct materialLess 00163 { 00164 _OgreExport bool operator()(const Material* x, const Material* y) const; 00165 }; 00167 struct lightLess 00168 { 00169 _OgreExport bool operator()(const Light* a, const Light* b) const; 00170 }; 00171 00173 enum IlluminationRenderStage 00174 { 00176 IRS_NONE, 00178 IRS_RENDER_TO_TEXTURE, 00180 IRS_RENDER_RECEIVER_PASS 00181 }; 00182 00187 enum SpecialCaseRenderQueueMode 00188 { 00190 SCRQM_INCLUDE, 00192 SCRQM_EXCLUDE 00193 }; 00194 00195 struct SkyDomeGenParameters 00196 { 00197 Real skyDomeCurvature; 00198 Real skyDomeTiling; 00199 Real skyDomeDistance; 00200 int skyDomeXSegments; 00201 int skyDomeYSegments; 00202 int skyDomeYSegments_keep; 00203 }; 00204 00205 struct SkyPlaneGenParameters 00206 { 00207 Real skyPlaneScale; 00208 Real skyPlaneTiling; 00209 Real skyPlaneBow; 00210 int skyPlaneXSegments; 00211 int skyPlaneYSegments; 00212 }; 00213 00214 struct SkyBoxGenParameters 00215 { 00216 Real skyBoxDistance; 00217 }; 00218 00222 class Listener 00223 { 00224 public: 00225 Listener() {} 00226 virtual ~Listener() {} 00227 00234 virtual void preUpdateSceneGraph(SceneManager* source, Camera* camera) 00235 { (void)source; (void)camera; } 00236 00243 virtual void postUpdateSceneGraph(SceneManager* source, Camera* camera) 00244 { (void)source; (void)camera; } 00245 00255 virtual void preFindVisibleObjects(SceneManager* source, 00256 IlluminationRenderStage irs, Viewport* v) 00257 { (void)source; (void)irs; (void)v; } 00258 00269 virtual void postFindVisibleObjects(SceneManager* source, 00270 IlluminationRenderStage irs, Viewport* v) 00271 { (void)source; (void)irs; (void)v; } 00272 00287 virtual void shadowTexturesUpdated(size_t numberOfShadowTextures) 00288 { (void)numberOfShadowTextures; } 00289 00303 virtual void shadowTextureCasterPreViewProj(Light* light, 00304 Camera* camera, size_t iteration) 00305 { (void)light; (void)camera; (void)iteration; } 00306 00320 virtual void shadowTextureReceiverPreViewProj(Light* light, 00321 Frustum* frustum) 00322 { (void)light; (void)frustum; } 00323 00346 virtual bool sortLightsAffectingFrustum(LightList& lightList) 00347 { (void)lightList; return false; } 00348 00350 virtual void sceneManagerDestroyed(SceneManager* source) 00351 { (void)source; } 00352 }; 00353 00357 class _OgreExport SceneMgrQueuedRenderableVisitor : public QueuedRenderableVisitor 00358 { 00359 protected: 00361 const Pass* mUsedPass; 00362 public: 00363 SceneMgrQueuedRenderableVisitor() 00364 :transparentShadowCastersMode(false) {} 00365 ~SceneMgrQueuedRenderableVisitor() {} 00366 void visit(Renderable* r); 00367 bool visit(const Pass* p); 00368 void visit(RenderablePass* rp); 00369 00371 SceneManager* targetSceneMgr; 00373 bool transparentShadowCastersMode; 00375 bool autoLights; 00377 const LightList* manualLightList; 00379 bool scissoring; 00380 00381 }; 00383 friend class SceneMgrQueuedRenderableVisitor; 00384 00385 protected: 00386 00388 virtual SceneNode* createSceneNodeImpl(void); 00390 virtual SceneNode* createSceneNodeImpl(const String& name); 00391 00393 String mName; 00394 00396 RenderQueue* mRenderQueue; 00397 bool mLastRenderQueueInvocationCustom; 00398 00400 ColourValue mAmbientLight; 00401 00403 RenderSystem *mDestRenderSystem; 00404 00405 typedef map<String, Camera* >::type CameraList; 00406 00409 CameraList mCameras; 00410 00411 typedef map<String, StaticGeometry* >::type StaticGeometryList; 00412 StaticGeometryList mStaticGeometryList; 00413 typedef map<String, InstancedGeometry* >::type InstancedGeometryList; 00414 InstancedGeometryList mInstancedGeometryList; 00415 00416 typedef map<String, InstanceManager*>::type InstanceManagerMap; 00417 InstanceManagerMap mInstanceManagerMap; 00418 00419 typedef map<String, SceneNode*>::type SceneNodeList; 00420 00427 SceneNodeList mSceneNodes; 00428 00430 Camera* mCameraInProgress; 00432 Viewport* mCurrentViewport; 00433 00435 SceneNode* mSceneRoot; 00436 00438 typedef set<SceneNode*>::type AutoTrackingSceneNodes; 00439 AutoTrackingSceneNodes mAutoTrackingSceneNodes; 00440 00441 // Sky params 00442 // Sky plane 00443 Entity* mSkyPlaneEntity; 00444 Entity* mSkyDomeEntity[5]; 00445 ManualObject* mSkyBoxObj; 00446 00447 SceneNode* mSkyPlaneNode; 00448 SceneNode* mSkyDomeNode; 00449 SceneNode* mSkyBoxNode; 00450 00451 // Sky plane 00452 bool mSkyPlaneEnabled; 00453 uint8 mSkyPlaneRenderQueue; 00454 Plane mSkyPlane; 00455 SkyPlaneGenParameters mSkyPlaneGenParameters; 00456 // Sky box 00457 bool mSkyBoxEnabled; 00458 uint8 mSkyBoxRenderQueue; 00459 Quaternion mSkyBoxOrientation; 00460 SkyBoxGenParameters mSkyBoxGenParameters; 00461 // Sky dome 00462 bool mSkyDomeEnabled; 00463 uint8 mSkyDomeRenderQueue; 00464 Quaternion mSkyDomeOrientation; 00465 SkyDomeGenParameters mSkyDomeGenParameters; 00466 00467 // Fog 00468 FogMode mFogMode; 00469 ColourValue mFogColour; 00470 Real mFogStart; 00471 Real mFogEnd; 00472 Real mFogDensity; 00473 00474 typedef set<uint8>::type SpecialCaseRenderQueueList; 00475 SpecialCaseRenderQueueList mSpecialCaseQueueList; 00476 SpecialCaseRenderQueueMode mSpecialCaseQueueMode; 00477 uint8 mWorldGeometryRenderQueue; 00478 00479 unsigned long mLastFrameNumber; 00480 Matrix4 mTempXform[256]; 00481 bool mResetIdentityView; 00482 bool mResetIdentityProj; 00483 00484 bool mNormaliseNormalsOnScale; 00485 bool mFlipCullingOnNegativeScale; 00486 CullingMode mPassCullingMode; 00487 00488 protected: 00489 00497 typedef map< const Camera*, VisibleObjectsBoundsInfo>::type CamVisibleObjectsMap; 00498 CamVisibleObjectsMap mCamVisibleObjectsMap; 00499 00501 typedef map< const Camera*, const Light* >::type ShadowCamLightMapping; 00502 ShadowCamLightMapping mShadowCamLightMapping; 00503 00505 size_t mShadowTextureCountPerType[3]; 00506 00508 vector<size_t>::type mShadowTextureIndexLightList; 00509 00511 struct _OgreExport LightInfo 00512 { 00513 Light* light; 00514 int type; 00515 Real range; 00516 Vector3 position; 00517 uint32 lightMask; 00518 00519 bool operator== (const LightInfo& rhs) const 00520 { 00521 return light == rhs.light && type == rhs.type && 00522 range == rhs.range && position == rhs.position && lightMask == rhs.lightMask; 00523 } 00524 00525 bool operator!= (const LightInfo& rhs) const 00526 { 00527 return !(*this == rhs); 00528 } 00529 }; 00530 00531 typedef vector<LightInfo>::type LightInfoList; 00532 00533 LightList mLightsAffectingFrustum; 00534 LightInfoList mCachedLightInfos; 00535 LightInfoList mTestLightInfos; // potentially new list 00536 ulong mLightsDirtyCounter; 00537 LightList mShadowTextureCurrentCasterLightList; 00538 00539 typedef map<String, MovableObject*>::type MovableObjectMap; 00541 struct MovableObjectCollection 00542 { 00543 MovableObjectMap map; 00544 OGRE_MUTEX(mutex); 00545 }; 00546 typedef map<String, MovableObjectCollection*>::type MovableObjectCollectionMap; 00547 MovableObjectCollectionMap mMovableObjectCollectionMap; 00548 NameGenerator mMovableNameGenerator; 00553 MovableObjectCollection* getMovableObjectCollection(const String& typeName); 00558 const MovableObjectCollection* getMovableObjectCollection(const String& typeName) const; 00560 OGRE_MUTEX(mMovableObjectCollectionMapMutex); 00561 00566 virtual void initRenderQueue(void); 00568 Pass* mShadowCasterPlainBlackPass; 00570 Pass* mShadowReceiverPass; 00580 virtual const Pass* deriveShadowCasterPass(const Pass* pass); 00589 virtual const Pass* deriveShadowReceiverPass(const Pass* pass); 00590 00597 virtual bool validatePassForRendering(const Pass* pass); 00598 00605 virtual bool validateRenderableForRendering(const Pass* pass, const Renderable* rend); 00606 00607 enum BoxPlane 00608 { 00609 BP_FRONT = 0, 00610 BP_BACK = 1, 00611 BP_LEFT = 2, 00612 BP_RIGHT = 3, 00613 BP_UP = 4, 00614 BP_DOWN = 5 00615 }; 00616 00617 /* Internal utility method for creating the planes of a skybox. 00618 */ 00619 virtual MeshPtr createSkyboxPlane( 00620 BoxPlane bp, 00621 Real distance, 00622 const Quaternion& orientation, 00623 const String& groupName); 00624 00625 /* Internal utility method for creating the planes of a skydome. 00626 */ 00627 virtual MeshPtr createSkydomePlane( 00628 BoxPlane bp, 00629 Real curvature, Real tiling, Real distance, 00630 const Quaternion& orientation, 00631 int xsegments, int ysegments, int ySegmentsToKeep, 00632 const String& groupName); 00633 00635 bool mDisplayNodes; 00636 00638 typedef map<String, Animation*>::type AnimationList; 00639 AnimationList mAnimationsList; 00640 OGRE_MUTEX(mAnimationsListMutex); 00641 AnimationStateSet mAnimationStates; 00642 00643 00646 virtual void useRenderableViewProjMode(const Renderable* pRend, bool fixedFunction); 00647 00650 virtual void resetViewProjMode(bool fixedFunction); 00651 00652 typedef vector<RenderQueueListener*>::type RenderQueueListenerList; 00653 RenderQueueListenerList mRenderQueueListeners; 00654 00655 typedef vector<RenderObjectListener*>::type RenderObjectListenerList; 00656 RenderObjectListenerList mRenderObjectListeners; 00657 typedef vector<Listener*>::type ListenerList; 00658 ListenerList mListeners; 00660 virtual void firePreRenderQueues(); 00662 virtual void firePostRenderQueues(); 00664 virtual bool fireRenderQueueStarted(uint8 id, const String& invocation); 00666 virtual bool fireRenderQueueEnded(uint8 id, const String& invocation); 00668 virtual void fireRenderSingleObject(Renderable* rend, const Pass* pass, const AutoParamDataSource* source, 00669 const LightList* pLightList, bool suppressRenderStateChanges); 00670 00672 virtual void fireShadowTexturesUpdated(size_t numberOfShadowTextures); 00674 virtual void fireShadowTexturesPreCaster(Light* light, Camera* camera, size_t iteration); 00676 virtual void fireShadowTexturesPreReceiver(Light* light, Frustum* f); 00678 virtual void firePreUpdateSceneGraph(Camera* camera); 00680 virtual void firePostUpdateSceneGraph(Camera* camera); 00682 virtual void firePreFindVisibleObjects(Viewport* v); 00684 virtual void firePostFindVisibleObjects(Viewport* v); 00686 virtual void fireSceneManagerDestroyed(); 00688 virtual void setViewport(Viewport *vp); 00689 00691 bool mShowBoundingBoxes; 00692 00694 virtual void renderVisibleObjectsDefaultSequence(void); 00696 virtual void renderVisibleObjectsCustomSequence(RenderQueueInvocationSequence* s); 00698 virtual void prepareRenderQueue(void); 00699 00700 00716 virtual void renderSingleObject(Renderable* rend, const Pass* pass, 00717 bool lightScissoringClipping, bool doLightIteration, const LightList* manualLightList = 0); 00718 00720 virtual AutoParamDataSource* createAutoParamDataSource(void) const 00721 { 00722 return OGRE_NEW AutoParamDataSource(); 00723 } 00724 00726 AutoParamDataSource* mAutoParamDataSource; 00727 00728 CompositorChain* mActiveCompositorChain; 00729 bool mLateMaterialResolving; 00730 00731 ShadowTechnique mShadowTechnique; 00732 bool mDebugShadows; 00733 ColourValue mShadowColour; 00734 Pass* mShadowDebugPass; 00735 Pass* mShadowStencilPass; 00736 Pass* mShadowModulativePass; 00737 bool mShadowMaterialInitDone; 00738 HardwareIndexBufferSharedPtr mShadowIndexBuffer; 00739 size_t mShadowIndexBufferSize; 00740 size_t mShadowIndexBufferUsedSize; 00741 Rectangle2D* mFullScreenQuad; 00742 Real mShadowDirLightExtrudeDist; 00743 IlluminationRenderStage mIlluminationStage; 00744 ShadowTextureConfigList mShadowTextureConfigList; 00745 bool mShadowTextureConfigDirty; 00746 ShadowTextureList mShadowTextures; 00747 TexturePtr mNullShadowTexture; 00748 typedef vector<Camera*>::type ShadowTextureCameraList; 00749 ShadowTextureCameraList mShadowTextureCameras; 00750 Texture* mCurrentShadowTexture; 00751 bool mShadowUseInfiniteFarPlane; 00752 bool mShadowCasterRenderBackFaces; 00753 bool mShadowAdditiveLightClip; 00755 struct LightClippingInfo 00756 { 00757 RealRect scissorRect; 00758 PlaneList clipPlanes; 00759 bool scissorValid; 00760 unsigned long clipPlanesValid; 00761 LightClippingInfo() : scissorValid(false), clipPlanesValid(false) {} 00762 00763 }; 00764 typedef map<Light*, LightClippingInfo>::type LightClippingInfoMap; 00765 LightClippingInfoMap mLightClippingInfoMap; 00766 unsigned long mLightClippingInfoMapFrameNumber; 00767 00769 ShadowCameraSetupPtr mDefaultShadowCameraSetup; 00770 00779 struct lightsForShadowTextureLess 00780 { 00781 _OgreExport bool operator()(const Light* l1, const Light* l2) const; 00782 }; 00783 00784 00791 virtual void findLightsAffectingFrustum(const Camera* camera); 00793 virtual void initShadowVolumeMaterials(void); 00795 virtual void ensureShadowTexturesCreated(); 00797 virtual void destroyShadowTextures(void); 00798 00799 typedef vector<InstanceManager*>::type InstanceManagerVec; 00800 InstanceManagerVec mDirtyInstanceManagers; 00801 InstanceManagerVec mDirtyInstanceMgrsTmp; 00802 00804 void updateDirtyInstanceManagers(void); 00805 00806 public: 00810 virtual void prepareShadowTextures(Camera* cam, Viewport* vp, const LightList* lightList = 0); 00811 00812 //A render context, used to store internal data for pausing/resuming rendering 00813 struct RenderContext 00814 { 00815 RenderQueue* renderQueue; 00816 Viewport* viewport; 00817 Camera* camera; 00818 CompositorChain* activeChain; 00819 RenderSystem::RenderSystemContext* rsContext; 00820 }; 00821 00825 virtual RenderContext* _pauseRendering(); 00829 virtual void _resumeRendering(RenderContext* context); 00830 00831 protected: 00839 virtual void renderShadowVolumesToStencil(const Light* light, const Camera* cam, 00840 bool calcScissor); 00846 virtual void setShadowVolumeStencilState(bool secondpass, bool zfail, bool twosided); 00848 void renderShadowVolumeObjects(ShadowCaster::ShadowRenderableListIterator iShadowRenderables, 00849 Pass* pass, const LightList *manualLightList, unsigned long flags, 00850 bool secondpass, bool zfail, bool twosided); 00851 typedef vector<ShadowCaster*>::type ShadowCasterList; 00852 ShadowCasterList mShadowCasterList; 00853 SphereSceneQuery* mShadowCasterSphereQuery; 00854 AxisAlignedBoxSceneQuery* mShadowCasterAABBQuery; 00855 Real mDefaultShadowFarDist; 00856 Real mDefaultShadowFarDistSquared; 00857 Real mShadowTextureOffset; 00858 Real mShadowTextureFadeStart; 00859 Real mShadowTextureFadeEnd; 00860 bool mShadowTextureSelfShadow; 00861 Pass* mShadowTextureCustomCasterPass; 00862 Pass* mShadowTextureCustomReceiverPass; 00863 String mShadowTextureCustomCasterVertexProgram; 00864 String mShadowTextureCustomCasterFragmentProgram; 00865 String mShadowTextureCustomReceiverVertexProgram; 00866 String mShadowTextureCustomReceiverFragmentProgram; 00867 GpuProgramParametersSharedPtr mShadowTextureCustomCasterVPParams; 00868 GpuProgramParametersSharedPtr mShadowTextureCustomCasterFPParams; 00869 GpuProgramParametersSharedPtr mShadowTextureCustomReceiverVPParams; 00870 GpuProgramParametersSharedPtr mShadowTextureCustomReceiverFPParams; 00871 00873 uint32 mVisibilityMask; 00874 bool mFindVisibleObjects; 00875 00877 bool mSuppressRenderStateChanges; 00879 bool mSuppressShadows; 00880 00881 00882 GpuProgramParametersSharedPtr mInfiniteExtrusionParams; 00883 GpuProgramParametersSharedPtr mFiniteExtrusionParams; 00884 00886 class _OgreExport ShadowCasterSceneQueryListener : public SceneQueryListener, public SceneMgtAlloc 00887 { 00888 protected: 00889 SceneManager* mSceneMgr; 00890 ShadowCasterList* mCasterList; 00891 bool mIsLightInFrustum; 00892 const PlaneBoundedVolumeList* mLightClipVolumeList; 00893 const Camera* mCamera; 00894 const Light* mLight; 00895 Real mFarDistSquared; 00896 public: 00897 ShadowCasterSceneQueryListener(SceneManager* sm) : mSceneMgr(sm), 00898 mCasterList(0), mIsLightInFrustum(false), mLightClipVolumeList(0), 00899 mCamera(0) {} 00900 // Prepare the listener for use with a set of parameters 00901 void prepare(bool lightInFrustum, 00902 const PlaneBoundedVolumeList* lightClipVolumes, 00903 const Light* light, const Camera* cam, ShadowCasterList* casterList, 00904 Real farDistSquared) 00905 { 00906 mCasterList = casterList; 00907 mIsLightInFrustum = lightInFrustum; 00908 mLightClipVolumeList = lightClipVolumes; 00909 mCamera = cam; 00910 mLight = light; 00911 mFarDistSquared = farDistSquared; 00912 } 00913 bool queryResult(MovableObject* object); 00914 bool queryResult(SceneQuery::WorldFragment* fragment); 00915 }; 00916 00917 ShadowCasterSceneQueryListener* mShadowCasterQueryListener; 00918 00925 virtual const ShadowCasterList& findShadowCastersForLight(const Light* light, 00926 const Camera* camera); 00928 virtual void renderBasicQueueGroupObjects(RenderQueueGroup* pGroup, 00929 QueuedRenderableCollection::OrganisationMode om); 00931 virtual void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* group, 00932 QueuedRenderableCollection::OrganisationMode om); 00934 virtual void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* group, 00935 QueuedRenderableCollection::OrganisationMode om); 00937 virtual void renderTextureShadowCasterQueueGroupObjects(RenderQueueGroup* group, 00938 QueuedRenderableCollection::OrganisationMode om); 00940 virtual void renderTextureShadowReceiverQueueGroupObjects(RenderQueueGroup* group, 00941 QueuedRenderableCollection::OrganisationMode om); 00943 virtual void renderModulativeTextureShadowedQueueGroupObjects(RenderQueueGroup* group, 00944 QueuedRenderableCollection::OrganisationMode om); 00945 00947 virtual void renderAdditiveTextureShadowedQueueGroupObjects(RenderQueueGroup* group, 00948 QueuedRenderableCollection::OrganisationMode om); 00950 virtual void renderObjects(const QueuedRenderableCollection& objs, 00951 QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping, 00952 bool doLightIteration, const LightList* manualLightList = 0); 00958 virtual void renderTransparentShadowCasterObjects(const QueuedRenderableCollection& objs, 00959 QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping, 00960 bool doLightIteration, const LightList* manualLightList = 0); 00961 00964 virtual void updateRenderQueueSplitOptions(void); 00967 virtual void updateRenderQueueGroupSplitOptions(RenderQueueGroup* group, 00968 bool suppressShadows, bool suppressRenderState); 00969 00971 virtual ClipResult buildAndSetScissor(const LightList& ll, const Camera* cam); 00973 virtual void buildScissor(const Light* l, const Camera* cam, RealRect& rect); 00974 virtual void resetScissor(); 00976 virtual ClipResult buildAndSetLightClip(const LightList& ll); 00977 virtual void buildLightClip(const Light* l, PlaneList& planes); 00978 virtual void resetLightClip(); 00979 virtual void checkCachedLightClippingInfo(); 00980 00982 SceneMgrQueuedRenderableVisitor* mActiveQueuedRenderableVisitor; 00984 SceneMgrQueuedRenderableVisitor mDefaultQueuedRenderableVisitor; 00985 00987 bool mCameraRelativeRendering; 00988 Matrix4 mCachedViewMatrix; 00989 Vector3 mCameraRelativePosition; 00990 00992 uint32 mLastLightHash; 00993 unsigned short mLastLightLimit; 00994 uint32 mLastLightHashGpuProgram; 00996 uint16 mGpuParamsDirty; 00997 00998 virtual void useLights(const LightList& lights, unsigned short limit); 00999 virtual void setViewMatrix(const Matrix4& m); 01000 virtual void useLightsGpuProgram(const Pass* pass, const LightList* lights); 01001 virtual void bindGpuProgram(GpuProgram* prog); 01002 virtual void updateGpuProgramParameters(const Pass* p); 01003 01004 01005 01006 01007 01008 01009 01010 01012 typedef set<LodListener*>::type LodListenerSet; 01013 LodListenerSet mLodListeners; 01014 01016 typedef vector<MovableObjectLodChangedEvent>::type MovableObjectLodChangedEventList; 01017 MovableObjectLodChangedEventList mMovableObjectLodChangedEvents; 01018 01020 typedef vector<EntityMeshLodChangedEvent>::type EntityMeshLodChangedEventList; 01021 EntityMeshLodChangedEventList mEntityMeshLodChangedEvents; 01022 01024 typedef vector<EntityMaterialLodChangedEvent>::type EntityMaterialLodChangedEventList; 01025 EntityMaterialLodChangedEventList mEntityMaterialLodChangedEvents; 01026 01027 public: 01030 SceneManager(const String& instanceName); 01031 01034 virtual ~SceneManager(); 01035 01036 01062 OGRE_MUTEX(sceneGraphMutex); 01063 01065 const String& getName(void) const { return mName; } 01066 01073 virtual const String& getTypeName(void) const = 0; 01074 01082 virtual Camera* createCamera(const String& name); 01083 01087 virtual Camera* getCamera(const String& name) const; 01088 01091 virtual bool hasCamera(const String& name) const; 01092 01101 virtual void destroyCamera(Camera *cam); 01102 01108 virtual void destroyCamera(const String& name); 01109 01118 virtual void destroyAllCameras(void); 01119 01130 virtual Light* createLight(const String& name); 01131 01133 virtual Light* createLight(); 01134 01138 virtual Light* getLight(const String& name) const; 01139 01142 virtual bool hasLight(const String& name) const; 01143 01146 virtual const PlaneList& getLightClippingPlanes(Light* l); 01147 01150 virtual const RealRect& getLightScissorRect(Light* l, const Camera* cam); 01151 01156 virtual void destroyLight(const String& name); 01157 01162 virtual void destroyLight(Light* light); 01165 virtual void destroyAllLights(void); 01166 01177 virtual void _notifyLightsDirty(void); 01178 01191 ulong _getLightsDirtyCounter(void) const { return mLightsDirtyCounter; } 01192 01199 virtual const LightList& _getLightsAffectingFrustum(void) const; 01200 01223 virtual void _populateLightList(const Vector3& position, Real radius, LightList& destList, uint32 lightMask = 0xFFFFFFFF); 01224 01253 virtual void _populateLightList(const SceneNode* sn, Real radius, LightList& destList, uint32 lightMask = 0xFFFFFFFF); 01254 01271 virtual SceneNode* createSceneNode(void); 01272 01287 virtual SceneNode* createSceneNode(const String& name); 01288 01295 virtual void destroySceneNode(const String& name); 01296 01303 virtual void destroySceneNode(SceneNode* sn); 01319 virtual SceneNode* getRootSceneNode(void); 01320 01328 virtual SceneNode* getSceneNode(const String& name) const; 01329 01332 virtual bool hasSceneNode(const String& name) const; 01333 01334 01342 virtual Entity* createEntity(const String& entityName, const String& meshName, const String& groupName = ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME ); 01343 01350 virtual Entity* createEntity(const String& entityName, const MeshPtr& pMesh ); 01351 01357 virtual Entity* createEntity(const String& meshName); 01358 01363 virtual Entity* createEntity(const MeshPtr& pMesh); 01364 01371 enum PrefabType { 01372 PT_PLANE, 01373 PT_CUBE, 01374 PT_SPHERE 01375 }; 01376 01383 virtual Entity* createEntity(const String& entityName, PrefabType ptype); 01384 01388 virtual Entity* createEntity(PrefabType ptype); 01392 virtual Entity* getEntity(const String& name) const; 01395 virtual bool hasEntity(const String& name) const; 01396 01405 virtual void destroyEntity(Entity* ent); 01406 01415 virtual void destroyEntity(const String& name); 01416 01426 virtual void destroyAllEntities(void); 01427 01433 virtual ManualObject* createManualObject(const String& name); 01437 virtual ManualObject* createManualObject(); 01441 virtual ManualObject* getManualObject(const String& name) const; 01444 virtual bool hasManualObject(const String& name) const; 01445 01448 virtual void destroyManualObject(ManualObject* obj); 01451 virtual void destroyManualObject(const String& name); 01454 virtual void destroyAllManualObjects(void); 01460 virtual BillboardChain* createBillboardChain(const String& name); 01464 virtual BillboardChain* createBillboardChain(); 01468 virtual BillboardChain* getBillboardChain(const String& name) const; 01471 virtual bool hasBillboardChain(const String& name) const; 01472 01475 virtual void destroyBillboardChain(BillboardChain* obj); 01478 virtual void destroyBillboardChain(const String& name); 01481 virtual void destroyAllBillboardChains(void); 01487 virtual RibbonTrail* createRibbonTrail(const String& name); 01491 virtual RibbonTrail* createRibbonTrail(); 01495 virtual RibbonTrail* getRibbonTrail(const String& name) const; 01498 virtual bool hasRibbonTrail(const String& name) const; 01499 01502 virtual void destroyRibbonTrail(RibbonTrail* obj); 01505 virtual void destroyRibbonTrail(const String& name); 01508 virtual void destroyAllRibbonTrails(void); 01509 01530 virtual ParticleSystem* createParticleSystem(const String& name, 01531 const String& templateName); 01551 virtual ParticleSystem* createParticleSystem(const String& name, 01552 size_t quota = 500, 01553 const String& resourceGroup = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 01554 01572 virtual ParticleSystem* createParticleSystem(size_t quota = 500, 01573 const String& resourceGroup = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 01577 virtual ParticleSystem* getParticleSystem(const String& name) const; 01580 virtual bool hasParticleSystem(const String& name) const; 01581 01584 virtual void destroyParticleSystem(ParticleSystem* obj); 01587 virtual void destroyParticleSystem(const String& name); 01590 virtual void destroyAllParticleSystems(void); 01591 01597 virtual void clearScene(void); 01598 01611 void setAmbientLight(const ColourValue& colour); 01612 01615 const ColourValue& getAmbientLight(void) const; 01616 01632 virtual void prepareWorldGeometry(const String& filename); 01633 01651 virtual void prepareWorldGeometry(DataStreamPtr& stream, 01652 const String& typeName = StringUtil::BLANK); 01653 01666 virtual void setWorldGeometry(const String& filename); 01667 01683 virtual void setWorldGeometry(DataStreamPtr& stream, 01684 const String& typeName = StringUtil::BLANK); 01685 01698 virtual size_t estimateWorldGeometry(const String& filename) 01699 { (void)filename; return 0; } 01700 01713 virtual size_t estimateWorldGeometry(DataStreamPtr& stream, 01714 const String& typeName = StringUtil::BLANK) 01715 { (void)stream; (void)typeName; return 0; } 01716 01731 virtual ViewPoint getSuggestedViewpoint(bool random = false); 01732 01746 virtual bool setOption( const String& strKey, const void* pValue ) 01747 { (void)strKey; (void)pValue; return false; } 01748 01762 virtual bool getOption( const String& strKey, void* pDestValue ) 01763 { (void)strKey; (void)pDestValue; return false; } 01764 01774 virtual bool hasOption( const String& strKey ) const 01775 { (void)strKey; return false; } 01776 01791 virtual bool getOptionValues( const String& strKey, StringVector& refValueList ) 01792 { (void)strKey; (void)refValueList; return false; } 01793 01800 virtual bool getOptionKeys( StringVector& refKeys ) 01801 { (void)refKeys; return false; } 01802 01811 virtual void _updateSceneGraph(Camera* cam); 01812 01824 virtual void _findVisibleObjects(Camera* cam, VisibleObjectsBoundsInfo* visibleBounds, bool onlyShadowCasters); 01825 01830 virtual void _applySceneAnimations(void); 01831 01834 virtual void _renderVisibleObjects(void); 01835 01849 virtual void _renderScene(Camera* camera, Viewport* vp, bool includeOverlays); 01850 01854 virtual void _queueSkiesForRendering(Camera* cam); 01855 01856 01857 01866 virtual void _setDestinationRenderSystem(RenderSystem* sys); 01867 01921 virtual void setSkyPlane( 01922 bool enable, 01923 const Plane& plane, const String& materialName, Real scale = 1000, 01924 Real tiling = 10, bool drawFirst = true, Real bow = 0, 01925 int xsegments = 1, int ysegments = 1, 01926 const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 01970 virtual void _setSkyPlane( 01971 bool enable, 01972 const Plane& plane, const String& materialName, Real scale = 1000, 01973 Real tiling = 10, uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, Real bow = 0, 01974 int xsegments = 1, int ysegments = 1, 01975 const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 01976 01978 virtual void setSkyPlaneEnabled(bool enable) { mSkyPlaneEnabled = enable; } 01979 01981 virtual bool isSkyPlaneEnabled(void) const { return mSkyPlaneEnabled; } 01982 01984 virtual SceneNode* getSkyPlaneNode(void) const { return mSkyPlaneNode; } 01985 01987 virtual const SkyPlaneGenParameters& getSkyPlaneGenParameters(void) const { return mSkyPlaneGenParameters; } 01988 02030 virtual void setSkyBox( 02031 bool enable, const String& materialName, Real distance = 5000, 02032 bool drawFirst = true, const Quaternion& orientation = Quaternion::IDENTITY, 02033 const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 02034 02067 virtual void _setSkyBox( 02068 bool enable, const String& materialName, Real distance = 5000, 02069 uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, const Quaternion& orientation = Quaternion::IDENTITY, 02070 const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 02071 02073 virtual void setSkyBoxEnabled(bool enable) { mSkyBoxEnabled = enable; } 02074 02076 virtual bool isSkyBoxEnabled(void) const { return mSkyBoxEnabled; } 02077 02079 virtual SceneNode* getSkyBoxNode(void) const { return mSkyBoxNode; } 02080 02082 virtual const SkyBoxGenParameters& getSkyBoxGenParameters(void) const { return mSkyBoxGenParameters; } 02083 02139 virtual void setSkyDome( 02140 bool enable, const String& materialName, Real curvature = 10, 02141 Real tiling = 8, Real distance = 4000, bool drawFirst = true, 02142 const Quaternion& orientation = Quaternion::IDENTITY, 02143 int xsegments = 16, int ysegments = 16, int ysegments_keep = -1, 02144 const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 02145 02192 virtual void _setSkyDome( 02193 bool enable, const String& materialName, Real curvature = 10, 02194 Real tiling = 8, Real distance = 4000, uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, 02195 const Quaternion& orientation = Quaternion::IDENTITY, 02196 int xsegments = 16, int ysegments = 16, int ysegments_keep = -1, 02197 const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 02198 02200 virtual void setSkyDomeEnabled(bool enable) { mSkyDomeEnabled = enable; } 02201 02203 virtual bool isSkyDomeEnabled(void) const { return mSkyDomeEnabled; } 02204 02206 virtual SceneNode* getSkyDomeNode(void) const { return mSkyDomeNode; } 02207 02209 virtual const SkyDomeGenParameters& getSkyDomeGenParameters(void) const { return mSkyDomeGenParameters; } 02210 02235 void setFog( 02236 FogMode mode = FOG_NONE, const ColourValue& colour = ColourValue::White, 02237 Real expDensity = 0.001, Real linearStart = 0.0, Real linearEnd = 1.0); 02238 02241 virtual FogMode getFogMode(void) const; 02242 02245 virtual const ColourValue& getFogColour(void) const; 02246 02249 virtual Real getFogStart(void) const; 02250 02253 virtual Real getFogEnd(void) const; 02254 02257 virtual Real getFogDensity(void) const; 02258 02259 02277 virtual BillboardSet* createBillboardSet(const String& name, unsigned int poolSize = 20); 02278 02285 virtual BillboardSet* createBillboardSet(unsigned int poolSize = 20); 02289 virtual BillboardSet* getBillboardSet(const String& name) const; 02292 virtual bool hasBillboardSet(const String& name) const; 02293 02300 virtual void destroyBillboardSet(BillboardSet* set); 02301 02308 virtual void destroyBillboardSet(const String& name); 02309 02319 virtual void destroyAllBillboardSets(void); 02320 02328 virtual void setDisplaySceneNodes(bool display); 02330 virtual bool getDisplaySceneNodes(void) const {return mDisplayNodes;} 02331 02352 virtual Animation* createAnimation(const String& name, Real length); 02353 02357 virtual Animation* getAnimation(const String& name) const; 02360 virtual bool hasAnimation(const String& name) const; 02361 02367 virtual void destroyAnimation(const String& name); 02368 02370 virtual void destroyAllAnimations(void); 02371 02399 virtual AnimationState* createAnimationState(const String& animName); 02400 02404 virtual AnimationState* getAnimationState(const String& animName) const; 02407 virtual bool hasAnimationState(const String& name) const; 02408 02414 virtual void destroyAnimationState(const String& name); 02415 02417 virtual void destroyAllAnimationStates(void); 02418 02442 virtual void manualRender(RenderOperation* rend, Pass* pass, Viewport* vp, 02443 const Matrix4& worldMatrix, const Matrix4& viewMatrix, const Matrix4& projMatrix, 02444 bool doBeginEndFrame = false) ; 02445 02465 virtual void manualRender(Renderable* rend, const Pass* pass, Viewport* vp, 02466 const Matrix4& viewMatrix, const Matrix4& projMatrix, bool doBeginEndFrame = false, bool lightScissoringClipping = true, 02467 bool doLightIteration = true, const LightList* manualLightList = 0); 02468 02479 virtual RenderQueue* getRenderQueue(void); 02480 02484 virtual void addRenderQueueListener(RenderQueueListener* newListener); 02485 02487 virtual void removeRenderQueueListener(RenderQueueListener* delListener); 02488 02491 virtual void addRenderObjectListener(RenderObjectListener* newListener); 02493 virtual void removeRenderObjectListener(RenderObjectListener* delListener); 02494 02508 virtual void addSpecialCaseRenderQueue(uint8 qid); 02514 virtual void removeSpecialCaseRenderQueue(uint8 qid); 02518 virtual void clearSpecialCaseRenderQueues(void); 02523 virtual void setSpecialCaseRenderQueueMode(SpecialCaseRenderQueueMode mode); 02525 virtual SpecialCaseRenderQueueMode getSpecialCaseRenderQueueMode(void); 02532 virtual bool isRenderQueueToBeProcessed(uint8 qid); 02533 02549 virtual void setWorldGeometryRenderQueue(uint8 qid); 02560 virtual uint8 getWorldGeometryRenderQueue(void); 02561 02563 virtual void showBoundingBoxes(bool bShow); 02564 02566 virtual bool getShowBoundingBoxes() const; 02567 02569 virtual void _notifyAutotrackingSceneNode(SceneNode* node, bool autoTrack); 02570 02571 02584 virtual AxisAlignedBoxSceneQuery* 02585 createAABBQuery(const AxisAlignedBox& box, uint32 mask = 0xFFFFFFFF); 02598 virtual SphereSceneQuery* 02599 createSphereQuery(const Sphere& sphere, uint32 mask = 0xFFFFFFFF); 02612 virtual PlaneBoundedVolumeListSceneQuery* 02613 createPlaneBoundedVolumeQuery(const PlaneBoundedVolumeList& volumes, uint32 mask = 0xFFFFFFFF); 02614 02615 02628 virtual RaySceneQuery* 02629 createRayQuery(const Ray& ray, uint32 mask = 0xFFFFFFFF); 02630 //PyramidSceneQuery* createPyramidQuery(const Pyramid& p, unsigned long mask = 0xFFFFFFFF); 02642 virtual IntersectionSceneQuery* 02643 createIntersectionQuery(uint32 mask = 0xFFFFFFFF); 02644 02646 virtual void destroyQuery(SceneQuery* query); 02647 02648 typedef MapIterator<CameraList> CameraIterator; 02649 typedef MapIterator<AnimationList> AnimationIterator; 02650 02653 CameraIterator getCameraIterator(void) { 02654 return CameraIterator(mCameras.begin(), mCameras.end()); 02655 } 02658 const CameraList& getCameras() const { return mCameras; } 02660 AnimationIterator getAnimationIterator(void) { 02661 return AnimationIterator(mAnimationsList.begin(), mAnimationsList.end()); 02662 } 02665 const AnimationList& getAnimations() const { return mAnimationsList; } 02667 AnimationStateIterator getAnimationStateIterator(void) { 02668 return mAnimationStates.getAnimationStateIterator(); 02669 } 02670 02703 virtual void setShadowTechnique(ShadowTechnique technique); 02704 02706 virtual ShadowTechnique getShadowTechnique(void) const { return mShadowTechnique; } 02707 02709 virtual void setShowDebugShadows(bool debug) { mDebugShadows = debug; } 02711 virtual bool getShowDebugShadows(void ) const { return mDebugShadows; } 02712 02719 virtual void setShadowColour(const ColourValue& colour); 02726 virtual const ColourValue& getShadowColour(void) const; 02738 virtual void setShadowDirectionalLightExtrusionDistance(Real dist); 02741 virtual Real getShadowDirectionalLightExtrusionDistance(void) const; 02758 virtual void setShadowFarDistance(Real distance); 02762 virtual Real getShadowFarDistance(void) const 02763 { return mDefaultShadowFarDist; } 02764 virtual Real getShadowFarDistanceSquared(void) const 02765 { return mDefaultShadowFarDistSquared; } 02766 02792 virtual void setShadowIndexBufferSize(size_t size); 02794 virtual size_t getShadowIndexBufferSize(void) const 02795 { return mShadowIndexBufferSize; } 02804 virtual void setShadowTextureSize(unsigned short size); 02805 02815 virtual void setShadowTextureConfig(size_t shadowIndex, unsigned short width, 02816 unsigned short height, PixelFormat format, unsigned short fsaa = 0, uint16 depthBufferPoolId=1); 02822 virtual void setShadowTextureConfig(size_t shadowIndex, 02823 const ShadowTextureConfig& config); 02824 02826 ConstShadowTextureConfigIterator getShadowTextureConfigIterator() const; 02827 02839 virtual void setShadowTexturePixelFormat(PixelFormat fmt); 02846 virtual void setShadowTextureFSAA(unsigned short fsaa); 02847 02855 virtual void setShadowTextureCount(size_t count); 02857 size_t getShadowTextureCount(void) const {return mShadowTextureConfigList.size(); } 02858 02868 void setShadowTextureCountPerLightType(Light::LightTypes type, size_t count) 02869 { mShadowTextureCountPerType[type] = count; } 02871 size_t getShadowTextureCountPerLightType(Light::LightTypes type) const 02872 {return mShadowTextureCountPerType[type]; } 02873 02881 virtual void setShadowTextureSettings(unsigned short size, unsigned short count, 02882 PixelFormat fmt = PF_X8R8G8B8, unsigned short fsaa = 0, uint16 depthBufferPoolId=1); 02883 02890 virtual const TexturePtr& getShadowTexture(size_t shadowIndex); 02891 02906 virtual void setShadowDirLightTextureOffset(Real offset) { mShadowTextureOffset = offset;} 02910 virtual Real getShadowDirLightTextureOffset(void) const { return mShadowTextureOffset; } 02918 virtual void setShadowTextureFadeStart(Real fadeStart) 02919 { mShadowTextureFadeStart = fadeStart; } 02927 virtual void setShadowTextureFadeEnd(Real fadeEnd) 02928 { mShadowTextureFadeEnd = fadeEnd; } 02929 02942 virtual void setShadowTextureSelfShadow(bool selfShadow); 02943 02945 virtual bool getShadowTextureSelfShadow(void) const 02946 { return mShadowTextureSelfShadow; } 02967 virtual void setShadowTextureCasterMaterial(const String& name); 02989 virtual void setShadowTextureReceiverMaterial(const String& name); 02990 03001 virtual void setShadowCasterRenderBackFaces(bool bf) { mShadowCasterRenderBackFaces = bf; } 03002 03006 virtual bool getShadowCasterRenderBackFaces() const { return mShadowCasterRenderBackFaces; } 03007 03012 virtual void setShadowCameraSetup(const ShadowCameraSetupPtr& shadowSetup); 03013 03018 virtual const ShadowCameraSetupPtr& getShadowCameraSetup() const; 03019 03056 virtual void setShadowUseInfiniteFarPlane(bool enable) { 03057 mShadowUseInfiniteFarPlane = enable; } 03058 03060 virtual bool isShadowTechniqueStencilBased(void) const 03061 { return (mShadowTechnique & SHADOWDETAILTYPE_STENCIL) != 0; } 03063 virtual bool isShadowTechniqueTextureBased(void) const 03064 { return (mShadowTechnique & SHADOWDETAILTYPE_TEXTURE) != 0; } 03066 virtual bool isShadowTechniqueModulative(void) const 03067 { return (mShadowTechnique & SHADOWDETAILTYPE_MODULATIVE) != 0; } 03069 virtual bool isShadowTechniqueAdditive(void) const 03070 { return (mShadowTechnique & SHADOWDETAILTYPE_ADDITIVE) != 0; } 03072 virtual bool isShadowTechniqueIntegrated(void) const 03073 { return (mShadowTechnique & SHADOWDETAILTYPE_INTEGRATED) != 0; } 03075 virtual bool isShadowTechniqueInUse(void) const 03076 { return mShadowTechnique != SHADOWTYPE_NONE; } 03080 virtual void setShadowUseLightClipPlanes(bool enabled) { mShadowAdditiveLightClip = enabled; } 03084 virtual bool getShadowUseLightClipPlanes() const { return mShadowAdditiveLightClip; } 03085 03089 virtual void _setActiveCompositorChain(CompositorChain* chain) { mActiveCompositorChain = chain; } 03090 03096 virtual void setLateMaterialResolving(bool isLate) { mLateMaterialResolving = isLate; } 03097 03100 virtual bool isLateMaterialResolving() const { return mLateMaterialResolving; } 03101 03103 virtual CompositorChain* _getActiveCompositorChain() const { return mActiveCompositorChain; } 03104 03107 virtual void addListener(Listener* s); 03110 virtual void removeListener(Listener* s); 03111 03121 virtual StaticGeometry* createStaticGeometry(const String& name); 03125 virtual StaticGeometry* getStaticGeometry(const String& name) const; 03127 virtual bool hasStaticGeometry(const String& name) const; 03129 virtual void destroyStaticGeometry(StaticGeometry* geom); 03131 virtual void destroyStaticGeometry(const String& name); 03133 virtual void destroyAllStaticGeometry(void); 03134 03144 virtual InstancedGeometry* createInstancedGeometry(const String& name); 03146 virtual InstancedGeometry* getInstancedGeometry(const String& name) const; 03148 virtual void destroyInstancedGeometry(InstancedGeometry* geom); 03150 virtual void destroyInstancedGeometry(const String& name); 03152 virtual void destroyAllInstancedGeometry(void); 03153 03172 virtual InstanceManager* createInstanceManager( const String &customName, const String &meshName, 03173 const String &groupName, 03174 InstanceManager::InstancingTechnique technique, 03175 size_t numInstancesPerBatch, uint16 flags=0, 03176 unsigned short subMeshIdx=0 ); 03177 03181 virtual InstanceManager* getInstanceManager( const String &managerName ) const; 03182 03184 virtual bool hasInstanceManager( const String &managerName ) const; 03185 03192 virtual void destroyInstanceManager( const String &name ); 03193 virtual void destroyInstanceManager( InstanceManager *instanceManager ); 03194 03195 virtual void destroyAllInstanceManagers(void); 03196 03209 virtual size_t getNumInstancesPerBatch( const String &meshName, const String &groupName, 03210 const String &materialName, 03211 InstanceManager::InstancingTechnique technique, 03212 size_t numInstancesPerBatch, uint16 flags=0, 03213 unsigned short subMeshIdx=0 ); 03214 03226 virtual InstancedEntity* createInstancedEntity( const String &materialName, 03227 const String &managerName ); 03228 03233 virtual void destroyInstancedEntity( InstancedEntity *instancedEntity ); 03234 03239 void _addDirtyInstanceManager( InstanceManager *dirtyManager ); 03240 03251 virtual MovableObject* createMovableObject(const String& name, 03252 const String& typeName, const NameValuePairList* params = 0); 03262 virtual MovableObject* createMovableObject(const String& typeName, const NameValuePairList* params = 0); 03268 virtual void destroyMovableObject(const String& name, const String& typeName); 03274 virtual void destroyMovableObject(MovableObject* m); 03276 virtual void destroyAllMovableObjectsByType(const String& typeName); 03278 virtual void destroyAllMovableObjects(void); 03282 virtual MovableObject* getMovableObject(const String& name, const String& typeName) const; 03284 virtual bool hasMovableObject(const String& name, const String& typeName) const; 03285 typedef MapIterator<MovableObjectMap> MovableObjectIterator; 03291 virtual MovableObjectIterator getMovableObjectIterator(const String& typeName); 03303 virtual void injectMovableObject(MovableObject* m); 03310 virtual void extractMovableObject(const String& name, const String& typeName); 03317 virtual void extractMovableObject(MovableObject* m); 03324 virtual void extractAllMovableObjectsByType(const String& typeName); 03325 03332 virtual void setVisibilityMask(uint32 vmask) { mVisibilityMask = vmask; } 03333 03337 virtual uint32 getVisibilityMask(void) { return mVisibilityMask; } 03338 03342 uint32 _getCombinedVisibilityMask(void) const; 03343 03350 virtual void setFindVisibleObjects(bool find) { mFindVisibleObjects = find; } 03351 03355 virtual bool getFindVisibleObjects(void) { return mFindVisibleObjects; } 03356 03365 virtual void setNormaliseNormalsOnScale(bool n) { mNormaliseNormalsOnScale = n; } 03366 03370 virtual bool getNormaliseNormalsOnScale() const { return mNormaliseNormalsOnScale; } 03371 03380 virtual void setFlipCullingOnNegativeScale(bool n) { mFlipCullingOnNegativeScale = n; } 03381 03385 virtual bool getFlipCullingOnNegativeScale() const { return mFlipCullingOnNegativeScale; } 03386 03392 virtual void _injectRenderWithPass(Pass *pass, Renderable *rend, bool shadowDerivation = true, 03393 bool doLightIteration = false, const LightList* manualLightList = 0); 03394 03413 virtual void _suppressRenderStateChanges(bool suppress); 03414 03418 virtual bool _areRenderStateChangesSuppressed(void) const 03419 { return mSuppressRenderStateChanges; } 03420 03433 virtual const Pass* _setPass(const Pass* pass, 03434 bool evenIfSuppressed = false, bool shadowDerivation = true); 03435 03443 virtual void _markGpuParamsDirty(uint16 mask); 03444 03445 03455 virtual void _suppressShadows(bool suppress); 03456 03460 virtual bool _areShadowsSuppressed(void) const 03461 { return mSuppressShadows; } 03462 03466 virtual void _renderQueueGroupObjects(RenderQueueGroup* group, 03467 QueuedRenderableCollection::OrganisationMode om); 03468 03484 void setQueuedRenderableVisitor(SceneMgrQueuedRenderableVisitor* visitor); 03485 03487 SceneMgrQueuedRenderableVisitor* getQueuedRenderableVisitor(void) const; 03488 03489 03493 RenderSystem *getDestinationRenderSystem(); 03494 03497 Viewport* getCurrentViewport(void) const { return mCurrentViewport; } 03498 03500 const VisibleObjectsBoundsInfo& getVisibleObjectsBoundsInfo(const Camera* cam) const; 03501 03503 const VisibleObjectsBoundsInfo& getShadowCasterBoundsInfo(const Light* light, size_t iteration = 0) const; 03504 03519 virtual void setCameraRelativeRendering(bool rel) { mCameraRelativeRendering = rel; } 03520 03524 virtual bool getCameraRelativeRendering() const { return mCameraRelativeRendering; } 03525 03526 03528 void addLodListener(LodListener *listener); 03529 03535 void removeLodListener(LodListener *listener); 03536 03538 void _notifyMovableObjectLodChanged(MovableObjectLodChangedEvent& evt); 03539 03541 void _notifyEntityMeshLodChanged(EntityMeshLodChangedEvent& evt); 03542 03544 void _notifyEntityMaterialLodChanged(EntityMaterialLodChangedEvent& evt); 03545 03547 void _handleLodEvents(); 03548 03549 IlluminationRenderStage _getCurrentRenderStage() {return mIlluminationStage;} 03550 }; 03551 03553 class _OgreExport DefaultIntersectionSceneQuery : 03554 public IntersectionSceneQuery 03555 { 03556 public: 03557 DefaultIntersectionSceneQuery(SceneManager* creator); 03558 ~DefaultIntersectionSceneQuery(); 03559 03561 void execute(IntersectionSceneQueryListener* listener); 03562 }; 03563 03565 class _OgreExport DefaultRaySceneQuery : public RaySceneQuery 03566 { 03567 public: 03568 DefaultRaySceneQuery(SceneManager* creator); 03569 ~DefaultRaySceneQuery(); 03570 03572 void execute(RaySceneQueryListener* listener); 03573 }; 03575 class _OgreExport DefaultSphereSceneQuery : public SphereSceneQuery 03576 { 03577 public: 03578 DefaultSphereSceneQuery(SceneManager* creator); 03579 ~DefaultSphereSceneQuery(); 03580 03582 void execute(SceneQueryListener* listener); 03583 }; 03585 class _OgreExport DefaultPlaneBoundedVolumeListSceneQuery : public PlaneBoundedVolumeListSceneQuery 03586 { 03587 public: 03588 DefaultPlaneBoundedVolumeListSceneQuery(SceneManager* creator); 03589 ~DefaultPlaneBoundedVolumeListSceneQuery(); 03590 03592 void execute(SceneQueryListener* listener); 03593 }; 03595 class _OgreExport DefaultAxisAlignedBoxSceneQuery : public AxisAlignedBoxSceneQuery 03596 { 03597 public: 03598 DefaultAxisAlignedBoxSceneQuery(SceneManager* creator); 03599 ~DefaultAxisAlignedBoxSceneQuery(); 03600 03602 void execute(SceneQueryListener* listener); 03603 }; 03604 03605 03607 typedef uint16 SceneTypeMask; 03608 03612 enum SceneType 03613 { 03614 ST_GENERIC = 1, 03615 ST_EXTERIOR_CLOSE = 2, 03616 ST_EXTERIOR_FAR = 4, 03617 ST_EXTERIOR_REAL_FAR = 8, 03618 ST_INTERIOR = 16 03619 }; 03620 03622 struct SceneManagerMetaData 03623 { 03625 String typeName; 03627 String description; 03629 SceneTypeMask sceneTypeMask; 03631 bool worldGeometrySupported; 03632 }; 03633 03634 03635 03637 class _OgreExport SceneManagerFactory : public SceneMgtAlloc 03638 { 03639 protected: 03640 mutable SceneManagerMetaData mMetaData; 03641 mutable bool mMetaDataInit; 03643 virtual void initMetaData(void) const = 0; 03644 public: 03645 SceneManagerFactory() : mMetaDataInit(true) {} 03646 virtual ~SceneManagerFactory() {} 03648 virtual const SceneManagerMetaData& getMetaData(void) const 03649 { 03650 if (mMetaDataInit) 03651 { 03652 initMetaData(); 03653 mMetaDataInit = false; 03654 } 03655 return mMetaData; 03656 } 03661 virtual SceneManager* createInstance(const String& instanceName) = 0; 03663 virtual void destroyInstance(SceneManager* instance) = 0; 03664 03665 }; 03666 03671 } // Namespace 03672 03673 #include "OgreHeaderSuffix.h" 03674 03675 #endif
Copyright © 2012 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Mon Jul 27 2020 13:40:45