bind_screenspace_preset() [2/2]

MAYAFLUX_API void MayaFlux::bind_screenspace_preset	(	const std::shared_ptr< Core::Window > &	window,
		const std::shared_ptr< Buffers::RenderProcessor > &	processor,
		const Kinesis::NavigationConfig &	config = {},
		const Kinesis::ScreenspaceKeyMap &	key_map = {},
		const std::string &	name = "default"
	)

Bind the screenspace navigation controller to a window and render processor.

Drag translates the eye along the camera's local right and up axes derived from the current yaw and pitch. Rotation is never modified. Scroll dollies along the forward vector. Perspective projection is preserved throughout.

To set the initial viewing direction, supply a NavigationConfig with initial_eye and initial_target; yaw and pitch are derived from those on construction exactly as in bind_fly_preset.

Parameters

window	Window supplying input events
processor	RenderProcessor that receives the ViewTransform source
config	Camera tuning parameters; move_speed is unused
key_map	Input assignments; defaults to RMB drag
name	Unique prefix for registered events; must be unique per window

Definition at line 319 of file ViewportPreset.cpp.

{
    auto& record = s_registry[make_key(window, name)];
    record.saved_config = window->get_input_config();
    record.registered_events.clear();
 
    auto st = std::make_shared<Kinesis::NavigationState>(
        Kinesis::make_navigation_state(config));
 
    on_mouse_pressed(window, key_map.drag_button, [st](double /*x*/, double /*y*/) {
        st->rmb_held    = true;
        st->first_mouse = true; }, event_name(name, "drag_dn"));
 
    on_mouse_released(window, key_map.drag_button, [st](double /*x*/, double /*y*/) { st->rmb_held = false; }, event_name(name, "drag_up"));
 
    on_mouse_move(window, [st](double x, double y) {
        if (!st->rmb_held) {
            st->first_mouse = true;
            return;
        }
        if (st->first_mouse) {
            st->last_x      = x;
            st->last_y      = y;
            st->first_mouse = false;
            return;
        }
        const auto  dx = static_cast<float>(x - st->last_x);
        const auto  dy = static_cast<float>(y - st->last_y);
        st->last_x = x;
        st->last_y = y;
 
        const glm::vec3 forward {
            std::cos(st->pitch) * std::sin(st->yaw),
            std::sin(st->pitch),
            std::cos(st->pitch) * std::cos(st->yaw)
        };
        const glm::vec3 right = glm::normalize(glm::cross(forward, glm::vec3(0.0F, 1.0F, 0.0F)));
        const glm::vec3 up    = glm::normalize(glm::cross(right, forward));
 
        st->eye -= right * (dx * st->mouse_sensitivity);
        st->eye += up    * (dy * st->mouse_sensitivity); }, event_name(name, "mouse"));
 
    on_scroll(window, [st](double /*dx*/, double dy) { Kinesis::apply_scroll(*st, static_cast<float>(dy)); }, event_name(name, "scroll"));
 
    processor->set_view_transform_source(
        [st, window_weak = std::weak_ptr<Core::Window>(window)]() -> Kinesis::ViewTransform {
            auto win = window_weak.lock();
            if (!win)
                return {};
            const auto& ws = win->get_state();
            const float aspect = (ws.current_height > 0)
                ? static_cast<float>(ws.current_width) / static_cast<float>(ws.current_height)
                : 1.0F;
            return Kinesis::build_view_transform(*st, aspect);
        });
}

References MayaFlux::Kinesis::apply_scroll(), MayaFlux::Kinesis::build_view_transform(), MayaFlux::Kinesis::ScreenspaceKeyMap::drag_button, MayaFlux::Kinesis::make_navigation_state(), name, on_mouse_move(), on_mouse_pressed(), on_mouse_released(), on_scroll(), and window.

Referenced by bind_screenspace_preset(), and bind_viewport_preset().

Here is the call graph for this function:

Here is the caller graph for this function: