ISceneManager.h

Go to the documentation of this file.

 
#ifndef __I_SCENE_MANAGER_H_INCLUDED__
#define __I_SCENE_MANAGER_H_INCLUDED__
 
#include "SColor.h"
#include "IEventReceiver.h"
#include "ESceneNodeTypes.h"
#include "ESceneNodeAnimatorTypes.h"
#include "ISceneNode.h"
#include "IMesh.h"
#include "SRenderPass.h"
#include "SPipeline.h"
#include <vector>
#include <unordered_map>
 
namespace saga
{
namespace video
{
  class IVideoDriver;
  class ITexture;
} // namespace video
 
namespace scene
{
  class IAnimatedMesh;
  class ISkinnedMesh;
  class IAnimatedMeshSceneNode;
  class ICameraSceneNode;
  class IMeshBuffer;
  class IMeshLoader;
  class IMeshSceneNode;
  // class ISceneNodeAnimator;
  // class ISceneNodeAnimatorCollisionResponse;
  // class ISceneNodeAnimatorFactory;
  // class ISceneNodeFactory;
 
  class ISceneManager : public IEventReceiver
  {
  public:
    using SceneNodeList = std::vector<std::shared_ptr<ISceneNode>>;
    using PassSceneNodeList = std::unordered_map<video::RenderPassHandle, SceneNodeList>;
 
    virtual void resetID() = 0;
    virtual ID getMeshID() = 0;
    virtual ID getTextureID() = 0;
    virtual ID getNodeID() = 0;
 
    virtual void onEvent(const SDL_Event& event) override {}
 
    /*
      \param fileName: path to mesh file
    */
    virtual const std::shared_ptr<IMesh>& getMesh(const std::string& fileName) = 0;
 
    virtual const std::shared_ptr<IMesh>& getMesh(void* data, const std::size_t size,
      const std::string& extension) = 0;
 
    virtual const std::shared_ptr<IMesh>& getMesh(const ID id) const = 0;
 
    virtual void removeMesh(const std::shared_ptr<IMesh>& mesh) = 0;
 
    virtual void removeMesh(const ID id) = 0;
 
 
    virtual std::shared_ptr<ISceneNode> createSceneNode(
      const std::shared_ptr<IMesh>& mesh, const std::shared_ptr<ISceneNode>& parent = nullptr,
      const glm::vec3& position = glm::vec3(0,0,0),
      const glm::vec3& rotation = glm::vec3(0,0,0),
      const glm::vec3& scale = glm::vec3(1.0f, 1.0f, 1.0f)) = 0;
 
    virtual void removeNode(const ID id) = 0;
 
    virtual void removeNode(const std::shared_ptr<ISceneNode>& node) = 0;
 
 
 
    virtual const std::shared_ptr<video::IVideoDriver>& getVideoDriver() const = 0;
 
    virtual void registerNode(const std::shared_ptr<ISceneNode>& node, video::RenderPassHandle pass) = 0;
 
    virtual const std::shared_ptr<ISceneNode>& getNode(const ID id) const = 0;
 
    virtual void unregisterNode(const std::shared_ptr<ISceneNode>& node, video::RenderPassHandle pass) = 0;
 
    virtual bool isEmptyPass(video::RenderPassHandle pass) const = 0;
 
    virtual void clearRegisteredNodes() = 0;
 
    virtual SceneNodeList& getNodeList(const video::RenderPassHandle pass) = 0;
 
    virtual PassSceneNodeList& getNodeList() = 0;
 
 
    // virtual IMeshSceneNode* addCubeSceneNode(float size=10.0f, ISceneNode* parent= 0, std::int32_t id=-1,
    //   const glm::vec3& position = glm::vec3(0,0,0),
    //   const glm::vec3& rotation = glm::vec3(0,0,0),
    //   const glm::vec3& scale = glm::vec3(1.0f, 1.0f, 1.0f)) = 0;
 
 
    // virtual IMeshSceneNode* addSphereSceneNode(float radius=5.0f, std::int32_t polyCount=16,
    //     ISceneNode* parent= 0, std::int32_t id=-1,
    //     const glm::vec3& position = glm::vec3(0,0,0),
    //     const glm::vec3& rotation = glm::vec3(0,0,0),
    //     const glm::vec3& scale = glm::vec3(1.0f, 1.0f, 1.0f)) = 0;
 
 
    // virtual IAnimatedMeshSceneNode* addAnimatedMeshSceneNode(IAnimatedMesh* mesh,
    //     ISceneNode* parent= 0, std::int32_t id=-1,
    //     const glm::vec3& position = glm::vec3(0,0,0),
    //     const glm::vec3& rotation = glm::vec3(0,0,0),
    //     const glm::vec3& scale = glm::vec3(1.0f, 1.0f, 1.0f),
    //     bool alsoAddIfMeshPointerZero=false) = 0;
 
 
    // virtual ISceneNode* addWaterSurfaceSceneNode(IMesh* mesh,
    //   float waveHeight=2.0f, float waveSpeed=300.0f, float waveLength=10.0f,
    //   ISceneNode* parent= 0, std::int32_t id=-1,
    //   const glm::vec3& position = glm::vec3(0,0,0),
    //   const glm::vec3& rotation = glm::vec3(0,0,0),
    //   const glm::vec3& scale = glm::vec3(1.0f, 1.0f, 1.0f)) = 0;
 
 
 
    // virtual IOctreeSceneNode* addOctreeSceneNode(IAnimatedMesh* mesh, ISceneNode* parent= 0,
    //   std::int32_t id=-1, std::int32_t minimalPolysPerNode=512, bool alsoAddIfMeshPointerZero=false) = 0;
 
 
    // virtual IOctreeSceneNode* addOctreeSceneNode(IMesh* mesh, ISceneNode* parent= 0,
    //   std::int32_t id=-1, std::int32_t minimalPolysPerNode=256, bool alsoAddIfMeshPointerZero=false) = 0;
 
 
    virtual const std::shared_ptr<ICameraSceneNode>& addCameraSceneNode(
      const std::shared_ptr<ISceneNode>& parent = nullptr,
      const glm::vec3& position = glm::vec3(0,0,0),
      const glm::vec3& lookAt = glm::vec3(0,0,-1),
      bool makeActive = true) = 0;
 
 
    // virtual ICameraSceneNode* addCameraSceneNodeMaya(ISceneNode* parent= 0,
    //   float rotateSpeed=-1500.f, float zoomSpeed=200.f,
    //   float translationSpeed=1500.f, std::int32_t id=-1, float distance=70.f,
    //   bool makeActive=true) = 0;
 
 
    virtual const std::shared_ptr<ICameraSceneNode>& addCameraSceneNodeFPS(
      const std::shared_ptr<ISceneNode>& parent = nullptr,
      float moveSpeed = 0.5f, float rotateSpeed = 1.f,
      bool makeActive = true) = 0;
 
 
    // virtual ILightSceneNode* addLightSceneNode(ISceneNode* parent = 0,
    //   const glm::vec3& position = glm::vec3(0,0,0),
    //   video::SColorf color = video::SColorf(1.0f, 1.0f, 1.0f),
    //   float radius=100.0f, std::int32_t id=-1) = 0;
 
 
    // virtual IBillboardSceneNode* addBillboardSceneNode(ISceneNode* parent = 0,
    //   const glm::vec2& size = glm::vec2(10.0f, 10.0f),
    //   const glm::vec3& position = glm::vec3(0,0,0), std::int32_t 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, std::int32_t id=-1) = 0;
 
 
    // virtual ISceneNode* addSkyDomeSceneNode(video::ITexture* texture,
    //   std::uint32_t horiRes=16, std::uint32_t vertRes=8,
    //   float texturePercentage= 0.9, float spherePercentage=2.0,float radius = 1000.f,
    //   ISceneNode* parent= 0, std::int32_t id=-1) = 0;
 
 
    // virtual IParticleSystemSceneNode* addParticleSystemSceneNode(
    //   bool withDefaultEmitter=true, ISceneNode* parent= 0, std::int32_t id=-1,
    //   const glm::vec3& position = glm::vec3(0,0,0),
    //   const glm::vec3& rotation = glm::vec3(0,0,0),
    //   const glm::vec3& scale = glm::vec3(1.0f, 1.0f, 1.0f)) = 0;
 
 
    // virtual ITerrainSceneNode* addTerrainSceneNode(
    //   const std::string& heightMapFileName,
    //     ISceneNode* parent= 0, std::int32_t id=-1,
    //   const glm::vec3& position = glm::vec3(0.0f,0.0f,0.0f),
    //   const glm::vec3& rotation = glm::vec3(0.0f,0.0f,0.0f),
    //   const glm::vec3& scale = glm::vec3(1.0f,1.0f,1.0f),
    //   video::SColor vertexColor = video::SColor(255,255,255,255),
    //   std::int32_t maxLOD=5, E_TERRAIN_PATCH_SIZE patchSize=E_TERRAIN_PATCH_SIZE::SIZE_17, std::int32_t smoothFactor= 0,
    //   bool addAlsoIfHeightmapEmpty = false) = 0;
 
 
    // virtual ITerrainSceneNode* addTerrainSceneNode(
    //   io::IReadFile* heightMapFile,
    //   ISceneNode* parent= 0, std::int32_t id=-1,
    //   const glm::vec3& position = glm::vec3(0.0f,0.0f,0.0f),
    //   const glm::vec3& rotation = glm::vec3(0.0f,0.0f,0.0f),
    //   const glm::vec3& scale = glm::vec3(1.0f,1.0f,1.0f),
    //   video::SColor vertexColor = video::SColor(255,255,255,255),
    //   std::int32_t maxLOD=5, E_TERRAIN_PATCH_SIZE patchSize=E_TERRAIN_PATCH_SIZE::SIZE_17, std::int32_t smoothFactor= 0,
    //   bool addAlsoIfHeightmapEmpty = false) = 0;
 
 
    // virtual ISceneNode* addEmptySceneNode(ISceneNode* parent= 0, std::int32_t id=-1) = 0;
 
 
    // virtual IDummyTransformationSceneNode* addDummyTransformationSceneNode(
    //   ISceneNode* parent= 0, std::int32_t id=-1) = 0;
 
    // virtual ITextSceneNode* addTextSceneNode(gui::IGUIFont* font, const char* text,
    //   video::SColor color=video::SColor(100,255,255,255),
    //   ISceneNode* parent = 0, const glm::vec3& position = glm::vec3(0,0,0),
    //   std::int32_t id=-1) = 0;
 
 
    // virtual IBillboardTextSceneNode* addBillboardTextSceneNode(gui::IGUIFont* font, const char* text,
    //   ISceneNode* parent = 0,
    //   const glm::vec2& size = glm::vec2(10.0f, 10.0f),
    //   const glm::vec3& position = glm::vec3(0,0,0), std::int32_t id=-1,
    //   video::SColor colorTop = 0xFFFFFFFF, video::SColor colorBottom = 0xFFFFFFFF) = 0;
 
 
    // virtual IAnimatedMesh* addHillPlaneMesh(const std::string& name,
    //   const glm::vec2& tileSize, const glm::uvec2& tileCount,
    //   video::SMaterial* material = 0, float hillHeight = 0.0f,
    //   const glm::vec2& countHills = glm::vec2(0.0f, 0.0f),
    //   const glm::vec2& textureRepeatCount = glm::vec2(1.0f, 1.0f)) = 0;
 
 
    // virtual IAnimatedMesh* addTerrainMesh(const std::string& meshname,
    //   video::IImage* texture, video::IImage* heightmap,
    //   const glm::vec2& stretchSize = glm::vec2(10.0f,10.0f),
    //   float maxHeight=200.0f,
    //   const glm::uvec2& defaultVertexBlockSize = glm::uvec2(64,64)) = 0;
 
 
    // virtual IAnimatedMesh* addArrowMesh(const std::string& name,
    //     video::SColor vtxColorCylinder= 0xFFFFFFFF,
    //     video::SColor vtxColorCone= 0xFFFFFFFF,
    //     std::uint32_t tesselationCylinder=4, std::uint32_t tesselationCone=8,
    //     float height=1.f, float cylinderHeight= 0.6f,
    //     float widthCylinder= 0.05f, float widthCone= 0.3f) = 0;
 
 
    // virtual IAnimatedMesh* addSphereMesh(const std::string& name,
    //     float radius=5.f, std::uint32_t polyCountX = 16,
    //     std::uint32_t polyCountY = 16) = 0;
 
 
    virtual const std::shared_ptr<ISceneNode>& getRootSceneNode() const = 0;
 
 
    // virtual ISceneNode* getSceneNodeFromId(std::int32_t id, ISceneNode* start= 0) = 0;
 
 
    // virtual ISceneNode* getSceneNodeFromName(const char* name, ISceneNode* start= 0) = 0;
 
 
    // virtual ISceneNode* getSceneNodeFromType(scene::E_SCENE_NODE_TYPE type, ISceneNode* start= 0) = 0;
 
 
    // virtual void getSceneNodesFromType(E_SCENE_NODE_TYPE type,
    //     std::vector<scene::ISceneNode*>& outNodes,
    //     ISceneNode* start= 0) = 0;
 
 
    virtual const std::shared_ptr<ICameraSceneNode>& getActiveCamera() const = 0;
 
 
    virtual void setActiveCamera(const std::shared_ptr<ICameraSceneNode>& camera) = 0;
 
 
    // virtual std::uint32_t registerNodeForRendering(ISceneNode* node,
      // E_SCENE_NODE_RENDER_PASS pass = E_SCENE_NODE_RENDER_PASS::AUTOMATIC) = 0;
 
 
    // virtual void clearAllRegisteredNodesForRendering() = 0;
 
 
    virtual void animate(const video::RenderPassHandle pass = video::NULL_GPU_RESOURCE_HANDLE) = 0;
 
 
    // virtual ISceneNodeAnimator* createRotationAnimator(const glm::vec3& rotationSpeed) = 0;
 
 
    // virtual ISceneNodeAnimator* createFlyCircleAnimator(
    //     const glm::vec3& center=glm::vec3(0.f,0.f,0.f),
    //     float radius=100.f, float speed= 0.001f,
    //     const glm::vec3& direction=glm::vec3(0.f, 1.f, 0.f),
    //     float startPosition = 0.f,
    //     float radiusEllipsoid = 0.f) = 0;
 
 
    // virtual ISceneNodeAnimator* createFlyStraightAnimator(const glm::vec3& startPoint,
    //   const glm::vec3& endPoint, std::uint32_t timeForWay, bool loop=false, bool pingpong = false) = 0;
 
 
    // virtual ISceneNodeAnimator* createTextureAnimator(const std::vector<video::ITexture*>& textures,
    //   std::int32_t timePerFrame, bool loop=true) = 0;
 
 
    // virtual ISceneNodeAnimator* createDeleteAnimator(std::uint32_t timeMs) = 0;
 
 
    // virtual ISceneNodeAnimatorCollisionResponse* createCollisionResponseAnimator(
    //   ITriangleSelector* world, ISceneNode* sceneNode,
    //   const glm::vec3& ellipsoidRadius = glm::vec3(30,60,30),
    //   const glm::vec3& gravityPerSecond = glm::vec3(0,-10.0f,0),
    //   const glm::vec3& ellipsoidTranslation = glm::vec3(0,0,0),
    //   float slidingValue = 0.0005f) = 0;
 
 
    // virtual ISceneNodeAnimator* createFollowSplineAnimator(std::int32_t startTime,
    //   const std::vector< glm::vec3 >& points,
    //   float speed = 1.0f, float 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, std::uint32_t 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, std::int32_t minimalPolysPerNode=32) = 0;
 
 
    // virtual ITriangleSelector* createOctreeTriangleSelector(IMeshBuffer* meshBuffer, std::uint32_t materialIndex,
    //   ISceneNode* node, std::int32_t minimalPolysPerNode=32) = 0;
 
    // //! //! Creates a Triangle Selector, optimized by an octree.
    // /**
    //  ITriangleSelector* createOctTreeTriangleSelector(IMesh* mesh,
    //   ISceneNode* node, std::int32_t minimalPolysPerNode=32)
    // {
    //   return createOctreeTriangleSelector(mesh, node, minimalPolysPerNode);
    // }
 
 
    // virtual IMetaTriangleSelector* createMetaTriangleSelector() = 0;
 
 
    // virtual ITriangleSelector* createTerrainTriangleSelector(
      // ITerrainSceneNode* node, std::int32_t LOD= 0) = 0;
 
 
    // virtual void addExternalMeshLoader(IMeshLoader* externalLoader) = 0;
 
    // virtual std::uint32_t getMeshLoaderCount() const = 0;
 
 
    // virtual IMeshLoader* getMeshLoader(std::uint32_t index) const = 0;
 
 
    // virtual void addExternalSceneLoader(ISceneLoader* externalLoader) = 0;
 
    // virtual std::uint32_t getSceneLoaderCount() const = 0;
 
 
    // virtual ISceneLoader* getSceneLoader(std::uint32_t index) const = 0;
 
 
    // virtual ISceneCollisionManager* getSceneCollisionManager() = 0;
 
 
    // virtual IMeshManipulator* getMeshManipulator() = 0;
 
 
    // virtual void addToDeletionQueue(ISceneNode* node) = 0;
 
 
    virtual void clear() = 0;
 
 
    // virtual ISceneNodeFactory* getDefaultSceneNodeFactory() = 0;
 
 
    // virtual void registerNodeFactory(ISceneNodeFactory* factoryToAdd) = 0;
 
    // virtual std::uint32_t getRegisteredSceneNodeFactoryCount() const = 0;
 
 
    // virtual ISceneNodeFactory* getSceneNodeFactory(std::uint32_t index) = 0;
 
 
    // virtual ISceneNodeAnimatorFactory* getDefaultSceneNodeAnimatorFactory() = 0;
 
 
    // virtual void registerNodeAnimatorFactory(ISceneNodeAnimatorFactory* factoryToAdd) = 0;
 
    // virtual std::uint32_t getRegisteredSceneNodeAnimatorFactoryCount() const = 0;
 
 
    // virtual ISceneNodeAnimatorFactory* getSceneNodeAnimatorFactory(std::uint32_t index) = 0;
 
    // virtual const char* getSceneNodeTypeName(E_SCENE_NODE_TYPE type) = 0;
 
    // virtual const char* 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 IMeshWriter* createMeshWriter(EMESH_WRITER_TYPE type) = 0;
 
 
    // virtual ISkinnedMesh* createSkinnedMesh() = 0;
 
 
    // virtual const IGeometryCreator* getGeometryCreator(void) const = 0;
 
 
    // virtual bool isCulled(const ISceneNode* node) const = 0;
  };
 
} // namespace scene
} // namespace saga
 
#endif