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