#include "irrArray.h"\r
#include "IMeshLoader.h"\r
#include "CAttributes.h"\r
-#include "ILightManager.h"\r
\r
namespace irr\r
{\r
namespace scene\r
{\r
class IMeshCache;\r
- class IGeometryCreator;\r
\r
/*!\r
The Scene Manager manages scene nodes, mesh resources, cameras and all the other stuff.\r
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
-\r
- //! adds Volume Lighting Scene Node.\r
- //! the returned pointer must not be dropped.\r
- virtual IVolumeLightSceneNode* addVolumeLightSceneNode(ISceneNode* parent=0, s32 id=-1,\r
- const u32 subdivU = 32, const u32 subdivV = 32,\r
- const video::SColor foot = video::SColor(51, 0, 230, 180),\r
- const video::SColor tail = video::SColor(0, 0, 0, 0),\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)) _IRR_OVERRIDE_;\r
-\r
- //! adds a cube scene node to the scene. It is a simple cube of (1,1,1) size.\r
- //! the returned pointer must not be dropped.\r
- virtual IMeshSceneNode* addCubeSceneNode(f32 size=10.0f, 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)) _IRR_OVERRIDE_;\r
-\r
- //! Adds a sphere scene node to the scene.\r
- virtual IMeshSceneNode* addSphereSceneNode(f32 radius=5.0f, s32 polyCount=16, 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)) _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
-\r
- //! Adds a scene node for rendering a animated water surface mesh.\r
- virtual ISceneNode* addWaterSurfaceSceneNode(IMesh* mesh, f32 waveHeight, f32 waveSpeed, f32 wlength, 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)) _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
-\r
- //! Adds a scene node for rendering using a octree to the scene graph. This a good method for rendering\r
- //! scenes with lots of geometry. The Octree is built on the fly from the mesh, much\r
- //! faster then a bsp tree.\r
- virtual IOctreeSceneNode* addOctreeSceneNode(IAnimatedMesh* mesh, ISceneNode* parent=0,\r
- s32 id=-1, s32 minimalPolysPerNode=512, bool alsoAddIfMeshPointerZero=false) _IRR_OVERRIDE_;\r
-\r
- //! Adss a scene node for rendering using a octree. This a good method for rendering\r
- //! scenes with lots of geometry. The Octree is built on the fly from the mesh, much\r
- //! faster then a bsp tree.\r
- virtual IOctreeSceneNode* addOctreeSceneNode(IMesh* mesh, ISceneNode* parent=0,\r
- s32 id=-1, s32 minimalPolysPerNode=128, bool alsoAddIfMeshPointerZero=false) _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
-\r
- //! Adds a camera scene node which is able to be controlle with the mouse similar\r
- //! like in the 3D Software Maya by Alias Wavefront.\r
- //! The returned pointer must not be dropped.\r
- virtual ICameraSceneNode* addCameraSceneNodeMaya(ISceneNode* parent=0,\r
- f32 rotateSpeed=-1500.f, f32 zoomSpeed=200.f,\r
- f32 translationSpeed=1500.f, s32 id=-1, f32 distance=70.f,\r
- bool makeActive=true) _IRR_OVERRIDE_;\r
-\r
- //! Adds a camera scene node which is able to be controled with the mouse and keys\r
- //! like in most first person shooters (FPS):\r
- virtual ICameraSceneNode* addCameraSceneNodeFPS(ISceneNode* parent = 0,\r
- f32 rotateSpeed = 100.0f, f32 moveSpeed = .5f, s32 id=-1,\r
- SKeyMap* keyMapArray=0, s32 keyMapSize=0,\r
- bool noVerticalMovement=false, f32 jumpSpeed = 0.f,\r
- bool invertMouseY=false, bool makeActive=true) _IRR_OVERRIDE_;\r
-\r
- //! Adds a dynamic light scene node. The light will cast dynamic light on all\r
- //! other scene nodes in the scene, which have the material flag video::MTF_LIGHTING\r
- //! turned on. (This is the default setting in most scene nodes).\r
- virtual ILightSceneNode* addLightSceneNode(ISceneNode* parent = 0,\r
- const core::vector3df& position = core::vector3df(0,0,0),\r
- video::SColorf color = video::SColorf(1.0f, 1.0f, 1.0f),\r
- f32 range=100.0f, s32 id=-1) _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
-\r
- //! Adds a skybox scene node. A skybox is a big cube with 6 textures on it and\r
- //! is drawn around the camera position.\r
- virtual ISceneNode* addSkyBoxSceneNode(video::ITexture* top, video::ITexture* bottom,\r
- video::ITexture* left, video::ITexture* right, video::ITexture* front,\r
- video::ITexture* back, ISceneNode* parent = 0, s32 id=-1) _IRR_OVERRIDE_;\r
-\r
- //! Adds a skydome scene node. A skydome is a large (half-) sphere with a\r
- //! panoramic texture on it and is drawn around the camera position.\r
- virtual ISceneNode* addSkyDomeSceneNode(video::ITexture* texture,\r
- u32 horiRes=16, u32 vertRes=8,\r
- f32 texturePercentage=0.9, f32 spherePercentage=2.0,f32 radius = 1000.f,\r
- ISceneNode* parent=0, s32 id=-1) _IRR_OVERRIDE_;\r
-\r
- //! Adds a text scene node, which is able to display\r
- //! 2d text at a position in three dimensional space\r
- virtual ITextSceneNode* addTextSceneNode(gui::IGUIFont* font, const wchar_t* text,\r
- video::SColor color=video::SColor(100,255,255,255),\r
- ISceneNode* parent = 0, const core::vector3df& position = core::vector3df(0,0,0),\r
- s32 id=-1) _IRR_OVERRIDE_;\r
-\r
- //! Adds a text scene node, which uses billboards\r
- virtual IBillboardTextSceneNode* addBillboardTextSceneNode(gui::IGUIFont* font, const wchar_t* text,\r
- 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 colorTop = 0xFFFFFFFF, video::SColor colorBottom = 0xFFFFFFFF) _IRR_OVERRIDE_;\r
-\r
- //! Adds a scene node, which can render a quake3 shader\r
- virtual IMeshSceneNode* addQuake3SceneNode(const IMeshBuffer* meshBuffer, const quake3::IShader * shader,\r
- ISceneNode* parent=0, s32 id=-1) _IRR_OVERRIDE_;\r
-\r
-\r
- //! Adds a Hill Plane mesh to the mesh pool. The mesh is\r
- //! generated on the fly and looks like a plane with some hills\r
- //! on it. You can specify how many hills should be on the plane\r
- //! and how high they should be. Also you must specify a name\r
- //! for the mesh because the mesh is added to the mesh pool and\r
- //! can be retrieved back using ISceneManager::getMesh with the\r
- //! name as parameter.\r
- virtual IAnimatedMesh* addHillPlaneMesh(const io::path& name,\r
- const core::dimension2d<f32>& tileSize, const core::dimension2d<u32>& tileCount,\r
- video::SMaterial* material = 0, f32 hillHeight = 0.0f,\r
- const core::dimension2d<f32>& countHills = core::dimension2d<f32>(1.0f, 1.0f),\r
- const core::dimension2d<f32>& textureRepeatCount = core::dimension2d<f32>(1.0f, 1.0f)) _IRR_OVERRIDE_;\r
-\r
- //! Adds a terrain mesh to the mesh pool.\r
- virtual IAnimatedMesh* addTerrainMesh(const io::path& meshname, video::IImage* texture, video::IImage* heightmap,\r
- const core::dimension2d<f32>& stretchSize = core::dimension2d<f32>(10.0f,10.0f),\r
- f32 maxHeight=200.0f,\r
- const core::dimension2d<u32>& defaultVertexBlockSize = core::dimension2d<u32>(64,64)) _IRR_OVERRIDE_;\r
-\r
- //! Add a arrow mesh to the mesh pool\r
- virtual IAnimatedMesh* addArrowMesh(const io::path& name,\r
- video::SColor vtxColor0, video::SColor vtxColor1,\r
- u32 tesselationCylinder, u32 tesselationCone,\r
- f32 height, f32 cylinderHeight, f32 width0,\r
- f32 width1) _IRR_OVERRIDE_;\r
-\r
- //! Adds a static sphere mesh to the mesh pool.\r
- virtual IAnimatedMesh* addSphereMesh(const io::path& name,\r
- f32 radius=5.f, u32 polyCountX=16, u32 polyCountY=16) _IRR_OVERRIDE_;\r
-\r
- //! Adds a static volume light mesh to the mesh pool.\r
- virtual IAnimatedMesh* addVolumeLightMesh(const io::path& name,\r
- const u32 SubdivideU = 32, const u32 SubdivideV = 32,\r
- const video::SColor FootColor = video::SColor(51, 0, 230, 180),\r
- const video::SColor TailColor = video::SColor(0, 0, 0, 0)) _IRR_OVERRIDE_;\r
-\r
- //! Adds a particle system scene node.\r
- virtual IParticleSystemSceneNode* addParticleSystemSceneNode(\r
- bool withDefaultEmitter=true, 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)) _IRR_OVERRIDE_;\r
-\r
- //! Adds a terrain scene node to the scene graph.\r
- virtual ITerrainSceneNode* addTerrainSceneNode(\r
- const io::path& heightMapFileName,\r
- ISceneNode* parent=0, s32 id=-1,\r
- const core::vector3df& position = core::vector3df(0.0f,0.0f,0.0f),\r
- const core::vector3df& rotation = core::vector3df(0.0f,0.0f,0.0f),\r
- const core::vector3df& scale = core::vector3df(1.0f,1.0f,1.0f),\r
- video::SColor vertexColor = video::SColor(255,255,255,255),\r
- s32 maxLOD=4, E_TERRAIN_PATCH_SIZE patchSize=ETPS_17,s32 smoothFactor=0,\r
- bool addAlsoIfHeightmapEmpty = false) _IRR_OVERRIDE_;\r
-\r
- //! Adds a terrain scene node to the scene graph.\r
- virtual ITerrainSceneNode* addTerrainSceneNode(\r
- io::IReadFile* heightMap,\r
- ISceneNode* parent=0, s32 id=-1,\r
- const core::vector3df& position = core::vector3df(0.0f,0.0f,0.0f),\r
- const core::vector3df& rotation = core::vector3df(0.0f,0.0f,0.0f),\r
- const core::vector3df& scale = core::vector3df(1.0f,1.0f,1.0f),\r
- video::SColor vertexColor = video::SColor(255,255,255,255),\r
- s32 maxLOD=4, E_TERRAIN_PATCH_SIZE patchSize=ETPS_17,s32 smoothFactor=0,\r
- bool addAlsoIfHeightmapEmpty=false) _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
-\r
- //! creates a rotation animator, which rotates the attached scene node around itself.\r
- //! \param rotationPerSecond: Specifies the speed of the animation\r
- //! \return The animator. Attach it to a scene node with ISceneNode::addAnimator()\r
- //! and the animator will animate it.\r
- virtual ISceneNodeAnimator* createRotationAnimator(const core::vector3df& rotationPerSecond) _IRR_OVERRIDE_;\r
-\r
- //! creates a fly circle animator\r
- /** Lets the attached scene node fly around a center.\r
- \param center Center relative to node origin\r
- \param speed: The orbital speed, in radians per millisecond.\r
- \param direction: Specifies the upvector used for alignment of the mesh.\r
- \param startPosition: The position on the circle where the animator will\r
- begin. Value is in multiples of a circle, i.e. 0.5 is half way around.\r
- \return The animator. Attach it to a scene node with ISceneNode::addAnimator()\r
- */\r
- virtual ISceneNodeAnimator* createFlyCircleAnimator(\r
- const core::vector3df& center=core::vector3df(0.f, 0.f, 0.f),\r
- f32 radius=100.f, f32 speed=0.001f,\r
- const core::vector3df& direction=core::vector3df(0.f, 1.f, 0.f),\r
- f32 startPosition = 0.f,\r
- f32 radiusEllipsoid = 0.f) _IRR_OVERRIDE_;\r
-\r
- //! Creates a fly straight animator, which lets the attached scene node\r
- //! fly or move along a line between two points.\r
- virtual ISceneNodeAnimator* createFlyStraightAnimator(const core::vector3df& startPoint,\r
- const core::vector3df& endPoint, u32 timeForWay, bool loop=false,bool pingpong = false) _IRR_OVERRIDE_;\r
-\r
- //! Creates a texture animator, which switches the textures of the target scene\r
- //! node based on a list of textures.\r
- virtual ISceneNodeAnimator* createTextureAnimator(const core::array<video::ITexture*>& textures,\r
- s32 timePerFrame, bool loop) _IRR_OVERRIDE_;\r
-\r
- //! Creates a scene node animator, which deletes the scene node after\r
- //! some time automatically.\r
- virtual ISceneNodeAnimator* createDeleteAnimator(u32 timeMS) _IRR_OVERRIDE_;\r
-\r
-\r
- //! Creates a special scene node animator for doing automatic collision detection\r
- //! and response.\r
- virtual ISceneNodeAnimatorCollisionResponse* createCollisionResponseAnimator(\r
- ITriangleSelector* world, ISceneNode* sceneNode,\r
- const core::vector3df& ellipsoidRadius = core::vector3df(30,60,30),\r
- const core::vector3df& gravityPerSecond = core::vector3df(0,-1.0f,0),\r
- const core::vector3df& ellipsoidTranslation = core::vector3df(0,0,0),\r
- f32 slidingValue = 0.0005f) _IRR_OVERRIDE_;\r
-\r
- //! Creates a follow spline animator.\r
- virtual ISceneNodeAnimator* createFollowSplineAnimator(s32 startTime,\r
- const core::array< core::vector3df >& points,\r
- f32 speed, f32 tightness, bool loop, bool pingpong) _IRR_OVERRIDE_;\r
-\r
-\r
- //! Creates a simple ITriangleSelector, based on a mesh.\r
- virtual ITriangleSelector* createTriangleSelector(IMesh* mesh, ISceneNode* node, bool separateMeshbuffers) _IRR_OVERRIDE_;\r
-\r
- //! Creates a simple ITriangleSelector, based on a meshbuffer.\r
- virtual ITriangleSelector* createTriangleSelector(const IMeshBuffer* meshBuffer, irr::u32 materialIndex, ISceneNode* node) _IRR_OVERRIDE_;\r
-\r
- //! Creates a simple ITriangleSelector, based on an animated mesh scene node.\r
- //! Details of the mesh associated with the node will be extracted internally.\r
- //! Call ITriangleSelector::update() to have the triangle selector updated based\r
- //! on the current frame of the animated mesh scene node.\r
- //! \param: The animated mesh scene node from which to build the selector\r
- virtual ITriangleSelector* createTriangleSelector(IAnimatedMeshSceneNode* node, bool separateMeshbuffers) _IRR_OVERRIDE_;\r
-\r
- //! Creates a simple ITriangleSelector, based on a mesh.\r
- virtual ITriangleSelector* createOctreeTriangleSelector(IMesh* mesh,\r
- ISceneNode* node, s32 minimalPolysPerNode) _IRR_OVERRIDE_;\r
-\r
- //! Creates a simple ITriangleSelector, based on a meshbuffer.\r
- virtual ITriangleSelector* createOctreeTriangleSelector(IMeshBuffer* meshBuffer, irr::u32 materialIndex,\r
- ISceneNode* node, s32 minimalPolysPerNode=32) _IRR_OVERRIDE_;\r
-\r
- //! Creates a simple dynamic ITriangleSelector, based on a axis aligned bounding box.\r
- virtual ITriangleSelector* createTriangleSelectorFromBoundingBox(\r
- ISceneNode* node) _IRR_OVERRIDE_;\r
-\r
- //! Creates a meta triangle selector.\r
- virtual IMetaTriangleSelector* createMetaTriangleSelector() _IRR_OVERRIDE_;\r
-\r
- //! Creates a triangle selector which can select triangles from a terrain scene node\r
- //! \param: Pointer to the created terrain scene node\r
- //! \param: Level of detail, 0 for highest detail.\r
- virtual ITriangleSelector* createTerrainTriangleSelector(\r
- ITerrainSceneNode* node, s32 LOD=0) _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
-\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
+ IMeshLoader* getMeshLoader(u32 index) const override;\r
\r
//! Returns a pointer to the scene collision manager.\r
- virtual ISceneCollisionManager* getSceneCollisionManager() _IRR_OVERRIDE_;\r
+ ISceneCollisionManager* getSceneCollisionManager() override;\r
\r
//! Returns a pointer to the mesh manipulator.\r
- virtual IMeshManipulator* getMeshManipulator() _IRR_OVERRIDE_;\r
-\r
- //! Sets the color of stencil buffers shadows drawn by the scene manager.\r
- virtual void setShadowColor(video::SColor color) _IRR_OVERRIDE_;\r
-\r
- //! Returns the current color of shadows.\r
- virtual video::SColor getShadowColor() const _IRR_OVERRIDE_;\r
-\r
- //! Create a shadow volume scene node to be used with custom nodes\r
- virtual IShadowVolumeSceneNode* createShadowVolumeSceneNode(const IMesh* shadowMesh, ISceneNode* parent, s32 id, bool zfailmethod, f32 infinity) _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
- //! Returns a typename from a scene node animator type or null if not found\r
- virtual const c8* getAnimatorTypeName(ESCENE_NODE_ANIMATOR_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
- //! creates a scene node animator based on its type name\r
- virtual ISceneNodeAnimator* createSceneNodeAnimator(const char* typeName, ISceneNode* target=0) _IRR_OVERRIDE_;\r
-\r
- //! Returns the default scene node animator factory which can create all built-in scene node animators\r
- virtual ISceneNodeAnimatorFactory* getDefaultSceneNodeAnimatorFactory() _IRR_OVERRIDE_;\r
-\r
- //! Adds a scene node animator factory to the scene manager.\r
- virtual void registerSceneNodeAnimatorFactory(ISceneNodeAnimatorFactory* factoryToAdd) _IRR_OVERRIDE_;\r
-\r
- //! Returns amount of registered scene node animator factories.\r
- virtual u32 getRegisteredSceneNodeAnimatorFactoryCount() const _IRR_OVERRIDE_;\r
-\r
- //! Returns a scene node animator factory by index\r
- virtual ISceneNodeAnimatorFactory* getSceneNodeAnimatorFactory(u32 index) _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
- //! Saves the current scene into a file.\r
- virtual bool saveScene(io::IXMLWriter* writer, const io::path& currentPath, 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
-\r
- //! Register a custom callbacks manager which gets callbacks during scene rendering.\r
- virtual void setLightManager(ILightManager* lightManager) _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
-\r
- //! Get an instance of a geometry creator.\r
- virtual const IGeometryCreator* getGeometryCreator(void) const _IRR_OVERRIDE_ { return GeometryCreator; }\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
//! clears the deletion list\r
void clearDeletionList();\r
\r
- //! writes a scene node\r
- void writeSceneNode(io::IXMLWriter* writer, ISceneNode* node, ISceneUserDataSerializer* userDataSerializer, const fschar_t* currentPath=0, bool init=false);\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
\r
//! render pass lists\r
core::array<ISceneNode*> CameraList;\r
- core::array<ISceneNode*> LightList;\r
- core::array<ISceneNode*> ShadowNodeList;\r
core::array<ISceneNode*> SkyBoxList;\r
core::array<DefaultNodeEntry> SolidNodeList;\r
core::array<TransparentNodeEntry> TransparentNodeList;\r
core::array<TransparentNodeEntry> TransparentEffectNodeList;\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
- core::array<ISceneNodeAnimatorFactory*> SceneNodeAnimatorFactoryList;\r
\r
//! current active camera\r
ICameraSceneNode* ActiveCamera;\r
IMeshCache* MeshCache;\r
\r
E_SCENE_NODE_RENDER_PASS CurrentRenderPass;\r
-\r
- //! An optional callbacks manager to allow the user app finer control\r
- //! over the scene lighting and rendering.\r
- ILightManager* LightManager;\r
-\r
- //! constants for reading and writing XML.\r
- //! Not made static due to portability problems.\r
- const core::stringw IRR_XML_FORMAT_SCENE;\r
- const core::stringw IRR_XML_FORMAT_NODE;\r
- const core::stringw IRR_XML_FORMAT_NODE_ATTR_TYPE;\r
-\r
- IGeometryCreator* GeometryCreator;\r
};\r
\r
} // end namespace video\r
projects / irrlicht.git / blobdiff