ISceneManager.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __I_SCENE_MANAGER_H_INCLUDED__
#define __I_SCENE_MANAGER_H_INCLUDED__

#include "IReferenceCounted.h"
#include "irrArray.h"
#include "irrString.h"
#include "path.h"
#include "vector3d.h"
#include "dimension2d.h"
#include "SColor.h"
#include "ETerrainElements.h"
#include "ESceneNodeTypes.h"
#include "ESceneNodeAnimatorTypes.h"
#include "EMeshWriterEnums.h"
#include "SceneParameters.h"
#include "IGeometryCreator.h"
#include "ISkinnedMesh.h"
#include "IXMLWriter.h"

namespace irr
{
        struct SKeyMap;
        struct SEvent;

namespace io
{
        class IReadFile;
        class IAttributes;
        class IWriteFile;
        class IFileSystem;
} // end namespace io

namespace gui
{
        class IGUIFont;
        class IGUIEnvironment;
} // end namespace gui

namespace video
{
        class IVideoDriver;
        class SMaterial;
        class IImage;
        class ITexture;
} // end namespace video

namespace scene
{

        enum E_SCENE_NODE_RENDER_PASS
        {
                ESNRP_NONE =0,

                ESNRP_CAMERA =1,

                ESNRP_LIGHT =2,

                ESNRP_SKY_BOX =4,


                ESNRP_AUTOMATIC =24,

                ESNRP_SOLID =8,

                ESNRP_TRANSPARENT =16,

                ESNRP_TRANSPARENT_EFFECT =32,

                ESNRP_SHADOW =64
        };

        class IAnimatedMesh;
        class IAnimatedMeshSceneNode;
        class IBillboardSceneNode;
        class IBillboardTextSceneNode;
        class ICameraSceneNode;
        class IDummyTransformationSceneNode;
        class ILightManager;
        class ILightSceneNode;
        class IMesh;
        class IMeshBuffer;
        class IMeshCache;
        class IMeshLoader;
        class IMeshManipulator;
        class IMeshSceneNode;
        class IMeshWriter;
        class IMetaTriangleSelector;
        class IOctreeSceneNode;
        class IParticleSystemSceneNode;
        class ISceneCollisionManager;
        class ISceneLoader;
        class ISceneNode;
        class ISceneNodeAnimator;
        class ISceneNodeAnimatorCollisionResponse;
        class ISceneNodeAnimatorFactory;
        class ISceneNodeFactory;
        class ISceneUserDataSerializer;
        class IShadowVolumeSceneNode;
        class ITerrainSceneNode;
        class ITextSceneNode;
        class ITriangleSelector;
        class IVolumeLightSceneNode;

        namespace quake3
        {
                struct IShader;
        } // end namespace quake3


        class ISceneManager : public virtual IReferenceCounted
        {
        public:


                virtual IAnimatedMesh* getMesh(const io::path& filename, const io::path& alternativeCacheName=io::path("")) = 0;


                virtual IAnimatedMesh* getMesh(io::IReadFile* file) = 0;


                virtual IMeshCache* getMeshCache() = 0;


                virtual video::IVideoDriver* getVideoDriver() = 0;


                virtual gui::IGUIEnvironment* getGUIEnvironment() = 0;


                virtual io::IFileSystem* getFileSystem() = 0;


                virtual IVolumeLightSceneNode* addVolumeLightSceneNode(ISceneNode* parent=0, s32 id=-1,
                        const u32 subdivU = 32, const u32 subdivV = 32,
                        const video::SColor foot = video::SColor(51, 0, 230, 180),
                        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)) = 0;


                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)) = 0;


                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)) = 0;


                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) = 0;


                virtual IMeshSceneNode* addMeshSceneNode(IMesh* 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) = 0;


                virtual ISceneNode* addWaterSurfaceSceneNode(IMesh* mesh,
                        f32 waveHeight=2.0f, f32 waveSpeed=300.0f, f32 waveLength=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)) = 0;



                virtual IOctreeSceneNode* addOctreeSceneNode(IAnimatedMesh* mesh, ISceneNode* parent=0,
                        s32 id=-1, s32 minimalPolysPerNode=512, bool alsoAddIfMeshPointerZero=false) = 0;


                virtual IOctreeSceneNode* addOctreeSceneNode(IMesh* mesh, ISceneNode* parent=0,
                        s32 id=-1, s32 minimalPolysPerNode=256, bool alsoAddIfMeshPointerZero=false) = 0;


                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) = 0;


                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) =0;


                virtual ICameraSceneNode* addCameraSceneNodeFPS(ISceneNode* parent = 0,
                        f32 rotateSpeed = 100.0f, f32 moveSpeed = 0.5f, s32 id=-1,
                        SKeyMap* keyMapArray=0, s32 keyMapSize=0, bool noVerticalMovement=false,
                        f32 jumpSpeed = 0.f, bool invertMouse=false,
                        bool makeActive=true) = 0;


                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 radius=100.0f, s32 id=-1) = 0;


                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 colorTop = 0xFFFFFFFF, video::SColor colorBottom = 0xFFFFFFFF) = 0;


                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) = 0;


                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) = 0;


                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)) = 0;


                virtual ITerrainSceneNode* addTerrainSceneNode(
                        const io::path& heightMapFileName,
                                ISceneNode* parent=0, s32 id=-1,
                        const core::vector3df& position = core::vector3df(0.0f,0.0f,0.0f),
                        const core::vector3df& rotation = core::vector3df(0.0f,0.0f,0.0f),
                        const core::vector3df& scale = core::vector3df(1.0f,1.0f,1.0f),
                        video::SColor vertexColor = video::SColor(255,255,255,255),
                        s32 maxLOD=5, E_TERRAIN_PATCH_SIZE patchSize=ETPS_17, s32 smoothFactor=0,
                        bool addAlsoIfHeightmapEmpty = false) = 0;


                virtual ITerrainSceneNode* addTerrainSceneNode(
                        io::IReadFile* heightMapFile,
                        ISceneNode* parent=0, s32 id=-1,
                        const core::vector3df& position = core::vector3df(0.0f,0.0f,0.0f),
                        const core::vector3df& rotation = core::vector3df(0.0f,0.0f,0.0f),
                        const core::vector3df& scale = core::vector3df(1.0f,1.0f,1.0f),
                        video::SColor vertexColor = video::SColor(255,255,255,255),
                        s32 maxLOD=5, E_TERRAIN_PATCH_SIZE patchSize=ETPS_17, s32 smoothFactor=0,
                        bool addAlsoIfHeightmapEmpty = false) = 0;


                virtual IMeshSceneNode* addQuake3SceneNode(const IMeshBuffer* meshBuffer, const quake3::IShader * shader,
                                                                                                ISceneNode* parent=0, s32 id=-1
                                                                                                ) = 0;



                virtual ISceneNode* addEmptySceneNode(ISceneNode* parent=0, s32 id=-1) = 0;


                virtual IDummyTransformationSceneNode* addDummyTransformationSceneNode(
                        ISceneNode* parent=0, s32 id=-1) = 0;

                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) = 0;


                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) = 0;


                virtual IAnimatedMesh* addHillPlaneMesh(const io::path& name,
                        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>(0.0f, 0.0f),
                        const core::dimension2d<f32>& textureRepeatCount = core::dimension2d<f32>(1.0f, 1.0f)) = 0;


                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)) = 0;


                virtual IAnimatedMesh* addArrowMesh(const io::path& name,
                                video::SColor vtxColorCylinder=0xFFFFFFFF,
                                video::SColor vtxColorCone=0xFFFFFFFF,
                                u32 tesselationCylinder=4, u32 tesselationCone=8,
                                f32 height=1.f, f32 cylinderHeight=0.6f,
                                f32 widthCylinder=0.05f, f32 widthCone=0.3f) = 0;


                virtual IAnimatedMesh* addSphereMesh(const io::path& name,
                                f32 radius=5.f, u32 polyCountX = 16,
                                u32 polyCountY = 16) = 0;


                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)) = 0;


                virtual ISceneNode* getRootSceneNode() = 0;


                virtual ISceneNode* getSceneNodeFromId(s32 id, ISceneNode* start=0) = 0;


                virtual ISceneNode* getSceneNodeFromName(const c8* name, ISceneNode* start=0) = 0;


                virtual ISceneNode* getSceneNodeFromType(scene::ESCENE_NODE_TYPE type, ISceneNode* start=0) = 0;


                virtual void getSceneNodesFromType(ESCENE_NODE_TYPE type,
                                core::array<scene::ISceneNode*>& outNodes,
                                ISceneNode* start=0) = 0;


                virtual ICameraSceneNode* getActiveCamera() const =0;


                virtual void setActiveCamera(ICameraSceneNode* camera) = 0;

                virtual void setShadowColor(video::SColor color = video::SColor(150,0,0,0)) = 0;

                virtual video::SColor getShadowColor() const = 0;


                virtual IShadowVolumeSceneNode* createShadowVolumeSceneNode(const IMesh* shadowMesh, ISceneNode* parent, s32 id, bool zfailmethod, f32 infinity) = 0;


                virtual u32 registerNodeForRendering(ISceneNode* node,
                        E_SCENE_NODE_RENDER_PASS pass = ESNRP_AUTOMATIC) = 0;


                virtual void clearAllRegisteredNodesForRendering() = 0;


                virtual void drawAll() = 0;


                virtual ISceneNodeAnimator* createRotationAnimator(const core::vector3df& rotationSpeed) = 0;


                virtual ISceneNodeAnimator* createFlyCircleAnimator(
                                const core::vector3df& center=core::vector3df(0.f,0.f,0.f),
                                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) = 0;


                virtual ISceneNodeAnimator* createFlyStraightAnimator(const core::vector3df& startPoint,
                        const core::vector3df& endPoint, u32 timeForWay, bool loop=false, bool pingpong = false) = 0;


                virtual ISceneNodeAnimator* createTextureAnimator(const core::array<video::ITexture*>& textures,
                        s32 timePerFrame, bool loop=true) = 0;


                virtual ISceneNodeAnimator* createDeleteAnimator(u32 timeMs) = 0;


                virtual ISceneNodeAnimatorCollisionResponse* createCollisionResponseAnimator(
                        ITriangleSelector* world, ISceneNode* sceneNode,
                        const core::vector3df& ellipsoidRadius = core::vector3df(30,60,30),
                        const core::vector3df& gravityPerSecond = core::vector3df(0,-10.0f,0),
                        const core::vector3df& ellipsoidTranslation = core::vector3df(0,0,0),
                        f32 slidingValue = 0.0005f) = 0;


                virtual ISceneNodeAnimator* createFollowSplineAnimator(s32 startTime,
                        const core::array< core::vector3df >& points,
                        f32 speed = 1.0f, f32 tightness = 0.5f, bool loop=true, bool pingpong=false) = 0;


                virtual ITriangleSelector* createTriangleSelector(IMesh* mesh, ISceneNode* node, bool separateMeshbuffers=false) = 0;


                virtual ITriangleSelector* createTriangleSelector(const IMeshBuffer* meshBuffer, irr::u32 materialIndex, ISceneNode* node) = 0;


                virtual ITriangleSelector* createTriangleSelector(IAnimatedMeshSceneNode* node, bool separateMeshbuffers=false) = 0;



                virtual ITriangleSelector* createTriangleSelectorFromBoundingBox(ISceneNode* node) = 0;


                virtual ITriangleSelector* createOctreeTriangleSelector(IMesh* mesh,
                        ISceneNode* node, s32 minimalPolysPerNode=32) = 0;


                virtual ITriangleSelector* createOctreeTriangleSelector(IMeshBuffer* meshBuffer, irr::u32 materialIndex,
                        ISceneNode* node, s32 minimalPolysPerNode=32) = 0;


                _IRR_DEPRECATED_ ITriangleSelector* createOctTreeTriangleSelector(IMesh* mesh,
                        ISceneNode* node, s32 minimalPolysPerNode=32)
                {
                        return createOctreeTriangleSelector(mesh, node, minimalPolysPerNode);
                }


                virtual IMetaTriangleSelector* createMetaTriangleSelector() = 0;


                virtual ITriangleSelector* createTerrainTriangleSelector(
                        ITerrainSceneNode* node, s32 LOD=0) = 0;


                virtual void addExternalMeshLoader(IMeshLoader* externalLoader) = 0;

                virtual u32 getMeshLoaderCount() const = 0;


                virtual IMeshLoader* getMeshLoader(u32 index) const = 0;


                virtual void addExternalSceneLoader(ISceneLoader* externalLoader) = 0;

                virtual u32 getSceneLoaderCount() const = 0;


                virtual ISceneLoader* getSceneLoader(u32 index) const = 0;


                virtual ISceneCollisionManager* getSceneCollisionManager() = 0;


                virtual IMeshManipulator* getMeshManipulator() = 0;


                virtual void addToDeletionQueue(ISceneNode* node) = 0;


                virtual bool postEventFromUser(const SEvent& event) = 0;


                virtual void clear() = 0;


                virtual io::IAttributes* getParameters() = 0;


                virtual E_SCENE_NODE_RENDER_PASS getSceneNodeRenderPass() const = 0;


                virtual ISceneNodeFactory* getDefaultSceneNodeFactory() = 0;


                virtual void registerSceneNodeFactory(ISceneNodeFactory* factoryToAdd) = 0;

                virtual u32 getRegisteredSceneNodeFactoryCount() const = 0;


                virtual ISceneNodeFactory* getSceneNodeFactory(u32 index) = 0;


                virtual ISceneNodeAnimatorFactory* getDefaultSceneNodeAnimatorFactory() = 0;


                virtual void registerSceneNodeAnimatorFactory(ISceneNodeAnimatorFactory* factoryToAdd) = 0;

                virtual u32 getRegisteredSceneNodeAnimatorFactoryCount() const = 0;


                virtual ISceneNodeAnimatorFactory* getSceneNodeAnimatorFactory(u32 index) = 0;

                virtual const c8* getSceneNodeTypeName(ESCENE_NODE_TYPE type) = 0;

                virtual const c8* getAnimatorTypeName(ESCENE_NODE_ANIMATOR_TYPE type) = 0;


                virtual ISceneNode* addSceneNode(const char* sceneNodeTypeName, ISceneNode* parent=0) = 0;


                virtual ISceneNodeAnimator* createSceneNodeAnimator(const char* typeName, ISceneNode* target=0) = 0;


                virtual ISceneManager* createNewSceneManager(bool cloneContent=false) = 0;


                virtual bool saveScene(const io::path& filename, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* node=0) = 0;


                virtual bool saveScene(io::IWriteFile* file, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* node=0) = 0;


                virtual bool saveScene(io::IXMLWriter* writer, const io::path& currentPath, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* node=0) = 0;


                virtual bool loadScene(const io::path& filename, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* rootNode=0) = 0;


                virtual bool loadScene(io::IReadFile* file, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* rootNode=0) = 0;


                virtual IMeshWriter* createMeshWriter(EMESH_WRITER_TYPE type) = 0;


                virtual ISkinnedMesh* createSkinnedMesh() = 0;

                virtual void setAmbientLight(const video::SColorf &ambientColor) = 0;

                virtual const video::SColorf& getAmbientLight() const = 0;


                virtual void setLightManager(ILightManager* lightManager) = 0;

                virtual E_SCENE_NODE_RENDER_PASS getCurrentRenderPass() const =0;

                virtual void setCurrentRenderPass(E_SCENE_NODE_RENDER_PASS nextPass) =0;


                virtual const IGeometryCreator* getGeometryCreator(void) const = 0;


                virtual bool isCulled(const ISceneNode* node) const =0;
        };


} // end namespace scene
} // end namespace irr

#endif