ISceneManager.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in nirtcpp/nirtcpp.hpp
 
#ifndef NIRT_I_SCENE_MANAGER_HPP_INCLUDED
#define NIRT_I_SCENE_MANAGER_HPP_INCLUDED
 
#include <nirtcpp/core/engine/IReferenceCounted.hpp>
#include <nirtcpp/core/engine/irrArray.hpp>
#include <nirtcpp/core/engine/irrString.hpp>
#include <nirtcpp/core/engine/path.hpp>
#include <nirtcpp/core/engine/vector3d.hpp>
#include <nirtcpp/core/engine/dimension2d.hpp>
#include <nirtcpp/core/engine/SColor.hpp>
#include <nirtcpp/core/engine/ETerrainElements.hpp>
#include <nirtcpp/core/engine/ESceneNodeTypes.hpp>
#include <nirtcpp/core/engine/ESceneNodeAnimatorTypes.hpp>
#include <nirtcpp/core/engine/EMeshWriterEnums.hpp>
#include <nirtcpp/core/engine/SceneParameters.hpp>
#include <nirtcpp/core/engine/IGeometryCreator.hpp>
#include <nirtcpp/core/engine/ISkinnedMesh.hpp>
#include <nirtcpp/core/engine/IXMLWriter.hpp>
 
namespace nirt
{
    class SKeyMap;
    class 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,
 
        ESNRP_GUI = 128
 
    };
 
    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
    {
        class 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),
            ECUBE_MESH_TYPE type=ECMT_1BUF_12VTX_NA) = 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
            , f32 rotX = 0.f, f32 rotY = 0.f
        ) =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, bool steer=false) = 0;
 
 
        virtual ITriangleSelector* createTriangleSelector(IMesh* mesh, ISceneNode* node, bool separateMeshbuffers=false) = 0;
 
 
        virtual ITriangleSelector* createTriangleSelector(const IMeshBuffer* meshBuffer, nirt::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, nirt::u32 materialIndex,
            ISceneNode* node, s32 minimalPolysPerNode=32) = 0;
 
 
        NIRT_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 nirt
 
#endif