starsystemcontroller.h

Go to the documentation of this file.

/* Conquer Space
 * Copyright (C) 2021-2025 Conquer Space
 *
 * This program 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.
 *
 * This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
 */
#pragma once
 
#include <optional>
 
#include <glm/glm.hpp>
 
#include "client/components/clientctx.h"
#include "client/scenes/universe/views/starsystemcamera.h"
#include "core/components/bodies.h"
#include "core/components/coordinates.h"
#include "core/components/surface.h"
#include "core/universe.h"
#include "engine/application.h"
 
namespace cqsp::client::systems {
class StarSystemViewUI;
class SysStarSystemRenderer;
class StarSystemController {
 public:
    StarSystemController(core::Universe &, engine::Application &, StarSystemCamera &, SysStarSystemRenderer &);
    void Update(float delta_time);
 
    // Gets the intersection in 3d point between the mouse and any planet
    glm::vec3 GetMouseOnObjectPosition() { return mouse_on_object_position; }
 
    glm::quat GetBodyRotation(double axial, double rotation, double day_offset) const;
    glm::quat GetBodyRotation(const core::components::bodies::Body &body) const;
 
    bool ShouldDrawCityPrototype();
 
    glm::vec3 CalculateCenteredObject(const entt::entity &);
    glm::vec3 CalculateCenteredObject(const glm::vec3 &);
 
    glm::vec3 CalculateObjectPos(const entt::entity &ent);
 
    void FocusOnProvince(entt::entity province);
    void FocusOnProvinceListener(const ctx::ViewProvince &province);
 
    void PreRender();
 
    entt::entity m_viewing_entity = entt::null;
 
    glm::vec3 CalculateFuturePosition(const entt::entity entity);
    glm::vec3 CalculateFutureCenteredPosition(const entt::entity entity);
 
    entt::entity GetSelectedCountry() { return selected_country; }
 
 private:
    void SeeEntity();
    void CenterCameraOnCity();
    void MoveCamera(double delta_time);
 
    void FocusOnEntity(entt::entity ent);
    void SeePlanet(entt::entity ent);
 
    void CalculateScroll();
    float GetScrollValue();
 
    void FocusPlanetView();
    void FocusCityView();
    void HandleCameraMovement(float delta_time);
 
    void CalculateCityPositions(entt::entity entity);
 
    void CenterCameraOnPoint();
    void SetCameraToPlanetReferenceFrame();
    void SetCameraToSolarSystemReferenceFrame();
    void FoundCity();
    bool IsFoundingCity();
 
    void UpdateMapMode();
 
    glm::vec3 CalculateMouseRay(const glm::vec3 &ray_nds);
    entt::entity GetMouseOnObject(int mouse_x, int mouse_y);
    void CalculateViewChange(double deltaX, double deltaY);
 
    core::components::types::SurfaceCoordinate GetMouseSurfaceIntersection();
 
    glm::vec3 GetMouseInScreenSpace(int mouse_x, int mouse_y);
    std::optional<glm::vec3> CheckIntersection(const glm::vec3 &object_pos, const glm::vec3 &ray_wor, float radius);
 
    void SetCountryProvincesColor(entt::entity country);
    void SetCountryProvincesToProvinceColor(entt::entity country);
    void HandleProvinceHoverColor();
 
    glm::vec4 GetCountryProvinceColor(entt::entity province);
    glm::vec4 ColonizationTargetProvinceColor(entt::entity province);
 
    void SelectProvince();
 
    void ResetProvinceColor(entt::entity province);
    void SelectForeignProvince(entt::entity province);
    void SelectDomesticProvince(entt::entity province);
 
    void HandleHoverTooltip();
    bool MouseOverObjectBillboard(glm::vec3 object_pos);
    std::optional<glm::vec3> IsMouseOverEntity(entt::entity entity, glm::vec3 ray_wor, double radius);
 
    void CheckHoveringEntity();
    entt::entity SurfaceCoordinateToProvince(core::components::types::SurfaceCoordinate coordinate,
                                             entt::entity planet);
 
    glm::vec4 CountryColorToVec4(const glm::vec3 &color);
    glm::vec4 CountryColorToVec4(const core::components::ProvinceColor &color);
    glm::vec4 CountryColorToVec4(const entt::entity province);
    glm::vec4 GetCountrySelectionColor(const glm::vec3 &country_color);
    glm::vec3 MixScale(float amount);
 
    core::Universe &universe;
    engine::Application &app;
 
    StarSystemCamera &camera;
    SysStarSystemRenderer &renderer;
 
    entt::entity terrain_displaying = entt::null;
    entt::entity selected_city = entt::null;
 
    double previous_mouseX = 0;
    double previous_mouseY = 0;
 
    int tex_x = 0;
    int tex_y = 0;
 
    int tex_r = 0;
    int tex_g = 0;
    int tex_b = 0;
 
    entt::entity hovering_province;
 
    entt::entity hovering_planet = entt::null;
    entt::entity hovering_country = entt::null;
    entt::entity selected_province = entt::null;
    entt::entity selected_country = entt::null;
 
    glm::vec3 mouse_on_object_position = glm::vec3(0);
 
    bool is_rendering_founding_city = false;
    bool is_founding_city = false;
 
    bool focus_on_city = false;
    bool planet_frame_scroll = false;
 
    const float CAMERA_MOVEMENT_SPEED = 30.f / 40.f;
    const float PAN_SPEED = 2.0f;
    const float SCROLL_SENSITIVITY = 3.f / 33.f;
    const float DEFAULT_PROVINCE_APLHA = 0.65f;
 
    core::components::types::SurfaceCoordinate target_surface_coordinate =
        core::components::types::SurfaceCoordinate(0, 0);
 
    core::components::types::SurfaceCoordinate GetCameraOverCoordinate();
 
    friend StarSystemViewUI;
 
    const glm::vec4 selected_province_color = glm::vec4(1.f, 0.f, 0.f, 0.35f);
 
    ctx::MapMode last_map_mode = ctx::MapMode::NoMapMode;
 
    entt::entity focused_planet = entt::null;
    entt::entity last_focused_planet = entt::null;
    entt::entity last_hovered_province = entt::null;
 
    enum CameraState {
        // Free camera just going anywhere
        FreeCamera,
        // Fixed on the planet/body but not rotating
        PlanetIntertial,
        // Fixed to a spot on the planet's surface
        PlanetFixed
    };
 
    CameraState camera_state = CameraState::FreeCamera;
};
}  // namespace cqsp::client::systems