Mirrors
/
Zelda64Recomp
mirror of https://github.com/Mr-Wiseguy/Zelda64Recomp.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Zelda64Recomp/src/ui/ui_config.cpp

952 lines
32 KiB
C++
Raw Blame History

#include "recomp_ui.h"
#include "recomp_input.h"
#include "recomp_sound.h"
#include "recomp_config.h"
#include "recomp_debug.h"
#include "promptfont.h"
#include "../../ultramodern/config.hpp"
#include "../../ultramodern/ultramodern.hpp"
#include "RmlUi/Core.h"
#include "rt64_layer.h"
ultramodern::GraphicsConfig new_options;
Rml::DataModelHandle nav_help_model_handle;
Rml::DataModelHandle general_model_handle;
Rml::DataModelHandle controls_model_handle;
Rml::DataModelHandle graphics_model_handle;
Rml::DataModelHandle sound_options_model_handle;
recomp::PromptContext prompt_context;
namespace recomp {
const std::unordered_map<ButtonVariant, std::string> button_variants {
{ButtonVariant::Primary, "primary"},
{ButtonVariant::Secondary, "secondary"},
{ButtonVariant::Tertiary, "tertiary"},
{ButtonVariant::Success, "success"},
{ButtonVariant::Error, "error"},
{ButtonVariant::Warning, "warning"}
};
void PromptContext::close_prompt() {
open = false;
model_handle.DirtyVariable("prompt__open");
}
void PromptContext::open_prompt(
const std::string& headerText,
const std::string& contentText,
const std::string& confirmLabelText,
const std::string& cancelLabelText,
std::function<void()> confirmCb,
std::function<void()> cancelCb,
ButtonVariant _confirmVariant,
ButtonVariant _cancelVariant,
bool _focusOnCancel,
const std::string& _returnElementId
) {
open = true;
header = headerText;
content = contentText;
confirmLabel = confirmLabelText;
cancelLabel = cancelLabelText;
onConfirm = confirmCb;
onCancel = cancelCb;
confirmVariant = _confirmVariant;
cancelVariant = _cancelVariant;
focusOnCancel = _focusOnCancel;
returnElementId = _returnElementId;
model_handle.DirtyVariable("prompt__open");
model_handle.DirtyVariable("prompt__header");
model_handle.DirtyVariable("prompt__content");
model_handle.DirtyVariable("prompt__confirmLabel");
model_handle.DirtyVariable("prompt__cancelLabel");
shouldFocus = true;
}
void PromptContext::on_confirm(void) {
onConfirm();
open = false;
model_handle.DirtyVariable("prompt__open");
}
void PromptContext::on_cancel(void) {
onCancel();
open = false;
model_handle.DirtyVariable("prompt__open");
}
void PromptContext::on_click(Rml::DataModelHandle model_handle, Rml::Event& event, const Rml::VariantList& inputs) {
Rml::Element *target = event.GetTargetElement();
auto id = target->GetId();
if (id == "prompt__confirm-button" || id == "prompt__confirm-button-label") {
on_confirm();
event.StopPropagation();
} else if (id == "prompt__cancel-button" || id == "prompt__cancel-button-label") {
on_cancel();
event.StopPropagation();
}
if (event.GetCurrentElement()->GetId() == "prompt-root") {
event.StopPropagation();
}
}
PromptContext *get_prompt_context() {
return &prompt_context;
}
};
// True if controller config menu is open, false if keyboard config menu is open, undefined otherwise
bool configuring_controller = false;
template <typename T>
void get_option(const T& input, Rml::Variant& output) {
std::string value = "";
to_json(value, input);
if (value.empty()) {
throw std::runtime_error("Invalid value :" + std::to_string(int(input)));
}
output = value;
}
template <typename T>
void set_option(T& output, const Rml::Variant& input) {
T value = T::OptionCount;
from_json(input.Get<std::string>(), value);
if (value == T::OptionCount) {
throw std::runtime_error("Invalid value :" + input.Get<std::string>());
}
output = value;
}
template <typename T>
void bind_option(Rml::DataModelConstructor& constructor, const std::string& name, T* option) {
constructor.BindFunc(name,
[option](Rml::Variant& out) { get_option(*option, out); },
[option](const Rml::Variant& in) {
set_option(*option, in);
graphics_model_handle.DirtyVariable("options_changed");
graphics_model_handle.DirtyVariable("ds_info");
}
);
};
template <typename T>
void bind_atomic(Rml::DataModelConstructor& constructor, Rml::DataModelHandle handle, const char* name, std::atomic<T>* atomic_val) {
constructor.BindFunc(name,
[atomic_val](Rml::Variant& out) {
out = atomic_val->load();
},
[atomic_val, handle, name](const Rml::Variant& in) mutable {
atomic_val->store(in.Get<T>());
handle.DirtyVariable(name);
}
);
}
static int scanned_binding_index = -1;
static int scanned_input_index = -1;
static int focused_input_index = -1;
static int focused_config_option_index = -1;
static bool msaa2x_supported = false;
static bool msaa4x_supported = false;
static bool msaa8x_supported = false;
static bool sample_positions_supported = false;
static bool cont_active = true;
static recomp::InputDevice cur_device = recomp::InputDevice::Controller;
void recomp::finish_scanning_input(recomp::InputField scanned_field) {
recomp::set_input_binding(static_cast<recomp::GameInput>(scanned_input_index), scanned_binding_index, cur_device, scanned_field);
scanned_input_index = -1;
scanned_binding_index = -1;
controls_model_handle.DirtyVariable("inputs");
controls_model_handle.DirtyVariable("active_binding_input");
controls_model_handle.DirtyVariable("active_binding_slot");
}
void recomp::cancel_scanning_input() {
recomp::stop_scanning_input();
scanned_input_index = -1;
scanned_binding_index = -1;
controls_model_handle.DirtyVariable("inputs");
controls_model_handle.DirtyVariable("active_binding_input");
controls_model_handle.DirtyVariable("active_binding_slot");
}
void recomp::config_menu_set_cont_or_kb(bool cont_interacted) {
if (cont_active != cont_interacted) {
cont_active = cont_interacted;
if (nav_help_model_handle) {
nav_help_model_handle.DirtyVariable("nav_help__navigate");
nav_help_model_handle.DirtyVariable("nav_help__accept");
nav_help_model_handle.DirtyVariable("nav_help__exit");
}
if (graphics_model_handle) {
graphics_model_handle.DirtyVariable("gfx_help__apply");
}
}
}
void close_config_menu_impl() {
recomp::save_config();
if (ultramodern::is_game_started()) {
recomp::set_current_menu(recomp::Menu::None);
}
else {
recomp::set_current_menu(recomp::Menu::Launcher);
}
}
// TODO: Remove once RT64 gets native fullscreen support on Linux
#if defined(__linux__)
extern SDL_Window* window;
#endif
void apply_graphics_config(void) {
ultramodern::set_graphics_config(new_options);
#if defined(__linux__) // TODO: Remove once RT64 gets native fullscreen support on Linux
if (new_options.wm_option == ultramodern::WindowMode::Fullscreen) {
SDL_SetWindowFullscreen(window,SDL_WINDOW_FULLSCREEN_DESKTOP);
} else {
SDL_SetWindowFullscreen(window,0);
}
#endif
}
void close_config_menu() {
if (ultramodern::get_graphics_config() != new_options) {
prompt_context.open_prompt(
"Graphics options have changed",
"Would you like to apply or discard the changes?",
"Apply",
"Discard",
[]() {
apply_graphics_config();
graphics_model_handle.DirtyAllVariables();
close_config_menu_impl();
},
[]() {
new_options = ultramodern::get_graphics_config();
graphics_model_handle.DirtyAllVariables();
close_config_menu_impl();
},
recomp::ButtonVariant::Success,
recomp::ButtonVariant::Error,
true,
"config__close-menu-button"
);
return;
}
close_config_menu_impl();
}
void recomp::open_quit_game_prompt() {
prompt_context.open_prompt(
"Are you sure you want to quit?",
"Any progress since your last save will be lost.",
"Quit",
"Cancel",
[]() {
ultramodern::quit();
},
[]() {},
recomp::ButtonVariant::Error,
recomp::ButtonVariant::Tertiary,
true,
"config__quit-game-button"
);
}
// These defaults values don't matter, as the config file handling overrides them.
struct ControlOptionsContext {
int rumble_strength; // 0 to 100
int gyro_sensitivity; // 0 to 100
int mouse_sensitivity; // 0 to 100
recomp::TargetingMode targeting_mode;
recomp::BackgroundInputMode background_input_mode;
recomp::AutosaveMode autosave_mode;
};
ControlOptionsContext control_options_context;
int recomp::get_rumble_strength() {
return control_options_context.rumble_strength;
}
void recomp::set_rumble_strength(int strength) {
control_options_context.rumble_strength = strength;
if (general_model_handle) {
general_model_handle.DirtyVariable("rumble_strength");
}
}
int recomp::get_gyro_sensitivity() {
return control_options_context.gyro_sensitivity;
}
int recomp::get_mouse_sensitivity() {
return control_options_context.mouse_sensitivity;
}
void recomp::set_gyro_sensitivity(int sensitivity) {
control_options_context.gyro_sensitivity = sensitivity;
if (general_model_handle) {
general_model_handle.DirtyVariable("gyro_sensitivity");
}
}
void recomp::set_mouse_sensitivity(int sensitivity) {
control_options_context.mouse_sensitivity = sensitivity;
if (general_model_handle) {
general_model_handle.DirtyVariable("mouse_sensitivity");
}
}
recomp::TargetingMode recomp::get_targeting_mode() {
return control_options_context.targeting_mode;
}
void recomp::set_targeting_mode(recomp::TargetingMode mode) {
control_options_context.targeting_mode = mode;
if (general_model_handle) {
general_model_handle.DirtyVariable("targeting_mode");
}
}
recomp::BackgroundInputMode recomp::get_background_input_mode() {
return control_options_context.background_input_mode;
}
void recomp::set_background_input_mode(recomp::BackgroundInputMode mode) {
control_options_context.background_input_mode = mode;
if (general_model_handle) {
general_model_handle.DirtyVariable("background_input_mode");
}
SDL_SetHint(
SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS,
mode == recomp::BackgroundInputMode::On
? "1"
: "0"
);
}
recomp::AutosaveMode recomp::get_autosave_mode() {
return control_options_context.autosave_mode;
}
void recomp::set_autosave_mode(recomp::AutosaveMode mode) {
control_options_context.autosave_mode = mode;
if (general_model_handle) {
general_model_handle.DirtyVariable("autosave_mode");
}
}
struct SoundOptionsContext {
std::atomic<int> bgm_volume;
std::atomic<int> low_health_beeps_enabled; // RmlUi doesn't seem to like "true"/"false" strings for setting variants so an int is used here instead.
void reset() {
bgm_volume = 100;
low_health_beeps_enabled = (int)true;
}
SoundOptionsContext() {
reset();
}
};
SoundOptionsContext sound_options_context;
void recomp::reset_sound_settings() {
sound_options_context.reset();
if (sound_options_model_handle) {
sound_options_model_handle.DirtyAllVariables();
}
}
void recomp::set_bgm_volume(int volume) {
sound_options_context.bgm_volume.store(volume);
if (sound_options_model_handle) {
sound_options_model_handle.DirtyVariable("bgm_volume");
}
}
int recomp::get_bgm_volume() {
return sound_options_context.bgm_volume.load();
}
void recomp::set_low_health_beeps_enabled(bool enabled) {
sound_options_context.low_health_beeps_enabled.store((int)enabled);
if (sound_options_model_handle) {
sound_options_model_handle.DirtyVariable("low_health_beeps_enabled");
}
}
bool recomp::get_low_health_beeps_enabled() {
return (bool)sound_options_context.low_health_beeps_enabled.load();
}
struct DebugContext {
Rml::DataModelHandle model_handle;
std::vector<std::string> area_names;
std::vector<std::string> scene_names;
std::vector<std::string> entrance_names;
int area_index = 0;
int scene_index = 0;
int entrance_index = 0;
int set_time_day = 1;
int set_time_hour = 12;
int set_time_minute = 0;
bool debug_enabled = false;
DebugContext() {
for (const auto& area : recomp::game_warps) {
area_names.emplace_back(area.name);
}
update_warp_names();
}
void update_warp_names() {
scene_names.clear();
for (const auto& scene : recomp::game_warps[area_index].scenes) {
scene_names.emplace_back(scene.name);
}
entrance_names = recomp::game_warps[area_index].scenes[scene_index].entrances;
}
};
void recomp::update_rml_display_refresh_rate() {
static uint32_t lastRate = 0;
if (!graphics_model_handle) return;
uint32_t curRate = ultramodern::get_display_refresh_rate();
if (curRate != lastRate) {
graphics_model_handle.DirtyVariable("display_refresh_rate");
}
lastRate = curRate;
}
DebugContext debug_context;
class ConfigMenu : public recomp::MenuController {
public:
ConfigMenu() {
}
~ConfigMenu() override {
}
Rml::ElementDocument* load_document(Rml::Context* context) override {
return context->LoadDocument("assets/config_menu.rml");
}
void register_events(recomp::UiEventListenerInstancer& listener) override {
recomp::register_event(listener, "apply_options",
[](const std::string& param, Rml::Event& event) {
graphics_model_handle.DirtyVariable("options_changed");
apply_graphics_config();
});
recomp::register_event(listener, "config_keydown",
[](const std::string& param, Rml::Event& event) {
if (!prompt_context.open && event.GetId() == Rml::EventId::Keydown) {
auto key = event.GetParameter<Rml::Input::KeyIdentifier>("key_identifier", Rml::Input::KeyIdentifier::KI_UNKNOWN);
switch (key) {
case Rml::Input::KeyIdentifier::KI_ESCAPE:
close_config_menu();
break;
case Rml::Input::KeyIdentifier::KI_F:
graphics_model_handle.DirtyVariable("options_changed");
apply_graphics_config();
break;
}
}
});
// This needs to be separate from `close_config_menu` so it ensures that the event is only on the target
recomp::register_event(listener, "close_config_menu_backdrop",
[](const std::string& param, Rml::Event& event) {
if (event.GetPhase() == Rml::EventPhase::Target) {
close_config_menu();
}
});
recomp::register_event(listener, "close_config_menu",
[](const std::string& param, Rml::Event& event) {
close_config_menu();
});
recomp::register_event(listener, "open_quit_game_prompt",
[](const std::string& param, Rml::Event& event) {
recomp::open_quit_game_prompt();
});
recomp::register_event(listener, "toggle_input_device",
[](const std::string& param, Rml::Event& event) {
cur_device = cur_device == recomp::InputDevice::Controller
? recomp::InputDevice::Keyboard
: recomp::InputDevice::Controller;
controls_model_handle.DirtyVariable("input_device_is_keyboard");
controls_model_handle.DirtyVariable("inputs");
});
recomp::register_event(listener, "area_index_changed",
[](const std::string& param, Rml::Event& event) {
debug_context.area_index = event.GetParameter<int>("value", 0);
debug_context.scene_index = 0;
debug_context.entrance_index = 0;
debug_context.update_warp_names();
debug_context.model_handle.DirtyVariable("scene_index");
debug_context.model_handle.DirtyVariable("entrance_index");
debug_context.model_handle.DirtyVariable("scene_names");
debug_context.model_handle.DirtyVariable("entrance_names");
});
recomp::register_event(listener, "scene_index_changed",
[](const std::string& param, Rml::Event& event) {
debug_context.scene_index = event.GetParameter<int>("value", 0);
debug_context.entrance_index = 0;
debug_context.update_warp_names();
debug_context.model_handle.DirtyVariable("entrance_index");
debug_context.model_handle.DirtyVariable("entrance_names");
});
recomp::register_event(listener, "do_warp",
[](const std::string& param, Rml::Event& event) {
recomp::do_warp(debug_context.area_index, debug_context.scene_index, debug_context.entrance_index);
});
recomp::register_event(listener, "set_time",
[](const std::string& param, Rml::Event& event) {
recomp::set_time(debug_context.set_time_day, debug_context.set_time_hour, debug_context.set_time_minute);
});
}
void bind_config_list_events(Rml::DataModelConstructor &constructor) {
constructor.BindEventCallback("set_cur_config_index",
[](Rml::DataModelHandle model_handle, Rml::Event& event, const Rml::VariantList& inputs) {
int option_index = inputs.at(0).Get<size_t>();
// watch for mouseout being overzealous during event bubbling, only clear if the event's attached element matches the current
if (option_index == -1 && event.GetType() == "mouseout" && event.GetCurrentElement() != event.GetTargetElement()) {
return;
}
focused_config_option_index = option_index;
model_handle.DirtyVariable("cur_config_index");
});
constructor.Bind("cur_config_index", &focused_config_option_index);
}
void make_graphics_bindings(Rml::Context* context) {
Rml::DataModelConstructor constructor = context->CreateDataModel("graphics_model");
if (!constructor) {
throw std::runtime_error("Failed to make RmlUi data model for the graphics config menu");
}
ultramodern::sleep_milliseconds(50);
new_options = ultramodern::get_graphics_config();
bind_config_list_events(constructor);
constructor.BindFunc("res_option",
[](Rml::Variant& out) { get_option(new_options.res_option, out); },
[](const Rml::Variant& in) {
set_option(new_options.res_option, in);
graphics_model_handle.DirtyVariable("options_changed");
graphics_model_handle.DirtyVariable("ds_info");
graphics_model_handle.DirtyVariable("ds_option");
}
);
bind_option(constructor, "wm_option", &new_options.wm_option);
bind_option(constructor, "ar_option", &new_options.ar_option);
bind_option(constructor, "hr_option", &new_options.hr_option);
bind_option(constructor, "msaa_option", &new_options.msaa_option);
bind_option(constructor, "rr_option", &new_options.rr_option);
constructor.BindFunc("rr_manual_value",
[](Rml::Variant& out) {
out = new_options.rr_manual_value;
},
[](const Rml::Variant& in) {
new_options.rr_manual_value = in.Get<int>();
graphics_model_handle.DirtyVariable("options_changed");
});
constructor.BindFunc("ds_option",
[](Rml::Variant& out) {
if (new_options.res_option == ultramodern::Resolution::Auto) {
out = 1;
} else {
out = new_options.ds_option;
}
},
[](const Rml::Variant& in) {
new_options.ds_option = in.Get<int>();
graphics_model_handle.DirtyVariable("options_changed");
graphics_model_handle.DirtyVariable("ds_info");
});
constructor.BindFunc("display_refresh_rate",
[](Rml::Variant& out) {
out = ultramodern::get_display_refresh_rate();
});
constructor.BindFunc("options_changed",
[](Rml::Variant& out) {
out = (ultramodern::get_graphics_config() != new_options);
});
constructor.BindFunc("ds_info",
[](Rml::Variant& out) {
switch (new_options.res_option) {
default:
case ultramodern::Resolution::Auto:
out = "Downsampling is not available at auto resolution";
return;
case ultramodern::Resolution::Original:
if (new_options.ds_option == 2) {
out = "Rendered in 480p and scaled to 240p";
} else if (new_options.ds_option == 4) {
out = "Rendered in 960p and scaled to 240p";
}
return;
case ultramodern::Resolution::Original2x:
if (new_options.ds_option == 2) {
out = "Rendered in 960p and scaled to 480p";
} else if (new_options.ds_option == 4) {
out = "Rendered in 4K and scaled to 480p";
}
return;
}
out = "";
});
constructor.BindFunc("gfx_help__apply", [](Rml::Variant& out) {
if (cont_active) {
out = PF_GAMEPAD_X " " PF_GAMEPAD_START;
} else {
out = PF_KEYBOARD_F;
}
});
constructor.Bind("msaa2x_supported", &msaa2x_supported);
constructor.Bind("msaa4x_supported", &msaa4x_supported);
constructor.Bind("msaa8x_supported", &msaa8x_supported);
constructor.Bind("sample_positions_supported", &sample_positions_supported);
graphics_model_handle = constructor.GetModelHandle();
}
void make_controls_bindings(Rml::Context* context) {
Rml::DataModelConstructor constructor = context->CreateDataModel("controls_model");
if (!constructor) {
throw std::runtime_error("Failed to make RmlUi data model for the controls config menu");
}
constructor.BindFunc("input_count", [](Rml::Variant& out) { out = recomp::get_num_inputs(); } );
constructor.BindFunc("input_device_is_keyboard", [](Rml::Variant& out) { out = cur_device == recomp::InputDevice::Keyboard; } );
constructor.RegisterTransformFunc("get_input_name", [](const Rml::VariantList& inputs) {
return Rml::Variant{recomp::get_input_name(static_cast<recomp::GameInput>(inputs.at(0).Get<size_t>()))};
});
constructor.RegisterTransformFunc("get_input_enum_name", [](const Rml::VariantList& inputs) {
return Rml::Variant{recomp::get_input_enum_name(static_cast<recomp::GameInput>(inputs.at(0).Get<size_t>()))};
});
constructor.BindEventCallback("set_input_binding",
[](Rml::DataModelHandle model_handle, Rml::Event& event, const Rml::VariantList& inputs) {
scanned_input_index = inputs.at(0).Get<size_t>();
scanned_binding_index = inputs.at(1).Get<size_t>();
recomp::start_scanning_input(cur_device);
model_handle.DirtyVariable("active_binding_input");
model_handle.DirtyVariable("active_binding_slot");
});
constructor.BindEventCallback("reset_input_bindings_to_defaults",
[](Rml::DataModelHandle model_handle, Rml::Event& event, const Rml::VariantList& inputs) {
if (cur_device == recomp::InputDevice::Controller) {
recomp::reset_cont_input_bindings();
} else {
recomp::reset_kb_input_bindings();
}
model_handle.DirtyAllVariables();
});
constructor.BindEventCallback("clear_input_bindings",
[](Rml::DataModelHandle model_handle, Rml::Event& event, const Rml::VariantList& inputs) {
recomp::GameInput input = static_cast<recomp::GameInput>(inputs.at(0).Get<size_t>());
for (size_t binding_index = 0; binding_index < recomp::bindings_per_input; binding_index++) {
recomp::set_input_binding(input, binding_index, cur_device, recomp::InputField{});
}
model_handle.DirtyVariable("inputs");
});
constructor.BindEventCallback("set_input_row_focus",
[](Rml::DataModelHandle model_handle, Rml::Event& event, const Rml::VariantList& inputs) {
int input_index = inputs.at(0).Get<size_t>();
// watch for mouseout being overzealous during event bubbling, only clear if the event's attached element matches the current
if (input_index == -1 && event.GetType() == "mouseout" && event.GetCurrentElement() != event.GetTargetElement()) {
return;
}
focused_input_index = input_index;
model_handle.DirtyVariable("cur_input_row");
});
// Rml variable definition for an individual InputField.
struct InputFieldVariableDefinition : public Rml::VariableDefinition {
InputFieldVariableDefinition() : Rml::VariableDefinition(Rml::DataVariableType::Scalar) {}
virtual bool Get(void* ptr, Rml::Variant& variant) override { variant = reinterpret_cast<recomp::InputField*>(ptr)->to_string(); return true; }
virtual bool Set(void* ptr, const Rml::Variant& variant) override { return false; }
};
// Static instance of the InputField variable definition to have a pointer to return to RmlUi.
static InputFieldVariableDefinition input_field_definition_instance{};
// Rml variable definition for an array of InputField values (e.g. all the bindings for a single input).
struct BindingContainerVariableDefinition : public Rml::VariableDefinition {
BindingContainerVariableDefinition() : Rml::VariableDefinition(Rml::DataVariableType::Array) {}
virtual bool Get(void* ptr, Rml::Variant& variant) override { return false; }
virtual bool Set(void* ptr, const Rml::Variant& variant) override { return false; }
virtual int Size(void* ptr) override { return recomp::bindings_per_input; }
virtual Rml::DataVariable Child(void* ptr, const Rml::DataAddressEntry& address) override {
recomp::GameInput input = static_cast<recomp::GameInput>((uintptr_t)ptr);
return Rml::DataVariable{&input_field_definition_instance, &recomp::get_input_binding(input, address.index, cur_device)};
}
};
// Static instance of the InputField array variable definition to have a fixed pointer to return to RmlUi.
static BindingContainerVariableDefinition binding_container_var_instance{};
// Rml variable definition for an array of an array of InputField values (e.g. all the bindings for all inputs).
struct BindingArrayContainerVariableDefinition : public Rml::VariableDefinition {
BindingArrayContainerVariableDefinition() : Rml::VariableDefinition(Rml::DataVariableType::Array) {}
virtual bool Get(void* ptr, Rml::Variant& variant) override { return false; }
virtual bool Set(void* ptr, const Rml::Variant& variant) override { return false; }
virtual int Size(void* ptr) override { return recomp::get_num_inputs(); }
virtual Rml::DataVariable Child(void* ptr, const Rml::DataAddressEntry& address) override {
// Encode the input index as the pointer to avoid needing to do any allocations.
return Rml::DataVariable(&binding_container_var_instance, (void*)(uintptr_t)address.index);
}
};
// Static instance of the BindingArrayContainerVariableDefinition variable definition to have a fixed pointer to return to RmlUi.
static BindingArrayContainerVariableDefinition binding_array_var_instance{};
struct InputContainerVariableDefinition : public Rml::VariableDefinition {
InputContainerVariableDefinition() : Rml::VariableDefinition(Rml::DataVariableType::Struct) {}
virtual bool Get(void* ptr, Rml::Variant& variant) override { return true; }
virtual bool Set(void* ptr, const Rml::Variant& variant) override { return false; }
virtual int Size(void* ptr) override { return recomp::get_num_inputs(); }
virtual Rml::DataVariable Child(void* ptr, const Rml::DataAddressEntry& address) override {
if (address.name == "array") {
return Rml::DataVariable(&binding_array_var_instance, nullptr);
}
else {
recomp::GameInput input = recomp::get_input_from_enum_name(address.name);
if (input != recomp::GameInput::COUNT) {
return Rml::DataVariable(&binding_container_var_instance, (void*)(uintptr_t)input);
}
}
return Rml::DataVariable{};
}
};
// Dummy type to associate with the variable definition.
struct InputContainer {};
constructor.RegisterCustomDataVariableDefinition<InputContainer>(Rml::MakeUnique<InputContainerVariableDefinition>());
// Dummy instance of the dummy type to bind to the variable.
static InputContainer dummy_container;
constructor.Bind("inputs", &dummy_container);
constructor.BindFunc("cur_input_row", [](Rml::Variant& out) {
if (focused_input_index == -1) {
out = "NONE";
}
else {
out = recomp::get_input_enum_name(static_cast<recomp::GameInput>(focused_input_index));
}
});
constructor.BindFunc("active_binding_input", [](Rml::Variant& out) {
if (scanned_input_index == -1) {
out = "NONE";
}
else {
out = recomp::get_input_enum_name(static_cast<recomp::GameInput>(scanned_input_index));
}
});
constructor.Bind<int>("active_binding_slot", &scanned_binding_index);
controls_model_handle = constructor.GetModelHandle();
}
void make_nav_help_bindings(Rml::Context* context) {
Rml::DataModelConstructor constructor = context->CreateDataModel("nav_help_model");
if (!constructor) {
throw std::runtime_error("Failed to make RmlUi data model for nav help");
}
constructor.BindFunc("nav_help__navigate", [](Rml::Variant& out) {
if (cont_active) {
out = PF_DPAD;
} else {
out = PF_KEYBOARD_ARROWS PF_KEYBOARD_TAB;
}
});
constructor.BindFunc("nav_help__accept", [](Rml::Variant& out) {
if (cont_active) {
out = PF_GAMEPAD_A;
} else {
out = PF_KEYBOARD_ENTER;
}
});
constructor.BindFunc("nav_help__exit", [](Rml::Variant& out) {
if (cont_active) {
out = PF_XBOX_VIEW;
} else {
out = PF_KEYBOARD_ESCAPE;
}
});
nav_help_model_handle = constructor.GetModelHandle();
}
void make_general_bindings(Rml::Context* context) {
Rml::DataModelConstructor constructor = context->CreateDataModel("general_model");
if (!constructor) {
throw std::runtime_error("Failed to make RmlUi data model for the control options menu");
}
bind_config_list_events(constructor);
constructor.Bind("rumble_strength", &control_options_context.rumble_strength);
constructor.Bind("gyro_sensitivity", &control_options_context.gyro_sensitivity);
constructor.Bind("mouse_sensitivity", &control_options_context.mouse_sensitivity);
bind_option(constructor, "targeting_mode", &control_options_context.targeting_mode);
bind_option(constructor, "background_input_mode", &control_options_context.background_input_mode);
bind_option(constructor, "autosave_mode", &control_options_context.autosave_mode);
general_model_handle = constructor.GetModelHandle();
}
void make_sound_options_bindings(Rml::Context* context) {
Rml::DataModelConstructor constructor = context->CreateDataModel("sound_options_model");
if (!constructor) {
throw std::runtime_error("Failed to make RmlUi data model for the sound options menu");
}
bind_config_list_events(constructor);
sound_options_model_handle = constructor.GetModelHandle();
bind_atomic(constructor, sound_options_model_handle, "bgm_volume", &sound_options_context.bgm_volume);
bind_atomic(constructor, sound_options_model_handle, "low_health_beeps_enabled", &sound_options_context.low_health_beeps_enabled);
}
void make_debug_bindings(Rml::Context* context) {
Rml::DataModelConstructor constructor = context->CreateDataModel("debug_model");
if (!constructor) {
throw std::runtime_error("Failed to make RmlUi data model for the debug menu");
}
bind_config_list_events(constructor);
// Bind the debug mode enabled flag.
constructor.Bind("debug_enabled", &debug_context.debug_enabled);
// Register the array type for string vectors.
constructor.RegisterArray<std::vector<std::string>>();
// Bind the warp parameter indices
constructor.Bind("area_index", &debug_context.area_index);
constructor.Bind("scene_index", &debug_context.scene_index);
constructor.Bind("entrance_index", &debug_context.entrance_index);
// Bind the vectors for warp names
constructor.Bind("area_names", &debug_context.area_names);
constructor.Bind("scene_names", &debug_context.scene_names);
constructor.Bind("entrance_names", &debug_context.entrance_names);
constructor.Bind("debug_time_day", &debug_context.set_time_day);
constructor.Bind("debug_time_hour", &debug_context.set_time_hour);
constructor.Bind("debug_time_minute", &debug_context.set_time_minute);
debug_context.model_handle = constructor.GetModelHandle();
}
void make_prompt_bindings(Rml::Context* context) {
Rml::DataModelConstructor constructor = context->CreateDataModel("prompt_model");
if (!constructor) {
throw std::runtime_error("Failed to make RmlUi data model for the prompt");
}
// Bind the debug mode enabled flag.
constructor.Bind("prompt__open", &prompt_context.open);
constructor.Bind("prompt__header", &prompt_context.header);
constructor.Bind("prompt__content", &prompt_context.content);
constructor.Bind("prompt__confirmLabel", &prompt_context.confirmLabel);
constructor.Bind("prompt__cancelLabel", &prompt_context.cancelLabel);
constructor.BindEventCallback("prompt__on_click", &recomp::PromptContext::on_click, &prompt_context);
prompt_context.model_handle = constructor.GetModelHandle();
}
void make_bindings(Rml::Context* context) override {
// initially set cont state for ui help
recomp::config_menu_set_cont_or_kb(recomp::get_cont_active());
make_nav_help_bindings(context);
make_general_bindings(context);
make_controls_bindings(context);
make_graphics_bindings(context);
make_sound_options_bindings(context);
make_debug_bindings(context);
make_prompt_bindings(context);
}
};
std::unique_ptr<recomp::MenuController> recomp::create_config_menu() {
return std::make_unique<ConfigMenu>();
}
bool recomp::get_debug_mode_enabled() {
return debug_context.debug_enabled;
}
void recomp::set_debug_mode_enabled(bool enabled) {
debug_context.debug_enabled = enabled;
if (debug_context.model_handle) {
debug_context.model_handle.DirtyVariable("debug_enabled");
}
}
void recomp::update_supported_options() {
msaa2x_supported = ultramodern::RT64MaxMSAA() >= RT64::UserConfiguration::Antialiasing::MSAA2X;
msaa4x_supported = ultramodern::RT64MaxMSAA() >= RT64::UserConfiguration::Antialiasing::MSAA4X;
msaa8x_supported = ultramodern::RT64MaxMSAA() >= RT64::UserConfiguration::Antialiasing::MSAA8X;
sample_positions_supported = ultramodern::RT64SamplePositionsSupported();
new_options = ultramodern::get_graphics_config();
graphics_model_handle.DirtyAllVariables();
}
void recomp::toggle_fullscreen() {
new_options.wm_option = (new_options.wm_option == ultramodern::WindowMode::Windowed) ? ultramodern::WindowMode::Fullscreen : ultramodern::WindowMode::Windowed;
apply_graphics_config();
graphics_model_handle.DirtyVariable("wm_option");
}
Reference in New Issue View Git Blame Copy Permalink