ISceneManager.h

// 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 "ESceneNodeTypes.h"
#include "ESceneNodeAnimatorTypes.h"
#include "SceneParameters.h"
#include "IGeometryCreator.h"
#include "IMeshManipulator.h"
#include "CMeshBuffer.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,

        ESNRP_CUBE_REFLECT = 128
    };
    
    class ICameraSceneNode;
    class ILightSceneNode;
    class IMesh;
    class IMeshBuffer;  
    class IMeshSceneNode;
    class IMetaTriangleSelector;
    class IParticleSystemSceneNode;
    class ISceneCollisionManager;
    class ISceneNode;
    class ISceneNodeAnimator;
    class ISceneNodeAnimatorCollisionResponse;
    class ISceneNodeAnimatorFactory;
    class ISceneNodeFactory;
    class ISceneUserDataSerializer; 
 
    class ITriangleSelector;


    class ISceneManager : public virtual IReferenceCounted
    {
    public:


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


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


        virtual io::IFileSystem* getFileSystem() = 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 ISceneNode* addEmptySceneNode(ISceneNode* parent=0, s32 id=-1) = 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 u32 registerNodeForRendering(ISceneNode* node,
            E_SCENE_NODE_RENDER_PASS pass = ESNRP_AUTOMATIC) = 0;


        virtual void drawAll() = 0;
 
        virtual void update() = 0;
        virtual void draw() = 0;
        virtual void draw(E_SCENE_NODE_RENDER_PASS renderPass) = 0;


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


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


        virtual ITriangleSelector* createOctreeTriangleSelector(IMesh* mesh,
            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 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 ISceneManager* createNewSceneManager(bool cloneContent=false) = 0;  

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

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


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


        virtual bool isCulled(const ISceneNode* node) const =0;
 
    };
 
 
} // end namespace scene
} // end namespace irr
 
#endif