ISceneNode.h

Go to the documentation of this file.

#ifndef __I_SCENE_NODE_H_INCLUDED__
#define __I_SCENE_NODE_H_INCLUDED__
 
#include "ID.h"
#include "ESceneNodeTypes.h"
#include "ISceneNodeAnimator.h"
#include "GraphicsConstants.h"
#include "SRenderPass.h"
#include "SPipeline.h"
#include "SIndirectCommand.h"
#include "aabbox3d.h"
#include <glm/gtx/euler_angles.hpp>
#include <glm/gtx/transform.hpp>
#include <glm/gtx/matrix_decompose.hpp>
#include <string>
#include <vector>
#include <array>
#include <algorithm>
#include <memory>
#include <functional>
 
namespace saga
{
namespace scene
{
  class ISceneNode;
 
  using ISceneNodeList = std::vector<std::shared_ptr<ISceneNode>>;
  // typedef std::vector<ISceneNodeAnimator*> ISceneNodeAnimatorList;
 
 
  class ISceneNode : public std::enable_shared_from_this<ISceneNode>, public IEventReceiver
  {
  public:
 
    ISceneNode(
      const std::shared_ptr<ISceneNode>& parent,
      const std::shared_ptr<ISceneManager>& mgr,
      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))
      : RelativeTranslation(position), RelativeRotation(rotation), RelativeScale(scale),
        SceneManager(mgr)
    {
      if (parent)
        parent->addChild(shared_from_this());
 
      updateAbsolutePosition();
    }
 
    virtual void onEvent(const SDL_Event& event) override
    {
      for (auto& anim : Animators)
      {
        anim->onEvent(event);
      }
    }
 
    virtual ~ISceneNode()
    {
      // delete all children
      removeAll();
 
      Animators.clear();
 
      // if (TriangleSelector)
        // TriangleSelector->drop();
    }
 
    void setID(const ID id) { NodeID = id; }
    const auto getID() const { return NodeID; }
 
 
    virtual void onRegisterSceneNode(video::RenderPassHandle pass)
    {
      if (IsVisible)
      {
        auto it = Children.begin();
        for (; it != Children.end(); ++it)
          (*it)->onRegisterSceneNode(pass);
      }
    }
 
    virtual void onUnregisterSceneNode(video::RenderPassHandle pass)
    {
      auto it = Children.begin();
      for (; it != Children.end(); ++it)
        (*it)->onUnregisterSceneNode(pass);
    }
 
    void setOnRender(std::function<void()> func) { OnRenderCallback = func; }
 
    void onRender() { if (OnRenderCallback) OnRenderCallback(); }
 
    bool hasDrawCommands() const { return !DrawCommands.empty(); }
 
    void setDrawCommands(video::DrawCommandList&& list) { DrawCommands = std::move(list); }
 
    const auto& getDrawCommands() const { return DrawCommands; }
 
    auto getTexture(int slot) const { return Textures.at(slot); }
 
    auto& getTextures() { return Textures; }
 
    void setTexture(int slot, video::TextureHandle texture)
    {
      Textures[slot] = texture;
    }
 
    virtual void setPipeline(video::PipelineHandle pipeline) { Pipeline = pipeline; }
 
    auto getPipeline() const { return Pipeline; }
 
 
    virtual void onAnimate(const float time)
    {
      if (IsVisible)
      {
        // animate this node with all animators
 
        for (auto& anim : Animators)
        {
          anim->animateNode(*this, time);
        }
 
        // update absolute position
        updateAbsolutePosition();
 
        // perform the post render process on all children
        auto it = Children.begin();
        for (; it != Children.end(); ++it)
          (*it)->onAnimate(time);
      }
    }
 
 
    virtual const std::string& getName() const
    {
      return Name;
    }
 
 
    virtual void setName(const std::string& name)
    {
      Name = name;
    }
 
 
    virtual const core::aabbox3d<float>& getBoundingBox() const = 0;
 
 
    virtual const core::aabbox3d<float> getTransformedBoundingBox() const
    {
      core::aabbox3d<float> box = getBoundingBox();
      // TODO: get transformed bounding box
      // AbsoluteTransformation.transformBoxEx(box);
      return box;
    }
 
 
    virtual void getTransformedBoundingBoxEdges(std::vector<glm::vec3>& edges) const
    {
      edges.resize(8);
      getBoundingBox().getEdges(edges.data());
      for (std::uint32_t i= 0; i<8; ++i)
        edges[i] = glm::vec3(AbsoluteTransformation * glm::vec4(edges[i], 1));
    }
 
 
    virtual const glm::mat4& getAbsoluteTransformation() const
    {
      return AbsoluteTransformation;
    }
 
 
    virtual glm::mat4 getRelativeTransformation() const
    {
      auto translation = glm::translate(glm::mat4(1.0f), RelativeTranslation);
      auto rotation = glm::eulerAngleXYZ(RelativeRotation.x, RelativeRotation.y, RelativeRotation.z);
      auto scale = glm::scale(RelativeScale);
      return translation * rotation * scale;
    }
 
 
    virtual bool isVisible() const
    {
      return IsVisible;
    }
 
 
    virtual bool isTrulyVisible() const
    {
      if(!IsVisible)
        return false;
 
      if(!Parent)
        return true;
 
      return Parent->isTrulyVisible();
    }
 
 
    virtual void setVisible(bool isVisible)
    {
      IsVisible = isVisible;
    }
 
 
    virtual void addChild(const std::shared_ptr<ISceneNode>& child)
    {
      if (child && (child.get() != this))
      {
        // Change scene manager?
        // if (SceneManager != child->SceneManager)
          // child->setSceneManager(SceneManager);
 
        // child->grab();
        child->remove(); // remove from old parent
        Children.push_back(child);
        child->Parent = shared_from_this();
      }
    }
 
    virtual bool removeChild(const std::shared_ptr<ISceneNode>& child)
    {
      auto it = Children.begin();
      for (; it != Children.end(); ++it)
        if ((*it).get() == child.get())
        {
          (*it)->Parent = 0;
          // (*it)->drop();
          Children.erase(it);
          return true;
        }
 
      return false;
    }
 
 
    virtual void removeAll()
    {
      auto it = Children.begin();
      for (; it != Children.end(); ++it)
      {
        (*it)->Parent = 0;
        // (*it)->drop();
      }
 
      Children.clear();
    }
 
 
    virtual void remove()
    {
      if (Parent)
        Parent->removeChild(shared_from_this());
    }
 
 
    virtual void addAnimator(const std::shared_ptr<ISceneNodeAnimator>& animator)
    {
      if (animator)
      {
        Animators.push_back(animator);
      }
    }
 
 
 
    const auto& getAnimators() const
    {
      return Animators;
    }
 
 
 
    virtual void removeAnimator(const std::shared_ptr<ISceneNodeAnimator>& animator)
    {
      Animators.erase(std::remove(Animators.begin(), Animators.end(), animator), Animators.end());
    }
 
 
    virtual void removeAnimators()
    {
      Animators.clear();
    }
 
 
    virtual const glm::vec3& getScale() const
    {
      return RelativeScale;
    }
 
 
    virtual void setScale(const glm::vec3& scale)
    {
      RelativeScale = scale;
    }
 
 
    virtual const glm::vec3& getRotation() const
    {
      return RelativeRotation;
    }
 
 
    virtual void setRotation(const glm::vec3& rotation)
    {
      RelativeRotation = rotation;
    }
 
 
    virtual const glm::vec3& getPosition() const
    {
      return RelativeTranslation;
    }
 
 
    virtual void setPosition(const glm::vec3& newpos)
    {
      RelativeTranslation = newpos;
    }
 
 
    virtual glm::vec3 getAbsolutePosition() const
    {
      return AbsoluteTransformation[3];
    }
 
 
    const std::vector<std::shared_ptr<ISceneNode>>& getChildren() const
    {
      return Children;
    }
 
 
    virtual void setParent(const std::shared_ptr<ISceneNode>& newParent)
    {
      remove();
 
      Parent = newParent;
 
      if (Parent)
        Parent->addChild(shared_from_this());
    }
 
 
    // virtual ITriangleSelector* getTriangleSelector() const
    // {
    //   return TriangleSelector;
    // }
 
 
 
    // virtual void setTriangleSelector(ITriangleSelector* selector)
    // {
    //   if (TriangleSelector != selector)
    //   {
    //     // if (TriangleSelector)
    //       // TriangleSelector->drop();
 
    //     TriangleSelector = selector;
    //     // if (TriangleSelector)
    //       // TriangleSelector->grab();
    //   }
    // }
 
    virtual void updateAbsolutePosition()
    {
      if (Parent)
      {
        AbsoluteTransformation =
          Parent->getAbsoluteTransformation() * getRelativeTransformation();
      }
      else
        AbsoluteTransformation = getRelativeTransformation();
    }
 
 
    const std::shared_ptr<ISceneNode>& getParent() const
    {
      return Parent;
    }
 
 
    virtual E_SCENE_NODE_TYPE getType() const
    {
      return E_SCENE_NODE_TYPE::UNKNOWN;
    }
 
 
    virtual std::shared_ptr<ISceneNode> clone(const std::shared_ptr<ISceneNode>& newParent = 0)
    {
      return nullptr; // to be implemented by derived classes
    }
 
 
    virtual const std::shared_ptr<ISceneManager>& getSceneManager() const { return SceneManager; }
 
  protected:
 
 
    // void cloneMembers(ISceneNode* toCopyFrom, ISceneManager* newManager)
    // {
    //   Name = toCopyFrom->Name;
    //   AbsoluteTransformation = toCopyFrom->AbsoluteTransformation;
    //   RelativeTranslation = toCopyFrom->RelativeTranslation;
    //   RelativeRotation = toCopyFrom->RelativeRotation;
    //   RelativeScale = toCopyFrom->RelativeScale;
    //   ID = toCopyFrom->ID;
    //   setTriangleSelector(toCopyFrom->TriangleSelector);
    //   AutomaticCullingState = toCopyFrom->AutomaticCullingState;
    //   // DebugDataVisible = toCopyFrom->DebugDataVisible;
    //   IsVisible = toCopyFrom->IsVisible;
    //   IsDebugObject = toCopyFrom->IsDebugObject;
 
    //   if (newManager)
    //     SceneManager = newManager;
    //   else
    //     SceneManager = toCopyFrom->SceneManager;
 
    //   // clone children
 
    //   auto it = toCopyFrom->Children.begin();
    //   for (; it != toCopyFrom->Children.end(); ++it)
    //     (*it)->clone(this, newManager);
 
      // clone animators
 
      // ISceneNodeAnimatorList::Iterator ait = toCopyFrom->Animators.begin();
      // for (; ait != toCopyFrom->Animators.end(); ++ait)
      // {
      //   ISceneNodeAnimator* anim = (*ait)->createClone(this, SceneManager);
      //   if (anim)
      //   {
      //     addAnimator(anim);
      //     anim->drop();
      //   }
      // }
    // }
 
    // void setSceneManager(ISceneManager* newManager)
    // {
    //   SceneManager = newManager;
 
    //   auto it = Children.begin();
    //   for (; it != Children.end(); ++it)
    //     (*it)->setSceneManager(newManager);
    // }
 
    ID NodeID = INVALID_ID;
 
    std::string Name;
 
    glm::mat4 AbsoluteTransformation;
 
    glm::vec3 RelativeTranslation;
 
    glm::vec3 RelativeRotation;
 
    glm::vec3 RelativeScale;
 
    std::shared_ptr<ISceneNode> Parent = nullptr;
 
    std::vector<std::shared_ptr<ISceneNode>> Children;
 
    std::array<video::STexture::HandleType, video::MAX_NODE_TEXTURES> Textures = { video::NULL_GPU_RESOURCE_HANDLE };
 
    std::vector<std::shared_ptr<ISceneNodeAnimator>> Animators;
 
    std::shared_ptr<ISceneManager> SceneManager = nullptr;
 
 
    std::function<void()> OnRenderCallback = nullptr;
 
    video::DrawCommandList DrawCommands;
 
    video::PipelineHandle Pipeline = video::NULL_GPU_RESOURCE_HANDLE;
 
    bool IsVisible = true;
  };
 
 
} // namespace scene
} // namespace saga
 
#endif