367 lines
14 KiB
C++
367 lines
14 KiB
C++
#include <cstdio>
|
|
#include <cassert>
|
|
#include <unordered_map>
|
|
|
|
#include "../../portultra/ultra64.h"
|
|
#include "../../portultra/multilibultra.hpp"
|
|
#define SDL_MAIN_HANDLED
|
|
#ifdef _WIN32
|
|
#include "SDL.h"
|
|
#else
|
|
#include "SDL2/SDL.h"
|
|
#include "SDL2/SDL_syswm.h"
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
#define NOMINMAX
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <Windows.h>
|
|
#include "SDL_syswm.h"
|
|
#endif
|
|
|
|
extern "C" void init();
|
|
/*extern "C"*/ void start(Multilibultra::WindowHandle window_handle, const Multilibultra::audio_callbacks_t* audio_callbacks, const Multilibultra::input_callbacks_t* input_callbacks);
|
|
|
|
template<typename... Ts>
|
|
void exit_error(const char* str, Ts ...args) {
|
|
// TODO pop up an error
|
|
((void)fprintf(stderr, str, args), ...);
|
|
assert(false);
|
|
std::quick_exit(EXIT_FAILURE);
|
|
}
|
|
|
|
|
|
std::vector<std::pair<SDL_Scancode, int>> keyboard_button_map{
|
|
{ SDL_Scancode::SDL_SCANCODE_LEFT, 0x0002 }, // c left
|
|
{ SDL_Scancode::SDL_SCANCODE_RIGHT, 0x0001 }, // c right
|
|
{ SDL_Scancode::SDL_SCANCODE_UP, 0x0008 }, // c up
|
|
{ SDL_Scancode::SDL_SCANCODE_DOWN, 0x0004 }, // c down
|
|
{ SDL_Scancode::SDL_SCANCODE_RETURN, 0x1000 }, // start
|
|
{ SDL_Scancode::SDL_SCANCODE_SPACE, 0x8000 }, // a
|
|
{ SDL_Scancode::SDL_SCANCODE_LSHIFT, 0x4000 }, // b
|
|
{ SDL_Scancode::SDL_SCANCODE_Q, 0x2000 }, // z
|
|
{ SDL_Scancode::SDL_SCANCODE_E, 0x0020 }, // l
|
|
{ SDL_Scancode::SDL_SCANCODE_R, 0x0010 }, // r
|
|
{ SDL_Scancode::SDL_SCANCODE_J, 0x0200 }, // dpad left
|
|
{ SDL_Scancode::SDL_SCANCODE_L, 0x0100 }, // dpad right
|
|
{ SDL_Scancode::SDL_SCANCODE_I, 0x0800 }, // dpad up
|
|
{ SDL_Scancode::SDL_SCANCODE_K, 0x0400 }, // dpad down
|
|
};
|
|
|
|
struct GameControllerAxisMapping {
|
|
SDL_GameControllerAxis axis;
|
|
int threshold; // Positive or negative to indicate direction
|
|
uint16_t output_mask;
|
|
};
|
|
|
|
constexpr int controller_default_threshold = 20000;
|
|
|
|
std::vector<GameControllerAxisMapping> controller_axis_map{
|
|
{ SDL_GameControllerAxis::SDL_CONTROLLER_AXIS_RIGHTX, -controller_default_threshold, 0x0002 }, // c left
|
|
{ SDL_GameControllerAxis::SDL_CONTROLLER_AXIS_RIGHTX, controller_default_threshold, 0x0001 }, // c right
|
|
{ SDL_GameControllerAxis::SDL_CONTROLLER_AXIS_RIGHTY, -controller_default_threshold, 0x0008 }, // c up
|
|
{ SDL_GameControllerAxis::SDL_CONTROLLER_AXIS_RIGHTY, controller_default_threshold, 0x0004 }, // c down
|
|
{ SDL_GameControllerAxis::SDL_CONTROLLER_AXIS_TRIGGERLEFT, 10000, 0x2000 }, // z
|
|
//{ SDL_Scancode::SDL_SCANCODE_RIGHT, 0x0001 }, // c right
|
|
//{ SDL_Scancode::SDL_SCANCODE_UP, 0x0008 }, // c up
|
|
//{ SDL_Scancode::SDL_SCANCODE_DOWN, 0x0004 }, // c down
|
|
//{ SDL_Scancode::SDL_SCANCODE_RETURN, 0x1000 }, // start
|
|
//{ SDL_Scancode::SDL_SCANCODE_SPACE, 0x8000 }, // a
|
|
//{ SDL_Scancode::SDL_SCANCODE_LSHIFT, 0x4000 }, // b
|
|
//{ SDL_Scancode::SDL_SCANCODE_Q, 0x2000 }, // z
|
|
//{ SDL_Scancode::SDL_SCANCODE_E, 0x0020 }, // l
|
|
//{ SDL_Scancode::SDL_SCANCODE_R, 0x0010 }, // r
|
|
//{ SDL_Scancode::SDL_SCANCODE_J, 0x0200 }, // dpad left
|
|
//{ SDL_Scancode::SDL_SCANCODE_L, 0x0100 }, // dpad right
|
|
//{ SDL_Scancode::SDL_SCANCODE_I, 0x0800 }, // dpad up
|
|
//{ SDL_Scancode::SDL_SCANCODE_K, 0x0400 }, // dpad down
|
|
};
|
|
|
|
struct GameControllerButtonMapping {
|
|
SDL_GameControllerButton button;
|
|
uint16_t output_mask;
|
|
};
|
|
std::vector<GameControllerButtonMapping> controller_button_map{
|
|
{ SDL_GameControllerButton::SDL_CONTROLLER_BUTTON_START, 0x1000 }, // start
|
|
{ SDL_GameControllerButton::SDL_CONTROLLER_BUTTON_A, 0x8000 }, // a
|
|
{ SDL_GameControllerButton::SDL_CONTROLLER_BUTTON_B, 0x4000 }, // b
|
|
{ SDL_GameControllerButton::SDL_CONTROLLER_BUTTON_X, 0x4000 }, // b
|
|
{ SDL_GameControllerButton::SDL_CONTROLLER_BUTTON_LEFTSHOULDER, 0x0020 }, // l
|
|
{ SDL_GameControllerButton::SDL_CONTROLLER_BUTTON_RIGHTSHOULDER, 0x0010 }, // r
|
|
{ SDL_GameControllerButton::SDL_CONTROLLER_BUTTON_DPAD_LEFT, 0x0200 }, // dpad left
|
|
{ SDL_GameControllerButton::SDL_CONTROLLER_BUTTON_DPAD_RIGHT, 0x0100 }, // dpad right
|
|
{ SDL_GameControllerButton::SDL_CONTROLLER_BUTTON_DPAD_UP, 0x0800 }, // dpad up
|
|
{ SDL_GameControllerButton::SDL_CONTROLLER_BUTTON_DPAD_DOWN, 0x0400 }, // dpad down
|
|
};
|
|
|
|
std::vector<SDL_JoystickID> controllers{};
|
|
|
|
int sdl_event_filter(void* userdata, SDL_Event* event) {
|
|
switch (event->type) {
|
|
//case SDL_EventType::SDL_KEYUP:
|
|
//case SDL_EventType::SDL_KEYDOWN:
|
|
// {
|
|
// const Uint8* key_states = SDL_GetKeyboardState(nullptr);
|
|
// int new_button = 0;
|
|
|
|
// for (const auto& mapping : keyboard_button_map) {
|
|
// if (key_states[mapping.first]) {
|
|
// new_button |= mapping.second;
|
|
// }
|
|
// }
|
|
|
|
// button = new_button;
|
|
|
|
// stick_x = (100.0f / 100.0f) * (key_states[SDL_Scancode::SDL_SCANCODE_D] - key_states[SDL_Scancode::SDL_SCANCODE_A]);
|
|
// stick_y = (100.0f / 100.0f) * (key_states[SDL_Scancode::SDL_SCANCODE_W] - key_states[SDL_Scancode::SDL_SCANCODE_S]);
|
|
// }
|
|
// break;
|
|
case SDL_EventType::SDL_CONTROLLERDEVICEADDED:
|
|
{
|
|
SDL_ControllerDeviceEvent* controller_event = (SDL_ControllerDeviceEvent*)event;
|
|
SDL_GameController* controller = SDL_GameControllerOpen(controller_event->which);
|
|
printf("Controller added: %d\n", controller_event->which);
|
|
if (controller != nullptr) {
|
|
printf(" Instance ID: %d\n", SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(controller)));
|
|
controllers.push_back(SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(controller)));
|
|
}
|
|
}
|
|
break;
|
|
case SDL_EventType::SDL_CONTROLLERDEVICEREMOVED:
|
|
{
|
|
SDL_ControllerDeviceEvent* controller_event = (SDL_ControllerDeviceEvent*)event;
|
|
printf("Controller removed: %d\n", controller_event->which);
|
|
std::remove(controllers.begin(), controllers.end(), controller_event->which);
|
|
}
|
|
break;
|
|
case SDL_EventType::SDL_QUIT:
|
|
std::quick_exit(EXIT_SUCCESS);
|
|
break;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
Multilibultra::gfx_callbacks_t::gfx_data_t create_gfx() {
|
|
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER) > 0) {
|
|
exit_error("Failed to initialize SDL2: %s\n", SDL_GetError());
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
Multilibultra::WindowHandle create_window(Multilibultra::gfx_callbacks_t::gfx_data_t) {
|
|
SDL_Window* window = SDL_CreateWindow("Majora's Mask", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, SDL_WINDOW_RESIZABLE);
|
|
|
|
if (window == nullptr) {
|
|
exit_error("Failed to create window: %s\n", SDL_GetError());
|
|
}
|
|
|
|
SDL_SysWMinfo wmInfo;
|
|
SDL_VERSION(&wmInfo.version);
|
|
SDL_GetWindowWMInfo(window, &wmInfo);
|
|
|
|
#if defined(_WIN32)
|
|
return wmInfo.info.win.window;
|
|
#elif defined(__ANDROID__)
|
|
static_assert(false && "Unimplemented");
|
|
#elif defined(__linux__)
|
|
return Multilibultra::WindowHandle{ wmInfo.info.x11.display, wmInfo.info.x11.window };
|
|
#else
|
|
static_assert(false && "Unimplemented");
|
|
#endif
|
|
}
|
|
|
|
void update_gfx(void*) {
|
|
// Handle events
|
|
constexpr int max_events_per_frame = 16;
|
|
SDL_Event cur_event;
|
|
int i = 0;
|
|
while (i++ < max_events_per_frame && SDL_PollEvent(&cur_event)) {
|
|
sdl_event_filter(nullptr, &cur_event);
|
|
}
|
|
}
|
|
|
|
void get_input(uint16_t* buttons_out, float* x_out, float* y_out) {
|
|
uint16_t cur_buttons = 0;
|
|
float cur_x = 0.0f;
|
|
float cur_y = 0.0f;
|
|
|
|
const Uint8* key_states = SDL_GetKeyboardState(nullptr);
|
|
int new_button = 0;
|
|
|
|
for (const auto& mapping : keyboard_button_map) {
|
|
if (key_states[mapping.first]) {
|
|
cur_buttons |= mapping.second;
|
|
}
|
|
}
|
|
|
|
cur_x += (100.0f / 100.0f) * (key_states[SDL_Scancode::SDL_SCANCODE_D] - key_states[SDL_Scancode::SDL_SCANCODE_A]);
|
|
cur_y += (100.0f / 100.0f) * (key_states[SDL_Scancode::SDL_SCANCODE_W] - key_states[SDL_Scancode::SDL_SCANCODE_S]);
|
|
|
|
for (SDL_JoystickID controller_id : controllers) {
|
|
SDL_GameController* controller = SDL_GameControllerFromInstanceID(controller_id);
|
|
if (controller != nullptr) {
|
|
cur_x += SDL_GameControllerGetAxis(controller, SDL_GameControllerAxis::SDL_CONTROLLER_AXIS_LEFTX) * (1/32768.0f);
|
|
cur_y -= SDL_GameControllerGetAxis(controller, SDL_GameControllerAxis::SDL_CONTROLLER_AXIS_LEFTY) * (1/32768.0f);
|
|
}
|
|
|
|
for (const auto& mapping : controller_axis_map) {
|
|
int input_value = SDL_GameControllerGetAxis(controller, mapping.axis);
|
|
if (mapping.threshold > 0) {
|
|
if (input_value > mapping.threshold) {
|
|
cur_buttons |= mapping.output_mask;
|
|
}
|
|
}
|
|
else {
|
|
if (input_value < mapping.threshold) {
|
|
cur_buttons |= mapping.output_mask;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const auto& mapping : controller_button_map) {
|
|
int input_value = SDL_GameControllerGetButton(controller, mapping.button);
|
|
if (input_value) {
|
|
cur_buttons |= mapping.output_mask;
|
|
}
|
|
}
|
|
}
|
|
|
|
*buttons_out = cur_buttons;
|
|
cur_x = std::clamp(cur_x, -1.0f, 1.0f);
|
|
cur_y = std::clamp(cur_y, -1.0f, 1.0f);
|
|
*x_out = cur_x;
|
|
*y_out = cur_y;
|
|
}
|
|
|
|
static SDL_AudioDeviceID audio_device = 0;
|
|
static uint32_t sample_rate = 48000;
|
|
|
|
void queue_samples(int16_t* audio_data, size_t sample_count) {
|
|
// Buffer for holding the output of swapping the audio channels. This is reused across
|
|
// calls to reduce runtime allocations.
|
|
static std::vector<float> swap_buffer;
|
|
|
|
// Make sure the swap buffer is large enough to hold all the incoming audio data.
|
|
if (sample_count > swap_buffer.size()) {
|
|
swap_buffer.resize(sample_count);
|
|
}
|
|
|
|
// Convert the audio from 16-bit values to floats and swap the audio channels into the
|
|
// swap buffer to correct for the address xor caused by endianness handling.
|
|
for (size_t i = 0; i < sample_count; i += 2) {
|
|
swap_buffer[i + 0] = audio_data[i + 1] * (0.5f / 32768.0f);
|
|
swap_buffer[i + 1] = audio_data[i + 0] * (0.5f / 32768.0f);
|
|
}
|
|
|
|
// Queue the swapped audio data.
|
|
SDL_QueueAudio(audio_device, swap_buffer.data(), sample_count * sizeof(swap_buffer[0]));
|
|
}
|
|
|
|
constexpr int channel_count = 2;
|
|
constexpr int bytes_per_frame = channel_count * sizeof(float);
|
|
|
|
size_t get_frames_remaining() {
|
|
constexpr float buffer_offset_frames = 1.0f;
|
|
// Get the number of remaining buffered audio bytes.
|
|
uint32_t buffered_byte_count = SDL_GetQueuedAudioSize(audio_device);
|
|
|
|
// Adjust the reported count to be some number of refreshes in the future, which helps ensure that
|
|
// there are enough samples even if the audio thread experiences a small amount of lag. This prevents
|
|
// audio popping on games that use the buffered audio byte count to determine how many samples
|
|
// to generate.
|
|
uint32_t frames_per_vi = (sample_rate / 60);
|
|
if (buffered_byte_count > (buffer_offset_frames * bytes_per_frame * frames_per_vi)) {
|
|
buffered_byte_count -= (buffer_offset_frames * bytes_per_frame * frames_per_vi);
|
|
}
|
|
else {
|
|
buffered_byte_count = 0;
|
|
}
|
|
// Convert from byte count to sample count.
|
|
return buffered_byte_count / bytes_per_frame;
|
|
}
|
|
|
|
void set_frequency(uint32_t freq) {
|
|
if (audio_device != 0) {
|
|
SDL_CloseAudioDevice(audio_device);
|
|
}
|
|
SDL_AudioSpec spec_desired{
|
|
.freq = (int)freq,
|
|
.format = AUDIO_F32,
|
|
.channels = channel_count,
|
|
.silence = 0, // calculated
|
|
.samples = 0x100, // Fairly small sample count to reduce the latency of internal buffering
|
|
.padding = 0, // unused
|
|
.size = 0, // calculated
|
|
.callback = nullptr,//feed_audio, // Use a callback as QueueAudio causes popping
|
|
.userdata = nullptr
|
|
};
|
|
|
|
audio_device = SDL_OpenAudioDevice(nullptr, false, &spec_desired, nullptr, 0);
|
|
if (audio_device == 0) {
|
|
exit_error("SDL error opening audio device: %s\n", SDL_GetError());
|
|
}
|
|
SDL_PauseAudioDevice(audio_device, 0);
|
|
sample_rate = freq;
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
|
|
#ifdef _WIN32
|
|
// Set up console output to accept UTF-8 on windows
|
|
SetConsoleOutputCP(CP_UTF8);
|
|
|
|
// Change to a font that supports Japanese characters
|
|
CONSOLE_FONT_INFOEX cfi;
|
|
cfi.cbSize = sizeof cfi;
|
|
cfi.nFont = 0;
|
|
cfi.dwFontSize.X = 0;
|
|
cfi.dwFontSize.Y = 16;
|
|
cfi.FontFamily = FF_DONTCARE;
|
|
cfi.FontWeight = FW_NORMAL;
|
|
wcscpy_s(cfi.FaceName, L"NSimSun");
|
|
SetCurrentConsoleFontEx(GetStdHandle(STD_OUTPUT_HANDLE), FALSE, &cfi);
|
|
#else
|
|
std::setlocale(LC_ALL, "en_US.UTF-8");
|
|
#endif
|
|
|
|
// Initialize SDL audio.
|
|
SDL_InitSubSystem(SDL_INIT_AUDIO);
|
|
// Pick an initial dummy sample rate; this will be set by the game later to the true sample rate.
|
|
set_frequency(sample_rate);
|
|
|
|
init();
|
|
|
|
Multilibultra::gfx_callbacks_t gfx_callbacks{
|
|
.create_gfx = create_gfx,
|
|
.create_window = create_window,
|
|
.update_gfx = update_gfx,
|
|
};
|
|
|
|
Multilibultra::audio_callbacks_t audio_callbacks{
|
|
.queue_samples = queue_samples,
|
|
.get_frames_remaining = get_frames_remaining,
|
|
.set_frequency = set_frequency,
|
|
};
|
|
|
|
Multilibultra::input_callbacks_t input_callbacks{
|
|
.get_input = get_input,
|
|
};
|
|
|
|
//create_gfx();
|
|
//void* window_handle = create_window(nullptr);
|
|
|
|
Multilibultra::set_gfx_callbacks(&gfx_callbacks);
|
|
start(Multilibultra::WindowHandle{}, &audio_callbacks, &input_callbacks);
|
|
|
|
// Do nothing forever
|
|
while (1) {
|
|
using namespace std::chrono_literals;
|
|
std::this_thread::sleep_for(10ms);
|
|
//update_gfx(nullptr);
|
|
//std::this_thread::sleep_for(1ms);
|
|
}
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|