node.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "lmgl/scene/light.hpp"
#include "lmgl/scene/mesh.hpp"
#include "lmgl/scene/lod.hpp"
 
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>
 
#include <memory>
#include <string>
#include <vector>
 
namespace lmgl {
 
namespace scene {

class Node : public std::enable_shared_from_this<Node> {
  public:
    // Transforms

    Node(const std::string &name = "Node");

    ~Node() = default;

    void set_position(const glm::vec3 &position);

    void set_rotation(const glm::quat &rotation);

    void set_rotation(const glm::vec3 &euler_angles);

    void set_scale(const glm::vec3 &scale);

    void set_scale(float scale);

    inline const glm::vec3 &get_position() const { return m_position; }

    inline const glm::quat &get_rotation() const { return m_rotation; }

    inline const glm::vec3 &get_scale() const { return m_scale; }

    void rotate(float angle, const glm::vec3 &axis);

    glm::vec3 get_euler_angles() const;

    void look_at(const glm::vec3 &target, const glm::vec3 &up = glm::vec3(0.0f, 1.0f, 0.0f));

    inline glm::mat4 get_local_transform() const { return m_local_transform; }

    inline glm::mat4 get_world_transform() const { return m_world_transform; }
 
    // Hierarchy

    void add_child(std::shared_ptr<Node> child);

    void remove_child(std::shared_ptr<Node> child);

    inline std::shared_ptr<Node> get_parent() const { return m_parent.lock(); }

    inline const std::vector<std::shared_ptr<Node>> &get_children() const { return m_children; }

    void detach_from_parent();

    void update_transform(const glm::mat4 &par_transform = glm::mat4(1.0f));

    inline void set_mesh(std::shared_ptr<Mesh> mesh) { m_mesh = mesh; }

    inline std::shared_ptr<Mesh> get_mesh() const { return m_mesh; }

    inline bool has_mesh() const { return m_mesh != nullptr; }

    inline std::string &get_name() { return m_name; }

    inline void set_name(const std::string &name) { m_name = name; }

    inline std::shared_ptr<Light> get_light() const { return m_light; }

    inline void set_light(std::shared_ptr<Light> light) { m_light = light; }

    bool has_light() const { return m_light != nullptr; }

    inline void set_lod(std::shared_ptr<LOD> lod) { m_lod = lod; };

    inline std::shared_ptr<LOD> get_lod() const { return m_lod; }

    inline bool has_lod() const { return m_lod != nullptr && m_lod->has_levels(); }

    std::shared_ptr<Mesh> get_mesh_for_rendering(const glm::vec3 &camera_pos) const;
 
  private:
    std::string m_name;

    glm::vec3 m_position{0.0f, 0.0f, 0.0f};

    glm::quat m_rotation{1.0f, 0.0f, 0.0f, 0.0f};

    glm::vec3 m_scale{1.0f, 1.0f, 1.0f};

    glm::mat4 m_local_transform{1.0f};

    glm::mat4 m_world_transform{1.0f};

    std::weak_ptr<Node> m_parent;

    std::vector<std::shared_ptr<Node>> m_children;

    std::shared_ptr<Mesh> m_mesh;

    std::shared_ptr<Light> m_light;

    std::shared_ptr<LOD> m_lod;

    void update_local_transform();
};
 
} // namespace scene
 
} // namespace lmgl