OGRE  1.9.0
OgreSceneManager.h
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2 This source file is a part of OGRE
3 (Object-oriented Graphics Rendering Engine)
4 
5 For the latest info, see http://www.ogre3d.org/
6 
7 Copyright (c) 2000-2014 Torus Knot Software Ltd
8 Permission is hereby granted, free of charge, to any person obtaining a copy
9 of this software and associated documentation files (the "Software"), to deal
10 in the Software without restriction, including without limitation the rights
11 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 copies of the Software, and to permit persons to whom the Software is
13 furnished to do so, subject to the following conditions:
14 
15 The above copyright notice and this permission notice shall be included in
16 all copies or substantial portions of the Software.
17 
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 THE SOFTWARE
25 
26 You may alternatively use this source under the terms of a specific version of
27 the OGRE Unrestricted License provided you have obtained such a license from
28 Torus Knot Software Ltd.
29 -------------------------------------------------------------------------*/
30 #ifndef __SceneManager_H__
31 #define __SceneManager_H__
32 
33 // Precompiler options
34 #include "OgrePrerequisites.h"
35 
36 #include "OgreString.h"
37 #include "OgreSceneNode.h"
38 #include "OgrePlane.h"
39 #include "OgreQuaternion.h"
40 #include "OgreColourValue.h"
41 #include "OgreCommon.h"
42 #include "OgreSceneQuery.h"
44 #include "OgreAnimationState.h"
45 #include "OgreRenderQueue.h"
47 #include "OgreRectangle2D.h"
48 #include "OgrePixelFormat.h"
50 #include "OgreTexture.h"
51 #include "OgreShadowCameraSetup.h"
53 #include "OgreCamera.h"
54 #include "OgreInstancedGeometry.h"
55 #include "OgreLodListener.h"
56 #include "OgreInstanceManager.h"
57 #include "OgreRenderSystem.h"
58 #include "OgreHeaderPrefix.h"
59 #include "OgreNameGenerator.h"
60 
61 namespace Ogre {
70  struct ViewPoint
71  {
74  };
75 
76  // Forward declarations
81  class CompositorChain;
82 
87  {
100 
102  void reset();
103  void merge(const AxisAlignedBox& boxBounds, const Sphere& sphereBounds,
104  const Camera* cam, bool receiver=true);
108  void mergeNonRenderedButInFrustum(const AxisAlignedBox& boxBounds,
109  const Sphere& sphereBounds, const Camera* cam);
110 
111 
112  };
113 
144  {
145  public:
163  {
164  _OgreExport bool operator()(const Material* x, const Material* y) const;
165  };
167  struct lightLess
168  {
169  _OgreExport bool operator()(const Light* a, const Light* b) const;
170  };
171 
174  {
180  IRS_RENDER_RECEIVER_PASS
181  };
182 
188  {
192  SCRQM_EXCLUDE
193  };
194 
196  {
203  };
204 
206  {
212  };
213 
215  {
217  };
218 
222  class Listener
223  {
224  public:
225  Listener() {}
226  virtual ~Listener() {}
227 
234  virtual void preUpdateSceneGraph(SceneManager* source, Camera* camera)
235  { (void)source; (void)camera; }
236 
243  virtual void postUpdateSceneGraph(SceneManager* source, Camera* camera)
244  { (void)source; (void)camera; }
245 
255  virtual void preFindVisibleObjects(SceneManager* source,
257  { (void)source; (void)irs; (void)v; }
258 
269  virtual void postFindVisibleObjects(SceneManager* source,
271  { (void)source; (void)irs; (void)v; }
272 
287  virtual void shadowTexturesUpdated(size_t numberOfShadowTextures)
288  { (void)numberOfShadowTextures; }
289 
303  virtual void shadowTextureCasterPreViewProj(Light* light,
304  Camera* camera, size_t iteration)
305  { (void)light; (void)camera; (void)iteration; }
306 
321  Frustum* frustum)
322  { (void)light; (void)frustum; }
323 
346  virtual bool sortLightsAffectingFrustum(LightList& lightList)
347  { (void)lightList; return false; }
348 
350  virtual void sceneManagerDestroyed(SceneManager* source)
351  { (void)source; }
352  };
353 
358  {
359  protected:
361  const Pass* mUsedPass;
362  public:
364  :transparentShadowCastersMode(false) {}
366  void visit(Renderable* r);
367  bool visit(const Pass* p);
368  void visit(RenderablePass* rp);
369 
380 
381  };
384 
385  protected:
386 
388  virtual SceneNode* createSceneNodeImpl(void);
390  virtual SceneNode* createSceneNodeImpl(const String& name);
391 
394 
398 
401 
404 
406 
410 
415 
418 
420 
428 
433 
436 
440 
441  // Sky params
442  // Sky plane
444  Entity* mSkyDomeEntity[5];
446 
450 
451  // Sky plane
456  // Sky box
461  // Sky dome
466 
467  // Fog
473 
478 
479  unsigned long mLastFrameNumber;
480  Matrix4 mTempXform[256];
483 
487 
488  protected:
489 
499 
503 
505  size_t mShadowTextureCountPerType[3];
506 
509 
512  {
514  int type;
519 
520  bool operator== (const LightInfo& rhs) const
521  {
522  return light == rhs.light && type == rhs.type &&
523  range == rhs.range && position == rhs.position && lightMask == rhs.lightMask &&
524  castsShadows == rhs.castsShadows;
525  }
526 
527  bool operator!= (const LightInfo& rhs) const
528  {
529  return !(*this == rhs);
530  }
531  };
532 
534 
537  LightInfoList mTestLightInfos; // potentially new list
540 
544  {
546  OGRE_MUTEX(mutex);
547  };
555  MovableObjectCollection* getMovableObjectCollection(const String& typeName);
560  const MovableObjectCollection* getMovableObjectCollection(const String& typeName) const;
562  OGRE_MUTEX(mMovableObjectCollectionMapMutex);
563 
568  virtual void initRenderQueue(void);
582  virtual const Pass* deriveShadowCasterPass(const Pass* pass);
591  virtual const Pass* deriveShadowReceiverPass(const Pass* pass);
592 
599  virtual bool validatePassForRendering(const Pass* pass);
600 
607  virtual bool validateRenderableForRendering(const Pass* pass, const Renderable* rend);
608 
609  enum BoxPlane
610  {
611  BP_FRONT = 0,
612  BP_BACK = 1,
613  BP_LEFT = 2,
614  BP_RIGHT = 3,
615  BP_UP = 4,
616  BP_DOWN = 5
617  };
618 
619  /* Internal utility method for creating the planes of a skybox.
620  */
621  virtual MeshPtr createSkyboxPlane(
622  BoxPlane bp,
623  Real distance,
624  const Quaternion& orientation,
625  const String& groupName);
626 
627  /* Internal utility method for creating the planes of a skydome.
628  */
629  virtual MeshPtr createSkydomePlane(
630  BoxPlane bp,
631  Real curvature, Real tiling, Real distance,
632  const Quaternion& orientation,
633  int xsegments, int ysegments, int ySegmentsToKeep,
634  const String& groupName);
635 
638 
642  OGRE_MUTEX(mAnimationsListMutex);
644 
645 
648  virtual void useRenderableViewProjMode(const Renderable* pRend, bool fixedFunction);
649 
652  virtual void resetViewProjMode(bool fixedFunction);
653 
656 
662  virtual void firePreRenderQueues();
664  virtual void firePostRenderQueues();
666  virtual bool fireRenderQueueStarted(uint8 id, const String& invocation);
668  virtual bool fireRenderQueueEnded(uint8 id, const String& invocation);
670  virtual void fireRenderSingleObject(Renderable* rend, const Pass* pass, const AutoParamDataSource* source,
671  const LightList* pLightList, bool suppressRenderStateChanges);
672 
674  virtual void fireShadowTexturesUpdated(size_t numberOfShadowTextures);
676  virtual void fireShadowTexturesPreCaster(Light* light, Camera* camera, size_t iteration);
678  virtual void fireShadowTexturesPreReceiver(Light* light, Frustum* f);
680  virtual void firePreUpdateSceneGraph(Camera* camera);
682  virtual void firePostUpdateSceneGraph(Camera* camera);
684  virtual void firePreFindVisibleObjects(Viewport* v);
686  virtual void firePostFindVisibleObjects(Viewport* v);
688  virtual void fireSceneManagerDestroyed();
690  virtual void setViewport(Viewport *vp);
691 
694 
696  virtual void renderVisibleObjectsDefaultSequence(void);
698  virtual void renderVisibleObjectsCustomSequence(RenderQueueInvocationSequence* s);
700  virtual void prepareRenderQueue(void);
701 
702 
718  virtual void renderSingleObject(Renderable* rend, const Pass* pass,
719  bool lightScissoringClipping, bool doLightIteration, const LightList* manualLightList = 0);
720 
723  {
724  return OGRE_NEW AutoParamDataSource();
725  }
726 
729 
732 
758  {
762  unsigned long clipPlanesValid;
763  LightClippingInfo() : scissorValid(false), clipPlanesValid(false) {}
764 
765  };
769 
772 
782  {
783  _OgreExport bool operator()(const Light* l1, const Light* l2) const;
784  };
785 
786 
793  virtual void findLightsAffectingFrustum(const Camera* camera);
795  virtual void initShadowVolumeMaterials(void);
797  virtual void ensureShadowTexturesCreated();
799  virtual void destroyShadowTextures(void);
800 
804 
806  void updateDirtyInstanceManagers(void);
807 
808  public:
812  virtual void prepareShadowTextures(Camera* cam, Viewport* vp, const LightList* lightList = 0);
813 
814  //A render context, used to store internal data for pausing/resuming rendering
816  {
822  };
823 
827  virtual RenderContext* _pauseRendering();
831  virtual void _resumeRendering(RenderContext* context);
832 
833  protected:
841  virtual void renderShadowVolumesToStencil(const Light* light, const Camera* cam,
842  bool calcScissor);
848  virtual void setShadowVolumeStencilState(bool secondpass, bool zfail, bool twosided);
850  void renderShadowVolumeObjects(ShadowCaster::ShadowRenderableListIterator iShadowRenderables,
851  Pass* pass, const LightList *manualLightList, unsigned long flags,
852  bool secondpass, bool zfail, bool twosided);
873 
877 
882 
883 
886 
889  {
890  protected:
895  const Camera* mCamera;
896  const Light* mLight;
898  public:
900  mCasterList(0), mIsLightInFrustum(false), mLightClipVolumeList(0),
901  mCamera(0) {}
902  // Prepare the listener for use with a set of parameters
903  void prepare(bool lightInFrustum,
904  const PlaneBoundedVolumeList* lightClipVolumes,
905  const Light* light, const Camera* cam, ShadowCasterList* casterList,
906  Real farDistSquared)
907  {
908  mCasterList = casterList;
909  mIsLightInFrustum = lightInFrustum;
910  mLightClipVolumeList = lightClipVolumes;
911  mCamera = cam;
912  mLight = light;
913  mFarDistSquared = farDistSquared;
914  }
915  bool queryResult(MovableObject* object);
916  bool queryResult(SceneQuery::WorldFragment* fragment);
917  };
918 
920 
927  virtual const ShadowCasterList& findShadowCastersForLight(const Light* light,
928  const Camera* camera);
930  virtual void renderBasicQueueGroupObjects(RenderQueueGroup* pGroup,
933  virtual void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* group,
936  virtual void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* group,
939  virtual void renderTextureShadowCasterQueueGroupObjects(RenderQueueGroup* group,
942  virtual void renderTextureShadowReceiverQueueGroupObjects(RenderQueueGroup* group,
945  virtual void renderModulativeTextureShadowedQueueGroupObjects(RenderQueueGroup* group,
947 
949  virtual void renderAdditiveTextureShadowedQueueGroupObjects(RenderQueueGroup* group,
952  virtual void renderObjects(const QueuedRenderableCollection& objs,
953  QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping,
954  bool doLightIteration, const LightList* manualLightList = 0);
960  virtual void renderTransparentShadowCasterObjects(const QueuedRenderableCollection& objs,
961  QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping,
962  bool doLightIteration, const LightList* manualLightList = 0);
963 
966  virtual void updateRenderQueueSplitOptions(void);
969  virtual void updateRenderQueueGroupSplitOptions(RenderQueueGroup* group,
970  bool suppressShadows, bool suppressRenderState);
971 
973  virtual ClipResult buildAndSetScissor(const LightList& ll, const Camera* cam);
975  virtual void buildScissor(const Light* l, const Camera* cam, RealRect& rect);
976  virtual void resetScissor();
978  virtual ClipResult buildAndSetLightClip(const LightList& ll);
979  virtual void buildLightClip(const Light* l, PlaneList& planes);
980  virtual void resetLightClip();
981  virtual void checkCachedLightClippingInfo();
982 
987 
992 
995  unsigned short mLastLightLimit;
999 
1000  virtual void useLights(const LightList& lights, unsigned short limit);
1001  virtual void setViewMatrix(const Matrix4& m);
1002  virtual void useLightsGpuProgram(const Pass* pass, const LightList* lights);
1003  virtual void bindGpuProgram(GpuProgram* prog);
1004  virtual void updateGpuProgramParameters(const Pass* p);
1005 
1006 
1007 
1008 
1009 
1010 
1011 
1012 
1016 
1020 
1024 
1028 
1029  public:
1032  SceneManager(const String& instanceName);
1033 
1036  virtual ~SceneManager();
1037 
1038 
1064  OGRE_MUTEX(sceneGraphMutex);
1065 
1067  const String& getName(void) const { return mName; }
1068 
1075  virtual const String& getTypeName(void) const = 0;
1076 
1084  virtual Camera* createCamera(const String& name);
1085 
1089  virtual Camera* getCamera(const String& name) const;
1090 
1093  virtual bool hasCamera(const String& name) const;
1094 
1103  virtual void destroyCamera(Camera *cam);
1104 
1110  virtual void destroyCamera(const String& name);
1111 
1120  virtual void destroyAllCameras(void);
1121 
1132  virtual Light* createLight(const String& name);
1133 
1135  virtual Light* createLight();
1136 
1140  virtual Light* getLight(const String& name) const;
1141 
1144  virtual bool hasLight(const String& name) const;
1145 
1148  virtual const PlaneList& getLightClippingPlanes(Light* l);
1149 
1152  virtual const RealRect& getLightScissorRect(Light* l, const Camera* cam);
1153 
1158  virtual void destroyLight(const String& name);
1159 
1164  virtual void destroyLight(Light* light);
1167  virtual void destroyAllLights(void);
1168 
1179  virtual void _notifyLightsDirty(void);
1180 
1193  ulong _getLightsDirtyCounter(void) const { return mLightsDirtyCounter; }
1194 
1201  virtual const LightList& _getLightsAffectingFrustum(void) const;
1202 
1225  virtual void _populateLightList(const Vector3& position, Real radius, LightList& destList, uint32 lightMask = 0xFFFFFFFF);
1226 
1255  virtual void _populateLightList(const SceneNode* sn, Real radius, LightList& destList, uint32 lightMask = 0xFFFFFFFF);
1256 
1273  virtual SceneNode* createSceneNode(void);
1274 
1289  virtual SceneNode* createSceneNode(const String& name);
1290 
1297  virtual void destroySceneNode(const String& name);
1298 
1305  virtual void destroySceneNode(SceneNode* sn);
1321  virtual SceneNode* getRootSceneNode(void);
1322 
1330  virtual SceneNode* getSceneNode(const String& name) const;
1331 
1334  virtual bool hasSceneNode(const String& name) const;
1335 
1336 
1344  virtual Entity* createEntity(const String& entityName, const String& meshName, const String& groupName = ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME );
1345 
1352  virtual Entity* createEntity(const String& entityName, const MeshPtr& pMesh );
1353 
1359  virtual Entity* createEntity(const String& meshName);
1360 
1365  virtual Entity* createEntity(const MeshPtr& pMesh);
1366 
1373  enum PrefabType {
1376  PT_SPHERE
1377  };
1378 
1385  virtual Entity* createEntity(const String& entityName, PrefabType ptype);
1386 
1390  virtual Entity* createEntity(PrefabType ptype);
1394  virtual Entity* getEntity(const String& name) const;
1397  virtual bool hasEntity(const String& name) const;
1398 
1407  virtual void destroyEntity(Entity* ent);
1408 
1417  virtual void destroyEntity(const String& name);
1418 
1428  virtual void destroyAllEntities(void);
1429 
1435  virtual ManualObject* createManualObject(const String& name);
1439  virtual ManualObject* createManualObject();
1443  virtual ManualObject* getManualObject(const String& name) const;
1446  virtual bool hasManualObject(const String& name) const;
1447 
1450  virtual void destroyManualObject(ManualObject* obj);
1453  virtual void destroyManualObject(const String& name);
1456  virtual void destroyAllManualObjects(void);
1462  virtual BillboardChain* createBillboardChain(const String& name);
1466  virtual BillboardChain* createBillboardChain();
1470  virtual BillboardChain* getBillboardChain(const String& name) const;
1473  virtual bool hasBillboardChain(const String& name) const;
1474 
1477  virtual void destroyBillboardChain(BillboardChain* obj);
1480  virtual void destroyBillboardChain(const String& name);
1483  virtual void destroyAllBillboardChains(void);
1489  virtual RibbonTrail* createRibbonTrail(const String& name);
1493  virtual RibbonTrail* createRibbonTrail();
1497  virtual RibbonTrail* getRibbonTrail(const String& name) const;
1500  virtual bool hasRibbonTrail(const String& name) const;
1501 
1504  virtual void destroyRibbonTrail(RibbonTrail* obj);
1507  virtual void destroyRibbonTrail(const String& name);
1510  virtual void destroyAllRibbonTrails(void);
1511 
1532  virtual ParticleSystem* createParticleSystem(const String& name,
1533  const String& templateName);
1553  virtual ParticleSystem* createParticleSystem(const String& name,
1554  size_t quota = 500,
1556 
1574  virtual ParticleSystem* createParticleSystem(size_t quota = 500,
1579  virtual ParticleSystem* getParticleSystem(const String& name) const;
1582  virtual bool hasParticleSystem(const String& name) const;
1583 
1586  virtual void destroyParticleSystem(ParticleSystem* obj);
1589  virtual void destroyParticleSystem(const String& name);
1592  virtual void destroyAllParticleSystems(void);
1593 
1599  virtual void clearScene(void);
1600 
1613  void setAmbientLight(const ColourValue& colour);
1614 
1617  const ColourValue& getAmbientLight(void) const;
1618 
1634  virtual void prepareWorldGeometry(const String& filename);
1635 
1653  virtual void prepareWorldGeometry(DataStreamPtr& stream,
1654  const String& typeName = StringUtil::BLANK);
1655 
1668  virtual void setWorldGeometry(const String& filename);
1669 
1685  virtual void setWorldGeometry(DataStreamPtr& stream,
1686  const String& typeName = StringUtil::BLANK);
1687 
1700  virtual size_t estimateWorldGeometry(const String& filename)
1701  { (void)filename; return 0; }
1702 
1715  virtual size_t estimateWorldGeometry(DataStreamPtr& stream,
1716  const String& typeName = StringUtil::BLANK)
1717  { (void)stream; (void)typeName; return 0; }
1718 
1733  virtual ViewPoint getSuggestedViewpoint(bool random = false);
1734 
1748  virtual bool setOption( const String& strKey, const void* pValue )
1749  { (void)strKey; (void)pValue; return false; }
1750 
1764  virtual bool getOption( const String& strKey, void* pDestValue )
1765  { (void)strKey; (void)pDestValue; return false; }
1766 
1776  virtual bool hasOption( const String& strKey ) const
1777  { (void)strKey; return false; }
1778 
1793  virtual bool getOptionValues( const String& strKey, StringVector& refValueList )
1794  { (void)strKey; (void)refValueList; return false; }
1795 
1802  virtual bool getOptionKeys( StringVector& refKeys )
1803  { (void)refKeys; return false; }
1804 
1813  virtual void _updateSceneGraph(Camera* cam);
1814 
1826  virtual void _findVisibleObjects(Camera* cam, VisibleObjectsBoundsInfo* visibleBounds, bool onlyShadowCasters);
1827 
1832  virtual void _applySceneAnimations(void);
1833 
1836  virtual void _renderVisibleObjects(void);
1837 
1851  virtual void _renderScene(Camera* camera, Viewport* vp, bool includeOverlays);
1852 
1856  virtual void _queueSkiesForRendering(Camera* cam);
1857 
1858 
1859 
1868  virtual void _setDestinationRenderSystem(RenderSystem* sys);
1869 
1923  virtual void setSkyPlane(
1924  bool enable,
1925  const Plane& plane, const String& materialName, Real scale = 1000,
1926  Real tiling = 10, bool drawFirst = true, Real bow = 0,
1927  int xsegments = 1, int ysegments = 1,
1972  virtual void _setSkyPlane(
1973  bool enable,
1974  const Plane& plane, const String& materialName, Real scale = 1000,
1975  Real tiling = 10, uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, Real bow = 0,
1976  int xsegments = 1, int ysegments = 1,
1978 
1980  virtual void setSkyPlaneEnabled(bool enable) { mSkyPlaneEnabled = enable; }
1981 
1983  virtual bool isSkyPlaneEnabled(void) const { return mSkyPlaneEnabled; }
1984 
1986  virtual SceneNode* getSkyPlaneNode(void) const { return mSkyPlaneNode; }
1987 
1989  virtual const SkyPlaneGenParameters& getSkyPlaneGenParameters(void) const { return mSkyPlaneGenParameters; }
1990 
2032  virtual void setSkyBox(
2033  bool enable, const String& materialName, Real distance = 5000,
2034  bool drawFirst = true, const Quaternion& orientation = Quaternion::IDENTITY,
2036 
2069  virtual void _setSkyBox(
2070  bool enable, const String& materialName, Real distance = 5000,
2071  uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY, const Quaternion& orientation = Quaternion::IDENTITY,
2073 
2075  virtual void setSkyBoxEnabled(bool enable) { mSkyBoxEnabled = enable; }
2076 
2078  virtual bool isSkyBoxEnabled(void) const { return mSkyBoxEnabled; }
2079 
2081  virtual SceneNode* getSkyBoxNode(void) const { return mSkyBoxNode; }
2082 
2084  virtual const SkyBoxGenParameters& getSkyBoxGenParameters(void) const { return mSkyBoxGenParameters; }
2085 
2141  virtual void setSkyDome(
2142  bool enable, const String& materialName, Real curvature = 10,
2143  Real tiling = 8, Real distance = 4000, bool drawFirst = true,
2144  const Quaternion& orientation = Quaternion::IDENTITY,
2145  int xsegments = 16, int ysegments = 16, int ysegments_keep = -1,
2147 
2194  virtual void _setSkyDome(
2195  bool enable, const String& materialName, Real curvature = 10,
2196  Real tiling = 8, Real distance = 4000, uint8 renderQueue = RENDER_QUEUE_SKIES_EARLY,
2197  const Quaternion& orientation = Quaternion::IDENTITY,
2198  int xsegments = 16, int ysegments = 16, int ysegments_keep = -1,
2200 
2202  virtual void setSkyDomeEnabled(bool enable) { mSkyDomeEnabled = enable; }
2203 
2205  virtual bool isSkyDomeEnabled(void) const { return mSkyDomeEnabled; }
2206 
2208  virtual SceneNode* getSkyDomeNode(void) const { return mSkyDomeNode; }
2209 
2211  virtual const SkyDomeGenParameters& getSkyDomeGenParameters(void) const { return mSkyDomeGenParameters; }
2212 
2237  void setFog(
2238  FogMode mode = FOG_NONE, const ColourValue& colour = ColourValue::White,
2239  Real expDensity = 0.001, Real linearStart = 0.0, Real linearEnd = 1.0);
2240 
2243  virtual FogMode getFogMode(void) const;
2244 
2247  virtual const ColourValue& getFogColour(void) const;
2248 
2251  virtual Real getFogStart(void) const;
2252 
2255  virtual Real getFogEnd(void) const;
2256 
2259  virtual Real getFogDensity(void) const;
2260 
2261 
2279  virtual BillboardSet* createBillboardSet(const String& name, unsigned int poolSize = 20);
2280 
2287  virtual BillboardSet* createBillboardSet(unsigned int poolSize = 20);
2291  virtual BillboardSet* getBillboardSet(const String& name) const;
2294  virtual bool hasBillboardSet(const String& name) const;
2295 
2302  virtual void destroyBillboardSet(BillboardSet* set);
2303 
2310  virtual void destroyBillboardSet(const String& name);
2311 
2321  virtual void destroyAllBillboardSets(void);
2322 
2330  virtual void setDisplaySceneNodes(bool display);
2332  virtual bool getDisplaySceneNodes(void) const {return mDisplayNodes;}
2333 
2354  virtual Animation* createAnimation(const String& name, Real length);
2355 
2359  virtual Animation* getAnimation(const String& name) const;
2362  virtual bool hasAnimation(const String& name) const;
2363 
2369  virtual void destroyAnimation(const String& name);
2370 
2372  virtual void destroyAllAnimations(void);
2373 
2401  virtual AnimationState* createAnimationState(const String& animName);
2402 
2406  virtual AnimationState* getAnimationState(const String& animName) const;
2409  virtual bool hasAnimationState(const String& name) const;
2410 
2416  virtual void destroyAnimationState(const String& name);
2417 
2419  virtual void destroyAllAnimationStates(void);
2420 
2444  virtual void manualRender(RenderOperation* rend, Pass* pass, Viewport* vp,
2445  const Matrix4& worldMatrix, const Matrix4& viewMatrix, const Matrix4& projMatrix,
2446  bool doBeginEndFrame = false) ;
2447 
2467  virtual void manualRender(Renderable* rend, const Pass* pass, Viewport* vp,
2468  const Matrix4& viewMatrix, const Matrix4& projMatrix, bool doBeginEndFrame = false, bool lightScissoringClipping = true,
2469  bool doLightIteration = true, const LightList* manualLightList = 0);
2470 
2481  virtual RenderQueue* getRenderQueue(void);
2482 
2486  virtual void addRenderQueueListener(RenderQueueListener* newListener);
2487 
2489  virtual void removeRenderQueueListener(RenderQueueListener* delListener);
2490 
2493  virtual void addRenderObjectListener(RenderObjectListener* newListener);
2495  virtual void removeRenderObjectListener(RenderObjectListener* delListener);
2496 
2510  virtual void addSpecialCaseRenderQueue(uint8 qid);
2516  virtual void removeSpecialCaseRenderQueue(uint8 qid);
2520  virtual void clearSpecialCaseRenderQueues(void);
2525  virtual void setSpecialCaseRenderQueueMode(SpecialCaseRenderQueueMode mode);
2527  virtual SpecialCaseRenderQueueMode getSpecialCaseRenderQueueMode(void);
2534  virtual bool isRenderQueueToBeProcessed(uint8 qid);
2535 
2551  virtual void setWorldGeometryRenderQueue(uint8 qid);
2562  virtual uint8 getWorldGeometryRenderQueue(void);
2563 
2565  virtual void showBoundingBoxes(bool bShow);
2566 
2568  virtual bool getShowBoundingBoxes() const;
2569 
2571  virtual void _notifyAutotrackingSceneNode(SceneNode* node, bool autoTrack);
2572 
2573 
2586  virtual AxisAlignedBoxSceneQuery*
2587  createAABBQuery(const AxisAlignedBox& box, uint32 mask = 0xFFFFFFFF);
2600  virtual SphereSceneQuery*
2601  createSphereQuery(const Sphere& sphere, uint32 mask = 0xFFFFFFFF);
2615  createPlaneBoundedVolumeQuery(const PlaneBoundedVolumeList& volumes, uint32 mask = 0xFFFFFFFF);
2616 
2617 
2630  virtual RaySceneQuery*
2631  createRayQuery(const Ray& ray, uint32 mask = 0xFFFFFFFF);
2632  //PyramidSceneQuery* createPyramidQuery(const Pyramid& p, unsigned long mask = 0xFFFFFFFF);
2644  virtual IntersectionSceneQuery*
2645  createIntersectionQuery(uint32 mask = 0xFFFFFFFF);
2646 
2648  virtual void destroyQuery(SceneQuery* query);
2649 
2652 
2656  return CameraIterator(mCameras.begin(), mCameras.end());
2657  }
2660  const CameraList& getCameras() const { return mCameras; }
2663  return AnimationIterator(mAnimationsList.begin(), mAnimationsList.end());
2664  }
2667  const AnimationList& getAnimations() const { return mAnimationsList; }
2670  return mAnimationStates.getAnimationStateIterator();
2671  }
2672 
2705  virtual void setShadowTechnique(ShadowTechnique technique);
2706 
2708  virtual ShadowTechnique getShadowTechnique(void) const { return mShadowTechnique; }
2709 
2711  virtual void setShowDebugShadows(bool debug) { mDebugShadows = debug; }
2713  virtual bool getShowDebugShadows(void ) const { return mDebugShadows; }
2714 
2721  virtual void setShadowColour(const ColourValue& colour);
2728  virtual const ColourValue& getShadowColour(void) const;
2740  virtual void setShadowDirectionalLightExtrusionDistance(Real dist);
2743  virtual Real getShadowDirectionalLightExtrusionDistance(void) const;
2760  virtual void setShadowFarDistance(Real distance);
2764  virtual Real getShadowFarDistance(void) const
2765  { return mDefaultShadowFarDist; }
2766  virtual Real getShadowFarDistanceSquared(void) const
2767  { return mDefaultShadowFarDistSquared; }
2768 
2794  virtual void setShadowIndexBufferSize(size_t size);
2796  virtual size_t getShadowIndexBufferSize(void) const
2797  { return mShadowIndexBufferSize; }
2806  virtual void setShadowTextureSize(unsigned short size);
2807 
2817  virtual void setShadowTextureConfig(size_t shadowIndex, unsigned short width,
2818  unsigned short height, PixelFormat format, unsigned short fsaa = 0, uint16 depthBufferPoolId=1);
2824  virtual void setShadowTextureConfig(size_t shadowIndex,
2825  const ShadowTextureConfig& config);
2826 
2828  ConstShadowTextureConfigIterator getShadowTextureConfigIterator() const;
2829 
2841  virtual void setShadowTexturePixelFormat(PixelFormat fmt);
2848  virtual void setShadowTextureFSAA(unsigned short fsaa);
2849 
2857  virtual void setShadowTextureCount(size_t count);
2859  size_t getShadowTextureCount(void) const {return mShadowTextureConfigList.size(); }
2860 
2871  { mShadowTextureCountPerType[type] = count; }
2874  {return mShadowTextureCountPerType[type]; }
2875 
2883  virtual void setShadowTextureSettings(unsigned short size, unsigned short count,
2884  PixelFormat fmt = PF_X8R8G8B8, unsigned short fsaa = 0, uint16 depthBufferPoolId=1);
2885 
2892  virtual const TexturePtr& getShadowTexture(size_t shadowIndex);
2893 
2908  virtual void setShadowDirLightTextureOffset(Real offset) { mShadowTextureOffset = offset;}
2912  virtual Real getShadowDirLightTextureOffset(void) const { return mShadowTextureOffset; }
2920  virtual void setShadowTextureFadeStart(Real fadeStart)
2921  { mShadowTextureFadeStart = fadeStart; }
2929  virtual void setShadowTextureFadeEnd(Real fadeEnd)
2930  { mShadowTextureFadeEnd = fadeEnd; }
2931 
2944  virtual void setShadowTextureSelfShadow(bool selfShadow);
2945 
2947  virtual bool getShadowTextureSelfShadow(void) const
2948  { return mShadowTextureSelfShadow; }
2969  virtual void setShadowTextureCasterMaterial(const String& name);
2991  virtual void setShadowTextureReceiverMaterial(const String& name);
2992 
3003  virtual void setShadowCasterRenderBackFaces(bool bf) { mShadowCasterRenderBackFaces = bf; }
3004 
3008  virtual bool getShadowCasterRenderBackFaces() const { return mShadowCasterRenderBackFaces; }
3009 
3014  virtual void setShadowCameraSetup(const ShadowCameraSetupPtr& shadowSetup);
3015 
3020  virtual const ShadowCameraSetupPtr& getShadowCameraSetup() const;
3021 
3058  virtual void setShadowUseInfiniteFarPlane(bool enable) {
3059  mShadowUseInfiniteFarPlane = enable; }
3060 
3062  virtual bool isShadowTechniqueStencilBased(void) const
3063  { return (mShadowTechnique & SHADOWDETAILTYPE_STENCIL) != 0; }
3065  virtual bool isShadowTechniqueTextureBased(void) const
3066  { return (mShadowTechnique & SHADOWDETAILTYPE_TEXTURE) != 0; }
3068  virtual bool isShadowTechniqueModulative(void) const
3069  { return (mShadowTechnique & SHADOWDETAILTYPE_MODULATIVE) != 0; }
3071  virtual bool isShadowTechniqueAdditive(void) const
3072  { return (mShadowTechnique & SHADOWDETAILTYPE_ADDITIVE) != 0; }
3074  virtual bool isShadowTechniqueIntegrated(void) const
3075  { return (mShadowTechnique & SHADOWDETAILTYPE_INTEGRATED) != 0; }
3077  virtual bool isShadowTechniqueInUse(void) const
3078  { return mShadowTechnique != SHADOWTYPE_NONE; }
3082  virtual void setShadowUseLightClipPlanes(bool enabled) { mShadowAdditiveLightClip = enabled; }
3086  virtual bool getShadowUseLightClipPlanes() const { return mShadowAdditiveLightClip; }
3087 
3091  virtual void _setActiveCompositorChain(CompositorChain* chain) { mActiveCompositorChain = chain; }
3092 
3098  virtual void setLateMaterialResolving(bool isLate) { mLateMaterialResolving = isLate; }
3099 
3102  virtual bool isLateMaterialResolving() const { return mLateMaterialResolving; }
3103 
3105  virtual CompositorChain* _getActiveCompositorChain() const { return mActiveCompositorChain; }
3106 
3109  virtual void addListener(Listener* s);
3112  virtual void removeListener(Listener* s);
3113 
3123  virtual StaticGeometry* createStaticGeometry(const String& name);
3127  virtual StaticGeometry* getStaticGeometry(const String& name) const;
3129  virtual bool hasStaticGeometry(const String& name) const;
3131  virtual void destroyStaticGeometry(StaticGeometry* geom);
3133  virtual void destroyStaticGeometry(const String& name);
3135  virtual void destroyAllStaticGeometry(void);
3136 
3146  virtual InstancedGeometry* createInstancedGeometry(const String& name);
3148  virtual InstancedGeometry* getInstancedGeometry(const String& name) const;
3150  virtual void destroyInstancedGeometry(InstancedGeometry* geom);
3152  virtual void destroyInstancedGeometry(const String& name);
3154  virtual void destroyAllInstancedGeometry(void);
3155 
3174  virtual InstanceManager* createInstanceManager( const String &customName, const String &meshName,
3175  const String &groupName,
3177  size_t numInstancesPerBatch, uint16 flags=0,
3178  unsigned short subMeshIdx=0 );
3179 
3183  virtual InstanceManager* getInstanceManager( const String &managerName ) const;
3184 
3186  virtual bool hasInstanceManager( const String &managerName ) const;
3187 
3194  virtual void destroyInstanceManager( const String &name );
3195  virtual void destroyInstanceManager( InstanceManager *instanceManager );
3196 
3197  virtual void destroyAllInstanceManagers(void);
3198 
3211  virtual size_t getNumInstancesPerBatch( const String &meshName, const String &groupName,
3212  const String &materialName,
3214  size_t numInstancesPerBatch, uint16 flags=0,
3215  unsigned short subMeshIdx=0 );
3216 
3228  virtual InstancedEntity* createInstancedEntity( const String &materialName,
3229  const String &managerName );
3230 
3235  virtual void destroyInstancedEntity( InstancedEntity *instancedEntity );
3236 
3241  void _addDirtyInstanceManager( InstanceManager *dirtyManager );
3242 
3253  virtual MovableObject* createMovableObject(const String& name,
3254  const String& typeName, const NameValuePairList* params = 0);
3264  virtual MovableObject* createMovableObject(const String& typeName, const NameValuePairList* params = 0);
3270  virtual void destroyMovableObject(const String& name, const String& typeName);
3276  virtual void destroyMovableObject(MovableObject* m);
3278  virtual void destroyAllMovableObjectsByType(const String& typeName);
3280  virtual void destroyAllMovableObjects(void);
3284  virtual MovableObject* getMovableObject(const String& name, const String& typeName) const;
3286  virtual bool hasMovableObject(const String& name, const String& typeName) const;
3293  virtual MovableObjectIterator getMovableObjectIterator(const String& typeName);
3305  virtual void injectMovableObject(MovableObject* m);
3312  virtual void extractMovableObject(const String& name, const String& typeName);
3319  virtual void extractMovableObject(MovableObject* m);
3326  virtual void extractAllMovableObjectsByType(const String& typeName);
3327 
3334  virtual void setVisibilityMask(uint32 vmask) { mVisibilityMask = vmask; }
3335 
3339  virtual uint32 getVisibilityMask(void) { return mVisibilityMask; }
3340 
3344  uint32 _getCombinedVisibilityMask(void) const;
3345 
3352  virtual void setFindVisibleObjects(bool find) { mFindVisibleObjects = find; }
3353 
3357  virtual bool getFindVisibleObjects(void) { return mFindVisibleObjects; }
3358 
3367  virtual void setNormaliseNormalsOnScale(bool n) { mNormaliseNormalsOnScale = n; }
3368 
3372  virtual bool getNormaliseNormalsOnScale() const { return mNormaliseNormalsOnScale; }
3373 
3382  virtual void setFlipCullingOnNegativeScale(bool n) { mFlipCullingOnNegativeScale = n; }
3383 
3387  virtual bool getFlipCullingOnNegativeScale() const { return mFlipCullingOnNegativeScale; }
3388 
3394  virtual void _injectRenderWithPass(Pass *pass, Renderable *rend, bool shadowDerivation = true,
3395  bool doLightIteration = false, const LightList* manualLightList = 0);
3396 
3415  virtual void _suppressRenderStateChanges(bool suppress);
3416 
3420  virtual bool _areRenderStateChangesSuppressed(void) const
3421  { return mSuppressRenderStateChanges; }
3422 
3435  virtual const Pass* _setPass(const Pass* pass,
3436  bool evenIfSuppressed = false, bool shadowDerivation = true);
3437 
3445  virtual void _markGpuParamsDirty(uint16 mask);
3446 
3447 
3457  virtual void _suppressShadows(bool suppress);
3458 
3462  virtual bool _areShadowsSuppressed(void) const
3463  { return mSuppressShadows; }
3464 
3468  virtual void _renderQueueGroupObjects(RenderQueueGroup* group,
3470 
3486  void setQueuedRenderableVisitor(SceneMgrQueuedRenderableVisitor* visitor);
3487 
3489  SceneMgrQueuedRenderableVisitor* getQueuedRenderableVisitor(void) const;
3490 
3491 
3495  RenderSystem *getDestinationRenderSystem();
3496 
3499  Viewport* getCurrentViewport(void) const { return mCurrentViewport; }
3500 
3502  const VisibleObjectsBoundsInfo& getVisibleObjectsBoundsInfo(const Camera* cam) const;
3503 
3505  const VisibleObjectsBoundsInfo& getShadowCasterBoundsInfo(const Light* light, size_t iteration = 0) const;
3506 
3521  virtual void setCameraRelativeRendering(bool rel) { mCameraRelativeRendering = rel; }
3522 
3526  virtual bool getCameraRelativeRendering() const { return mCameraRelativeRendering; }
3527 
3528 
3530  void addLodListener(LodListener *listener);
3531 
3537  void removeLodListener(LodListener *listener);
3538 
3540  void _notifyMovableObjectLodChanged(MovableObjectLodChangedEvent& evt);
3541 
3543  void _notifyEntityMeshLodChanged(EntityMeshLodChangedEvent& evt);
3544 
3546  void _notifyEntityMaterialLodChanged(EntityMaterialLodChangedEvent& evt);
3547 
3549  void _handleLodEvents();
3550 
3551  IlluminationRenderStage _getCurrentRenderStage() {return mIlluminationStage;}
3552  };
3553 
3556  public IntersectionSceneQuery
3557  {
3558  public:
3561 
3563  void execute(IntersectionSceneQueryListener* listener);
3564  };
3565 
3568  {
3569  public:
3572 
3574  void execute(RaySceneQueryListener* listener);
3575  };
3578  {
3579  public:
3582 
3584  void execute(SceneQueryListener* listener);
3585  };
3588  {
3589  public:
3592 
3594  void execute(SceneQueryListener* listener);
3595  };
3598  {
3599  public:
3602 
3604  void execute(SceneQueryListener* listener);
3605  };
3606 
3607 
3610 
3615  {
3621  };
3622 
3625  {
3634  };
3635 
3636 
3637 
3640  {
3641  protected:
3643  mutable bool mMetaDataInit;
3645  virtual void initMetaData(void) const = 0;
3646  public:
3647  SceneManagerFactory() : mMetaDataInit(true) {}
3650  virtual const SceneManagerMetaData& getMetaData(void) const
3651  {
3652  if (mMetaDataInit)
3653  {
3654  initMetaData();
3655  mMetaDataInit = false;
3656  }
3657  return mMetaData;
3658  }
3663  virtual SceneManager* createInstance(const String& instanceName) = 0;
3665  virtual void destroyInstance(SceneManager* instance) = 0;
3666 
3667  };
3668 
3673 } // Namespace
3674 
3675 #include "OgreHeaderSuffix.h"
3676 
3677 #endif
vector< Plane >::type PlaneList
Definition: OgrePlane.h:160
String description
A text description of the scene manager.
RenderSystem::RenderSystemContext * rsContext
virtual void shadowTextureCasterPreViewProj(Light *light, Camera *camera, size_t iteration)
This event occurs just before the view & projection matrices are set for rendering into a shadow text...
Mask for modulative shadows (not for direct use, use SHADOWTYPE_ enum instead)
Definition: OgreCommon.h:199
Viewport * mCurrentViewport
Current Viewport.
unsigned short mLastLightLimit
Separate SceneQuery class to query for pairs of objects which are possibly intersecting one another.
Concrete IteratorWrapper for nonconst access to the underlying container.
Mask for integrated shadows (not for direct use, use SHADOWTYPE_ enum instead)
Definition: OgreCommon.h:202
EntityMaterialLodChangedEventList mEntityMaterialLodChangedEvents
Default sorting routine which sorts lights which cast shadows to the front of a list,...
ShadowCamLightMapping mShadowCamLightMapping
bool mShowBoundingBoxes
Flag that indicates if all of the scene node's bounding boxes should be shown as a wireframe.
size_t getShadowTextureCount(void) const
Get the number of the textures allocated for texture based shadows.
Mask for stencil shadows (not for direct use, use SHADOWTYPE_ enum instead)
Definition: OgreCommon.h:205
FogMode
Fog modes.
Definition: OgreCommon.h:121
Abstract class defining the interface all renderable objects must implement.
Viewport * getCurrentViewport(void) const
Gets the current viewport being rendered (advanced use only, only valid during viewport update.
virtual void setSkyBoxEnabled(bool enable)
Enables / disables a 'sky box'.
const AnimationList & getAnimations() const
Returns a const version of the animation list.
virtual bool isSkyPlaneEnabled(void) const
Return whether a key plane is enabled.
Class defining a single pass of a Technique (of a Material), i.e.
Definition: OgrePass.h:80
InstancedGeometryList mInstancedGeometryList
Render only the queues in the special case list.
Render to texture stage, used for texture based shadows.
vector< Camera * >::type ShadowTextureCameraList
CompositorChain * mActiveCompositorChain
#define _OgreExport
Definition: OgrePlatform.h:260
virtual Real getShadowFarDistanceSquared(void) const
String mShadowTextureCustomReceiverFragmentProgram
Quaternion mSkyBoxOrientation
MovableObjectLodChangedEventList mMovableObjectLodChangedEvents
PrefabType
Prefab shapes available without loading a model.
MapIterator< CameraList > CameraIterator
SceneNode * mSceneRoot
Root scene node.
InstanceManagerVec mDirtyInstanceManagers
Abstract class defining a movable object in a scene.
GpuProgramParametersSharedPtr mInfiniteExtrusionParams
const PlaneBoundedVolumeList * mLightClipVolumeList
RenderObjectListenerList mRenderObjectListeners
Camera * mCameraInProgress
Camera in progress.
Shared pointer implementation used to share index buffers.
virtual void sceneManagerDestroyed(SceneManager *source)
Event notifying the listener of the SceneManager's destruction.
String mShadowTextureCustomReceiverVertexProgram
AnimationStateSet mAnimationStates
virtual void setShadowUseLightClipPlanes(bool enabled)
Sets whether when using a built-in additive shadow mode, user clip planes should be used to restrict ...
Specialises the SceneQuery class for querying within an axis aligned box.
Default implementation of SphereSceneQuery.
LightInfoList mTestLightInfos
virtual AutoParamDataSource * createAutoParamDataSource(void) const
Internal method for creating the AutoParamDataSource instance.
SceneManager * targetSceneMgr
Target SM to send renderables to.
Default implementation of PlaneBoundedVolumeListSceneQuery.
virtual void setShadowCasterRenderBackFaces(bool bf)
Sets whether or not shadow casters should be rendered into shadow textures using their back faces rat...
Implementation of a Quaternion, i.e.
Vector3 position
Sets to zero if directional light.
A sphere primitive, mostly used for bounds checking.
Definition: OgreSphere.h:51
Real maxDistanceInFrustum
The farthest object in the frustum regardless of visibility / shadow caster flags.
static uint32 FX_TYPE_MASK
Query type mask which will be used for effects like billboardsets / particle systems.
Struct for caching light clipping information for re-use in a frame.
virtual SceneNode * getSkyPlaneNode(void) const
Get the sky plane node, if enabled.
vector< LightInfo >::type LightInfoList
Concrete IteratorWrapper for nonconst access to the underlying key-value container.
virtual void postFindVisibleObjects(SceneManager *source, IlluminationRenderStage irs, Viewport *v)
Called after searching for visible objects in this SceneManager.
const Pass * mUsedPass
Pass that was actually used at the grouping level.
static uint32 LIGHT_TYPE_MASK
Query type mask which will be used for lights.
virtual void setShadowDirLightTextureOffset(Real offset)
Sets the proportional distance which a texture shadow which is generated from a directional light wil...
MovableObjectCollectionMap mMovableObjectCollectionMap
LightList mLightsAffectingFrustum
Utility class to generate a sequentially numbered series of names.
AnimationStateIterator getAnimationStateIterator(void)
Returns a specialised MapIterator over all animation states in the scene.
virtual void setFindVisibleObjects(bool find)
Sets whether the SceneManager should search for visible objects, or whether they are being manually h...
static String AUTODETECT_RESOURCE_GROUP_NAME
Special resource group name which causes resource group to be automatically determined based on searc...
vector< ShadowCaster * >::type ShadowCasterList
Class which will create instances of a given SceneManager.
set< uint8 >::type SpecialCaseRenderQueueList
ShadowTextureList mShadowTextures
virtual void preFindVisibleObjects(SceneManager *source, IlluminationRenderStage irs, Viewport *v)
Called prior to searching for visible objects in this SceneManager.
Real minDistance
The closest a visible object is to the camera.
Class representing colour.
float Real
Software floating point type.
SceneManagerMetaData mMetaData
IlluminationRenderStage mIlluminationStage
const CameraList & getCameras() const
Returns a const version of the camera list.
Real mShadowTextureFadeEnd
As a proportion e.g. 0.6.
map< Light *, LightClippingInfo >::type LightClippingInfoMap
virtual const SkyPlaneGenParameters & getSkyPlaneGenParameters(void) const
Get the parameters used to construct the SkyPlane, if any.
Alternative listener class for dealing with IntersectionSceneQuery.
Class to manage the scene object rendering queue.
32-bit pixel format, 8 bits for red, 8 bits for green, 8 bits for blue like PF_A8R8G8B8,...
vector< String >::type StringVector
bool transparentShadowCastersMode
Are we in transparent shadow caster mode?
ulong _getLightsDirtyCounter(void) const
Advance method to gets the lights dirty counter.
PixelFormat
The pixel format used for images, textures, and render surfaces.
Real minDistanceInFrustum
The closest a object in the frustum regardless of visibility / shadow caster flags.
#define OGRE_MUTEX(name)
InstanceManagerVec mDirtyInstanceMgrsTmp
AutoParamDataSource * mAutoParamDataSource
Utility class for calculating automatic parameters for gpu programs.
ShadowCameraSetupPtr mDefaultShadowCameraSetup
default shadow camera setup
Class representing a node in the scene graph.
Definition: OgreSceneNode.h:58
ClipResult
Generic result of clipping.
Definition: OgreCommon.h:740
const String & getName(void) const
Return the instance name of this SceneManager.
HardwareIndexBufferSharedPtr mShadowIndexBuffer
virtual Real getShadowDirLightTextureOffset(void) const
Gets the proportional distance which a texture shadow which is generated from a directional light wil...
virtual void setShowDebugShadows(bool debug)
Enables / disables the rendering of debug information for shadows.
Abstract class representing a Texture resource.
Definition: OgreTexture.h:102
ShadowTextureConfigList mShadowTextureConfigList
IlluminationRenderStage
Describes the stage of rendering when performing complex illumination.
virtual SceneNode * getSkyBoxNode(void) const
Get the skybox node, if enabled.
static String DEFAULT_RESOURCE_GROUP_NAME
Default resource group name.
virtual uint32 getVisibilityMask(void)
Gets a mask which is bitwise 'and'ed with objects own visibility masks to determine if the object is ...
ShadowTechnique
An enumeration of broad shadow techniques.
Definition: OgreCommon.h:190
An abstraction of a viewport, i.e.
Definition: OgreViewport.h:57
CullingMode mPassCullingMode
#define OGRE_NEW
String typeName
A globally unique string identifying the scene manager type.
uint32 mLastLightHash
Last light sets.
Real range
Use int instead of Light::LightTypes to avoid header file dependence.
Structure containing the configuration for one shadow texture.
static uint32 STATICGEOMETRY_TYPE_MASK
Query type mask which will be used for StaticGeometry.
No special illumination stage.
virtual bool isShadowTechniqueModulative(void) const
Is there a modulative shadowing technique in use?
static uint32 WORLD_GEOMETRY_TYPE_MASK
Query type mask which will be used for world geometry.
static uint32 FRUSTUM_TYPE_MASK
Query type mask which will be used for frusta and cameras.
vector< MovableObjectLodChangedEvent >::type MovableObjectLodChangedEventList
List of movable object LOD changed events.
static uint32 USER_TYPE_MASK_LIMIT
User type mask limit.
Class providing a much simplified interface to generating manual objects with custom geometry.
SphereSceneQuery * mShadowCasterSphereQuery
virtual bool getNormaliseNormalsOnScale() const
Get whether to automatically normalise normals on objects whenever they are scaled.
virtual bool isSkyDomeEnabled(void) const
Return whether a skydome is enabled.
bool worldGeometrySupported
Flag indicating whether world geometry is supported.
Defines a plane in 3D space.
Definition: OgrePlane.h:61
Class that allows listening in on the various stages of SceneManager processing, so that custom behav...
IlluminationRenderStage _getCurrentRenderStage()
GpuProgramParametersSharedPtr mShadowTextureCustomCasterVPParams
virtual bool getCameraRelativeRendering() const
Get whether to use camera-relative co-ordinates when rendering, ie to always place the camera at the ...
LightClippingInfoMap mLightClippingInfoMap
virtual void shadowTexturesUpdated(size_t numberOfShadowTextures)
Event raised after all shadow textures have been rendered into for all queues / targets but before an...
virtual bool getOptionKeys(StringVector &refKeys)
Method for getting all the implementation-specific options of the scene manager.
Subclass of BillboardChain which automatically leaves a trail behind one or more Node instances.
Specialises the SceneQuery class for querying within a sphere.
String mName
Instance name.
map< String, Camera * >::type CameraList
static const ColourValue White
virtual CompositorChain * _getActiveCompositorChain() const
Gets the active compositor chain of the current scene being rendered.
virtual size_t estimateWorldGeometry(DataStreamPtr &stream, const String &typeName=StringUtil::BLANK)
Estimate the number of loading stages required to load the named world geometry.
RenderQueueListenerList mRenderQueueListeners
uint16 SceneTypeMask
Bitmask containing scene types.
Class encapsulating a set of AnimationState objects.
InstanceManagerMap mInstanceManagerMap
vector< EntityMeshLodChangedEvent >::type EntityMeshLodChangedEventList
List of entity mesh LOD changed events.
SkyDomeGenParameters mSkyDomeGenParameters
virtual bool setOption(const String &strKey, const void *pValue)
Method for setting a specific option of the Scene Manager.
RenderSystem * mDestRenderSystem
The rendering system to send the scene to.
SceneType
Classification of a scene to allow a decision of what type of SceenManager to provide back to the app...
virtual bool getFindVisibleObjects(void)
Gets whether the SceneManager should search for visible objects, or whether they are being manually h...
map< const Camera *, const Light * >::type ShadowCamLightMapping
ShadowCamera to light mapping.
virtual SceneNode * getSkyDomeNode(void) const
Get the sky dome node, if enabled.
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:78
Standard 3-dimensional vector.
Definition: OgreVector3.h:51
uint32 lightMask
Sets to zero if directional light.
Class to hold a linear sequence of RenderQueueInvocation objects.
RenderQueue * mRenderQueue
Queue of objects for rendering.
virtual size_t estimateWorldGeometry(const String &filename)
Estimate the number of loading stages required to load the named world geometry.
Pre-transforms and batches up meshes for efficient use as instanced geometry in a scene.
map< String, Animation * >::type AnimationList
Storage of animations, lookup by name.
CullingMode
Hardware culling modes based on vertex winding.
Definition: OgreCommon.h:135
NameGenerator mMovableNameGenerator
CameraIterator getCameraIterator(void)
Returns a specialised MapIterator over all cameras in the scene.
Lowest level collection of renderables.
AxisAlignedBoxSceneQuery * mShadowCasterAABBQuery
A grouping level underneath RenderQueue which groups renderables to be issued at coarsely the same ti...
virtual bool isShadowTechniqueIntegrated(void) const
Is the shadow technique integrated into primary materials?
AnimationIterator getAnimationIterator(void)
Returns a specialised MapIterator over all animations in the scene.
Comparator for sorting lights relative to a point.
virtual void _setActiveCompositorChain(CompositorChain *chain)
Sets the active compositor chain of the current scene being rendered.
static uint32 ENTITY_TYPE_MASK
Query type mask which will be used for entities.
virtual bool getOption(const String &strKey, void *pDestValue)
Method for getting the value of an implementation-specific Scene Manager option.
LodListenerSet mLodListeners
GpuProgramParametersSharedPtr mShadowTextureCustomReceiverFPParams
ShadowCasterList mShadowCasterList
AxisAlignedBox receiverAabb
The axis-aligned bounds of the visible shadow receiver objects.
virtual bool sortLightsAffectingFrustum(LightList &lightList)
Hook to allow the listener to override the ordering of lights for the entire frustum.
ManualObject * mSkyBoxObj
virtual bool getShadowTextureSelfShadow(void) const
Gets whether or not texture shadows attempt to self-shadow.
Pass * mShadowReceiverPass
A pass designed to let us render shadow receivers for texture shadows.
virtual const SkyBoxGenParameters & getSkyBoxGenParameters(void) const
Get the parameters used to generate the current SkyBox, if any.
map< String, MovableObjectCollection * >::type MovableObjectCollectionMap
Pass * mShadowTextureCustomCasterPass
An animation sequence.
Definition: OgreAnimation.h:92
unsigned char uint8
Definition: OgrePlatform.h:346
Defines the functionality of a 3D API.
vector< PlaneBoundedVolume >::type PlaneBoundedVolumeList
Quaternion mSkyDomeOrientation
bool operator!=(STLAllocator< T, P > const &, STLAllocator< T2, P > const &)
determine equality, can memory from another allocator be released by this allocator,...
virtual void setShadowTextureFadeStart(Real fadeStart)
Sets the proportional distance at which texture shadows begin to fade out.
map< String, String >::type NameValuePairList
Name / value parameter pair (first = name, second = value)
Definition: OgreCommon.h:550
Specialises the SceneQuery class for querying along a ray.
Struct containing information about a mesh LOD change event for entities.
map< String, InstancedGeometry * >::type InstancedGeometryList
SceneMgrQueuedRenderableVisitor * mActiveQueuedRenderableVisitor
The active renderable visitor class - subclasses could override this.
virtual size_t getShadowIndexBufferSize(void) const
Get the size of the shadow index buffer.
bool mSuppressShadows
Suppress shadows?
Structure collecting together information about the visible objects that have been discovered in a sc...
MapIterator< AnimationList > AnimationIterator
virtual bool _areShadowsSuppressed(void) const
Are shadows suppressed?
SceneNodeList mSceneNodes
Central list of SceneNodes - for easy memory management.
uint32 mVisibilityMask
Visibility mask used to show / hide objects.
ListenerList mListeners
Abstract interface which classes must implement if they wish to receive events from the scene manager...
void prepare(bool lightInFrustum, const PlaneBoundedVolumeList *lightClipVolumes, const Light *light, const Camera *cam, ShadowCasterList *casterList, Real farDistSquared)
unsigned long mLightClippingInfoMapFrameNumber
Specialises the SceneQuery class for querying within a plane-bounded volume.
_StringBase String
vector< Listener * >::type ListenerList
map< String, SceneNode * >::type SceneNodeList
Structure containing information about a scene manager.
vector< RenderQueueListener * >::type RenderQueueListenerList
Default implementation of RaySceneQuery.
CamVisibleObjectsMap mCamVisibleObjectsMap
virtual void setFlipCullingOnNegativeScale(bool n)
Set whether to automatically flip the culling mode on objects whenever they are negatively scaled.
virtual bool isLateMaterialResolving() const
Gets whether using late material resolving or not.
This is the main starting point for the new instancing system.
AxisAlignedBox aabb
The axis-aligned bounds of the visible objects.
SpecialCaseRenderQueueList mSpecialCaseQueueList
ColourValue mShadowColour
virtual bool getShadowUseLightClipPlanes() const
Gets whether when using a built-in additive shadow mode, user clip planes should be used to restrict ...
GpuProgramParametersSharedPtr mShadowTextureCustomReceiverVPParams
Simple structure to hold MovableObject map and a mutex to go with it.
SkyPlaneGenParameters mSkyPlaneGenParameters
unsigned long mLastFrameNumber
SceneTypeMask sceneTypeMask
A mask describing which sorts of scenes this manager can handle.
Rectangle2D * mFullScreenQuad
bool mCameraRelativeRendering
Whether to use camera-relative rendering.
virtual void shadowTextureReceiverPreViewProj(Light *light, Frustum *frustum)
This event occurs just before the view & projection matrices are set for re-rendering a shadow receiv...
A viewpoint from which the scene will be rendered.
Definition: OgreCamera.h:86
virtual void preUpdateSceneGraph(SceneManager *source, Camera *camera)
Called prior to updating the scene graph in this SceneManager.
Chain of compositor effects applying to one viewport.
A class for performing queries on a scene.
Inner class to use as callback for shadow caster scene query.
virtual void setSkyDomeEnabled(bool enable)
Enables / disables a 'sky dome'.
Inner helper class to implement the visitor pattern for rendering objects in a queue.
ColourValue mAmbientLight
Current ambient light, cached for RenderSystem.
virtual void setShadowUseInfiniteFarPlane(bool enable)
Sets whether we should use an inifinite camera far plane when rendering stencil shadows.
GpuProgramParametersSharedPtr mShadowTextureCustomCasterFPParams
map< String, MovableObject * >::type MovableObjectMap
unsigned int uint32
Definition: OgrePlatform.h:344
virtual bool getShadowCasterRenderBackFaces() const
Gets whether or not shadow casters should be rendered into shadow textures using their back faces rat...
virtual bool isShadowTechniqueTextureBased(void) const
Is there a texture shadow based shadowing technique in use?
Allows the rendering of a simple 2D rectangle This class renders a simple 2D rectangle; this rectangl...
Abstract interface which classes must implement if they wish to receive events from the render queue.
virtual bool getShowDebugShadows(void) const
Are debug shadows shown?
vector< EntityMaterialLodChangedEvent >::type EntityMaterialLodChangedEventList
List of entity material LOD changed events.
This optional class allows you to receive per-result callbacks from SceneQuery executions instead of ...
Mask for additive shadows (not for direct use, use SHADOWTYPE_ enum instead)
Definition: OgreCommon.h:196
Defines a program which runs on the GPU such as a vertex or fragment program.
virtual void setCameraRelativeRendering(bool rel)
Set whether to use camera-relative co-ordinates when rendering, ie to always place the camera at the ...
Default implementation of IntersectionSceneQuery.
ShadowTextureCameraList mShadowTextureCameras
virtual bool isSkyBoxEnabled(void) const
Return whether a skybox is enabled.
virtual void setNormaliseNormalsOnScale(bool n)
Set whether to automatically normalise normals on objects whenever they are scaled.
virtual bool isShadowTechniqueAdditive(void) const
Is there an additive shadowing technique in use?
Struct associating a single Pass with a single Renderable.
size_t getShadowTextureCountPerLightType(Light::LightTypes type) const
Get the number of shadow textures is assigned for the given light type.
Class encapsulates rendering properties of an object.
Definition: OgreMaterial.h:88
First queue (after backgrounds), used for skyboxes if rendered first.
SceneNode * mSkyPlaneNode
Texture * mCurrentShadowTexture
EntityMeshLodChangedEventList mEntityMeshLodChangedEvents
void setShadowTextureCountPerLightType(Light::LightTypes type, size_t count)
Set the number of shadow textures a light type uses.
LightList mShadowTextureCurrentCasterLightList
Pre-transforms and batches up meshes for efficient use as static geometry in a scene.
No fog. Duh.
Definition: OgreCommon.h:124
virtual bool getDisplaySceneNodes(void) const
Returns true if all scene nodes axis are to be displayed.
LightTypes
Defines the type of light.
Definition: OgreLight.h:82
A interface class defining a listener which can be used to receive notifications of LOD events.
Concrete IteratorWrapper for const access to the underlying container.
SpecialCaseRenderQueueMode
Enumeration of the possible modes allowed for processing the special case render queue list.
unsigned long ulong
virtual bool getOptionValues(const String &strKey, StringVector &refValueList)
Method for getting all possible values for a specific option.
virtual const SkyDomeGenParameters & getSkyDomeGenParameters(void) const
Get the parameters used to generate the current SkyDome, if any.
bool mDisplayNodes
Flag indicating whether SceneNodes will be rendered as a set of 3 axes.
virtual void setVisibilityMask(uint32 vmask)
Sets a mask which is bitwise 'and'ed with objects own visibility masks to determine if the object is ...
virtual bool isShadowTechniqueInUse(void) const
Is there any shadowing technique in use?
Struct containing information about a material LOD change event for entities.
StaticGeometryList mStaticGeometryList
map< const Camera *, VisibleObjectsBoundsInfo >::type CamVisibleObjectsMap
Visible objects bounding box list.
MapIterator< MovableObjectMap > MovableObjectIterator
bool operator==(STLAllocator< T, P > const &, STLAllocator< T2, P > const &)
determine equality, can memory from another allocator be released by this allocator,...
set< SceneNode * >::type AutoTrackingSceneNodes
Autotracking scene nodes.
set< LodListener * >::type LodListenerSet
Set of registered LOD listeners.
AnimationStateIterator getAnimationStateIterator(void)
Get an iterator over all the animation states in this set.
vector< ShadowTextureConfig >::type ShadowTextureConfigList
ShadowTechnique mShadowTechnique
vector< size_t >::type mShadowTextureIndexLightList
Array defining shadow texture index in light list.
TexturePtr mNullShadowTexture
Real mShadowTextureFadeStart
Proportion of texture offset in view direction e.g. 0.4.
uint16 mGpuParamsDirty
Gpu params that need rebinding (mask of GpuParamVariability)
Structure for holding a position & orientation pair.
'New' rendering operation using vertex buffers.
Defines an instance of a discrete, movable object based on a Mesh.
Definition: OgreEntity.h:82
virtual bool getFlipCullingOnNegativeScale() const
Get whether to automatically flip the culling mode on objects whenever they are negatively scaled.
A collection of billboards (faces which are always facing the given direction) with the same (default...
Comparator for material map, for sorting materials into render order (e.g.
vector< TexturePtr >::type ShadowTextureList
vector< RenderObjectListener * >::type RenderObjectListenerList
String mShadowTextureCustomCasterVertexProgram
Class defining particle system based special effects.
Represents the state of an animation and the weight of its influence.
virtual void postUpdateSceneGraph(SceneManager *source, Camera *camera)
Called after updating the scene graph in this SceneManager.
Alternative listener class for dealing with RaySceneQuery.
AnimationList mAnimationsList
virtual void setLateMaterialResolving(bool isLate)
Sets whether to use late material resolving or not.
map< String, InstanceManager * >::type InstanceManagerMap
vector< InstanceManager * >::type InstanceManagerVec
static const Quaternion IDENTITY
bool mSuppressRenderStateChanges
Suppress render state changes?
This utility class is used to hold the information used to generate the matrices and other informatio...
A frustum represents a pyramid, capped at the near and far end which is used to represent either a vi...
Definition: OgreFrustum.h:85
virtual bool isShadowTechniqueStencilBased(void) const
Is there a stencil shadow based shadowing technique in use?
Visitor interface for items in a QueuedRenderableCollection.
virtual void setSkyPlaneEnabled(bool enable)
Enables / disables a 'sky plane'.
A 3D box aligned with the x/y/z axes.
Manages the organisation and rendering of a 'scene' i.e.
Pass * mShadowCasterPlainBlackPass
A pass designed to let us render shadow colour on white for texture shadows.
bool mShadowTextureSelfShadow
As a proportion e.g. 0.9.
LightInfoList mCachedLightInfos
Represents part of the world geometry that is a result of a SceneQuery.
SkyBoxGenParameters mSkyBoxGenParameters
virtual ShadowTechnique getShadowTechnique(void) const
Gets the current shadow technique.
Pass * mShadowTextureCustomReceiverPass
virtual bool _areRenderStateChangesSuppressed(void) const
Are render state changes suppressed?
virtual const SceneManagerMetaData & getMetaData(void) const
Get information about the SceneManager type created by this factory.
SpecialCaseRenderQueueMode mSpecialCaseQueueMode
static const String BLANK
Constant blank string, useful for returning by ref where local does not exist.
Definition: OgreString.h:196
ShadowCasterSceneQueryListener * mShadowCasterQueryListener
OrganisationMode
Organisation modes required for this collection.
Struct containing information about a LOD change event for movable objects.
unsigned short uint16
Definition: OgrePlatform.h:345
int type
Just a pointer for comparison, the light might destroyed for some reason.
virtual Real getShadowFarDistance(void) const
Gets the default maximum distance away from the camera that shadows will be visible.
CameraList mCameras
Central list of cameras - for easy memory management and lookup.
Representation of a dynamic light source in the scene.
Definition: OgreLight.h:73
GpuProgramParametersSharedPtr mFiniteExtrusionParams
Allows the rendering of a chain of connected billboards.
SceneMgrQueuedRenderableVisitor mDefaultQueuedRenderableVisitor
Storage for default renderable visitor.
virtual bool hasOption(const String &strKey) const
Method for verifying whether the scene manager has an implementation-specific option.
Cached light information, used to tracking light's changes.
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
Representation of a ray in space, i.e.
Definition: OgreRay.h:46
map< String, StaticGeometry * >::type StaticGeometryList
AutoTrackingSceneNodes mAutoTrackingSceneNodes
Default implementation of AxisAlignedBoxSceneQuery.
String mShadowTextureCustomCasterFragmentProgram
const LightList * manualLightList
Manual light list.
SceneNode * mSkyDomeNode
Mask for texture shadows (not for direct use, use SHADOWTYPE_ enum instead)
Definition: OgreCommon.h:208
Real maxDistance
The farthest a visible objects is from the camera.
virtual void setShadowTextureFadeEnd(Real fadeEnd)
Sets the proportional distance at which texture shadows finish to fading out.
Quaternion orientation