transform_actions.cpp

Go to the documentation of this file.

#include "transform_actions.h"
#include "base/basetypes.hpp"
#include <editor/hub/panels/inspector_panel/inspectors/inspectors.h>
 
namespace unravel
{
 
// Transform Move Action Implementation
transform_move_action_t::transform_move_action_t(entt::handle ent, const math::vec3& old_pos, const math::vec3& new_pos)
    : entity(ent), old_position(old_pos), new_position(new_pos)
{
    name = "Position";
}
 
void transform_move_action_t::do_action()
{
    if (entity)
    {
        if (auto transform = entity.try_get<transform_component>())
        {
            transform->set_position_local(new_position);
            prefab_override_context::mark_transform_as_changed(entity, true, false, false, false);
        }
    }
}
 
void transform_move_action_t::undo_action()
{
    if (entity)
    {
        if (auto transform = entity.try_get<transform_component>())
        {
            transform->set_position_local(old_position);
            prefab_override_context::mark_transform_as_changed(entity, true, false, false, false);
        }
    }
}
 
auto transform_move_action_t::is_mergeable(const editing_action_t& previous) const -> bool
{
    const auto& prev = static_cast<const transform_move_action_t&>(previous);
    return entity == prev.entity && name == prev.name;
}
 
void transform_move_action_t::merge_with(const editing_action_t& previous)
{
    const auto& prev = static_cast<const transform_move_action_t&>(previous);
    old_position = prev.old_position; // Extend the range of the move
}
 
auto transform_move_action_t::is_valid() const -> bool
{
    return entity.valid() && entity.try_get<transform_component>();
}   
 
 
void transform_move_action_t::draw_in_inspector(rtti::context& ctx)
{
    auto custom = entt::make_custom<entt::attributes>(entt::attributes{
        {"name", "position"}, 
        {"pretty_name", "Position"}}
    );
    draw_in_inspector_impl(ctx, old_position, new_position, custom);
}
 
// Transform Move Global Action Implementation
transform_move_global_action_t::transform_move_global_action_t(entt::handle ent, const math::vec3& old_pos, const math::vec3& new_pos)
    : entity(ent), old_position(old_pos), new_position(new_pos)
{
    name = "Global Position";
}
 
void transform_move_global_action_t::do_action()
{
    if (entity)
    {
        if (auto transform = entity.try_get<transform_component>())
        {
            transform->set_position_global(new_position);
            prefab_override_context::mark_transform_global_as_changed(entity, true, false, false, false);
        }
    }
}
 
void transform_move_global_action_t::undo_action()
{
    if (entity)
    {
        if (auto transform = entity.try_get<transform_component>())
        {
            transform->set_position_global(old_position);
            prefab_override_context::mark_transform_global_as_changed(entity, true, false, false, false);
        }
    }
}
 
auto transform_move_global_action_t::is_mergeable(const editing_action_t& previous) const -> bool
{
    const auto& prev = static_cast<const transform_move_global_action_t&>(previous);
    return entity == prev.entity && name == prev.name;
}
 
void transform_move_global_action_t::merge_with(const editing_action_t& previous)
{
    const auto& prev = static_cast<const transform_move_global_action_t&>(previous);
    old_position = prev.old_position; // Extend the range of the move
}
 
auto transform_move_global_action_t::is_valid() const -> bool
{
    return entity.valid() && entity.try_get<transform_component>();
}   
 
void transform_move_global_action_t::draw_in_inspector(rtti::context& ctx)
{
    auto custom = entt::make_custom<entt::attributes>(entt::attributes{
        {"name", "global_position"}, 
        {"pretty_name", "Global Position"}}
    );
    draw_in_inspector_impl(ctx, old_position, new_position, custom);
}
 
// Transform Rotate Action Implementation
transform_rotate_action_t::transform_rotate_action_t(entt::handle ent, const math::quat& old_rot, const math::quat& new_rot)
    : entity(ent), old_rotation(old_rot), new_rotation(new_rot)
{
    name = "Rotation";
}
 
void transform_rotate_action_t::do_action()
{
    if (entity)
    {
        if (auto transform = entity.try_get<transform_component>())
        {
            transform->set_rotation_local(new_rotation);
            prefab_override_context::mark_transform_as_changed(entity, false, true, false, false);
        }
    }
}
 
void transform_rotate_action_t::undo_action()
{
    if (entity)
    {
        if (auto transform = entity.try_get<transform_component>())
        {
            transform->set_rotation_local(old_rotation);
            prefab_override_context::mark_transform_as_changed(entity, false, true, false, false);
        }
    }
}
 
auto transform_rotate_action_t::is_mergeable(const editing_action_t& previous) const -> bool
{
    const auto& prev = static_cast<const transform_rotate_action_t&>(previous);
    return entity == prev.entity && name == prev.name;
}
 
void transform_rotate_action_t::merge_with(const editing_action_t& previous)
{
    const auto& prev = static_cast<const transform_rotate_action_t&>(previous);
    old_rotation = prev.old_rotation; // Extend the range of the rotation
}
 
auto transform_rotate_action_t::is_valid() const -> bool
{
    return entity.valid() && entity.try_get<transform_component>();
}
 
void transform_rotate_action_t::draw_in_inspector(rtti::context& ctx)
{
    auto custom = entt::make_custom<entt::attributes>(entt::attributes{
        {"name", "rotation"}, 
        {"pretty_name", "Rotation"}}
    );
    draw_in_inspector_impl(ctx, old_rotation, new_rotation, custom);
}
 
 
// Transform Scale Action Implementation
transform_scale_action_t::transform_scale_action_t(entt::handle ent, const math::vec3& old_sc, const math::vec3& new_sc)
    : entity(ent), old_scale(old_sc), new_scale(new_sc)
{
    name = "Scale";
}
 
void transform_scale_action_t::do_action()
{
    if (entity)
    {
        if (auto transform = entity.try_get<transform_component>())
        {
            transform->set_scale_local(new_scale);
            prefab_override_context::mark_transform_as_changed(entity, false, false, true, false);
        }
    }
}
 
void transform_scale_action_t::undo_action()
{
    if (entity)
    {
        if (auto transform = entity.try_get<transform_component>())
        {
            transform->set_scale_local(old_scale);
            prefab_override_context::mark_transform_as_changed(entity, false, false, true, false);
        }
    }
}
 
auto transform_scale_action_t::is_mergeable(const editing_action_t& previous) const -> bool
{
    const auto& prev = static_cast<const transform_scale_action_t&>(previous);
    return entity == prev.entity && name == prev.name;
}
 
void transform_scale_action_t::merge_with(const editing_action_t& previous)
{
    const auto& prev = static_cast<const transform_scale_action_t&>(previous);
    old_scale = prev.old_scale; // Extend the range of the scale
}
 
auto transform_scale_action_t::is_valid() const -> bool
{
    return entity.valid() && entity.try_get<transform_component>();
}
 
void transform_scale_action_t::draw_in_inspector(rtti::context& ctx)
{
    auto custom = entt::make_custom<entt::attributes>(entt::attributes{
        {"name", "scale"}, 
        {"pretty_name", "Scale"}}
    );
    draw_in_inspector_impl(ctx, old_scale, new_scale, custom);
}
 
 
// Transform Skew Action Implementation
transform_skew_action_t::transform_skew_action_t(entt::handle ent, const math::vec3& old_sk, const math::vec3& new_sk)
    : entity(ent), old_skew(old_sk), new_skew(new_sk)
{
    name = "Skew";
}
 
void transform_skew_action_t::do_action()
{
    if (entity)
    {
        if (auto transform = entity.try_get<transform_component>())
        {
            transform->set_skew_local(new_skew);
            prefab_override_context::mark_transform_as_changed(entity, false, false, false, true);
        }
    }
}
 
void transform_skew_action_t::undo_action()
{
    if (entity)
    {
        if (auto transform = entity.try_get<transform_component>())
        {
            transform->set_skew_local(old_skew);
            prefab_override_context::mark_transform_as_changed(entity, false, false, false, true);
        }
    }
}
 
auto transform_skew_action_t::is_mergeable(const editing_action_t& previous) const -> bool
{
    const auto& prev = static_cast<const transform_skew_action_t&>(previous);
    return entity == prev.entity && name == prev.name;
}
 
void transform_skew_action_t::merge_with(const editing_action_t& previous)
{
    const auto& prev = static_cast<const transform_skew_action_t&>(previous);
    old_skew = prev.old_skew; // Extend the range of the skew
}
 
auto transform_skew_action_t::is_valid() const -> bool
{
    return entity.valid() && entity.try_get<transform_component>();
}
 
void transform_skew_action_t::draw_in_inspector(rtti::context& ctx)
{
    auto custom = entt::make_custom<entt::attributes>(entt::attributes{
        {"name", "skew"}, 
        {"pretty_name", "Skew"}}
    );
    draw_in_inspector_impl(ctx, old_skew, new_skew, custom);
}
 
 
} // namespace unravel