transform_component.h

Go to the documentation of this file.

#pragma once
 
#include "basic_component.h"
#include <bitset>
#include <math/math.h>
 
namespace unravel
{
 
auto is_roots_order_changed() -> bool;
void reset_roots_order_changed();
 
struct root_component : public component_crtp<root_component>
{
    static constexpr bool in_place_delete = false;
 
    static void on_create_component(entt::registry& r, entt::entity e);
 
    static void on_update_component(entt::registry& r, entt::entity e);
 
    static void on_destroy_component(entt::registry& r, entt::entity e);
 
 
 
    uint64_t order{};
};
 
struct active_component : public component_crtp<root_component>
{
};
 
class transform_component : public component_crtp<transform_component, owned_component>
{
public:
    using flags_t = std::bitset<8>;
    static void on_create_component(entt::registry& r, entt::entity e);
 
    static void on_destroy_component(entt::registry& r, entt::entity e);
 
    static auto get_top_level_entities(const std::vector<entt::handle>& list) -> std::vector<entt::handle>;
    static auto get_top_level_entities(const std::vector<entt::handle*>& list) -> std::vector<entt::handle>;
    static auto is_parent_of(entt::handle parent_to_test, entt::handle child) -> bool;
    //---------------------------------------------
    //---------------------------------------------
    void resolve_transform_global() noexcept;
 
    auto get_transform_global() const noexcept -> const math::transform&;
 
    auto set_transform_global(const math::transform& trans) noexcept -> bool;
    auto set_transform_global_epsilon(const math::transform& trans, float epsilon) noexcept -> bool;
 
    auto get_transform_local() const noexcept -> const math::transform&;
 
    void set_transform_local(const math::transform& trans) noexcept;
 
    //---------------------------------------------
    //---------------------------------------------
 
    auto get_position_global() const noexcept -> const math::vec3&;
 
    void set_position_global(const math::vec3& position) noexcept;
 
    void move_by_global(const math::vec3& amount) noexcept;
 
    void reset_position_global() noexcept;
 
    auto get_position_local() const noexcept -> const math::vec3&;
 
    void set_position_local(const math::vec3& position) noexcept;
 
    void move_by_local(const math::vec3& amount) noexcept;
 
    void reset_position_local() noexcept;
 
    auto set_position_and_rotation_global(const math::vec3& position,
                                          const math::quat& rotation,
                                          float epsilon) noexcept -> bool;
 
    //---------------------------------------------
    //---------------------------------------------
 
    auto get_rotation_global() const noexcept -> const math::quat&;
 
    void set_rotation_global(const math::quat& rotation) noexcept;
 
    void rotate_by_global(const math::quat& rotation) noexcept;
 
    void reset_rotation_global() noexcept;
 
    auto get_rotation_local() const noexcept -> const math::quat&;
 
    void set_rotation_local(const math::quat& rotation) noexcept;
 
    void rotate_by_local(const math::quat& rotation) noexcept;
 
    void reset_rotation_local() noexcept;
 
    auto get_rotation_euler_global() const noexcept -> math::vec3;
 
    void set_rotation_euler_global(math::vec3 rotation) noexcept;
 
    void rotate_by_euler_global(math::vec3 rotation) noexcept;
 
    auto get_rotation_euler_local() const noexcept -> math::vec3;
 
    void set_rotation_euler_local(math::vec3 rotation) noexcept;
 
    void rotate_by_euler_local(math::vec3 rotation) noexcept;
 
    void rotate_axis_global(float degrees, const math::vec3& axis) noexcept;
 
    void rotate_around_global(const math::vec3& point, const math::vec3& axis, float degrees);
 
    void rotate_around_global(const math::vec3& point, const math::quat& rotation);
 
    void look_at(const math::vec3& point) noexcept;
    void look_at(const math::vec3& point, const math::vec3& up) noexcept;
 
    //---------------------------------------------
    //---------------------------------------------
 
    auto get_scale_global() const noexcept -> const math::vec3&;
 
    void set_scale_global(const math::vec3& scale) noexcept;
 
    void scale_by_global(const math::vec3& scale) noexcept;
 
    void reset_scale_global() noexcept;
 
    auto get_scale_local() const noexcept -> const math::vec3&;
 
    void set_scale_local(const math::vec3& scale) noexcept;
 
    void scale_by_local(const math::vec3& scale) noexcept;
 
    void reset_scale_local() noexcept;
 
    //---------------------------------------------
    //---------------------------------------------
 
    auto get_skew_global() const noexcept -> const math::vec3&;
 
    void set_skew_global(const math::vec3& s) noexcept;
 
    auto get_skew_local() const noexcept -> const math::vec3&;
 
    void set_skew_local(const math::vec3& s) noexcept;
 
    //---------------------------------------------
    //---------------------------------------------
 
    auto get_perspective_global() const noexcept -> const math::vec4&;
 
    void set_perspective_global(const math::vec4& p) noexcept;
 
    auto get_perspective_local() const noexcept -> const math::vec4&;
 
    void set_perspective_local(const math::vec4& p) noexcept;
 
    //---------------------------------------------
    //---------------------------------------------
 
    auto get_x_axis_global() const noexcept -> math::vec3;
 
    auto get_x_axis_local() const noexcept -> math::vec3;
 
    auto get_y_axis_global() const noexcept -> math::vec3;
 
    auto get_y_axis_local() const noexcept -> math::vec3;
 
    auto get_z_axis_global() const noexcept -> math::vec3;
 
    auto get_z_axis_local() const noexcept -> math::vec3;
 
    //---------------------------------------------
    //---------------------------------------------
 
    auto to_local(const math::vec3& point) const noexcept -> math::vec3;
 
    //---------------------------------------------
    //---------------------------------------------
 
    auto get_parent() const noexcept -> entt::handle;
 
    auto set_parent(const entt::handle& parent, bool global_stays = true) -> bool;
 
    auto get_children() const noexcept -> const std::vector<entt::handle>&;
 
    void set_children(const std::vector<entt::handle>& children);
 
    void sort_children() noexcept;
 
    void set_active(bool active) noexcept;
 
    auto is_active() const noexcept -> bool;
 
    auto is_active_global() const noexcept -> bool;
 
    void set_dirty(bool dirty) noexcept;
 
    auto is_dirty() const noexcept -> bool;
 
    void set_dirty(uint8_t id, bool dirty) noexcept;
 
    auto is_dirty(uint8_t id) const noexcept -> bool;
 
    void _clear_relationships();
 
private:
    void set_owner(entt::handle owner);
 
    void apply_transform(const math::transform& tr) noexcept;
 
    auto inverse_parent_transform(const entt::handle& parent) noexcept -> math::transform;
 
    void on_dirty_transform(bool dirty) noexcept;
    void on_dirty_flags(bool dirty) noexcept;
    void on_flags_changed(flags_t flags);
    auto get_flags_global() const noexcept -> flags_t;
    auto resolve_global_value_transform() const noexcept -> math::transform;
    auto resolve_global_value_flags() const noexcept -> flags_t;
 
    void attach_child(const entt::handle& child, transform_component& child_transform);
 
    auto remove_child(const entt::handle& child, transform_component& child_transform) -> bool;
 
    int32_t sort_index_{-1};
 
    entt::handle parent_{};
    std::vector<entt::handle> children_{};
 
    template<typename T,
             typename Owner,
             void (Owner::*on_dirty)(bool),
             T (Owner::*resolve_global_value)() const,
             bool auto_resolve>
    struct local_global_property
    {
        auto set_value(Owner* owner, const T& val) noexcept -> bool
        {
            local = val;
 
            set_dirty(owner, true);
 
            return true;
        }
 
        auto get_value(const Owner* owner) const noexcept -> const T&
        {
            return local;
        }
 
        auto value(Owner* owner) noexcept -> T&
        {
            set_dirty(owner, true);
 
            return local;
        }
 
        void set_dirty(Owner* owner, bool flag) const noexcept
        {
            if(dirty == flag)
            {
                return;
            }
            dirty = flag;
 
            if(dirty)
            {
                assert(owner);
                (owner->*on_dirty)(flag);
            }
        }
 
        auto get_global_value(const Owner* owner, bool force) const noexcept -> const T&
        {
            if(force || auto_resolve && dirty)
            {
                assert(owner);
                global = (owner->*resolve_global_value)();
 
                set_dirty(const_cast<Owner*>(owner), false);
            }
 
            return global;
        }
 
        auto has_auto_resolve() const noexcept -> bool
        {
            return auto_resolve;
        }
 
        T local{};
        mutable T global{};
        mutable bool dirty{true};
    };
 
    using property_transform = local_global_property<math::transform,
                                                     transform_component,
                                                     &transform_component::on_dirty_transform,
                                                     &transform_component::resolve_global_value_transform,
                                                     true>;
 
    using property_flags = local_global_property<flags_t,
                                                 transform_component,
                                                 &transform_component::on_dirty_flags,
                                                 &transform_component::resolve_global_value_flags,
                                                 true>;
 
    enum flags_types
    {
        active,
        count = 8,
    };
 
    property_transform transform_{};
 
    property_flags flags_{};
    std::bitset<32> transform_dirty_{};
};
 
} // namespace unravel