TurntableCameraController.h

//
//  TurntableCameraController.h
//  avara3d
//
//  Created by Morgan Davis on 8/9/26.
//  Copyright © 2026 Morgan K Davis. All rights reserved.
//
 
#ifndef AVARA3D_EXTENSION_CAMERA_TURNTABLECAMERACONTROLLER_H
#define AVARA3D_EXTENSION_CAMERA_TURNTABLECAMERACONTROLLER_H
 
#include <memory>
#include <optional>
#include <variant>
 
#include "a3d/Math.h"
#include "a3d/input/DesktopInputContext.h"
 
namespace a3d {
 
class Node;
 
} // namespace a3d
 
namespace a3d::ext {
 
class TurntableCameraController {
 
public:
    // [Public Types]
 
    struct NodeTarget {
 
        std::weak_ptr<Node> node; 
        math::vec3          localPosition {0.0f}; 
    };
 
    using Target = std::variant<math::vec3, NodeTarget>;
 
    struct View {
 
        Target target {math::vec3 {0.0f}}; 
        float  yaw {0.0f}; 
        float  pitch {0.0f}; 
        float  distance {10.0f}; 
    };
 
    struct Controls {
 
        DesktopInputContext::MouseButton orbitButton {
            DesktopInputContext::MouseButton::One}; 
        DesktopInputContext::MouseButton panButton {
            DesktopInputContext::MouseButton::Two}; 
        DesktopInputContext::Key panModifier {
            DesktopInputContext::Key::LeftShift}; 
        DesktopInputContext::Key dollyModifier {
            DesktopInputContext::Key::LeftControl}; 
    };
 
    struct PointerClick {
 
        math::vec2 position; 
    };
 
    struct Config {
 
        float minPitch {-math::radians(85.0f)}; 
        float maxPitch {math::radians(85.0f)}; 
 
        float minDistance {0.01f}; 
        float maxDistance {math::F32_MAX}; 
 
        float orbitSensitivity {0.002f}; 
        float dollySensitivity {0.002f}; 
        float scrollDollySensitivity {0.05f}; 
        float dragThreshold {5.0f}; 
        bool  invertPitch {false}; 
 
        Controls controls; 
    };
 
    struct UpdateResult {
 
        bool cameraChanged {false}; 
        bool pointerDragging {false}; 
        std::optional<PointerClick>
            orbitButtonClick; 
        std::optional<PointerClick>
            panButtonClick; 
    };
 
    // [Public Lifecycle Functions]
 
    TurntableCameraController();
 
    explicit TurntableCameraController(const Config& config);
 
    // [Public Member Functions]
 
    const Config& config() const;
 
    void          config(const Config& config);
 
    const View&   view() const;
 
    void          view(const View& view);
 
    void          target(const math::vec3& worldPosition);
 
    void          target(const std::shared_ptr<Node>& node);
 
    void          target(const std::shared_ptr<Node>& node, const math::vec3& localPosition);
 
    UpdateResult  update(DesktopInputContext& input, float vFov, float viewportHeight);
 
    void          apply(Node& pov);
 
private:
    // [Private Types]
 
    enum class DragMode {
        Orbit,
        Pan,
        Dolly
    };
 
    // [Private Member Functions]
 
    math::vec3 resolveTarget();
    void       translateTarget(const math::vec3& worldTranslation);
 
    // [Private Member Variables]
 
    Config     _config;
    View       _view;
    math::vec3 _resolvedTarget;
    bool       _orbitButtonActive;
    bool       _orbitButtonDragging;
    DragMode   _orbitButtonDragMode;
    math::vec2 _orbitButtonPressPosition;
    bool       _panButtonActive;
    bool       _panButtonDragging;
    math::vec2 _panButtonPressPosition;
};
 
} // namespace a3d::ext
 
#endif // AVARA3D_EXTENSION_CAMERA_TURNTABLECAMERACONTROLLER_H