D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/SceneGraph/spSceneManager.hpp

Go to the documentation of this file.

/*
 * Scene manager header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_SCENE_MANAGER_H__
#define __SP_SCENE_MANAGER_H__


#include "Base/spStandard.hpp"
#include "Base/spBasicMeshGenerator.hpp"
#include "Base/spGeometryStructures.hpp"
#include "SceneGraph/spSceneLight.hpp"

#include <list>


namespace sp
{
namespace scene
{


class Mesh;
class Billboard;
class Terrain;
class Camera;


class SP_EXPORT SceneManager
{
    
    public:
        
        SceneManager();
        ~SceneManager();
        
        /* === Functions === */
        
        Mesh* createMesh();
        
        Mesh* createMesh(const EBasicMeshes Model, const SMeshConstruct &BuildConstruct = SMeshConstruct());
        
        Mesh* createSuperShape(const f32 (&ValueList)[12], s32 Detail = DEF_MESH_SEGMENTS);
        
        Mesh* createSkyBox(video::Texture* (&TextureList)[6], f32 Radius = 50.0f);
        
        Mesh* createHeightField(const video::Texture* TexHeightMap, const s32 Segments = DEF_MESH_SEGMENTS);
        
        Mesh* createMeshList(std::list<Mesh*> MergeList, bool isOldDelete);
        
        Mesh* createMeshSurface(Mesh* Model, u32 Surface);
        
        Mesh* loadMesh(
            io::stringc Filename, io::stringc TexturePath = video::TEXPATH_IGNORE,
            const EMeshFileFormats Format = MESHFORMAT_UNKNOWN, const s32 Flags = 0
        );
        
        Mesh* getMesh(
            const io::stringc &Filename, io::stringc TexturePath = video::TEXPATH_IGNORE, const EMeshFileFormats Format = MESHFORMAT_UNKNOWN
        );
        
        bool saveMesh(Mesh* Model, io::stringc Filename, const EMeshFileFormats Format = MESHFORMAT_UNKNOWN);
        
        Mesh* loadScene(
            io::stringc Filename, io::stringc TexturePath = video::TEXPATH_IGNORE,
            const ESceneFileFormats Format = SCENEFORMAT_UNKNOWN, const s32 Flags = DEF_SCENE_FLAGS
        );
        
        void createFurMesh(
            Mesh* Model, video::Texture* FurTexture,
            s32 LayerCount = 25, f32 HairLength = 0.2f, s32 HairCloseness = 2
        );
        
        SceneNode* createNode();
        
        Camera* createCamera();
        
        Light* createLight(const ELightModels Type = LIGHT_DIRECTIONAL);
        
        Billboard* createBillboard(video::Texture* BaseTexture = 0);
        
        Terrain* createTerrain(
            const video::SHeightMapTexture &TextureHeightMap, const dim::size2di &Resolution, s32 GeoMIPLevels = DEF_GEOMIP_LEVELS
        );
        
        SceneNode*  copyNode(const SceneNode*   TemplateObject);
        Mesh*       copyNode(const Mesh*        TemplateObject);
        Light*      copyNode(const Light*       TemplateObject);
        Billboard*  copyNode(const Billboard*   TemplateObject);
        Camera*     copyNode(const Camera*      TemplateObject);
        Terrain*    copyNode(const Terrain*     TemplateObject);
        
        bool deleteNode(SceneNode* Object);
        
        std::list<SceneNode*> findNodes(const io::stringc &Name) const;
        
        SceneNode* findNode(const io::stringc &Name) const;
        
        std::list<SceneNode*> findChildren(const SceneNode* Parent) const;
        
        SceneNode* findChild(const SceneNode* Parent, const io::stringc &Name) const;
        
        void deleteAnimation(Animation* Anim);
        
        void clearAnimations();
        
        void updateAnimations();
        
        void clearScene(
            bool isDeleteNodes = true, bool isDeleteMeshes = true,
            bool isDeleteCameras = true, bool isDeleteLights = true,
            bool isDeleteBillboards = true, bool isDeleteTerrains = true
        );
        
        void removeTexture(const video::Texture* Tex);
        
        u32 getSceneMeshBufferCount() const;
        u32 getSceneVertexCount() const;
        u32 getSceneTriangleCount() const;
        u32 getSceneObjectsCount() const;
        
        /* === Templates === */
        
        template <class T> T* createCamera()
        {
            T* NewCamera = MemoryManager::createMemory<T>("scene::Camera");
            CameraList_.push_back(NewCamera);
            return NewCamera;
        }
        
        template <class T> T* createAnimation(const io::stringc &Name = "")
        {
            T* NewAnim = MemoryManager::createMemory<T>(Name.size() ? Name : "Animation");
            NewAnim->setName(Name);
            AnimationList_.push_back(NewAnim);
            return NewAnim;
        }
        
        /* === Inline functions === */
        
        inline const std::list<Mesh*>& getMeshList() const
        {
            return MeshList_;
        }
        inline const std::list<Billboard*>& getBillboardList() const
        {
            return BillboardList_;
        }
        inline const std::list<Terrain*>& getTerrainList() const
        {
            return TerrainList_;
        }
        inline const std::list<Light*>& getLightList() const
        {
            return LightList_;
        }
        inline const std::list<Camera*>& getCameraList() const
        {
            return CameraList_;
        }
        inline const std::list<SceneNode*>& getNodeList() const
        {
            return NodeList_;
        }
        inline const std::list<Animation*>& getAnimationList() const
        {
            return AnimationList_;
        }
        
        /* === Static functions === */
        
        static void setDefaultVertexFormat(const video::VertexFormat* Format);
        
        static const video::VertexFormat* getDefaultVertexFormat();
        
        static void setDefaultIndexFormat(const video::ERendererDataTypes Format);
        
        static video::ERendererDataTypes getDefaultIndexFormat();
        
        static void setTextureLoadingState(bool AllowTextureLoading);
        static bool getTextureLoadingState();
        
        static EMeshFileFormats getMeshFileFormat(const io::stringc &Filename, const EMeshFileFormats DefaultFormat);
        static ESceneFileFormats getSceneFileFormat(const io::stringc &Filename, const ESceneFileFormats DefaultFormat);
        
    private:
        
        /* === Templates === */
        
        template <class T> void addChildToList(
            const Node* ParentNode, std::list<SceneNode*> &NodeList, const std::list<T*> &SearchList) const
        {
            for (typename std::list< T*, std::allocator<T*> >::const_iterator it = SearchList.begin(); it != SearchList.end(); ++it)
            {
                if ((*it)->getParent() == ParentNode)
                    NodeList.push_back(*it);
            }
        }
        
        template <class T> SceneNode* findChildInList(
            const SceneNode* ParentNode, const std::list<T*> &SearchList, const io::stringc &Name) const
        {
            for (typename std::list< T*, std::allocator<T*> >::const_iterator it = SearchList.begin(); it != SearchList.end(); ++it)
            {
                if ((*it)->getParent() == ParentNode && (*it)->getName() == Name)
                    return *it;
            }
            
            return 0;
        }
        
        template <class T> void filterNodeByName(
            const io::stringc &Name, std::list<SceneNode*> &NodeList, const std::list<T*> &SearchList) const
        {
            for (typename std::list< T*, std::allocator<T*> >::const_iterator it = SearchList.begin(); it != SearchList.end(); ++it)
            {
                if ((*it)->getName() == Name)
                    NodeList.push_back(*it);
            }
        }
        
        template <class T> SceneNode* findNodeInList(
            const io::stringc &Name, const std::list<T*> &SearchList) const
        {
            for (typename std::list< T*, std::allocator<T*> >::const_iterator it = SearchList.begin(); it != SearchList.end(); ++it)
            {
                if ((*it)->getName() == Name)
                    return *it;
            }
            
            return 0;
        }
        
        template <class T> T* copySceneNode(std::list<T*> &NodeList, const T* TemplateObject)
        {
            if (TemplateObject)
            {
                T* NewObject = TemplateObject->copy();
                NodeList.push_back(NewObject);
                return NewObject;
            }
            return 0;
        }
        
        template <class T> void deleteSceneNode(std::list<T*> &NodeList, T* Object)
        {
            MemoryManager::removeElement(NodeList, Object, true);
        }
        
        /* === Members === */
        
        std::list<SceneNode*>   NodeList_;
        
        std::list<Mesh*>        MeshList_;
        std::list<Billboard*>   BillboardList_;
        std::list<Terrain*>     TerrainList_;
        std::list<Camera*>      CameraList_;
        std::list<Light*>       LightList_;
        
        std::list<Animation*>   AnimationList_;
        
        std::map<std::string, Mesh*> MeshMap_;
        
        static const video::VertexFormat* DefaultVertexFormat_;
        static video::ERendererDataTypes DefaultIndexFormat_;
        
        static bool TextureLoadingState_;
        
};


} // /namespace scene

} // /namespace sp


#endif



// ================================================================================