camera-controls.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2023  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "game/controls.hpp"
#include "game/components/spring-arm-component.hpp"
#include "game/components/rigid-body-component.hpp"
#include "game/components/scene-component.hpp"
#include <engine/debug/log.hpp>
 
namespace {
    
    void handle_mouse_motion(::game& ctx, const input::mouse_moved_event& event)
    {
        if (ctx.active_camera_eid == entt::null)
        {
            return;
        }
        
        auto& spring_arm = ctx.entity_registry->get<spring_arm_component>(ctx.active_camera_eid);
        
        // Rotate camera
        if (ctx.camera_mouse_look_action.is_active())
        {
            // Adjust target pitch and yaw angles according to mouse motion
            auto target_angles = spring_arm.angles_spring.get_target_value();
            target_angles.x() -= ctx.mouse_tilt_factor * static_cast<double>(event.difference.y());
            target_angles.y() -= ctx.mouse_pan_factor * static_cast<double>(event.difference.x());
            
            // Apply angular constraints
            target_angles = math::clamp(target_angles, spring_arm.min_angles, spring_arm.max_angles);
            
            // Update spring arm target angles
            spring_arm.angles_spring.set_target_value(target_angles);
        }
        
        // Zoom camera
        if (ctx.camera_mouse_zoom_action.is_active())
        {
            // Adjust zoom factor
            spring_arm.zoom -= static_cast<double>(event.difference.y()) / static_cast<double>(ctx.window->get_viewport_size().y());
            
            // Limit zoom factor
            spring_arm.zoom = std::min<double>(std::max<double>(spring_arm.zoom, 0.0), 1.0);
        }
    }
    
    void load_camera_preset(::game& ctx,std::uint8_t index)
    {
        
    }
    
    void save_camera_preset(::game& ctx,std::uint8_t index)
    {
        
    }
    
    void step_camera_zoom(::game& ctx, double scale)
    {
        if (ctx.active_camera_eid == entt::null)
        {
            return;
        }
        
        auto& spring_arm = ctx.entity_registry->get<spring_arm_component>(ctx.active_camera_eid);
        auto target_angles = spring_arm.angles_spring.get_target_value();
        
        // Modulate target pitch angle
        target_angles.x() += (spring_arm.max_angles.x() - spring_arm.min_angles.x()) / ctx.zoom_steps * scale;
        
        // Apply angular constraints
        target_angles = math::clamp(target_angles, spring_arm.min_angles, spring_arm.max_angles);
        
        // Update spring arm target angles
        spring_arm.angles_spring.set_target_value(target_angles);
    }
    
    void update_relative_mouse_mode(::game& ctx)
    {
        if (ctx.camera_mouse_look_action.is_active() ||
            ctx.camera_mouse_drag_action.is_active() ||
            ctx.camera_mouse_zoom_action.is_active())
        {
            ctx.input_manager->set_relative_mouse_mode(true);
        }
        else
        {
            ctx.input_manager->set_relative_mouse_mode(false);
        }
    }
    
    void load_or_save_camera_preset(::game& ctx, std::uint8_t index)
    {
        if (ctx.camera_save_preset_action.is_active())
        {
            save_camera_preset(ctx, index);
        }
        else
        {
            load_camera_preset(ctx, index);
        }
    }
}
 
void setup_camera_controls(::game& ctx)
{
    // Camera mouse motion
    ctx.event_subscriptions.emplace_back
    (
        ctx.input_manager->get_event_dispatcher().subscribe<input::mouse_moved_event>
        (
            [&](const auto& event)
            {
                if (ctx.camera_action_map.is_enabled())
                {
                    handle_mouse_motion(ctx, event);
                }
            }
        )
    );
    
    // Camera mouse pick
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_mouse_pick_action.get_activated_channel().subscribe
        (
            [&](const auto& event)
            {
            }
        )
    );
    
    // Camera mouse look
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_mouse_look_action.get_activated_channel().subscribe
        (
            [&](const auto& event)
            {
                update_relative_mouse_mode(ctx);
            }
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_mouse_look_action.get_deactivated_channel().subscribe
        (
            [&](const auto& event)
            {
                update_relative_mouse_mode(ctx);
            }
        )
    );
    
    // Camera mouse drag
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_mouse_drag_action.get_activated_channel().subscribe
        (
            [&](const auto& event)
            {
                update_relative_mouse_mode(ctx);
                
                /*
                mouse_grip = ctx.toggle_mouse_grip ? !mouse_grip : true;
                
                if (mouse_grip)
                {
                    const auto& mouse_position = (*ctx.input_manager->get_mice().begin())->get_position();
                    
                    // Cast ray to plane
                    const auto mouse_ray = get_mouse_ray(mouse_position);
                    const auto intersection = geom::intersection(mouse_ray, mouse_grip_plane);
                    if (intersection)
                    {
                        mouse_grip_point = mouse_ray.origin + mouse_ray.direction * (*intersection);
                    }
                }
                
                ctx.input_manager->set_relative_mouse_mode(mouse_look || mouse_grip || mouse_zoom);
                */
            }
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_mouse_drag_action.get_deactivated_channel().subscribe
        (
            [&](const auto& event)
            {
                update_relative_mouse_mode(ctx);
            }
        )
    );
    
    // Camera mouse zoom
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_mouse_zoom_action.get_activated_channel().subscribe
        (
            [&](const auto& event)
            {
                update_relative_mouse_mode(ctx);
            }
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_mouse_zoom_action.get_deactivated_channel().subscribe
        (
            [&](const auto& event)
            {
                update_relative_mouse_mode(ctx);
            }
        )
    );
    
    // Camera zoom in
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_zoom_in_action.get_activated_channel().subscribe
        (
            [&](const auto& event)
            {
                step_camera_zoom(ctx, static_cast<double>(ctx.camera_zoom_in_action.get_input_value()));
            }
        )
    );
    
    // Camera zoom out
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_zoom_out_action.get_activated_channel().subscribe
        (
            [&](const auto& event)
            {
                step_camera_zoom(ctx, -static_cast<double>(ctx.camera_zoom_out_action.get_input_value()));
            }
        )
    );
    
    // Camera orbit left
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_orbit_left_action.get_active_channel().subscribe
        (
            [&](const auto& event)
            {
                if (ctx.active_camera_eid == entt::null)
                {
                    return;
                }
                
                auto& spring_arm = ctx.entity_registry->get<spring_arm_component>(ctx.active_camera_eid);
                spring_arm.angular_velocities.y() = -ctx.gamepad_pan_factor * static_cast<double>(event.input_value);
            }
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_orbit_left_action.get_deactivated_channel().subscribe
        (
            [&](const auto& event)
            {
                if (ctx.active_camera_eid == entt::null)
                {
                    return;
                }
                
                auto& spring_arm = ctx.entity_registry->get<spring_arm_component>(ctx.active_camera_eid);
                spring_arm.angular_velocities.y() = 0.0;
            }
        )
    );
    
    // Camera orbit right
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_orbit_right_action.get_active_channel().subscribe
        (
            [&](const auto& event)
            {
                if (ctx.active_camera_eid == entt::null)
                {
                    return;
                }
                
                auto& spring_arm = ctx.entity_registry->get<spring_arm_component>(ctx.active_camera_eid);
                spring_arm.angular_velocities.y() = ctx.gamepad_pan_factor * static_cast<double>(event.input_value);
            }
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_orbit_right_action.get_deactivated_channel().subscribe
        (
            [&](const auto& event)
            {
                if (ctx.active_camera_eid == entt::null)
                {
                    return;
                }
                
                auto& spring_arm = ctx.entity_registry->get<spring_arm_component>(ctx.active_camera_eid);
                spring_arm.angular_velocities.y() = 0.0;
            }
        )
    );
    
    // Camera orbit up
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_orbit_up_action.get_active_channel().subscribe
        (
            [&](const auto& event)
            {
                if (ctx.active_camera_eid == entt::null)
                {
                    return;
                }
                
                auto& spring_arm = ctx.entity_registry->get<spring_arm_component>(ctx.active_camera_eid);
                spring_arm.angular_velocities.x() = ctx.gamepad_tilt_factor * static_cast<double>(event.input_value);
            }
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_orbit_up_action.get_deactivated_channel().subscribe
        (
            [&](const auto& event)
            {
                if (ctx.active_camera_eid == entt::null)
                {
                    return;
                }
                
                auto& spring_arm = ctx.entity_registry->get<spring_arm_component>(ctx.active_camera_eid);
                spring_arm.angular_velocities.x() = 0.0;
            }
        )
    );
    
    // Camera orbit down
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_orbit_down_action.get_active_channel().subscribe
        (
            [&](const auto& event)
            {
                if (ctx.active_camera_eid == entt::null)
                {
                    return;
                }
                
                auto& spring_arm = ctx.entity_registry->get<spring_arm_component>(ctx.active_camera_eid);
                spring_arm.angular_velocities.x() = -ctx.gamepad_tilt_factor * static_cast<double>(event.input_value);
            }
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_orbit_down_action.get_deactivated_channel().subscribe
        (
            [&](const auto& event)
            {
                if (ctx.active_camera_eid == entt::null)
                {
                    return;
                }
                
                auto& spring_arm = ctx.entity_registry->get<spring_arm_component>(ctx.active_camera_eid);
                spring_arm.angular_velocities.x() = 0.0;
            }
        )
    );
    
    // Camera look ahead
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_look_ahead_action.get_activated_channel().subscribe
        (
            [&](const auto& event)
            {
                if (ctx.active_camera_eid == entt::null || ctx.controlled_ant_eid == entt::null)
                {
                    return;
                }
                
                auto& spring_arm = ctx.entity_registry->get<spring_arm_component>(ctx.active_camera_eid);
                const auto& subject_rigid_body = *ctx.entity_registry->get<rigid_body_component>(ctx.controlled_ant_eid).body;
                
                
                // Determine camera up direction
                const auto camera_up = math::fvec3(spring_arm.up_rotation * math::dvec3{0, 1, 0});
 
                // Get spring arm target angles
                auto target_angles = spring_arm.angles_spring.get_target_value();
 
                
                // Determine camera forward direction
                const auto camera_yaw_rotation = math::angle_axis(target_angles.y(), {0.0, 1.0, 0.0});
                const auto camera_pitchless_orientation = math::normalize(spring_arm.up_rotation * camera_yaw_rotation);
                const auto camera_forward = math::fvec3(camera_pitchless_orientation * math::dvec3{0, 0, -1});
                
                // Determine subject forward direction
                const auto subject_forward = subject_rigid_body.get_transform().rotation * math::fvec3{0, 0, 1};
                
                // Find signed angle between the two forward directions about camera up axis
                const auto angular_difference = math::signed_angle(camera_forward, subject_forward, camera_up);
                
                // Add angular difference to spring arm target yaw angle
                target_angles.y() += angular_difference;
                
                // Update spring arm target angles
                spring_arm.angles_spring.set_target_value(target_angles);
            }
        )
    );
    
    // Camera presets
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_preset_1_action.get_activated_channel().subscribe
        (
            [&](const auto& event) {load_or_save_camera_preset(ctx, 0);}
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_preset_2_action.get_activated_channel().subscribe
        (
            [&](const auto& event) {load_or_save_camera_preset(ctx, 1);}
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_preset_3_action.get_activated_channel().subscribe
        (
            [&](const auto& event) {load_or_save_camera_preset(ctx, 2);}
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_preset_4_action.get_activated_channel().subscribe
        (
            [&](const auto& event) {load_or_save_camera_preset(ctx, 3);}
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_preset_5_action.get_activated_channel().subscribe
        (
            [&](const auto& event) {load_or_save_camera_preset(ctx, 4);}
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_preset_6_action.get_activated_channel().subscribe
        (
            [&](const auto& event) {load_or_save_camera_preset(ctx, 5);}
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_preset_7_action.get_activated_channel().subscribe
        (
            [&](const auto& event) {load_or_save_camera_preset(ctx, 6);}
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_preset_8_action.get_activated_channel().subscribe
        (
            [&](const auto& event) {load_or_save_camera_preset(ctx, 7);}
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_preset_9_action.get_activated_channel().subscribe
        (
            [&](const auto& event) {load_or_save_camera_preset(ctx, 8);}
        )
    );
    ctx.event_subscriptions.emplace_back
    (
        ctx.camera_preset_10_action.get_activated_channel().subscribe
        (
            [&](const auto& event) {load_or_save_camera_preset(ctx, 9);}
        )
    );
}
 
void enable_camera_controls(::game& ctx)
{
    ctx.camera_action_map.enable();
}
 
void disable_camera_controls(::game& ctx)
{
    ctx.camera_action_map.disable();
    ctx.camera_action_map.reset();
}