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