director.h

Go to the documentation of this file.

#pragma once
 
#include <Strings/components/classes/events/events.h>
#include "components/core/world/world.h"
 
#include <vector>
#include <map>
 
#ifndef BLAM
#define BLAM
#endif
 
class BlamDirector : BlamEventListener
{
private:
    bool mouse_capture_state_changed = false; 
    int current_speed_index = 0; 
 
    std::vector<float> camera_speeds = {
        1.000000f,
        5.000000f,
        20.00000f,
        40.000000f,
        100.000000f
    };
 
    int viewport_center_x = 0; 
    int viewport_center_y = 0; 
 
    bool zoom_state_changed = false; 
    float zoom_increment = 0.0f;
 
    std::map<BlamDirection, float> move_accelerations = {
        std::pair<BlamDirection, float>(BlamDirection::Forward, 0.0f),
        std::pair<BlamDirection, float>(BlamDirection::Backward, 0.0f),
        std::pair<BlamDirection, float>(BlamDirection::Left, 0.0f),
        std::pair<BlamDirection, float>(BlamDirection::Right, 0.0f),
        std::pair<BlamDirection, float>(BlamDirection::Up, 0.0f),
        std::pair<BlamDirection, float>(BlamDirection::Down, 0.0f)
    };
 
    std::map<BlamDirection, float> look_accelerations = {
        std::pair<BlamDirection, float>(BlamDirection::Up, 0.0f),
        std::pair<BlamDirection, float>(BlamDirection::Down, 0.0f),
        std::pair<BlamDirection, float>(BlamDirection::Left, 0.0f),
        std::pair<BlamDirection, float>(BlamDirection::Right, 0.0f)
    };
 
    float accel_increment = 0.0f;
 
    BlamVector3 camera_velocity = BlamVector3();
    BlamVector3 camera_coast_velocity = BlamVector3();
    BlamVector3 camera_spring_velocity = BlamVector3();
    BlamVector2 look_input_accumulator = BlamVector2();
    BlamVector2 look_velocity = BlamVector2();
    BlamVector2 look_coast_velocity = BlamVector2();
    BlamVector2 look_spring_velocity = BlamVector2();
    bool look_was_turning = false;
    float fov_spring_velocity = 0.0f;
 
public:
    BlamVector3 camera_pos = BlamVector3();   
    BlamVector3 camera_angle = BlamVector3(); 
 
    bool auto_verify_coords = true; 
    BlamVector3 camera_front = BlamVector3(); 
    BlamVector3 camera_right = BlamVector3(); 
 
    bool mouse_capture_ready = false;  
    int mouse_capture_delay_ticks = 3; 
 
    bool mouse_captured = false;      
    float fov = 70.0f;                
    float fov_normal = 70.0f;         
    float fov_zoomed = 20.0f;         
    float speed = 1.0f;               
    float zoom_increment_count = 30;  
    bool lock_camera = false;         
    bool pancam = true;               
    bool pancam_lock_xy = false;      
    bool move_acceleration = true;    
    bool look_acceleration = false;   
    float accel_increment_count = 30; 
    bool camera_bouncing = true;     
    bool zoomed = false;              
    float look_sensetivity_vertical = 0.35f;  
    float look_sensetivity_horizontal = 0.7f; 
    bool persistent_look_motion = false; 
    bool tick_based_looking = false;     
 
    bool calculate_angle = true;
    float horizontal_angle = 0.0f;
    float vertical_angle = 0.0f;
 
    float near_clip_plane_distance = 0.1f;
    float far_clip_plane_distance = 100.0f;
 
    bool enable_movement_spring = true; 
    float spring_stiffness = 0.3f;      
    float damping = 0.6f;               
    float movement_spring_scale = 1.0f; 
 
    bool enable_look_spring = true;     
    float look_spring_stiffness = 0.3f; 
    float look_damping = 0.6f;          
    float look_accel_rate = 0.3f;       
 
    bool enable_zoom_spring = true;     
    float fov_spring_stiffness = 0.05f; 
    float fov_damping = 0.8f;           
    float fov_spring_scale = 0.45f;     
 
    BlamDirector();
 
    ~BlamDirector();
 
    void OnNewFrameEvent(NewFrameEvent* event) override;
    void OnTickEvent(TickEvent* event) override;
    void OnMouseMoveEvent(MouseMoveEvent* event) override;
    void OnMouseClickEvent(MouseClickEvent* event) override;
    void OnKeyPressEvent(KeyPressEvent* event) override;
 
    BlamVector3 MoveCamera(BlamDirection direction, float acceleration);
 
    void ValidateCameraCoords();
 
    void CalculateCameraAngles();
 
    void SetCameraSpeed(float _speed);
};
 
class BlamDirector2D : BlamEventListener
{
private:
    BlamVector3 click_start_camera_pos = BlamVector3();
    BlamVector2 click_start_point = BlamVector2();
    bool clicking = false;
 
public:
    BlamVector3 camera_pos = BlamVector3();
    BlamVector3 camera_direction = { 0, 0, 1 };
    float zoom = 0.0f;
    bool lock_camera = false; 
 
    float near_clip_plane_distance = 0.000001f;
    float far_clip_plane_distance = 100000.0f;
 
    BlamDirector2D();
 
    void OnMouseMoveEvent(MouseMoveEvent* event) override;
    void OnMouseClickEvent(MouseClickEvent* event) override;
    void OnMouseUnclickEvent(MouseUnclickEvent* event) override;
    void OnKeyPressEvent(KeyPressEvent* event) override;
    void OnMouseWheelEvent(MouseWheelEvent* event) override;
};
 
namespace Blam::Director
{
    BLAM void PrepareCamera();
 
    BLAM void ShutdownCamera();
 
    BLAM BlamDirector* GetCamera();
 
    BLAM void SetCamera2DMode(bool use_2d, bool copy_from_last = false);
 
    BLAM BlamDirector2D* GetCamera2D();
 
    BLAM bool Use2DCamera();
}