virtual ~CSceneManager();\r
\r
//! gets an animateable mesh. loads it if needed. returned pointer must not be dropped.\r
- virtual IAnimatedMesh* getMesh(const io::path& filename, const io::path& alternativeCacheName) _IRR_OVERRIDE_;\r
+ IAnimatedMesh* getMesh(const io::path& filename, const io::path& alternativeCacheName) override;\r
\r
//! gets an animateable mesh. loads it if needed. returned pointer must not be dropped.\r
- virtual IAnimatedMesh* getMesh(io::IReadFile* file) _IRR_OVERRIDE_;\r
+ IAnimatedMesh* getMesh(io::IReadFile* file) override;\r
\r
//! Returns an interface to the mesh cache which is shared between all existing scene managers.\r
- virtual IMeshCache* getMeshCache() _IRR_OVERRIDE_;\r
+ IMeshCache* getMeshCache() override;\r
\r
//! returns the video driver\r
- virtual video::IVideoDriver* getVideoDriver() _IRR_OVERRIDE_;\r
+ video::IVideoDriver* getVideoDriver() override;\r
\r
//! return the gui environment\r
- virtual gui::IGUIEnvironment* getGUIEnvironment() _IRR_OVERRIDE_;\r
+ gui::IGUIEnvironment* getGUIEnvironment() override;\r
\r
//! return the filesystem\r
- virtual io::IFileSystem* getFileSystem() _IRR_OVERRIDE_;\r
+ io::IFileSystem* getFileSystem() override;\r
\r
//! adds a scene node for rendering an animated mesh model\r
virtual IAnimatedMeshSceneNode* addAnimatedMeshSceneNode(IAnimatedMesh* mesh, ISceneNode* parent=0, s32 id=-1,\r
const core::vector3df& position = core::vector3df(0,0,0),\r
const core::vector3df& rotation = core::vector3df(0,0,0),\r
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f),\r
- bool alsoAddIfMeshPointerZero=false) _IRR_OVERRIDE_;\r
+ bool alsoAddIfMeshPointerZero=false) override;\r
\r
//! adds a scene node for rendering a static mesh\r
//! the returned pointer must not be dropped.\r
const core::vector3df& position = core::vector3df(0,0,0),\r
const core::vector3df& rotation = core::vector3df(0,0,0),\r
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f),\r
- bool alsoAddIfMeshPointerZero=false) _IRR_OVERRIDE_;\r
+ bool alsoAddIfMeshPointerZero=false) override;\r
\r
//! renders the node.\r
- virtual void render() _IRR_OVERRIDE_;\r
+ void render() override;\r
\r
//! returns the axis aligned bounding box of this node\r
- virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_OVERRIDE_;\r
+ const core::aabbox3d<f32>& getBoundingBox() const override;\r
\r
//! registers a node for rendering it at a specific time.\r
- virtual u32 registerNodeForRendering(ISceneNode* node, E_SCENE_NODE_RENDER_PASS pass = ESNRP_AUTOMATIC) _IRR_OVERRIDE_;\r
+ u32 registerNodeForRendering(ISceneNode* node, E_SCENE_NODE_RENDER_PASS pass = ESNRP_AUTOMATIC) override;\r
\r
//! Clear all nodes which are currently registered for rendering\r
- virtual void clearAllRegisteredNodesForRendering() _IRR_OVERRIDE_;\r
+ void clearAllRegisteredNodesForRendering() override;\r
\r
//! draws all scene nodes\r
- virtual void drawAll() _IRR_OVERRIDE_;\r
+ void drawAll() override;\r
\r
//! Adds a camera scene node to the tree and sets it as active camera.\r
//! \param position: Position of the space relative to its parent where the camera will be placed.\r
virtual ICameraSceneNode* addCameraSceneNode(ISceneNode* parent = 0,\r
const core::vector3df& position = core::vector3df(0,0,0),\r
const core::vector3df& lookat = core::vector3df(0,0,100),\r
- s32 id=-1, bool makeActive=true) _IRR_OVERRIDE_;\r
+ s32 id=-1, bool makeActive=true) override;\r
\r
//! Adds a billboard scene node to the scene. A billboard is like a 3d sprite: A 2d element,\r
//! which always looks to the camera. It is usually used for things like explosions, fire,\r
virtual IBillboardSceneNode* addBillboardSceneNode(ISceneNode* parent = 0,\r
const core::dimension2d<f32>& size = core::dimension2d<f32>(10.0f, 10.0f),\r
const core::vector3df& position = core::vector3df(0,0,0), s32 id=-1,\r
- video::SColor shadeTop = 0xFFFFFFFF, video::SColor shadeBottom = 0xFFFFFFFF) _IRR_OVERRIDE_;\r
+ video::SColor shadeTop = 0xFFFFFFFF, video::SColor shadeBottom = 0xFFFFFFFF) override;\r
\r
//! Adds a dummy transformation scene node to the scene graph.\r
virtual IDummyTransformationSceneNode* addDummyTransformationSceneNode(\r
- ISceneNode* parent=0, s32 id=-1) _IRR_OVERRIDE_;\r
+ ISceneNode* parent=0, s32 id=-1) override;\r
\r
//! Adds an empty scene node.\r
- virtual ISceneNode* addEmptySceneNode(ISceneNode* parent, s32 id=-1) _IRR_OVERRIDE_;\r
+ ISceneNode* addEmptySceneNode(ISceneNode* parent, s32 id=-1) override;\r
\r
//! Returns the root scene node. This is the scene node which is parent\r
//! of all scene nodes. The root scene node is a special scene node which\r
//! only exists to manage all scene nodes. It is not rendered and cannot\r
//! be removed from the scene.\r
//! \return Pointer to the root scene node.\r
- virtual ISceneNode* getRootSceneNode() _IRR_OVERRIDE_;\r
+ ISceneNode* getRootSceneNode() override;\r
\r
//! Returns the current active camera.\r
//! \return The active camera is returned. Note that this can be NULL, if there\r
//! was no camera created yet.\r
- virtual ICameraSceneNode* getActiveCamera() const _IRR_OVERRIDE_;\r
+ ICameraSceneNode* getActiveCamera() const override;\r
\r
//! Sets the active camera. The previous active camera will be deactivated.\r
//! \param camera: The new camera which should be active.\r
- virtual void setActiveCamera(ICameraSceneNode* camera) _IRR_OVERRIDE_;\r
+ void setActiveCamera(ICameraSceneNode* camera) override;\r
\r
//! Adds an external mesh loader.\r
- virtual void addExternalMeshLoader(IMeshLoader* externalLoader) _IRR_OVERRIDE_;\r
+ void addExternalMeshLoader(IMeshLoader* externalLoader) override;\r
\r
//! Returns the number of mesh loaders supported by Irrlicht at this time\r
- virtual u32 getMeshLoaderCount() const _IRR_OVERRIDE_;\r
+ u32 getMeshLoaderCount() const override;\r
\r
//! Retrieve the given mesh loader\r
- virtual IMeshLoader* getMeshLoader(u32 index) const _IRR_OVERRIDE_;\r
+ IMeshLoader* getMeshLoader(u32 index) const override;\r
\r
- //! Adds an external scene loader.\r
- virtual void addExternalSceneLoader(ISceneLoader* externalLoader) _IRR_OVERRIDE_;\r
-\r
- //! Returns the number of scene loaders supported by Irrlicht at this time\r
- virtual u32 getSceneLoaderCount() const _IRR_OVERRIDE_;\r
-\r
- //! Retrieve the given scene loader\r
- virtual ISceneLoader* getSceneLoader(u32 index) const _IRR_OVERRIDE_;\r
+ //! Returns a pointer to the scene collision manager.\r
+ ISceneCollisionManager* getSceneCollisionManager() override;\r
\r
//! Returns a pointer to the mesh manipulator.\r
- virtual IMeshManipulator* getMeshManipulator() _IRR_OVERRIDE_;\r
+ IMeshManipulator* getMeshManipulator() override;\r
\r
//! Adds a scene node to the deletion queue.\r
- virtual void addToDeletionQueue(ISceneNode* node) _IRR_OVERRIDE_;\r
+ void addToDeletionQueue(ISceneNode* node) override;\r
\r
//! Returns the first scene node with the specified id.\r
- virtual ISceneNode* getSceneNodeFromId(s32 id, ISceneNode* start=0) _IRR_OVERRIDE_;\r
+ ISceneNode* getSceneNodeFromId(s32 id, ISceneNode* start=0) override;\r
\r
//! Returns the first scene node with the specified name.\r
- virtual ISceneNode* getSceneNodeFromName(const c8* name, ISceneNode* start=0) _IRR_OVERRIDE_;\r
+ ISceneNode* getSceneNodeFromName(const c8* name, ISceneNode* start=0) override;\r
\r
//! Returns the first scene node with the specified type.\r
- virtual ISceneNode* getSceneNodeFromType(scene::ESCENE_NODE_TYPE type, ISceneNode* start=0) _IRR_OVERRIDE_;\r
+ ISceneNode* getSceneNodeFromType(scene::ESCENE_NODE_TYPE type, ISceneNode* start=0) override;\r
\r
//! returns scene nodes by type.\r
- virtual void getSceneNodesFromType(ESCENE_NODE_TYPE type, core::array<scene::ISceneNode*>& outNodes, ISceneNode* start=0) _IRR_OVERRIDE_;\r
+ void getSceneNodesFromType(ESCENE_NODE_TYPE type, core::array<scene::ISceneNode*>& outNodes, ISceneNode* start=0) override;\r
\r
//! Posts an input event to the environment. Usually you do not have to\r
//! use this method, it is used by the internal engine.\r
- virtual bool postEventFromUser(const SEvent& event) _IRR_OVERRIDE_;\r
+ bool postEventFromUser(const SEvent& event) override;\r
\r
//! Clears the whole scene. All scene nodes are removed.\r
- virtual void clear() _IRR_OVERRIDE_;\r
+ void clear() override;\r
\r
//! Removes all children of this scene node\r
- virtual void removeAll() _IRR_OVERRIDE_;\r
+ void removeAll() override;\r
\r
//! Returns interface to the parameters set in this scene.\r
- virtual io::IAttributes* getParameters() _IRR_OVERRIDE_;\r
+ io::IAttributes* getParameters() override;\r
\r
//! Returns current render pass.\r
- virtual E_SCENE_NODE_RENDER_PASS getSceneNodeRenderPass() const _IRR_OVERRIDE_;\r
+ E_SCENE_NODE_RENDER_PASS getSceneNodeRenderPass() const override;\r
\r
//! Creates a new scene manager.\r
- virtual ISceneManager* createNewSceneManager(bool cloneContent) _IRR_OVERRIDE_;\r
+ ISceneManager* createNewSceneManager(bool cloneContent) override;\r
\r
//! Returns type of the scene node\r
- virtual ESCENE_NODE_TYPE getType() const _IRR_OVERRIDE_ { return ESNT_SCENE_MANAGER; }\r
-\r
- //! Returns the default scene node factory which can create all built in scene nodes\r
- virtual ISceneNodeFactory* getDefaultSceneNodeFactory() _IRR_OVERRIDE_;\r
-\r
- //! Adds a scene node factory to the scene manager.\r
- /** Use this to extend the scene manager with new scene node types which it should be\r
- able to create automatically, for example when loading data from xml files. */\r
- virtual void registerSceneNodeFactory(ISceneNodeFactory* factoryToAdd) _IRR_OVERRIDE_;\r
-\r
- //! Returns amount of registered scene node factories.\r
- virtual u32 getRegisteredSceneNodeFactoryCount() const _IRR_OVERRIDE_;\r
-\r
- //! Returns a scene node factory by index\r
- virtual ISceneNodeFactory* getSceneNodeFactory(u32 index) _IRR_OVERRIDE_;\r
-\r
- //! Returns a typename from a scene node type or null if not found\r
- virtual const c8* getSceneNodeTypeName(ESCENE_NODE_TYPE type) _IRR_OVERRIDE_;\r
-\r
- //! Adds a scene node to the scene by name\r
- virtual ISceneNode* addSceneNode(const char* sceneNodeTypeName, ISceneNode* parent=0) _IRR_OVERRIDE_;\r
-\r
- //! Saves the current scene into a file.\r
- virtual bool saveScene(const io::path& filename, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* node=0) _IRR_OVERRIDE_;\r
-\r
- //! Saves the current scene into a file.\r
- virtual bool saveScene(io::IWriteFile* file, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* node=0) _IRR_OVERRIDE_;\r
-\r
- //! Loads a scene. Note that the current scene is not cleared before.\r
- virtual bool loadScene(const io::path& filename, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* rootNode=0) _IRR_OVERRIDE_;\r
-\r
- //! Loads a scene. Note that the current scene is not cleared before.\r
- virtual bool loadScene(io::IReadFile* file, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* rootNode=0) _IRR_OVERRIDE_;\r
-\r
- //! Writes attributes of the scene node.\r
- virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const _IRR_OVERRIDE_;\r
-\r
- //! Reads attributes of the scene node.\r
- virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) _IRR_OVERRIDE_;\r
+ ESCENE_NODE_TYPE getType() const override { return ESNT_SCENE_MANAGER; }\r
\r
//! Returns a mesh writer implementation if available\r
- virtual IMeshWriter* createMeshWriter(EMESH_WRITER_TYPE type) _IRR_OVERRIDE_;\r
+ IMeshWriter* createMeshWriter(EMESH_WRITER_TYPE type) override;\r
\r
//! Get a skinned mesh, which is not available as header-only code\r
- virtual ISkinnedMesh* createSkinnedMesh() _IRR_OVERRIDE_;\r
+ ISkinnedMesh* createSkinnedMesh() override;\r
\r
//! Sets ambient color of the scene\r
- virtual void setAmbientLight(const video::SColorf &ambientColor) _IRR_OVERRIDE_;\r
+ void setAmbientLight(const video::SColorf &ambientColor) override;\r
\r
//! Returns ambient color of the scene\r
- virtual const video::SColorf& getAmbientLight() const _IRR_OVERRIDE_;\r
+ const video::SColorf& getAmbientLight() const override;\r
\r
//! Get current render time.\r
- virtual E_SCENE_NODE_RENDER_PASS getCurrentRenderPass() const _IRR_OVERRIDE_ { return CurrentRenderPass; }\r
+ E_SCENE_NODE_RENDER_PASS getCurrentRenderPass() const override { return CurrentRenderPass; }\r
\r
//! Set current render time.\r
- virtual void setCurrentRenderPass(E_SCENE_NODE_RENDER_PASS nextPass) _IRR_OVERRIDE_ { CurrentRenderPass = nextPass; }\r
+ void setCurrentRenderPass(E_SCENE_NODE_RENDER_PASS nextPass) override { CurrentRenderPass = nextPass; }\r
\r
//! returns if node is culled\r
- virtual bool isCulled(const ISceneNode* node) const _IRR_OVERRIDE_;\r
+ bool isCulled(const ISceneNode* node) const override;\r
\r
private:\r
\r
\r
struct DefaultNodeEntry\r
{\r
+ DefaultNodeEntry()\r
+ { }\r
+\r
DefaultNodeEntry(ISceneNode* n) :\r
Node(n), TextureValue(0)\r
{\r
//! sort on distance (center) to camera\r
struct TransparentNodeEntry\r
{\r
+ TransparentNodeEntry()\r
+ { }\r
+\r
TransparentNodeEntry(ISceneNode* n, const core::vector3df& camera)\r
: Node(n)\r
{\r
//! cursor control\r
gui::ICursorControl* CursorControl;\r
\r
+ //! collision manager\r
+ ISceneCollisionManager* CollisionManager;\r
+\r
//! render pass lists\r
core::array<ISceneNode*> CameraList;\r
core::array<ISceneNode*> SkyBoxList;\r
core::array<ISceneNode*> GuiNodeList;\r
\r
core::array<IMeshLoader*> MeshLoaderList;\r
- core::array<ISceneLoader*> SceneLoaderList;\r
core::array<ISceneNode*> DeletionList;\r
- core::array<ISceneNodeFactory*> SceneNodeFactoryList;\r
\r
//! current active camera\r
ICameraSceneNode* ActiveCamera;\r
projects / irrlicht.git / blobdiff