minetest/irrlicht
1
0
Fork 0
mirror of https://github.com/minetest/irrlicht.git synced 2025-06-30 23:30:27 +02:00
Code Issues Projects Releases Wiki Activity

API BREAKER: Replacing defines in irrTypes.h which are conflicting with c++ reserved identifier rules.

Browse Source 
C++ has undefined behavior for identifiers starting with __ or with _ followed by an uppercase letter.
We still have many more (in IrrCompileConfig.h and in all header-guards), will likely replace those later as well.
As a workaround for users which might use irrlicht defines in their code, I've added the header irrLegacyDefines.h
Including that allows to continue using old defines for a while - or make it easier to have code which compiles 
with old and new Irrlicht library versions.


git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6251 dfc29bdd-3216-0410-991c-e03cc46cb475
This commit is contained in:
cutealien
2021-08-27 12:55:10 +00:00
parent ee180dbd24
commit ffd7b63af0
289 changed files with 3401 additions and 3379 deletions
Download Patch File Download Diff File Expand all files Collapse all files

216
source/Irrlicht/CSceneManager.h
View File

@ -41,22 +41,22 @@ namespace scene
virtual ~CSceneManager();
//! gets an animateable mesh. loads it if needed. returned pointer must not be dropped.
virtual IAnimatedMesh* getMesh(const io::path& filename, const io::path& alternativeCacheName) _IRR_OVERRIDE_;
virtual IAnimatedMesh* getMesh(const io::path& filename, const io::path& alternativeCacheName) IRR_OVERRIDE;
//! gets an animateable mesh. loads it if needed. returned pointer must not be dropped.
virtual IAnimatedMesh* getMesh(io::IReadFile* file) _IRR_OVERRIDE_;
virtual IAnimatedMesh* getMesh(io::IReadFile* file) IRR_OVERRIDE;
//! Returns an interface to the mesh cache which is shared between all existing scene managers.
virtual IMeshCache* getMeshCache() _IRR_OVERRIDE_;
virtual IMeshCache* getMeshCache() IRR_OVERRIDE;
//! returns the video driver
virtual video::IVideoDriver* getVideoDriver() _IRR_OVERRIDE_;
virtual video::IVideoDriver* getVideoDriver() IRR_OVERRIDE;
//! return the gui environment
virtual gui::IGUIEnvironment* getGUIEnvironment() _IRR_OVERRIDE_;
virtual gui::IGUIEnvironment* getGUIEnvironment() IRR_OVERRIDE;
//! return the filesystem
virtual io::IFileSystem* getFileSystem() _IRR_OVERRIDE_;
virtual io::IFileSystem* getFileSystem() IRR_OVERRIDE;
//! adds Volume Lighting Scene Node.
//! the returned pointer must not be dropped.
@ -66,27 +66,27 @@ namespace scene
const video::SColor tail = video::SColor(0, 0, 0, 0),
const core::vector3df& position = core::vector3df(0,0,0),
const core::vector3df& rotation = core::vector3df(0,0,0),
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f)) _IRR_OVERRIDE_;
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f)) IRR_OVERRIDE;
//! adds a cube scene node to the scene. It is a simple cube of (1,1,1) size.
//! the returned pointer must not be dropped.
virtual IMeshSceneNode* addCubeSceneNode(f32 size=10.0f, ISceneNode* parent=0, s32 id=-1,
const core::vector3df& position = core::vector3df(0,0,0),
const core::vector3df& rotation = core::vector3df(0,0,0),
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f)) _IRR_OVERRIDE_;
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f)) IRR_OVERRIDE;
//! Adds a sphere scene node to the scene.
virtual IMeshSceneNode* addSphereSceneNode(f32 radius=5.0f, s32 polyCount=16, ISceneNode* parent=0, s32 id=-1,
const core::vector3df& position = core::vector3df(0,0,0),
const core::vector3df& rotation = core::vector3df(0,0,0),
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f)) _IRR_OVERRIDE_;
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f)) IRR_OVERRIDE;
//! adds a scene node for rendering an animated mesh model
virtual IAnimatedMeshSceneNode* addAnimatedMeshSceneNode(IAnimatedMesh* mesh, ISceneNode* parent=0, s32 id=-1,
const core::vector3df& position = core::vector3df(0,0,0),
const core::vector3df& rotation = core::vector3df(0,0,0),
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f),
bool alsoAddIfMeshPointerZero=false) _IRR_OVERRIDE_;
bool alsoAddIfMeshPointerZero=false) IRR_OVERRIDE;
//! adds a scene node for rendering a static mesh
//! the returned pointer must not be dropped.
@ -94,40 +94,40 @@ namespace scene
const core::vector3df& position = core::vector3df(0,0,0),
const core::vector3df& rotation = core::vector3df(0,0,0),
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f),
bool alsoAddIfMeshPointerZero=false) _IRR_OVERRIDE_;
bool alsoAddIfMeshPointerZero=false) IRR_OVERRIDE;
//! Adds a scene node for rendering a animated water surface mesh.
virtual ISceneNode* addWaterSurfaceSceneNode(IMesh* mesh, f32 waveHeight, f32 waveSpeed, f32 wlength, ISceneNode* parent=0, s32 id=-1,
const core::vector3df& position = core::vector3df(0,0,0),
const core::vector3df& rotation = core::vector3df(0,0,0),
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f)) _IRR_OVERRIDE_;
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f)) IRR_OVERRIDE;
//! renders the node.
virtual void render() _IRR_OVERRIDE_;
virtual void render() IRR_OVERRIDE;
//! returns the axis aligned bounding box of this node
virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_OVERRIDE_;
virtual const core::aabbox3d<f32>& getBoundingBox() const IRR_OVERRIDE;
//! registers a node for rendering it at a specific time.
virtual u32 registerNodeForRendering(ISceneNode* node, E_SCENE_NODE_RENDER_PASS pass = ESNRP_AUTOMATIC) _IRR_OVERRIDE_;
virtual u32 registerNodeForRendering(ISceneNode* node, E_SCENE_NODE_RENDER_PASS pass = ESNRP_AUTOMATIC) IRR_OVERRIDE;
//! Clear all nodes which are currently registered for rendering
virtual void clearAllRegisteredNodesForRendering() _IRR_OVERRIDE_;
virtual void clearAllRegisteredNodesForRendering() IRR_OVERRIDE;
//! draws all scene nodes
virtual void drawAll() _IRR_OVERRIDE_;
virtual void drawAll() IRR_OVERRIDE;
//! Adds a scene node for rendering using a octree to the scene graph. This a good method for rendering
//! scenes with lots of geometry. The Octree is built on the fly from the mesh, much
//! faster then a bsp tree.
virtual IOctreeSceneNode* addOctreeSceneNode(IAnimatedMesh* mesh, ISceneNode* parent=0,
s32 id=-1, s32 minimalPolysPerNode=512, bool alsoAddIfMeshPointerZero=false) _IRR_OVERRIDE_;
s32 id=-1, s32 minimalPolysPerNode=512, bool alsoAddIfMeshPointerZero=false) IRR_OVERRIDE;
//! Adss a scene node for rendering using a octree. This a good method for rendering
//! scenes with lots of geometry. The Octree is built on the fly from the mesh, much
//! faster then a bsp tree.
virtual IOctreeSceneNode* addOctreeSceneNode(IMesh* mesh, ISceneNode* parent=0,
s32 id=-1, s32 minimalPolysPerNode=128, bool alsoAddIfMeshPointerZero=false) _IRR_OVERRIDE_;
s32 id=-1, s32 minimalPolysPerNode=128, bool alsoAddIfMeshPointerZero=false) IRR_OVERRIDE;
//! Adds a camera scene node to the tree and sets it as active camera.
//! \param position: Position of the space relative to its parent where the camera will be placed.
@ -138,7 +138,7 @@ namespace scene
virtual ICameraSceneNode* addCameraSceneNode(ISceneNode* parent = 0,
const core::vector3df& position = core::vector3df(0,0,0),
const core::vector3df& lookat = core::vector3df(0,0,100),
s32 id=-1, bool makeActive=true) _IRR_OVERRIDE_;
s32 id=-1, bool makeActive=true) IRR_OVERRIDE;
//! Adds a camera scene node which is able to be controlle with the mouse similar
//! like in the 3D Software Maya by Alias Wavefront.
@ -146,7 +146,7 @@ namespace scene
virtual ICameraSceneNode* addCameraSceneNodeMaya(ISceneNode* parent=0,
f32 rotateSpeed=-1500.f, f32 zoomSpeed=200.f,
f32 translationSpeed=1500.f, s32 id=-1, f32 distance=70.f,
bool makeActive=true) _IRR_OVERRIDE_;
bool makeActive=true) IRR_OVERRIDE;
//! Adds a camera scene node which is able to be controled with the mouse and keys
//! like in most first person shooters (FPS):
@ -154,7 +154,7 @@ namespace scene
f32 rotateSpeed = 100.0f, f32 moveSpeed = .5f, s32 id=-1,
SKeyMap* keyMapArray=0, s32 keyMapSize=0,
bool noVerticalMovement=false, f32 jumpSpeed = 0.f,
bool invertMouseY=false, bool makeActive=true) _IRR_OVERRIDE_;
bool invertMouseY=false, bool makeActive=true) IRR_OVERRIDE;
//! Adds a dynamic light scene node. The light will cast dynamic light on all
//! other scene nodes in the scene, which have the material flag video::MTF_LIGHTING
@ -162,7 +162,7 @@ namespace scene
virtual ILightSceneNode* addLightSceneNode(ISceneNode* parent = 0,
const core::vector3df& position = core::vector3df(0,0,0),
video::SColorf color = video::SColorf(1.0f, 1.0f, 1.0f),
f32 range=100.0f, s32 id=-1) _IRR_OVERRIDE_;
f32 range=100.0f, s32 id=-1) IRR_OVERRIDE;
//! Adds a billboard scene node to the scene. A billboard is like a 3d sprite: A 2d element,
//! which always looks to the camera. It is usually used for things like explosions, fire,
@ -170,38 +170,38 @@ namespace scene
virtual IBillboardSceneNode* addBillboardSceneNode(ISceneNode* parent = 0,
const core::dimension2d<f32>& size = core::dimension2d<f32>(10.0f, 10.0f),
const core::vector3df& position = core::vector3df(0,0,0), s32 id=-1,
video::SColor shadeTop = 0xFFFFFFFF, video::SColor shadeBottom = 0xFFFFFFFF) _IRR_OVERRIDE_;
video::SColor shadeTop = 0xFFFFFFFF, video::SColor shadeBottom = 0xFFFFFFFF) IRR_OVERRIDE;
//! Adds a skybox scene node. A skybox is a big cube with 6 textures on it and
//! is drawn around the camera position.
virtual ISceneNode* addSkyBoxSceneNode(video::ITexture* top, video::ITexture* bottom,
video::ITexture* left, video::ITexture* right, video::ITexture* front,
video::ITexture* back, ISceneNode* parent = 0, s32 id=-1) _IRR_OVERRIDE_;
video::ITexture* back, ISceneNode* parent = 0, s32 id=-1) IRR_OVERRIDE;
//! Adds a skydome scene node. A skydome is a large (half-) sphere with a
//! panoramic texture on it and is drawn around the camera position.
virtual ISceneNode* addSkyDomeSceneNode(video::ITexture* texture,
u32 horiRes=16, u32 vertRes=8,
f32 texturePercentage=0.9, f32 spherePercentage=2.0,f32 radius = 1000.f,
ISceneNode* parent=0, s32 id=-1) _IRR_OVERRIDE_;
ISceneNode* parent=0, s32 id=-1) IRR_OVERRIDE;
//! Adds a text scene node, which is able to display
//! 2d text at a position in three dimensional space
virtual ITextSceneNode* addTextSceneNode(gui::IGUIFont* font, const wchar_t* text,
video::SColor color=video::SColor(100,255,255,255),
ISceneNode* parent = 0, const core::vector3df& position = core::vector3df(0,0,0),
s32 id=-1) _IRR_OVERRIDE_;
s32 id=-1) IRR_OVERRIDE;
//! Adds a text scene node, which uses billboards
virtual IBillboardTextSceneNode* addBillboardTextSceneNode(gui::IGUIFont* font, const wchar_t* text,
ISceneNode* parent = 0,
const core::dimension2d<f32>& size = core::dimension2d<f32>(10.0f, 10.0f),
const core::vector3df& position = core::vector3df(0,0,0), s32 id=-1,
video::SColor colorTop = 0xFFFFFFFF, video::SColor colorBottom = 0xFFFFFFFF) _IRR_OVERRIDE_;
video::SColor colorTop = 0xFFFFFFFF, video::SColor colorBottom = 0xFFFFFFFF) IRR_OVERRIDE;
//! Adds a scene node, which can render a quake3 shader
virtual IMeshSceneNode* addQuake3SceneNode(const IMeshBuffer* meshBuffer, const quake3::IShader * shader,
ISceneNode* parent=0, s32 id=-1) _IRR_OVERRIDE_;
ISceneNode* parent=0, s32 id=-1) IRR_OVERRIDE;
//! Adds a Hill Plane mesh to the mesh pool. The mesh is
@ -215,37 +215,37 @@ namespace scene
const core::dimension2d<f32>& tileSize, const core::dimension2d<u32>& tileCount,
video::SMaterial* material = 0, f32 hillHeight = 0.0f,
const core::dimension2d<f32>& countHills = core::dimension2d<f32>(1.0f, 1.0f),
const core::dimension2d<f32>& textureRepeatCount = core::dimension2d<f32>(1.0f, 1.0f)) _IRR_OVERRIDE_;
const core::dimension2d<f32>& textureRepeatCount = core::dimension2d<f32>(1.0f, 1.0f)) IRR_OVERRIDE;
//! Adds a terrain mesh to the mesh pool.
virtual IAnimatedMesh* addTerrainMesh(const io::path& meshname, video::IImage* texture, video::IImage* heightmap,
const core::dimension2d<f32>& stretchSize = core::dimension2d<f32>(10.0f,10.0f),
f32 maxHeight=200.0f,
const core::dimension2d<u32>& defaultVertexBlockSize = core::dimension2d<u32>(64,64)) _IRR_OVERRIDE_;
const core::dimension2d<u32>& defaultVertexBlockSize = core::dimension2d<u32>(64,64)) IRR_OVERRIDE;
//! Add a arrow mesh to the mesh pool
virtual IAnimatedMesh* addArrowMesh(const io::path& name,
video::SColor vtxColor0, video::SColor vtxColor1,
u32 tesselationCylinder, u32 tesselationCone,
f32 height, f32 cylinderHeight, f32 width0,
f32 width1) _IRR_OVERRIDE_;
f32 width1) IRR_OVERRIDE;
//! Adds a static sphere mesh to the mesh pool.
virtual IAnimatedMesh* addSphereMesh(const io::path& name,
f32 radius=5.f, u32 polyCountX=16, u32 polyCountY=16) _IRR_OVERRIDE_;
f32 radius=5.f, u32 polyCountX=16, u32 polyCountY=16) IRR_OVERRIDE;
//! Adds a static volume light mesh to the mesh pool.
virtual IAnimatedMesh* addVolumeLightMesh(const io::path& name,
const u32 SubdivideU = 32, const u32 SubdivideV = 32,
const video::SColor FootColor = video::SColor(51, 0, 230, 180),
const video::SColor TailColor = video::SColor(0, 0, 0, 0)) _IRR_OVERRIDE_;
const video::SColor TailColor = video::SColor(0, 0, 0, 0)) IRR_OVERRIDE;
//! Adds a particle system scene node.
virtual IParticleSystemSceneNode* addParticleSystemSceneNode(
bool withDefaultEmitter=true, ISceneNode* parent=0, s32 id=-1,
const core::vector3df& position = core::vector3df(0,0,0),
const core::vector3df& rotation = core::vector3df(0,0,0),
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f)) _IRR_OVERRIDE_;
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f)) IRR_OVERRIDE;
//! Adds a terrain scene node to the scene graph.
virtual ITerrainSceneNode* addTerrainSceneNode(
@ -256,7 +256,7 @@ namespace scene
const core::vector3df& scale = core::vector3df(1.0f,1.0f,1.0f),
video::SColor vertexColor = video::SColor(255,255,255,255),
s32 maxLOD=4, E_TERRAIN_PATCH_SIZE patchSize=ETPS_17,s32 smoothFactor=0,
bool addAlsoIfHeightmapEmpty = false) _IRR_OVERRIDE_;
bool addAlsoIfHeightmapEmpty = false) IRR_OVERRIDE;
//! Adds a terrain scene node to the scene graph.
virtual ITerrainSceneNode* addTerrainSceneNode(
@ -267,36 +267,36 @@ namespace scene
const core::vector3df& scale = core::vector3df(1.0f,1.0f,1.0f),
video::SColor vertexColor = video::SColor(255,255,255,255),
s32 maxLOD=4, E_TERRAIN_PATCH_SIZE patchSize=ETPS_17,s32 smoothFactor=0,
bool addAlsoIfHeightmapEmpty=false) _IRR_OVERRIDE_;
bool addAlsoIfHeightmapEmpty=false) IRR_OVERRIDE;
//! Adds a dummy transformation scene node to the scene graph.
virtual IDummyTransformationSceneNode* addDummyTransformationSceneNode(
ISceneNode* parent=0, s32 id=-1) _IRR_OVERRIDE_;
ISceneNode* parent=0, s32 id=-1) IRR_OVERRIDE;
//! Adds an empty scene node.
virtual ISceneNode* addEmptySceneNode(ISceneNode* parent, s32 id=-1) _IRR_OVERRIDE_;
virtual ISceneNode* addEmptySceneNode(ISceneNode* parent, s32 id=-1) IRR_OVERRIDE;
//! Returns the root scene node. This is the scene node which is parent
//! of all scene nodes. The root scene node is a special scene node which
//! only exists to manage all scene nodes. It is not rendered and cannot
//! be removed from the scene.
//! \return Pointer to the root scene node.
virtual ISceneNode* getRootSceneNode() _IRR_OVERRIDE_;
virtual ISceneNode* getRootSceneNode() IRR_OVERRIDE;
//! Returns the current active camera.
//! \return The active camera is returned. Note that this can be NULL, if there
//! was no camera created yet.
virtual ICameraSceneNode* getActiveCamera() const _IRR_OVERRIDE_;
virtual ICameraSceneNode* getActiveCamera() const IRR_OVERRIDE;
//! Sets the active camera. The previous active camera will be deactivated.
//! \param camera: The new camera which should be active.
virtual void setActiveCamera(ICameraSceneNode* camera) _IRR_OVERRIDE_;
virtual void setActiveCamera(ICameraSceneNode* camera) IRR_OVERRIDE;
//! creates a rotation animator, which rotates the attached scene node around itself.
//! \param rotationPerSecond: Specifies the speed of the animation
//! \return The animator. Attach it to a scene node with ISceneNode::addAnimator()
//! and the animator will animate it.
virtual ISceneNodeAnimator* createRotationAnimator(const core::vector3df& rotationPerSecond) _IRR_OVERRIDE_;
virtual ISceneNodeAnimator* createRotationAnimator(const core::vector3df& rotationPerSecond) IRR_OVERRIDE;
//! creates a fly circle animator
/** Lets the attached scene node fly around a center.
@ -312,21 +312,21 @@ namespace scene
f32 radius=100.f, f32 speed=0.001f,
const core::vector3df& direction=core::vector3df(0.f, 1.f, 0.f),
f32 startPosition = 0.f,
f32 radiusEllipsoid = 0.f) _IRR_OVERRIDE_;
f32 radiusEllipsoid = 0.f) IRR_OVERRIDE;
//! Creates a fly straight animator, which lets the attached scene node
//! fly or move along a line between two points.
virtual ISceneNodeAnimator* createFlyStraightAnimator(const core::vector3df& startPoint,
const core::vector3df& endPoint, u32 timeForWay, bool loop=false,bool pingpong = false) _IRR_OVERRIDE_;
const core::vector3df& endPoint, u32 timeForWay, bool loop=false,bool pingpong = false) IRR_OVERRIDE;
//! Creates a texture animator, which switches the textures of the target scene
//! node based on a list of textures.
virtual ISceneNodeAnimator* createTextureAnimator(const core::array<video::ITexture*>& textures,
s32 timePerFrame, bool loop) _IRR_OVERRIDE_;
s32 timePerFrame, bool loop) IRR_OVERRIDE;
//! Creates a scene node animator, which deletes the scene node after
//! some time automatically.
virtual ISceneNodeAnimator* createDeleteAnimator(u32 timeMS) _IRR_OVERRIDE_;
virtual ISceneNodeAnimator* createDeleteAnimator(u32 timeMS) IRR_OVERRIDE;
//! Creates a special scene node animator for doing automatic collision detection
@ -336,203 +336,203 @@ namespace scene
const core::vector3df& ellipsoidRadius = core::vector3df(30,60,30),
const core::vector3df& gravityPerSecond = core::vector3df(0,-1.0f,0),
const core::vector3df& ellipsoidTranslation = core::vector3df(0,0,0),
f32 slidingValue = 0.0005f) _IRR_OVERRIDE_;
f32 slidingValue = 0.0005f) IRR_OVERRIDE;
//! Creates a follow spline animator.
virtual ISceneNodeAnimator* createFollowSplineAnimator(s32 startTime,
const core::array< core::vector3df >& points,
f32 speed, f32 tightness, bool loop, bool pingpong, bool steer) _IRR_OVERRIDE_;
f32 speed, f32 tightness, bool loop, bool pingpong, bool steer) IRR_OVERRIDE;
//! Creates a simple ITriangleSelector, based on a mesh.
virtual ITriangleSelector* createTriangleSelector(IMesh* mesh, ISceneNode* node, bool separateMeshbuffers) _IRR_OVERRIDE_;
virtual ITriangleSelector* createTriangleSelector(IMesh* mesh, ISceneNode* node, bool separateMeshbuffers) IRR_OVERRIDE;
//! Creates a simple ITriangleSelector, based on a meshbuffer.
virtual ITriangleSelector* createTriangleSelector(const IMeshBuffer* meshBuffer, irr::u32 materialIndex, ISceneNode* node) _IRR_OVERRIDE_;
virtual ITriangleSelector* createTriangleSelector(const IMeshBuffer* meshBuffer, irr::u32 materialIndex, ISceneNode* node) IRR_OVERRIDE;
//! Creates a simple ITriangleSelector, based on an animated mesh scene node.
//! Details of the mesh associated with the node will be extracted internally.
//! Call ITriangleSelector::update() to have the triangle selector updated based
//! on the current frame of the animated mesh scene node.
//! \param: The animated mesh scene node from which to build the selector
virtual ITriangleSelector* createTriangleSelector(IAnimatedMeshSceneNode* node, bool separateMeshbuffers) _IRR_OVERRIDE_;
virtual ITriangleSelector* createTriangleSelector(IAnimatedMeshSceneNode* node, bool separateMeshbuffers) IRR_OVERRIDE;
//! Creates a simple ITriangleSelector, based on a mesh.
virtual ITriangleSelector* createOctreeTriangleSelector(IMesh* mesh,
ISceneNode* node, s32 minimalPolysPerNode) _IRR_OVERRIDE_;
ISceneNode* node, s32 minimalPolysPerNode) IRR_OVERRIDE;
//! Creates a simple ITriangleSelector, based on a meshbuffer.
virtual ITriangleSelector* createOctreeTriangleSelector(IMeshBuffer* meshBuffer, irr::u32 materialIndex,
ISceneNode* node, s32 minimalPolysPerNode=32) _IRR_OVERRIDE_;
ISceneNode* node, s32 minimalPolysPerNode=32) IRR_OVERRIDE;
//! Creates a simple dynamic ITriangleSelector, based on a axis aligned bounding box.
virtual ITriangleSelector* createTriangleSelectorFromBoundingBox(
ISceneNode* node) _IRR_OVERRIDE_;
ISceneNode* node) IRR_OVERRIDE;
//! Creates a meta triangle selector.
virtual IMetaTriangleSelector* createMetaTriangleSelector() _IRR_OVERRIDE_;
virtual IMetaTriangleSelector* createMetaTriangleSelector() IRR_OVERRIDE;
//! Creates a triangle selector which can select triangles from a terrain scene node
//! \param: Pointer to the created terrain scene node
//! \param: Level of detail, 0 for highest detail.
virtual ITriangleSelector* createTerrainTriangleSelector(
ITerrainSceneNode* node, s32 LOD=0) _IRR_OVERRIDE_;
ITerrainSceneNode* node, s32 LOD=0) IRR_OVERRIDE;
//! Adds an external mesh loader.
virtual void addExternalMeshLoader(IMeshLoader* externalLoader) _IRR_OVERRIDE_;
virtual void addExternalMeshLoader(IMeshLoader* externalLoader) IRR_OVERRIDE;
//! Returns the number of mesh loaders supported by Irrlicht at this time
virtual u32 getMeshLoaderCount() const _IRR_OVERRIDE_;
virtual u32 getMeshLoaderCount() const IRR_OVERRIDE;
//! Retrieve the given mesh loader
virtual IMeshLoader* getMeshLoader(u32 index) const _IRR_OVERRIDE_;
virtual IMeshLoader* getMeshLoader(u32 index) const IRR_OVERRIDE;
//! Adds an external scene loader.
virtual void addExternalSceneLoader(ISceneLoader* externalLoader) _IRR_OVERRIDE_;
virtual void addExternalSceneLoader(ISceneLoader* externalLoader) IRR_OVERRIDE;
//! Returns the number of scene loaders supported by Irrlicht at this time
virtual u32 getSceneLoaderCount() const _IRR_OVERRIDE_;
virtual u32 getSceneLoaderCount() const IRR_OVERRIDE;
//! Retrieve the given scene loader
virtual ISceneLoader* getSceneLoader(u32 index) const _IRR_OVERRIDE_;
virtual ISceneLoader* getSceneLoader(u32 index) const IRR_OVERRIDE;
//! Returns a pointer to the scene collision manager.
virtual ISceneCollisionManager* getSceneCollisionManager() _IRR_OVERRIDE_;
virtual ISceneCollisionManager* getSceneCollisionManager() IRR_OVERRIDE;
//! Returns a pointer to the mesh manipulator.
virtual IMeshManipulator* getMeshManipulator() _IRR_OVERRIDE_;
virtual IMeshManipulator* getMeshManipulator() IRR_OVERRIDE;
//! Sets the color of stencil buffers shadows drawn by the scene manager.
virtual void setShadowColor(video::SColor color) _IRR_OVERRIDE_;
virtual void setShadowColor(video::SColor color) IRR_OVERRIDE;
//! Returns the current color of shadows.
virtual video::SColor getShadowColor() const _IRR_OVERRIDE_;
virtual video::SColor getShadowColor() const IRR_OVERRIDE;
//! Create a shadow volume scene node to be used with custom nodes
virtual IShadowVolumeSceneNode* createShadowVolumeSceneNode(const IMesh* shadowMesh, ISceneNode* parent, s32 id, bool zfailmethod, f32 infinity) _IRR_OVERRIDE_;
virtual IShadowVolumeSceneNode* createShadowVolumeSceneNode(const IMesh* shadowMesh, ISceneNode* parent, s32 id, bool zfailmethod, f32 infinity) IRR_OVERRIDE;
//! Adds a scene node to the deletion queue.
virtual void addToDeletionQueue(ISceneNode* node) _IRR_OVERRIDE_;
virtual void addToDeletionQueue(ISceneNode* node) IRR_OVERRIDE;
//! Returns the first scene node with the specified id.
virtual ISceneNode* getSceneNodeFromId(s32 id, ISceneNode* start=0) _IRR_OVERRIDE_;
virtual ISceneNode* getSceneNodeFromId(s32 id, ISceneNode* start=0) IRR_OVERRIDE;
//! Returns the first scene node with the specified name.
virtual ISceneNode* getSceneNodeFromName(const c8* name, ISceneNode* start=0) _IRR_OVERRIDE_;
virtual ISceneNode* getSceneNodeFromName(const c8* name, ISceneNode* start=0) IRR_OVERRIDE;
//! Returns the first scene node with the specified type.
virtual ISceneNode* getSceneNodeFromType(scene::ESCENE_NODE_TYPE type, ISceneNode* start=0) _IRR_OVERRIDE_;
virtual ISceneNode* getSceneNodeFromType(scene::ESCENE_NODE_TYPE type, ISceneNode* start=0) IRR_OVERRIDE;
//! returns scene nodes by type.
virtual void getSceneNodesFromType(ESCENE_NODE_TYPE type, core::array<scene::ISceneNode*>& outNodes, ISceneNode* start=0) _IRR_OVERRIDE_;
virtual void getSceneNodesFromType(ESCENE_NODE_TYPE type, core::array<scene::ISceneNode*>& outNodes, ISceneNode* start=0) IRR_OVERRIDE;
//! Posts an input event to the environment. Usually you do not have to
//! use this method, it is used by the internal engine.
virtual bool postEventFromUser(const SEvent& event) _IRR_OVERRIDE_;
virtual bool postEventFromUser(const SEvent& event) IRR_OVERRIDE;
//! Clears the whole scene. All scene nodes are removed.
virtual void clear() _IRR_OVERRIDE_;
virtual void clear() IRR_OVERRIDE;
//! Removes all children of this scene node
virtual void removeAll() _IRR_OVERRIDE_;
virtual void removeAll() IRR_OVERRIDE;
//! Returns interface to the parameters set in this scene.
virtual io::IAttributes* getParameters() _IRR_OVERRIDE_;
virtual io::IAttributes* getParameters() IRR_OVERRIDE;
//! Returns current render pass.
virtual E_SCENE_NODE_RENDER_PASS getSceneNodeRenderPass() const _IRR_OVERRIDE_;
virtual E_SCENE_NODE_RENDER_PASS getSceneNodeRenderPass() const IRR_OVERRIDE;
//! Creates a new scene manager.
virtual ISceneManager* createNewSceneManager(bool cloneContent) _IRR_OVERRIDE_;
virtual ISceneManager* createNewSceneManager(bool cloneContent) IRR_OVERRIDE;
//! Returns type of the scene node
virtual ESCENE_NODE_TYPE getType() const _IRR_OVERRIDE_ { return ESNT_SCENE_MANAGER; }
virtual ESCENE_NODE_TYPE getType() const IRR_OVERRIDE { return ESNT_SCENE_MANAGER; }
//! Returns the default scene node factory which can create all built in scene nodes
virtual ISceneNodeFactory* getDefaultSceneNodeFactory() _IRR_OVERRIDE_;
virtual ISceneNodeFactory* getDefaultSceneNodeFactory() IRR_OVERRIDE;
//! Adds a scene node factory to the scene manager.
/** Use this to extend the scene manager with new scene node types which it should be
able to create automatically, for example when loading data from xml files. */
virtual void registerSceneNodeFactory(ISceneNodeFactory* factoryToAdd) _IRR_OVERRIDE_;
virtual void registerSceneNodeFactory(ISceneNodeFactory* factoryToAdd) IRR_OVERRIDE;
//! Returns amount of registered scene node factories.
virtual u32 getRegisteredSceneNodeFactoryCount() const _IRR_OVERRIDE_;
virtual u32 getRegisteredSceneNodeFactoryCount() const IRR_OVERRIDE;
//! Returns a scene node factory by index
virtual ISceneNodeFactory* getSceneNodeFactory(u32 index) _IRR_OVERRIDE_;
virtual ISceneNodeFactory* getSceneNodeFactory(u32 index) IRR_OVERRIDE;
//! Returns a typename from a scene node type or null if not found
virtual const c8* getSceneNodeTypeName(ESCENE_NODE_TYPE type) _IRR_OVERRIDE_;
virtual const c8* getSceneNodeTypeName(ESCENE_NODE_TYPE type) IRR_OVERRIDE;
//! Returns a typename from a scene node animator type or null if not found
virtual const c8* getAnimatorTypeName(ESCENE_NODE_ANIMATOR_TYPE type) _IRR_OVERRIDE_;
virtual const c8* getAnimatorTypeName(ESCENE_NODE_ANIMATOR_TYPE type) IRR_OVERRIDE;
//! Adds a scene node to the scene by name
virtual ISceneNode* addSceneNode(const char* sceneNodeTypeName, ISceneNode* parent=0) _IRR_OVERRIDE_;
virtual ISceneNode* addSceneNode(const char* sceneNodeTypeName, ISceneNode* parent=0) IRR_OVERRIDE;
//! creates a scene node animator based on its type name
virtual ISceneNodeAnimator* createSceneNodeAnimator(const char* typeName, ISceneNode* target=0) _IRR_OVERRIDE_;
virtual ISceneNodeAnimator* createSceneNodeAnimator(const char* typeName, ISceneNode* target=0) IRR_OVERRIDE;
//! Returns the default scene node animator factory which can create all built-in scene node animators
virtual ISceneNodeAnimatorFactory* getDefaultSceneNodeAnimatorFactory() _IRR_OVERRIDE_;
virtual ISceneNodeAnimatorFactory* getDefaultSceneNodeAnimatorFactory() IRR_OVERRIDE;
//! Adds a scene node animator factory to the scene manager.
virtual void registerSceneNodeAnimatorFactory(ISceneNodeAnimatorFactory* factoryToAdd) _IRR_OVERRIDE_;
virtual void registerSceneNodeAnimatorFactory(ISceneNodeAnimatorFactory* factoryToAdd) IRR_OVERRIDE;
//! Returns amount of registered scene node animator factories.
virtual u32 getRegisteredSceneNodeAnimatorFactoryCount() const _IRR_OVERRIDE_;
virtual u32 getRegisteredSceneNodeAnimatorFactoryCount() const IRR_OVERRIDE;
//! Returns a scene node animator factory by index
virtual ISceneNodeAnimatorFactory* getSceneNodeAnimatorFactory(u32 index) _IRR_OVERRIDE_;
virtual ISceneNodeAnimatorFactory* getSceneNodeAnimatorFactory(u32 index) IRR_OVERRIDE;
//! Saves the current scene into a file.
virtual bool saveScene(const io::path& filename, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* node=0) _IRR_OVERRIDE_;
virtual bool saveScene(const io::path& filename, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* node=0) IRR_OVERRIDE;
//! Saves the current scene into a file.
virtual bool saveScene(io::IWriteFile* file, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* node=0) _IRR_OVERRIDE_;
virtual bool saveScene(io::IWriteFile* file, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* node=0) IRR_OVERRIDE;
//! Saves the current scene into a file.
virtual bool saveScene(io::IXMLWriter* writer, const io::path& currentPath, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* node=0) _IRR_OVERRIDE_;
virtual bool saveScene(io::IXMLWriter* writer, const io::path& currentPath, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* node=0) IRR_OVERRIDE;
//! Loads a scene. Note that the current scene is not cleared before.
virtual bool loadScene(const io::path& filename, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* rootNode=0) _IRR_OVERRIDE_;
virtual bool loadScene(const io::path& filename, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* rootNode=0) IRR_OVERRIDE;
//! Loads a scene. Note that the current scene is not cleared before.
virtual bool loadScene(io::IReadFile* file, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* rootNode=0) _IRR_OVERRIDE_;
virtual bool loadScene(io::IReadFile* file, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* rootNode=0) IRR_OVERRIDE;
//! Writes attributes of the scene node.
virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const _IRR_OVERRIDE_;
virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const IRR_OVERRIDE;
//! Reads attributes of the scene node.
virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) _IRR_OVERRIDE_;
virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0) IRR_OVERRIDE;
//! Returns a mesh writer implementation if available
virtual IMeshWriter* createMeshWriter(EMESH_WRITER_TYPE type) _IRR_OVERRIDE_;
virtual IMeshWriter* createMeshWriter(EMESH_WRITER_TYPE type) IRR_OVERRIDE;
//! Get a skinned mesh, which is not available as header-only code
virtual ISkinnedMesh* createSkinnedMesh() _IRR_OVERRIDE_;
virtual ISkinnedMesh* createSkinnedMesh() IRR_OVERRIDE;
//! Sets ambient color of the scene
virtual void setAmbientLight(const video::SColorf &ambientColor) _IRR_OVERRIDE_;
virtual void setAmbientLight(const video::SColorf &ambientColor) IRR_OVERRIDE;
//! Returns ambient color of the scene
virtual const video::SColorf& getAmbientLight() const _IRR_OVERRIDE_;
virtual const video::SColorf& getAmbientLight() const IRR_OVERRIDE;
//! Register a custom callbacks manager which gets callbacks during scene rendering.
virtual void setLightManager(ILightManager* lightManager) _IRR_OVERRIDE_;
virtual void setLightManager(ILightManager* lightManager) IRR_OVERRIDE;
//! Get current render time.
virtual E_SCENE_NODE_RENDER_PASS getCurrentRenderPass() const _IRR_OVERRIDE_ { return CurrentRenderPass; }
virtual E_SCENE_NODE_RENDER_PASS getCurrentRenderPass() const IRR_OVERRIDE { return CurrentRenderPass; }
//! Set current render time.
virtual void setCurrentRenderPass(E_SCENE_NODE_RENDER_PASS nextPass) _IRR_OVERRIDE_ { CurrentRenderPass = nextPass; }
virtual void setCurrentRenderPass(E_SCENE_NODE_RENDER_PASS nextPass) IRR_OVERRIDE { CurrentRenderPass = nextPass; }
//! Get an instance of a geometry creator.
virtual const IGeometryCreator* getGeometryCreator(void) const _IRR_OVERRIDE_ { return GeometryCreator; }
virtual const IGeometryCreator* getGeometryCreator(void) const IRR_OVERRIDE { return GeometryCreator; }
//! returns if node is culled
virtual bool isCulled(const ISceneNode* node) const _IRR_OVERRIDE_;
virtual bool isCulled(const ISceneNode* node) const IRR_OVERRIDE;
private: