Node.h

//
//  Node.h
//  avara3d
//
//  Created by Morgan Davis on 10/20/16.
//  Copyright © 2026 Morgan K Davis. All rights reserved.
//
 
#ifndef AVARA3D_SCENE_NODE_H
#define AVARA3D_SCENE_NODE_H
 
#include <climits>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include "a3d/mesh/AABB.h"
#include "a3d/util/Bitmask.h"
 
namespace a3d {
 
class Camera;
class Light;
class Mesh;
class Renderer;
class RenderContext;
class RenderItem;
class Scene;
class PhysicsWorld;
class PhysicsBody;
class VisualWorld;
 
class Node : public std::enable_shared_from_this<Node> {
 
public:
    // [Public Types]
 
    // TODO: probably move these
    enum class DebugOptions : uint32_t {
        None              = 0,      
        ShowHighlightBox  = 1 << 0, 
        ShowHighlightTint = 1 << 1  
    };
 
    // [Public Static Member Functions]
 
    static std::shared_ptr<Node> NamedNode(const std::string& name);
 
    static std::shared_ptr<Node> MeshNode(const std::shared_ptr<Mesh>& geometry);
 
    static std::shared_ptr<Node> LightNode(const std::shared_ptr<Light>& light);
 
    static std::shared_ptr<Node> CameraNode(const std::shared_ptr<Camera>& camera);
 
    // [Public Lifecycle Functions]
 
    Node();
 
    explicit Node(const std::string& name);
 
    explicit Node(const std::shared_ptr<Mesh>& mesh);
 
    explicit Node(const std::shared_ptr<Light>& light);
 
    explicit Node(const std::shared_ptr<Camera>& camera);
 
    Node(const Node&)            = delete;
    Node& operator=(const Node&) = delete;
 
    Node(Node&&)            = delete;
    Node& operator=(Node&&) = delete;
 
    ~Node();
 
    // [Public Member Functions]
 
    const std::optional<std::string>& name() const;
 
    void                              name(const std::string& name);
 
    const std::shared_ptr<Mesh>&      mesh() const;
 
    void                              mesh(const std::shared_ptr<Mesh>& mesh);
 
    const std::shared_ptr<Light>&     light() const;
 
    void                              light(const std::shared_ptr<Light>& light);
 
    const std::shared_ptr<Camera>&    camera() const;
 
    void                              camera(const std::shared_ptr<Camera>& camera);
 
    PhysicsBody*                      physicsBody() const;
 
    void                              physicsBody(std::unique_ptr<PhysicsBody> body);
 
    const math::vec3&                 position() const;
 
    void                              position(const math::vec3& position);
 
    math::vec4                        rotation() const;
 
    void                              rotation(const math::vec3& axis, float angle);
 
    math::vec3                        eulerAngles() const;
 
    void                              eulerAngles(const math::vec3& angles);
 
    const math::quat&                 orientation() const;
 
    void                              orientation(const math::quat& orientation);
 
    const math::vec3&                 scale() const;
 
    void                              scale(const math::vec3& scale);
 
    math::vec3                        forward() const;
 
    math::vec3                        up() const;
 
    math::vec3                        right() const;
 
    math::mat4                        transform() const;
 
    void                              transform(const math::mat4& transform);
 
    math::vec3                        worldPosition() const;
 
    math::vec4                        worldRotation() const;
 
    math::vec3                        worldEulerAngles() const;
 
    math::quat                        worldOrientation() const;
 
    math::vec3                        worldScale() const;
 
    math::vec3                        worldForward() const;
 
    math::vec3                        worldUp() const;
 
    math::vec3                        worldRight() const;
 
    math::mat4                        worldTransform() const;
 
    math::vec3                        convertFrom(const math::vec3& pos, const Node& from);
 
    math::vec3                        convertTo(const math::vec3& pos, const Node& to);
 
    math::mat4                        convertFrom(const math::mat4& t, const Node& from);
 
    math::mat4                        convertTo(const math::mat4& t, const Node& to);
 
    void                              addChild(const std::shared_ptr<Node>& node, bool reparent = false);
 
    void addChildren(const std::vector<std::shared_ptr<Node>>& nodes, bool reparent = false);
 
    void removeFromParent();
 
    std::vector<std::shared_ptr<Node>> children(bool recursive = false) const;
 
    std::shared_ptr<Node>              childNamed(const std::string& name, bool recursive = false) const;
 
    bool                               hidden() const;
 
    void                               hidden(bool hidden);
 
    int                                renderOrder() const;
 
    void                               renderOrder(int order);
 
    DebugOptions                       debugOptions() const;
 
    void                               debugOptions(DebugOptions options);
 
    Scene*                             scene() const;
 
    std::weak_ptr<Node>                parent() const;
 
    // [Internal Types]
 
    enum class DirtyMask : uint32_t {
        None           = 0,
        WorldTransform = 1 << 0,
        All            = UINT_MAX
    };
 
    // [Internal Member Functions]
 
    void          attachedToParent(Node& parent);
    void          detachedFromParent(Node& parent);
 
    void          attachedToScene(Scene& scene);
    void          detachedFromScene(Scene& scene);
 
    void          ancestorAttachedToParent(Node& ancestor, Node& parent);
    void          ancestorDetachedFromParent(Node& ancestor, Node& parent);
 
    void          ancestorAttachedToScene(Node& ancestor, Scene& scene);
    void          ancestorDetachedFromScene(Node& ancestor, Scene& scene);
 
    void          visualWorldAttachedToScene(VisualWorld& world, Scene& scene);
    void          visualWorldDetachedFromScene(VisualWorld& world, Scene& scene);
 
    void          physicsWorldAttachedToScene(PhysicsWorld& world, Scene& scene);
    void          physicsWorldDetachedFromScene(PhysicsWorld& world, Scene& scene);
 
    VisualWorld*  visualWorld() const;
    PhysicsWorld* physicsWorld() const;
 
    void          checkNotifyPhysicsBodyOfReachablePhysicsWorld() const;
    void          checkNotifyPhysicsBodyOfUnreachablePhysicsWorld() const;
 
    bool          containsChild(const std::shared_ptr<Node>& node);
 
    AABB          aabb(bool vertfit = false) const; // recursive world AABB
    math::vec3    extent(bool vertfit = false) const; // recursive world extent
 
    void          applyPhysicsTransform(const math::mat4& transform);
 
    void          _debugPrint();
    void          _debugPrintRec(Node& node, unsigned level);
 
private:
    // [Private Member Functions]
 
    void                               getAABBRec(AABB& aabb);
 
    void                               setTransformComponents(const math::mat4& transform);
    void                               syncPhysicsTransforms();
 
    std::vector<std::shared_ptr<Node>> children(const Node& root) const;
    void childrenRec(const std::shared_ptr<Node>& node, std::vector<std::shared_ptr<Node>>& children) const;
 
    DirtyMask                          dirtyMask() const;
    void                               dirtyMask(DirtyMask mask);
 
    // [Private Member Variables]
 
    std::optional<std::string>         _name;
    std::shared_ptr<Light>             _light;
    std::shared_ptr<Camera>            _camera;
    std::shared_ptr<Mesh>              _mesh;
    std::vector<std::shared_ptr<Node>> _children;
    math::vec3                         _position;
    math::quat                         _orientation;
    math::vec3                         _scale;
    mutable std::optional<math::vec3>  _eulerAngles;
    std::unique_ptr<PhysicsBody>       _physicsBody;
    bool                               _hidden;
    int                                _renderOrder;
    DebugOptions                       _debugOptions;
    Scene*                             _scene;
    std::weak_ptr<Node>                _parent;
    DirtyMask                          _dirtyMask;
};
 
namespace util::bitmask {
 
    template<>
    struct enable_ops<Node::DebugOptions> : std::true_type {};
 
    template<>
    struct enable_ops<Node::DirtyMask> : std::true_type {};
 
} // namespace util::bitmask
} // namespace a3d
 
#endif // AVARA3D_SCENE_NODE_H