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 Real minDistance; 00080 Real maxDistance; 00081 00082 VisibleObjectsBoundsInfo() 00083 { 00084 reset(); 00085 } 00086 00087 void reset() 00088 { 00089 aabb.setNull(); 00090 minDistance = std::numeric_limits<Real>::infinity(); 00091 maxDistance = 0; 00092 } 00093 00094 void merge(const AxisAlignedBox& boxBounds, const Sphere& sphereBounds, 00095 const Camera* cam) 00096 { 00097 aabb.merge(boxBounds); 00098 Real camDistToCenter = 00099 (cam->getDerivedPosition() - sphereBounds.getCenter()).length(); 00100 minDistance = (std::min)(minDistance, (std::max)((Real)0, camDistToCenter - sphereBounds.getRadius())); 00101 maxDistance = (std::max)(maxDistance, camDistToCenter + sphereBounds.getRadius()); 00102 } 00103 00104 00105 }; 00106 00110 class _OgreExport ShadowListener 00111 { 00112 public: 00113 ShadowListener() {} 00114 virtual ~ShadowListener() {} 00115 00130 virtual void shadowTexturesUpdated(size_t numberOfShadowTextures) = 0; 00131 00144 virtual void shadowTextureCasterPreViewProj(Light* light, 00145 Camera* camera) = 0; 00159 virtual void shadowTextureReceiverPreViewProj(Light* light, 00160 Frustum* frustum) = 0; 00161 00184 virtual bool sortLightsAffectingFrustum(LightList& lightList) { return false; } 00185 00186 00187 }; 00188 00218 class _OgreExport SceneManager 00219 { 00220 public: 00222 static uint32 WORLD_GEOMETRY_TYPE_MASK; 00224 static uint32 ENTITY_TYPE_MASK; 00226 static uint32 FX_TYPE_MASK; 00228 static uint32 STATICGEOMETRY_TYPE_MASK; 00230 static uint32 LIGHT_TYPE_MASK; 00232 static uint32 USER_TYPE_MASK_LIMIT; 00235 struct materialLess 00236 { 00237 _OgreExport bool operator()(const Material* x, const Material* y) const; 00238 }; 00240 struct lightLess 00241 { 00242 _OgreExport bool operator()(const Light* a, const Light* b) const; 00243 }; 00244 00246 enum IlluminationRenderStage 00247 { 00249 IRS_NONE, 00251 IRS_RENDER_TO_TEXTURE, 00253 IRS_RENDER_RECEIVER_PASS 00254 }; 00255 00260 enum SpecialCaseRenderQueueMode 00261 { 00263 SCRQM_INCLUDE, 00265 SCRQM_EXCLUDE 00266 }; 00267 00268 struct SkyDomeGenParameters 00269 { 00270 Real skyDomeCurvature; 00271 Real skyDomeTiling; 00272 Real skyDomeDistance; 00273 int skyDomeXSegments; 00274 int skyDomeYSegments; 00275 int skyDomeYSegments_keep; 00276 }; 00277 00278 struct SkyPlaneGenParameters 00279 { 00280 Real skyPlaneScale; 00281 Real skyPlaneTiling; 00282 Real skyPlaneBow; 00283 int skyPlaneXSegments; 00284 int skyPlaneYSegments; 00285 }; 00286 00287 struct SkyBoxGenParameters 00288 { 00289 Real skyBoxDistance; 00290 }; 00291 00292 protected: 00294 String mName; 00295 00297 RenderQueue* mRenderQueue; 00298 00300 ColourValue mAmbientLight; 00301 00303 RenderSystem *mDestRenderSystem; 00304 00305 typedef std::map<String, Camera* > CameraList; 00306 00309 CameraList mCameras; 00310 00311 typedef std::map<String, StaticGeometry* > StaticGeometryList; 00312 StaticGeometryList mStaticGeometryList; 00313 typedef std::map<String, InstancedGeometry* > InstancedGeometryList; 00314 InstancedGeometryList mInstancedGeometryList; 00315 00316 typedef std::map<String, SceneNode*> SceneNodeList; 00317 00324 SceneNodeList mSceneNodes; 00325 00327 Camera* mCameraInProgress; 00329 Viewport* mCurrentViewport; 00330 00332 SceneNode* mSceneRoot; 00333 00335 typedef std::set<SceneNode*> AutoTrackingSceneNodes; 00336 AutoTrackingSceneNodes mAutoTrackingSceneNodes; 00337 00338 // Sky params 00339 // Sky plane 00340 Entity* mSkyPlaneEntity; 00341 Entity* mSkyDomeEntity[5]; 00342 Entity* mSkyBoxEntity[6]; 00343 00344 SceneNode* mSkyPlaneNode; 00345 SceneNode* mSkyDomeNode; 00346 SceneNode* mSkyBoxNode; 00347 00348 // Sky plane 00349 bool mSkyPlaneEnabled; 00350 bool mSkyPlaneDrawFirst; 00351 Plane mSkyPlane; 00352 SkyPlaneGenParameters mSkyPlaneGenParameters; 00353 // Sky box 00354 bool mSkyBoxEnabled; 00355 bool mSkyBoxDrawFirst; 00356 Quaternion mSkyBoxOrientation; 00357 SkyBoxGenParameters mSkyBoxGenParameters; 00358 // Sky dome 00359 bool mSkyDomeEnabled; 00360 bool mSkyDomeDrawFirst; 00361 Quaternion mSkyDomeOrientation; 00362 SkyDomeGenParameters mSkyDomeGenParameters; 00363 00364 // Fog 00365 FogMode mFogMode; 00366 ColourValue mFogColour; 00367 Real mFogStart; 00368 Real mFogEnd; 00369 Real mFogDensity; 00370 00371 typedef std::set<uint8> SpecialCaseRenderQueueList; 00372 SpecialCaseRenderQueueList mSpecialCaseQueueList; 00373 SpecialCaseRenderQueueMode mSpecialCaseQueueMode; 00374 uint8 mWorldGeometryRenderQueue; 00375 00376 unsigned long mLastFrameNumber; 00377 Matrix4 mTempXform[256]; 00378 bool mResetIdentityView; 00379 bool mResetIdentityProj; 00380 00381 protected: 00382 00390 typedef std::map< const Camera*, VisibleObjectsBoundsInfo> CamVisibleObjectsMap; 00391 CamVisibleObjectsMap mCamVisibleObjectsMap; 00392 00394 typedef std::map< const Camera*, const Light* > ShadowCamLightMapping; 00395 ShadowCamLightMapping mShadowCamLightMapping; 00396 00398 struct _OgreExport LightInfo 00399 { 00400 Light* light; // Just a pointer for comparison, the light might destroyed for some reason 00401 int type; // Use int instead of Light::LightTypes to avoid header file dependence 00402 Real range; // Sets to zero if directional light 00403 Vector3 position; // Sets to zero if directional light 00404 00405 bool operator== (const LightInfo& rhs) const 00406 { 00407 return light == rhs.light && type == rhs.type && 00408 range == rhs.range && position == rhs.position; 00409 } 00410 00411 bool operator!= (const LightInfo& rhs) const 00412 { 00413 return !(*this == rhs); 00414 } 00415 }; 00416 00417 typedef std::vector<LightInfo> LightInfoList; 00418 00419 LightList mLightsAffectingFrustum; 00420 LightInfoList mCachedLightInfos; 00421 LightInfoList mTestLightInfos; // potentially new list 00422 ulong mLightsDirtyCounter; 00423 00424 typedef std::map<String, MovableObject*> MovableObjectMap; 00426 struct MovableObjectCollection 00427 { 00428 MovableObjectMap map; 00429 OGRE_MUTEX(mutex) 00430 }; 00431 typedef std::map<String, MovableObjectCollection*> MovableObjectCollectionMap; 00432 MovableObjectCollectionMap mMovableObjectCollectionMap; 00437 MovableObjectCollection* getMovableObjectCollection(const String& typeName); 00442 const MovableObjectCollection* getMovableObjectCollection(const String& typeName) const; 00444 OGRE_MUTEX(mMovableObjectCollectionMapMutex) 00445 00446 00450 virtual void initRenderQueue(void); 00452 Pass* mShadowCasterPlainBlackPass; 00454 Pass* mShadowReceiverPass; 00464 const Pass* deriveShadowCasterPass(const Pass* pass); 00473 const Pass* deriveShadowReceiverPass(const Pass* pass); 00474 00481 bool validatePassForRendering(const Pass* pass); 00482 00489 bool validateRenderableForRendering(const Pass* pass, const Renderable* rend); 00490 00491 enum BoxPlane 00492 { 00493 BP_FRONT = 0, 00494 BP_BACK = 1, 00495 BP_LEFT = 2, 00496 BP_RIGHT = 3, 00497 BP_UP = 4, 00498 BP_DOWN = 5 00499 }; 00500 00501 /* Internal utility method for creating the planes of a skybox. 00502 */ 00503 MeshPtr createSkyboxPlane( 00504 BoxPlane bp, 00505 Real distance, 00506 const Quaternion& orientation, 00507 const String& groupName); 00508 00509 /* Internal utility method for creating the planes of a skydome. 00510 */ 00511 MeshPtr createSkydomePlane( 00512 BoxPlane bp, 00513 Real curvature, Real tiling, Real distance, 00514 const Quaternion& orientation, 00515 int xsegments, int ysegments, int ySegmentsToKeep, 00516 const String& groupName); 00517 00518 // Flag indicating whether SceneNodes will be rendered as a set of 3 axes 00519 bool mDisplayNodes; 00520 00522 typedef std::map<String, Animation*> AnimationList; 00523 AnimationList mAnimationsList; 00524 OGRE_MUTEX(mAnimationsListMutex) 00525 AnimationStateSet mAnimationStates; 00526 00527 00530 void useRenderableViewProjMode(const Renderable* pRend); 00531 00534 void resetViewProjMode(void); 00535 00536 typedef std::vector<RenderQueueListener*> RenderQueueListenerList; 00537 RenderQueueListenerList mRenderQueueListeners; 00538 00539 typedef std::vector<ShadowListener*> ShadowListenerList; 00540 ShadowListenerList mShadowListeners; 00542 bool fireRenderQueueStarted(uint8 id, const String& invocation); 00544 bool fireRenderQueueEnded(uint8 id, const String& invocation); 00545 00547 void fireShadowTexturesUpdated(size_t numberOfShadowTextures); 00549 void fireShadowTexturesPreCaster(Light* light, Camera* camera); 00551 void fireShadowTexturesPreReceiver(Light* light, Frustum* f); 00553 virtual void setViewport(Viewport *vp); 00554 00556 bool mShowBoundingBoxes; 00557 00559 virtual void renderVisibleObjectsDefaultSequence(void); 00561 virtual void renderVisibleObjectsCustomSequence(RenderQueueInvocationSequence* s); 00563 virtual void prepareRenderQueue(void); 00564 00565 00578 virtual void renderSingleObject(const Renderable* rend, const Pass* pass, 00579 bool doLightIteration, const LightList* manualLightList = 0); 00580 00582 AutoParamDataSource mAutoParamDataSource; 00583 00584 ShadowTechnique mShadowTechnique; 00585 bool mDebugShadows; 00586 ColourValue mShadowColour; 00587 Pass* mShadowDebugPass; 00588 Pass* mShadowStencilPass; 00589 Pass* mShadowModulativePass; 00590 bool mShadowMaterialInitDone; 00591 HardwareIndexBufferSharedPtr mShadowIndexBuffer; 00592 size_t mShadowIndexBufferSize; 00593 Rectangle2D* mFullScreenQuad; 00594 Real mShadowDirLightExtrudeDist; 00595 IlluminationRenderStage mIlluminationStage; 00596 ShadowTextureConfigList mShadowTextureConfigList; 00597 bool mShadowTextureConfigDirty; 00598 ShadowTextureList mShadowTextures; 00599 TexturePtr mNullShadowTexture; 00600 typedef std::vector<Camera*> ShadowTextureCameraList; 00601 ShadowTextureCameraList mShadowTextureCameras; 00602 Texture* mCurrentShadowTexture; 00603 bool mShadowUseInfiniteFarPlane; 00604 bool mShadowCasterRenderBackFaces; 00605 00607 ShadowCameraSetupPtr mDefaultShadowCameraSetup; 00608 00617 struct lightsForShadowTextureLess 00618 { 00619 _OgreExport bool operator()(const Light* l1, const Light* l2) const; 00620 }; 00621 00622 00629 virtual void findLightsAffectingFrustum(const Camera* camera); 00631 virtual void initShadowVolumeMaterials(void); 00633 virtual void ensureShadowTexturesCreated(); 00635 virtual void destroyShadowTextures(void); 00637 virtual void prepareShadowTextures(Camera* cam, Viewport* vp); 00638 00644 virtual void renderShadowVolumesToStencil(const Light* light, const Camera* cam); 00650 virtual void setShadowVolumeStencilState(bool secondpass, bool zfail, bool twosided); 00652 void renderShadowVolumeObjects(ShadowCaster::ShadowRenderableListIterator iShadowRenderables, 00653 Pass* pass, const LightList *manualLightList, unsigned long flags, 00654 bool secondpass, bool zfail, bool twosided); 00655 typedef std::vector<ShadowCaster*> ShadowCasterList; 00656 ShadowCasterList mShadowCasterList; 00657 SphereSceneQuery* mShadowCasterSphereQuery; 00658 AxisAlignedBoxSceneQuery* mShadowCasterAABBQuery; 00659 Real mShadowFarDist; 00660 Real mShadowFarDistSquared; 00661 Real mShadowTextureOffset; // proportion of texture offset in view direction e.g. 0.4 00662 Real mShadowTextureFadeStart; // as a proportion e.g. 0.6 00663 Real mShadowTextureFadeEnd; // as a proportion e.g. 0.9 00664 bool mShadowTextureSelfShadow; 00665 Pass* mShadowTextureCustomCasterPass; 00666 Pass* mShadowTextureCustomReceiverPass; 00667 String mShadowTextureCustomCasterVertexProgram; 00668 String mShadowTextureCustomReceiverVertexProgram; 00669 String mShadowTextureCustomReceiverFragmentProgram; 00670 GpuProgramParametersSharedPtr mShadowTextureCustomCasterVPParams; 00671 GpuProgramParametersSharedPtr mShadowTextureCustomReceiverVPParams; 00672 GpuProgramParametersSharedPtr mShadowTextureCustomReceiverFPParams; 00673 00675 uint32 mVisibilityMask; 00676 bool mFindVisibleObjects; 00677 00679 bool mSuppressRenderStateChanges; 00681 bool mSuppressShadows; 00682 00683 00684 GpuProgramParametersSharedPtr mInfiniteExtrusionParams; 00685 GpuProgramParametersSharedPtr mFiniteExtrusionParams; 00686 00688 class _OgreExport ShadowCasterSceneQueryListener : public SceneQueryListener 00689 { 00690 protected: 00691 SceneManager* mSceneMgr; 00692 ShadowCasterList* mCasterList; 00693 bool mIsLightInFrustum; 00694 const PlaneBoundedVolumeList* mLightClipVolumeList; 00695 const Camera* mCamera; 00696 const Light* mLight; 00697 Real mFarDistSquared; 00698 public: 00699 ShadowCasterSceneQueryListener(SceneManager* sm) : mSceneMgr(sm), 00700 mCasterList(0), mIsLightInFrustum(false), mLightClipVolumeList(0), 00701 mCamera(0) {} 00702 // Prepare the listener for use with a set of parameters 00703 void prepare(bool lightInFrustum, 00704 const PlaneBoundedVolumeList* lightClipVolumes, 00705 const Light* light, const Camera* cam, ShadowCasterList* casterList, 00706 Real farDistSquared) 00707 { 00708 mCasterList = casterList; 00709 mIsLightInFrustum = lightInFrustum; 00710 mLightClipVolumeList = lightClipVolumes; 00711 mCamera = cam; 00712 mLight = light; 00713 mFarDistSquared = farDistSquared; 00714 } 00715 bool queryResult(MovableObject* object); 00716 bool queryResult(SceneQuery::WorldFragment* fragment); 00717 }; 00718 00719 ShadowCasterSceneQueryListener* mShadowCasterQueryListener; 00720 00727 virtual const ShadowCasterList& findShadowCastersForLight(const Light* light, 00728 const Camera* camera); 00730 virtual void renderBasicQueueGroupObjects(RenderQueueGroup* pGroup, 00731 QueuedRenderableCollection::OrganisationMode om); 00733 virtual void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* group, 00734 QueuedRenderableCollection::OrganisationMode om); 00736 virtual void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* group, 00737 QueuedRenderableCollection::OrganisationMode om); 00739 virtual void renderTextureShadowCasterQueueGroupObjects(RenderQueueGroup* group, 00740 QueuedRenderableCollection::OrganisationMode om); 00742 virtual void renderTextureShadowReceiverQueueGroupObjects(RenderQueueGroup* group, 00743 QueuedRenderableCollection::OrganisationMode om); 00745 virtual void renderModulativeTextureShadowedQueueGroupObjects(RenderQueueGroup* group, 00746 QueuedRenderableCollection::OrganisationMode om); 00747 00749 virtual void renderAdditiveTextureShadowedQueueGroupObjects(RenderQueueGroup* group, 00750 QueuedRenderableCollection::OrganisationMode om); 00752 virtual void renderObjects(const QueuedRenderableCollection& objs, 00753 QueuedRenderableCollection::OrganisationMode om, 00754 bool doLightIteration, const LightList* manualLightList = 0); 00760 virtual void renderTransparentShadowCasterObjects(const QueuedRenderableCollection& objs, 00761 QueuedRenderableCollection::OrganisationMode om, 00762 bool doLightIteration, const LightList* manualLightList = 0); 00763 00766 virtual void updateRenderQueueSplitOptions(void); 00769 virtual void updateRenderQueueGroupSplitOptions(RenderQueueGroup* group, 00770 bool suppressShadows, bool suppressRenderState); 00771 00775 class _OgreExport SceneMgrQueuedRenderableVisitor : public QueuedRenderableVisitor 00776 { 00777 protected: 00779 const Pass* mUsedPass; 00780 public: 00781 SceneMgrQueuedRenderableVisitor() 00782 :transparentShadowCastersMode(false) {} 00783 ~SceneMgrQueuedRenderableVisitor() {} 00784 void visit(const Renderable* r); 00785 bool visit(const Pass* p); 00786 void visit(const RenderablePass* rp); 00787 00789 SceneManager* targetSceneMgr; 00791 bool transparentShadowCastersMode; 00793 bool autoLights; 00795 const LightList* manualLightList; 00796 00797 }; 00799 friend class SceneMgrQueuedRenderableVisitor; 00801 SceneMgrQueuedRenderableVisitor* mActiveQueuedRenderableVisitor; 00803 SceneMgrQueuedRenderableVisitor mDefaultQueuedRenderableVisitor; 00804 00805 public: 00808 SceneManager(const String& instanceName); 00809 00812 virtual ~SceneManager(); 00813 00814 00840 OGRE_MUTEX(sceneGraphMutex) 00841 00842 00843 const String& getName(void) const { return mName; } 00844 00851 virtual const String& getTypeName(void) const = 0; 00852 00860 virtual Camera* createCamera(const String& name); 00861 00865 virtual Camera* getCamera(const String& name) const; 00866 00869 virtual bool hasCamera(const String& name) const; 00870 00879 virtual void destroyCamera(Camera *cam); 00880 00886 virtual void destroyCamera(const String& name); 00887 00896 virtual void destroyAllCameras(void); 00897 00908 virtual Light* createLight(const String& name); 00909 00913 virtual Light* getLight(const String& name) const; 00914 00917 virtual bool hasLight(const String& name) const; 00918 00923 virtual void destroyLight(const String& name); 00924 00929 virtual void destroyLight(Light* light); 00932 virtual void destroyAllLights(void); 00933 00944 virtual void _notifyLightsDirty(void); 00945 00958 ulong _getLightsDirtyCounter(void) const { return mLightsDirtyCounter; } 00959 00966 virtual const LightList& _getLightsAffectingFrustum(void) const; 00967 00989 virtual void _populateLightList(const Vector3& position, Real radius, LightList& destList); 00990 00991 01008 virtual SceneNode* createSceneNode(void); 01009 01024 virtual SceneNode* createSceneNode(const String& name); 01025 01032 virtual void destroySceneNode(const String& name); 01033 01049 virtual SceneNode* getRootSceneNode(void) const; 01050 01058 virtual SceneNode* getSceneNode(const String& name) const; 01059 01062 virtual bool hasSceneNode(const String& name) const; 01063 01064 01072 virtual Entity* createEntity(const String& entityName, const String& meshName); 01073 01080 enum PrefabType { 01081 PT_PLANE, 01082 PT_CUBE, 01083 PT_SPHERE 01084 }; 01085 01092 virtual Entity* createEntity(const String& entityName, PrefabType ptype); 01096 virtual Entity* getEntity(const String& name) const; 01099 virtual bool hasEntity(const String& name) const; 01100 01109 virtual void destroyEntity(Entity* ent); 01110 01119 virtual void destroyEntity(const String& name); 01120 01130 virtual void destroyAllEntities(void); 01131 01137 virtual ManualObject* createManualObject(const String& name); 01141 virtual ManualObject* getManualObject(const String& name) const; 01144 virtual bool hasManualObject(const String& name) const; 01145 01148 virtual void destroyManualObject(ManualObject* obj); 01151 virtual void destroyManualObject(const String& name); 01154 virtual void destroyAllManualObjects(void); 01160 virtual BillboardChain* createBillboardChain(const String& name); 01164 virtual BillboardChain* getBillboardChain(const String& name) const; 01167 virtual bool hasBillboardChain(const String& name) const; 01168 01171 virtual void destroyBillboardChain(BillboardChain* obj); 01174 virtual void destroyBillboardChain(const String& name); 01177 virtual void destroyAllBillboardChains(void); 01183 virtual RibbonTrail* createRibbonTrail(const String& name); 01187 virtual RibbonTrail* getRibbonTrail(const String& name) const; 01190 virtual bool hasRibbonTrail(const String& name) const; 01191 01194 virtual void destroyRibbonTrail(RibbonTrail* obj); 01197 virtual void destroyRibbonTrail(const String& name); 01200 virtual void destroyAllRibbonTrails(void); 01201 01222 virtual ParticleSystem* createParticleSystem(const String& name, 01223 const String& templateName); 01243 virtual ParticleSystem* createParticleSystem(const String& name, 01244 size_t quota = 500, 01245 const String& resourceGroup = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 01249 virtual ParticleSystem* getParticleSystem(const String& name) const; 01252 virtual bool hasParticleSystem(const String& name) const; 01253 01256 virtual void destroyParticleSystem(ParticleSystem* obj); 01259 virtual void destroyParticleSystem(const String& name); 01262 virtual void destroyAllParticleSystems(void); 01263 01269 virtual void clearScene(void); 01270 01283 void setAmbientLight(const ColourValue& colour); 01284 01287 const ColourValue& getAmbientLight(void) const; 01288 01301 virtual void setWorldGeometry(const String& filename); 01302 01318 virtual void setWorldGeometry(DataStreamPtr& stream, 01319 const String& typeName = StringUtil::BLANK); 01320 01333 virtual size_t estimateWorldGeometry(const String& filename) { return 0; } 01334 01347 virtual size_t estimateWorldGeometry(DataStreamPtr& stream, 01348 const String& typeName = StringUtil::BLANK) { return 0; } 01363 virtual ViewPoint getSuggestedViewpoint(bool random = false); 01364 01378 virtual bool setOption( const String& strKey, const void* pValue ) { return false; } 01379 01393 virtual bool getOption( const String& strKey, void* pDestValue ) { return false; } 01394 01404 virtual bool hasOption( const String& strKey ) const { return false; } 01419 virtual bool getOptionValues( const String& strKey, StringVector& refValueList ) { return false; } 01420 01427 virtual bool getOptionKeys( StringVector& refKeys ) { return false; } 01428 01437 virtual void _updateSceneGraph(Camera* cam); 01438 01450 virtual void _findVisibleObjects(Camera* cam, VisibleObjectsBoundsInfo* visibleBounds, bool onlyShadowCasters); 01451 01456 virtual void _applySceneAnimations(void); 01457 01460 virtual void _renderVisibleObjects(void); 01461 01475 virtual void _renderScene(Camera* camera, Viewport* vp, bool includeOverlays); 01476 01480 virtual void _queueSkiesForRendering(Camera* cam); 01481 01482 01483 01492 virtual void _setDestinationRenderSystem(RenderSystem* sys); 01493 01546 virtual void setSkyPlane( 01547 bool enable, 01548 const Plane& plane, const String& materialName, Real scale = 1000, 01549 Real tiling = 10, bool drawFirst = true, Real bow = 0, 01550 int xsegments = 1, int ysegments = 1, 01551 const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 01552 01554 virtual bool isSkyPlaneEnabled(void) const { return mSkyPlaneEnabled; } 01555 01557 virtual SceneNode* getSkyPlaneNode(void) const { return mSkyPlaneNode; } 01558 01560 virtual const SkyPlaneGenParameters& getSkyPlaneGenParameters(void) const { return mSkyPlaneGenParameters; } 01561 01603 virtual void setSkyBox( 01604 bool enable, const String& materialName, Real distance = 5000, 01605 bool drawFirst = true, const Quaternion& orientation = Quaternion::IDENTITY, 01606 const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 01607 01609 virtual bool isSkyBoxEnabled(void) const { return mSkyBoxEnabled; } 01610 01612 virtual SceneNode* getSkyBoxNode(void) const { return mSkyBoxNode; } 01613 01615 virtual const SkyBoxGenParameters& getSkyBoxGenParameters(void) const { return mSkyBoxGenParameters; } 01616 01672 virtual void setSkyDome( 01673 bool enable, const String& materialName, Real curvature = 10, 01674 Real tiling = 8, Real distance = 4000, bool drawFirst = true, 01675 const Quaternion& orientation = Quaternion::IDENTITY, 01676 int xsegments = 16, int ysegments = 16, int ysegments_keep = -1, 01677 const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 01678 01680 virtual bool isSkyDomeEnabled(void) const { return mSkyDomeEnabled; } 01681 01683 virtual SceneNode* getSkyDomeNode(void) const { return mSkyDomeNode; } 01684 01686 virtual const SkyDomeGenParameters& getSkyDomeGenParameters(void) const { return mSkyDomeGenParameters; } 01687 01712 void setFog( 01713 FogMode mode = FOG_NONE, const ColourValue& colour = ColourValue::White, 01714 Real expDensity = 0.001, Real linearStart = 0.0, Real linearEnd = 1.0); 01715 01718 virtual FogMode getFogMode(void) const; 01719 01722 virtual const ColourValue& getFogColour(void) const; 01723 01726 virtual Real getFogStart(void) const; 01727 01730 virtual Real getFogEnd(void) const; 01731 01734 virtual Real getFogDensity(void) const; 01735 01736 01754 virtual BillboardSet* createBillboardSet(const String& name, unsigned int poolSize = 20); 01755 01759 virtual BillboardSet* getBillboardSet(const String& name) const; 01762 virtual bool hasBillboardSet(const String& name) const; 01763 01770 virtual void destroyBillboardSet(BillboardSet* set); 01771 01778 virtual void destroyBillboardSet(const String& name); 01779 01789 virtual void destroyAllBillboardSets(void); 01790 01798 virtual void setDisplaySceneNodes(bool display); 01800 virtual bool getDisplaySceneNodes(void) const {return mDisplayNodes;} 01801 01822 virtual Animation* createAnimation(const String& name, Real length); 01823 01827 virtual Animation* getAnimation(const String& name) const; 01830 virtual bool hasAnimation(const String& name) const; 01831 01837 virtual void destroyAnimation(const String& name); 01838 01840 virtual void destroyAllAnimations(void); 01841 01869 virtual AnimationState* createAnimationState(const String& animName); 01870 01874 virtual AnimationState* getAnimationState(const String& animName) const; 01877 virtual bool hasAnimationState(const String& name) const; 01878 01884 virtual void destroyAnimationState(const String& name); 01885 01887 virtual void destroyAllAnimationStates(void); 01888 01912 virtual void manualRender(RenderOperation* rend, Pass* pass, Viewport* vp, 01913 const Matrix4& worldMatrix, const Matrix4& viewMatrix, const Matrix4& projMatrix, 01914 bool doBeginEndFrame = false) ; 01915 01926 virtual RenderQueue* getRenderQueue(void); 01927 01931 virtual void addRenderQueueListener(RenderQueueListener* newListener); 01932 01934 virtual void removeRenderQueueListener(RenderQueueListener* delListener); 01935 01949 virtual void addSpecialCaseRenderQueue(uint8 qid); 01955 virtual void removeSpecialCaseRenderQueue(uint8 qid); 01959 virtual void clearSpecialCaseRenderQueues(void); 01964 virtual void setSpecialCaseRenderQueueMode(SpecialCaseRenderQueueMode mode); 01966 virtual SpecialCaseRenderQueueMode getSpecialCaseRenderQueueMode(void); 01973 virtual bool isRenderQueueToBeProcessed(uint8 qid); 01974 01990 virtual void setWorldGeometryRenderQueue(uint8 qid); 02001 virtual uint8 getWorldGeometryRenderQueue(void); 02002 02004 virtual void showBoundingBoxes(bool bShow); 02005 02007 virtual bool getShowBoundingBoxes() const; 02008 02010 virtual void _notifyAutotrackingSceneNode(SceneNode* node, bool autoTrack); 02011 02012 02025 virtual AxisAlignedBoxSceneQuery* 02026 createAABBQuery(const AxisAlignedBox& box, unsigned long mask = 0xFFFFFFFF); 02039 virtual SphereSceneQuery* 02040 createSphereQuery(const Sphere& sphere, unsigned long mask = 0xFFFFFFFF); 02053 virtual PlaneBoundedVolumeListSceneQuery* 02054 createPlaneBoundedVolumeQuery(const PlaneBoundedVolumeList& volumes, unsigned long mask = 0xFFFFFFFF); 02055 02056 02069 virtual RaySceneQuery* 02070 createRayQuery(const Ray& ray, unsigned long mask = 0xFFFFFFFF); 02071 //PyramidSceneQuery* createPyramidQuery(const Pyramid& p, unsigned long mask = 0xFFFFFFFF); 02083 virtual IntersectionSceneQuery* 02084 createIntersectionQuery(unsigned long mask = 0xFFFFFFFF); 02085 02087 virtual void destroyQuery(SceneQuery* query); 02088 02089 typedef MapIterator<CameraList> CameraIterator; 02090 typedef MapIterator<AnimationList> AnimationIterator; 02091 02094 CameraIterator getCameraIterator(void) { 02095 return CameraIterator(mCameras.begin(), mCameras.end()); 02096 } 02098 AnimationIterator getAnimationIterator(void) { 02099 return AnimationIterator(mAnimationsList.begin(), mAnimationsList.end()); 02100 } 02102 AnimationStateIterator getAnimationStateIterator(void) { 02103 return mAnimationStates.getAnimationStateIterator(); 02104 } 02105 02138 virtual void setShadowTechnique(ShadowTechnique technique); 02139 02141 virtual ShadowTechnique getShadowTechnique(void) const { return mShadowTechnique; } 02142 02144 virtual void setShowDebugShadows(bool debug) { mDebugShadows = debug; } 02146 virtual bool getShowDebugShadows(void ) const { return mDebugShadows; } 02147 02154 virtual void setShadowColour(const ColourValue& colour); 02161 virtual const ColourValue& getShadowColour(void) const; 02173 virtual void setShadowDirectionalLightExtrusionDistance(Real dist); 02176 virtual Real getShadowDirectionalLightExtrusionDistance(void) const; 02192 virtual void setShadowFarDistance(Real distance); 02196 virtual Real getShadowFarDistance(void) const 02197 { return mShadowFarDist; } 02198 02224 virtual void setShadowIndexBufferSize(size_t size); 02226 virtual size_t getShadowIndexBufferSize(void) const 02227 { return mShadowIndexBufferSize; } 02236 virtual void setShadowTextureSize(unsigned short size); 02237 02244 virtual void setShadowTextureConfig(size_t shadowIndex, unsigned short width, 02245 unsigned short height, PixelFormat format); 02251 virtual void setShadowTextureConfig(size_t shadowIndex, 02252 const ShadowTextureConfig& config); 02253 02255 ConstShadowTextureConfigIterator getShadowTextureConfigIterator() const; 02256 02268 virtual void setShadowTexturePixelFormat(PixelFormat fmt); 02276 virtual void setShadowTextureCount(size_t count); 02278 size_t getShadowTextureCount(void) const {return mShadowTextureConfigList.size(); } 02287 virtual void setShadowTextureSettings(unsigned short size, unsigned short count, 02288 PixelFormat fmt = PF_X8R8G8B8); 02289 02296 virtual const TexturePtr& getShadowTexture(size_t shadowIndex); 02297 02312 virtual void setShadowDirLightTextureOffset(Real offset) { mShadowTextureOffset = offset;} 02316 virtual Real getShadowDirLightTextureOffset(void) const { return mShadowTextureOffset; } 02324 virtual void setShadowTextureFadeStart(Real fadeStart) 02325 { mShadowTextureFadeStart = fadeStart; } 02333 virtual void setShadowTextureFadeEnd(Real fadeEnd) 02334 { mShadowTextureFadeEnd = fadeEnd; } 02335 02348 virtual void setShadowTextureSelfShadow(bool selfShadow); 02349 02351 virtual bool getShadowTextureSelfShadow(void) const 02352 { return mShadowTextureSelfShadow; } 02373 virtual void setShadowTextureCasterMaterial(const String& name); 02395 virtual void setShadowTextureReceiverMaterial(const String& name); 02396 02407 virtual void setShadowCasterRenderBackFaces(bool bf) { mShadowCasterRenderBackFaces = bf; } 02408 02412 virtual bool getShadowCasterRenderBackFaces() const { return mShadowCasterRenderBackFaces; } 02413 02418 virtual void setShadowCameraSetup(const ShadowCameraSetupPtr& shadowSetup); 02419 02424 virtual const ShadowCameraSetupPtr& getShadowCameraSetup() const; 02425 02462 virtual void setShadowUseInfiniteFarPlane(bool enable) { 02463 mShadowUseInfiniteFarPlane = enable; } 02464 02466 virtual bool isShadowTechniqueStencilBased(void) const 02467 { return (mShadowTechnique & SHADOWDETAILTYPE_STENCIL) != 0; } 02469 virtual bool isShadowTechniqueTextureBased(void) const 02470 { return (mShadowTechnique & SHADOWDETAILTYPE_TEXTURE) != 0; } 02472 virtual bool isShadowTechniqueModulative(void) const 02473 { return (mShadowTechnique & SHADOWDETAILTYPE_MODULATIVE) != 0; } 02475 virtual bool isShadowTechniqueAdditive(void) const 02476 { return (mShadowTechnique & SHADOWDETAILTYPE_ADDITIVE) != 0; } 02478 virtual bool isShadowTechniqueIntegrated(void) const 02479 { return (mShadowTechnique & SHADOWDETAILTYPE_INTEGRATED) != 0; } 02481 virtual bool isShadowTechniqueInUse(void) const 02482 { return mShadowTechnique != SHADOWTYPE_NONE; } 02483 02487 virtual void addShadowListener(ShadowListener* s); 02490 virtual void removeShadowListener(ShadowListener* s); 02491 02501 virtual StaticGeometry* createStaticGeometry(const String& name); 02505 virtual StaticGeometry* getStaticGeometry(const String& name) const; 02507 virtual bool hasStaticGeometry(const String& name) const; 02509 virtual void destroyStaticGeometry(StaticGeometry* geom); 02511 virtual void destroyStaticGeometry(const String& name); 02513 virtual void destroyAllStaticGeometry(void); 02514 02524 virtual InstancedGeometry* createInstancedGeometry(const String& name); 02526 virtual InstancedGeometry* getInstancedGeometry(const String& name) const; 02528 virtual void destroyInstancedGeometry(InstancedGeometry* geom); 02530 virtual void destroyInstancedGeometry(const String& name); 02532 virtual void destroyAllInstancedGeometry(void); 02533 02534 02545 virtual MovableObject* createMovableObject(const String& name, 02546 const String& typeName, const NameValuePairList* params = 0); 02552 virtual void destroyMovableObject(const String& name, const String& typeName); 02558 virtual void destroyMovableObject(MovableObject* m); 02560 virtual void destroyAllMovableObjectsByType(const String& typeName); 02562 virtual void destroyAllMovableObjects(void); 02566 virtual MovableObject* getMovableObject(const String& name, const String& typeName) const; 02568 virtual bool hasMovableObject(const String& name, const String& typeName) const; 02569 typedef MapIterator<MovableObjectMap> MovableObjectIterator; 02575 virtual MovableObjectIterator getMovableObjectIterator(const String& typeName); 02587 virtual void injectMovableObject(MovableObject* m); 02594 virtual void extractMovableObject(const String& name, const String& typeName); 02601 virtual void extractMovableObject(MovableObject* m); 02608 virtual void extractAllMovableObjectsByType(const String& typeName); 02609 02616 virtual void setVisibilityMask(uint32 vmask) { mVisibilityMask = vmask; } 02617 02621 virtual uint32 getVisibilityMask(void) { return mVisibilityMask; } 02622 02626 uint32 _getCombinedVisibilityMask(void) const; 02627 02634 virtual void setFindVisibleObjects(bool find) { mFindVisibleObjects = find; } 02635 02639 virtual bool getFindVisibleObjects(void) { return mFindVisibleObjects; } 02640 02646 virtual void _injectRenderWithPass(Pass *pass, Renderable *rend, bool shadowDerivation = true); 02647 02666 virtual void _suppressRenderStateChanges(bool suppress); 02667 02671 virtual bool _areRenderStateChangesSuppressed(void) const 02672 { return mSuppressRenderStateChanges; } 02673 02686 virtual const Pass* _setPass(const Pass* pass, 02687 bool evenIfSuppressed = false, bool shadowDerivation = true); 02688 02689 02699 virtual void _suppressShadows(bool suppress); 02700 02704 virtual bool _areShadowsSuppressed(void) const 02705 { return mSuppressShadows; } 02706 02710 virtual void _renderQueueGroupObjects(RenderQueueGroup* group, 02711 QueuedRenderableCollection::OrganisationMode om); 02712 02728 void setQueuedRenderableVisitor(SceneMgrQueuedRenderableVisitor* visitor); 02729 02731 SceneMgrQueuedRenderableVisitor* getQueuedRenderableVisitor(void) const; 02732 02733 02737 RenderSystem *getDestinationRenderSystem(); 02738 02741 Viewport* getCurrentViewport(void) const { return mCurrentViewport; } 02742 02744 const VisibleObjectsBoundsInfo& getVisibleObjectsBoundsInfo(const Camera* cam) const; 02745 02747 const VisibleObjectsBoundsInfo& getShadowCasterBoundsInfo(const Light* light) const; 02748 }; 02749 02751 class _OgreExport DefaultIntersectionSceneQuery : 02752 public IntersectionSceneQuery 02753 { 02754 public: 02755 DefaultIntersectionSceneQuery(SceneManager* creator); 02756 ~DefaultIntersectionSceneQuery(); 02757 02759 void execute(IntersectionSceneQueryListener* listener); 02760 }; 02761 02763 class _OgreExport DefaultRaySceneQuery : public RaySceneQuery 02764 { 02765 public: 02766 DefaultRaySceneQuery(SceneManager* creator); 02767 ~DefaultRaySceneQuery(); 02768 02770 void execute(RaySceneQueryListener* listener); 02771 }; 02773 class _OgreExport DefaultSphereSceneQuery : public SphereSceneQuery 02774 { 02775 public: 02776 DefaultSphereSceneQuery(SceneManager* creator); 02777 ~DefaultSphereSceneQuery(); 02778 02780 void execute(SceneQueryListener* listener); 02781 }; 02783 class _OgreExport DefaultPlaneBoundedVolumeListSceneQuery : public PlaneBoundedVolumeListSceneQuery 02784 { 02785 public: 02786 DefaultPlaneBoundedVolumeListSceneQuery(SceneManager* creator); 02787 ~DefaultPlaneBoundedVolumeListSceneQuery(); 02788 02790 void execute(SceneQueryListener* listener); 02791 }; 02793 class _OgreExport DefaultAxisAlignedBoxSceneQuery : public AxisAlignedBoxSceneQuery 02794 { 02795 public: 02796 DefaultAxisAlignedBoxSceneQuery(SceneManager* creator); 02797 ~DefaultAxisAlignedBoxSceneQuery(); 02798 02800 void execute(SceneQueryListener* listener); 02801 }; 02802 02803 02805 typedef uint16 SceneTypeMask; 02806 02810 enum SceneType 02811 { 02812 ST_GENERIC = 1, 02813 ST_EXTERIOR_CLOSE = 2, 02814 ST_EXTERIOR_FAR = 4, 02815 ST_EXTERIOR_REAL_FAR = 8, 02816 ST_INTERIOR = 16 02817 }; 02818 02820 struct SceneManagerMetaData 02821 { 02823 String typeName; 02825 String description; 02827 SceneTypeMask sceneTypeMask; 02829 bool worldGeometrySupported; 02830 }; 02831 02832 02833 02835 class _OgreExport SceneManagerFactory 02836 { 02837 protected: 02838 mutable SceneManagerMetaData mMetaData; 02839 mutable bool mMetaDataInit; 02841 virtual void initMetaData(void) const = 0; 02842 public: 02843 SceneManagerFactory() : mMetaDataInit(true) {} 02844 virtual ~SceneManagerFactory() {} 02846 virtual const SceneManagerMetaData& getMetaData(void) const 02847 { 02848 if (mMetaDataInit) 02849 { 02850 initMetaData(); 02851 mMetaDataInit = false; 02852 } 02853 return mMetaData; 02854 } 02859 virtual SceneManager* createInstance(const String& instanceName) = 0; 02861 virtual void destroyInstance(SceneManager* instance) = 0; 02862 02863 }; 02864 02865 02866 02867 } // Namespace 02868 02869 02870 02871 #endif
Copyright © 2000-2005 by The OGRE Team
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 25 13:03:16 2007