source/Irrlicht/CSceneManager.h

   1 // Copyright (C) 2002-2012 Nikolaus Gebhardt\r
   2 // This file is part of the "Irrlicht Engine".\r
   3 // For conditions of distribution and use, see copyright notice in irrlicht.h\r
   4 \r
   5 #ifndef __C_SCENE_MANAGER_H_INCLUDED__\r
   6 #define __C_SCENE_MANAGER_H_INCLUDED__\r
   7 \r
   8 #include "ISceneManager.h"\r
   9 #include "ISceneNode.h"\r
  10 #include "ICursorControl.h"\r
  11 #include "irrString.h"\r
  12 #include "irrArray.h"\r
  13 #include "IMeshLoader.h"\r
  14 #include "CAttributes.h"\r
  15 #include "ILightManager.h"\r
  16 \r
  17 namespace irr\r
  18 {\r
  19 namespace io\r
  20 {\r
  21         class IFileSystem;\r
  22 }\r
  23 namespace scene\r
  24 {\r
  25         class IMeshCache;\r
  26 \r
  27         /*!\r
  28                 The Scene Manager manages scene nodes, mesh resources, cameras and all the other stuff.\r
  29         */\r
  30         class CSceneManager : public ISceneManager, public ISceneNode\r
  31         {\r
  32         public:\r
  33 \r
  34                 //! constructor\r
  35                 CSceneManager(video::IVideoDriver* driver, gui::ICursorControl* cursorControl, IMeshCache* cache = 0);\r
  36 \r
  37                 //! destructor\r
  38                 virtual ~CSceneManager();\r
  39 \r
  40                 //! gets an animateable mesh. loads it if needed. returned pointer must not be dropped.\r
  41                 IAnimatedMesh* getMesh(io::IReadFile* file) override;\r
  42 \r
  43                 //! Returns an interface to the mesh cache which is shared between all existing scene managers.\r
  44                 IMeshCache* getMeshCache() override;\r
  45 \r
  46                 //! returns the video driver\r
  47                 video::IVideoDriver* getVideoDriver() override;\r
  48 \r
  49                 //! adds a scene node for rendering an animated mesh model\r
  50                 virtual IAnimatedMeshSceneNode* addAnimatedMeshSceneNode(IAnimatedMesh* mesh, ISceneNode* parent=0, s32 id=-1,\r
  51                         const core::vector3df& position = core::vector3df(0,0,0),\r
  52                         const core::vector3df& rotation = core::vector3df(0,0,0),\r
  53                         const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f),\r
  54                         bool alsoAddIfMeshPointerZero=false) override;\r
  55 \r
  56                 //! adds a scene node for rendering a static mesh\r
  57                 //! the returned pointer must not be dropped.\r
  58                 virtual IMeshSceneNode* addMeshSceneNode(IMesh* mesh, ISceneNode* parent=0, s32 id=-1,\r
  59                         const core::vector3df& position = core::vector3df(0,0,0),\r
  60                         const core::vector3df& rotation = core::vector3df(0,0,0),\r
  61                         const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f),\r
  62                         bool alsoAddIfMeshPointerZero=false) override;\r
  63 \r
  64                 //! renders the node.\r
  65                 void render() override;\r
  66 \r
  67                 //! returns the axis aligned bounding box of this node\r
  68                 const core::aabbox3d<f32>& getBoundingBox() const override;\r
  69 \r
  70                 //! registers a node for rendering it at a specific time.\r
  71                 u32 registerNodeForRendering(ISceneNode* node, E_SCENE_NODE_RENDER_PASS pass = ESNRP_AUTOMATIC) override;\r
  72 \r
  73                 //! Clear all nodes which are currently registered for rendering\r
  74                 void clearAllRegisteredNodesForRendering() override;\r
  75 \r
  76                 //! draws all scene nodes\r
  77                 void drawAll() override;\r
  78 \r
  79                 //! Adds a camera scene node to the tree and sets it as active camera.\r
  80                 //! \param position: Position of the space relative to its parent where the camera will be placed.\r
  81                 //! \param lookat: Position where the camera will look at. Also known as target.\r
  82                 //! \param parent: Parent scene node of the camera. Can be null. If the parent moves,\r
  83                 //! the camera will move too.\r
  84                 //! \return Pointer to interface to camera\r
  85                 virtual ICameraSceneNode* addCameraSceneNode(ISceneNode* parent = 0,\r
  86                         const core::vector3df& position = core::vector3df(0,0,0),\r
  87                         const core::vector3df& lookat = core::vector3df(0,0,100),\r
  88                         s32 id=-1, bool makeActive=true) override;\r
  89 \r
  90                 //! Adds a dynamic light scene node. The light will cast dynamic light on all\r
  91                 //! other scene nodes in the scene, which have the material flag video::MTF_LIGHTING\r
  92                 //! turned on. (This is the default setting in most scene nodes).\r
  93                 virtual ILightSceneNode* addLightSceneNode(ISceneNode* parent = 0,\r
  94                         const core::vector3df& position = core::vector3df(0,0,0),\r
  95                         video::SColorf color = video::SColorf(1.0f, 1.0f, 1.0f),\r
  96                         f32 range=100.0f, s32 id=-1) override;\r
  97 \r
  98                 //! Adds a billboard scene node to the scene. A billboard is like a 3d sprite: A 2d element,\r
  99                 //! which always looks to the camera. It is usually used for things like explosions, fire,\r
 100                 //! lensflares and things like that.\r
 101                 virtual IBillboardSceneNode* addBillboardSceneNode(ISceneNode* parent = 0,\r
 102                         const core::dimension2d<f32>& size = core::dimension2d<f32>(10.0f, 10.0f),\r
 103                         const core::vector3df& position = core::vector3df(0,0,0), s32 id=-1,\r
 104                         video::SColor shadeTop = 0xFFFFFFFF, video::SColor shadeBottom = 0xFFFFFFFF) override;\r
 105 \r
 106                 //! Adds a dummy transformation scene node to the scene graph.\r
 107                 virtual IDummyTransformationSceneNode* addDummyTransformationSceneNode(\r
 108                         ISceneNode* parent=0, s32 id=-1) override;\r
 109 \r
 110                 //! Adds an empty scene node.\r
 111                 ISceneNode* addEmptySceneNode(ISceneNode* parent, s32 id=-1) override;\r
 112 \r
 113                 //! Returns the root scene node. This is the scene node which is parent\r
 114                 //! of all scene nodes. The root scene node is a special scene node which\r
 115                 //! only exists to manage all scene nodes. It is not rendered and cannot\r
 116                 //! be removed from the scene.\r
 117                 //! \return Pointer to the root scene node.\r
 118                 ISceneNode* getRootSceneNode() override;\r
 119 \r
 120                 //! Returns the current active camera.\r
 121                 //! \return The active camera is returned. Note that this can be NULL, if there\r
 122                 //! was no camera created yet.\r
 123                 ICameraSceneNode* getActiveCamera() const override;\r
 124 \r
 125                 //! Sets the active camera. The previous active camera will be deactivated.\r
 126                 //! \param camera: The new camera which should be active.\r
 127                 void setActiveCamera(ICameraSceneNode* camera) override;\r
 128 \r
 129                 //! Adds an external mesh loader.\r
 130                 void addExternalMeshLoader(IMeshLoader* externalLoader) override;\r
 131 \r
 132                 //! Returns the number of mesh loaders supported by Irrlicht at this time\r
 133                 u32 getMeshLoaderCount() const override;\r
 134 \r
 135                 //! Retrieve the given mesh loader\r
 136                 IMeshLoader* getMeshLoader(u32 index) const override;\r
 137 \r
 138                 //! Returns a pointer to the scene collision manager.\r
 139                 ISceneCollisionManager* getSceneCollisionManager() override;\r
 140 \r
 141                 //! Returns a pointer to the mesh manipulator.\r
 142                 IMeshManipulator* getMeshManipulator() override;\r
 143 \r
 144                 //! Sets the color of stencil buffers shadows drawn by the scene manager.\r
 145                 virtual void setShadowColor(video::SColor color) override;\r
 146 \r
 147                 //! Returns the current color of shadows.\r
 148                 virtual video::SColor getShadowColor() const override;\r
 149 \r
 150                 //! Create a shadow volume scene node to be used with custom nodes\r
 151                 virtual IShadowVolumeSceneNode* createShadowVolumeSceneNode(const IMesh* shadowMesh, ISceneNode* parent, s32 id, bool zfailmethod, f32 infinity) override;\r
 152 \r
 153                 //! Adds a scene node to the deletion queue.\r
 154                 void addToDeletionQueue(ISceneNode* node) override;\r
 155 \r
 156                 //! Returns the first scene node with the specified id.\r
 157                 ISceneNode* getSceneNodeFromId(s32 id, ISceneNode* start=0) override;\r
 158 \r
 159                 //! Returns the first scene node with the specified name.\r
 160                 ISceneNode* getSceneNodeFromName(const c8* name, ISceneNode* start=0) override;\r
 161 \r
 162                 //! Returns the first scene node with the specified type.\r
 163                 ISceneNode* getSceneNodeFromType(scene::ESCENE_NODE_TYPE type, ISceneNode* start=0) override;\r
 164 \r
 165                 //! returns scene nodes by type.\r
 166                 void getSceneNodesFromType(ESCENE_NODE_TYPE type, core::array<scene::ISceneNode*>& outNodes, ISceneNode* start=0) override;\r
 167 \r
 168                 //! Posts an input event to the environment. Usually you do not have to\r
 169                 //! use this method, it is used by the internal engine.\r
 170                 bool postEventFromUser(const SEvent& event) override;\r
 171 \r
 172                 //! Clears the whole scene. All scene nodes are removed.\r
 173                 void clear() override;\r
 174 \r
 175                 //! Removes all children of this scene node\r
 176                 void removeAll() override;\r
 177 \r
 178                 //! Returns interface to the parameters set in this scene.\r
 179                 io::IAttributes* getParameters() override;\r
 180 \r
 181                 //! Returns current render pass.\r
 182                 E_SCENE_NODE_RENDER_PASS getSceneNodeRenderPass() const override;\r
 183 \r
 184                 //! Creates a new scene manager.\r
 185                 ISceneManager* createNewSceneManager(bool cloneContent) override;\r
 186 \r
 187                 //! Returns type of the scene node\r
 188                 ESCENE_NODE_TYPE getType() const override { return ESNT_SCENE_MANAGER; }\r
 189 \r
 190                 //! Returns a mesh writer implementation if available\r
 191                 IMeshWriter* createMeshWriter(EMESH_WRITER_TYPE type) override;\r
 192 \r
 193                 //! Get a skinned mesh, which is not available as header-only code\r
 194                 ISkinnedMesh* createSkinnedMesh() override;\r
 195 \r
 196                 //! Sets ambient color of the scene\r
 197                 void setAmbientLight(const video::SColorf &ambientColor) override;\r
 198 \r
 199                 //! Returns ambient color of the scene\r
 200                 const video::SColorf& getAmbientLight() const override;\r
 201 \r
 202                 //! Register a custom callbacks manager which gets callbacks during scene rendering.\r
 203                 virtual void setLightManager(ILightManager* lightManager) override;\r
 204 \r
 205                 //! Get current render time.\r
 206                 E_SCENE_NODE_RENDER_PASS getCurrentRenderPass() const override { return CurrentRenderPass; }\r
 207 \r
 208                 //! Set current render time.\r
 209                 void setCurrentRenderPass(E_SCENE_NODE_RENDER_PASS nextPass) override { CurrentRenderPass = nextPass; }\r
 210 \r
 211                 //! returns if node is culled\r
 212                 bool isCulled(const ISceneNode* node) const override;\r
 213 \r
 214         private:\r
 215 \r
 216                 // load and create a mesh which we know already isn't in the cache and put it in there\r
 217                 IAnimatedMesh* getUncachedMesh(io::IReadFile* file, const io::path& filename, const io::path& cachename);\r
 218 \r
 219                 //! clears the deletion list\r
 220                 void clearDeletionList();\r
 221 \r
 222                 struct DefaultNodeEntry\r
 223                 {\r
 224                         DefaultNodeEntry()\r
 225                         { }\r
 226 \r
 227                         DefaultNodeEntry(ISceneNode* n) :\r
 228                                 Node(n), TextureValue(0)\r
 229                         {\r
 230                                 if (n->getMaterialCount())\r
 231                                         TextureValue = (n->getMaterial(0).getTexture(0));\r
 232                         }\r
 233 \r
 234                         bool operator < (const DefaultNodeEntry& other) const\r
 235                         {\r
 236                                 return (TextureValue < other.TextureValue);\r
 237                         }\r
 238 \r
 239                         ISceneNode* Node;\r
 240                         private:\r
 241                         void* TextureValue;\r
 242                 };\r
 243 \r
 244                 //! sort on distance (center) to camera\r
 245                 struct TransparentNodeEntry\r
 246                 {\r
 247                         TransparentNodeEntry()\r
 248                         { }\r
 249 \r
 250                         TransparentNodeEntry(ISceneNode* n, const core::vector3df& camera)\r
 251                                 : Node(n)\r
 252                         {\r
 253                                 Distance = Node->getAbsoluteTransformation().getTranslation().getDistanceFromSQ(camera);\r
 254                         }\r
 255 \r
 256                         bool operator < (const TransparentNodeEntry& other) const\r
 257                         {\r
 258                                 return Distance > other.Distance;\r
 259                         }\r
 260 \r
 261                         ISceneNode* Node;\r
 262                         private:\r
 263                                 f64 Distance;\r
 264                 };\r
 265 \r
 266                 //! sort on distance (sphere) to camera\r
 267                 struct DistanceNodeEntry\r
 268                 {\r
 269                         DistanceNodeEntry()\r
 270                         { }\r
 271 \r
 272                         DistanceNodeEntry(ISceneNode* n, const core::vector3df& cameraPos)\r
 273                                 : Node(n)\r
 274                         {\r
 275                                 setNodeAndDistanceFromPosition(n, cameraPos);\r
 276                         }\r
 277 \r
 278                         bool operator < (const DistanceNodeEntry& other) const\r
 279                         {\r
 280                                 return Distance < other.Distance;\r
 281                         }\r
 282 \r
 283                         void setNodeAndDistanceFromPosition(ISceneNode* n, const core::vector3df & fromPosition)\r
 284                         {\r
 285                                 Node = n;\r
 286                                 Distance = Node->getAbsoluteTransformation().getTranslation().getDistanceFromSQ(fromPosition);\r
 287                                 Distance -= Node->getBoundingBox().getExtent().getLengthSQ() * 0.5;\r
 288                         }\r
 289 \r
 290                         ISceneNode* Node;\r
 291                         private:\r
 292                         f64 Distance;\r
 293                 };\r
 294 \r
 295                 //! video driver\r
 296                 video::IVideoDriver* Driver;\r
 297 \r
 298                 //! cursor control\r
 299                 gui::ICursorControl* CursorControl;\r
 300 \r
 301                 //! collision manager\r
 302                 ISceneCollisionManager* CollisionManager;\r
 303 \r
 304                 //! render pass lists\r
 305                 core::array<ISceneNode*> CameraList;\r
 306                 core::array<ISceneNode*> LightList;\r
 307                 core::array<ISceneNode*> ShadowNodeList;\r
 308                 core::array<ISceneNode*> SkyBoxList;\r
 309                 core::array<DefaultNodeEntry> SolidNodeList;\r
 310                 core::array<TransparentNodeEntry> TransparentNodeList;\r
 311                 core::array<TransparentNodeEntry> TransparentEffectNodeList;\r
 312                 core::array<ISceneNode*> GuiNodeList;\r
 313 \r
 314                 core::array<IMeshLoader*> MeshLoaderList;\r
 315                 core::array<ISceneNode*> DeletionList;\r
 316 \r
 317                 //! current active camera\r
 318                 ICameraSceneNode* ActiveCamera;\r
 319                 core::vector3df camWorldPos; // Position of camera for transparent nodes.\r
 320 \r
 321                 video::SColor ShadowColor;\r
 322                 video::SColorf AmbientLight;\r
 323 \r
 324                 //! String parameters\r
 325                 // NOTE: Attributes are slow and should only be used for debug-info and not in release\r
 326                 io::CAttributes* Parameters;\r
 327 \r
 328                 //! Mesh cache\r
 329                 IMeshCache* MeshCache;\r
 330 \r
 331                 E_SCENE_NODE_RENDER_PASS CurrentRenderPass;\r
 332 \r
 333                 //! An optional callbacks manager to allow the user app finer control\r
 334                 //! over the scene lighting and rendering.\r
 335                 ILightManager* LightManager;\r
 336         };\r
 337 \r
 338 } // end namespace video\r
 339 } // end namespace scene\r
 340 \r
 341 #endif\r
 342 \r