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