bind_fly_preset() [1/2]

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

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

Registers event handlers under the prefix "vp_<name>_". Key assignments default to WASD/QE translation with KP ortho snaps; pass a FlyKeyMap to override any or all bindings. Ortho snap slots set to std::nullopt are silently skipped.

Parameters

window	Window supplying input events
processor	RenderProcessor that receives the ViewTransform source
config	Camera/motion tuning parameters
key_map	Key assignments; defaults to WASD/QE + KP snaps
name	Unique prefix for registered events; must be unique per window

Definition at line 72 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, IO::MouseButtons::Right, [st](double /*x*/, double /*y*/) {
        st->rmb_held    = true;
        st->first_mouse = true; }, event_name(name, "rmb_dn"));
 
    on_mouse_released(window, IO::MouseButtons::Right, [st](double /*x*/, double /*y*/) { st->rmb_held = false; }, event_name(name, "rmb_up"));
 
    on_key_pressed(window, key_map.forward, [st] { st->forward_held = true; }, event_name(name, "fwd_dn"));
    on_key_released(window, key_map.forward, [st] { st->forward_held = false; }, event_name(name, "fwd_up"));
    on_key_pressed(window, key_map.back, [st] { st->back_held = true; }, event_name(name, "bck_dn"));
    on_key_released(window, key_map.back, [st] { st->back_held = false; }, event_name(name, "bck_up"));
    on_key_pressed(window, key_map.left, [st] { st->left_held = true; }, event_name(name, "lft_dn"));
    on_key_released(window, key_map.left, [st] { st->left_held = false; }, event_name(name, "lft_up"));
    on_key_pressed(window, key_map.right, [st] { st->right_held = true; }, event_name(name, "rgt_dn"));
    on_key_released(window, key_map.right, [st] { st->right_held = false; }, event_name(name, "rgt_up"));
    on_key_pressed(window, key_map.down, [st] { st->down_held = true; }, event_name(name, "dwn_dn"));
    on_key_released(window, key_map.down, [st] { st->down_held = false; }, event_name(name, "dwn_up"));
    on_key_pressed(window, key_map.up, [st] { st->up_held = true; }, event_name(name, "up_dn"));
    on_key_released(window, key_map.up, [st] { st->up_held = false; }, event_name(name, "up_up"));
 
    if (key_map.ortho_front)
        on_key_pressed(window, *key_map.ortho_front, [st] { Kinesis::snap_ortho(*st, 0); }, event_name(name, "kp_front"));
    if (key_map.ortho_right)
        on_key_pressed(window, *key_map.ortho_right, [st] { Kinesis::snap_ortho(*st, 1); }, event_name(name, "kp_right"));
    if (key_map.ortho_top)
        on_key_pressed(window, *key_map.ortho_top, [st] { Kinesis::snap_ortho(*st, 2); }, event_name(name, "kp_top"));
    if (key_map.ortho_flip)
        on_key_pressed(window, *key_map.ortho_flip, [st] { Kinesis::snap_ortho(*st, 3); }, event_name(name, "kp_flip"));
 
    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;
        }
        Kinesis::apply_mouse_delta(*st,
            static_cast<float>(x - st->last_x),
            static_cast<float>(y - st->last_y));
        st->last_x = x;
        st->last_y = y; }, 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::compute_view_transform(*st, aspect);
        });
}

References MayaFlux::Kinesis::apply_mouse_delta(), MayaFlux::Kinesis::apply_scroll(), MayaFlux::Kinesis::FlyKeyMap::back, MayaFlux::Kinesis::compute_view_transform(), MayaFlux::Kinesis::FlyKeyMap::down, MayaFlux::Kinesis::FlyKeyMap::forward, MayaFlux::Kinesis::FlyKeyMap::left, MayaFlux::Kinesis::make_navigation_state(), on_key_pressed(), on_key_released(), on_mouse_move(), on_mouse_pressed(), on_mouse_released(), on_scroll(), MayaFlux::Kinesis::FlyKeyMap::ortho_flip, MayaFlux::Kinesis::FlyKeyMap::ortho_front, MayaFlux::Kinesis::FlyKeyMap::ortho_right, MayaFlux::Kinesis::FlyKeyMap::ortho_top, MayaFlux::IO::Right, MayaFlux::Kinesis::FlyKeyMap::right, and MayaFlux::Kinesis::FlyKeyMap::up.

Referenced by bind_fly_preset(), and bind_viewport_preset().

Here is the call graph for this function:

Here is the caller graph for this function: