300 lines
8.0 KiB
C++
300 lines
8.0 KiB
C++
#define _CRT_SECURE_NO_WARNINGS 1 // for fopen
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
#include <sys/time.h>
|
|
#include <unistd.h>
|
|
#include <pthread.h>
|
|
|
|
#include "../src/libsm64.h"
|
|
|
|
extern "C"
|
|
{
|
|
#define SDL_MAIN_HANDLED
|
|
#include "level.h"
|
|
#include "context.h"
|
|
#include "renderer.h"
|
|
#include "gl33core/gl33core_renderer.h"
|
|
#include "gl20/gl20_renderer.h"
|
|
}
|
|
|
|
#include "audio.h"
|
|
|
|
static SDL_Haptic *gHaptic = nullptr;
|
|
|
|
static void InitHaptics(SDL_GameController *controller)
|
|
{
|
|
if (controller == nullptr || gHaptic != nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SDL_Joystick *joy = SDL_GameControllerGetJoystick(controller);
|
|
|
|
if (joy == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
gHaptic = SDL_HapticOpenFromJoystick(joy);
|
|
|
|
if (gHaptic == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (SDL_HapticRumbleInit(gHaptic) != 0)
|
|
{
|
|
SDL_HapticClose(gHaptic);
|
|
gHaptic = nullptr;
|
|
}
|
|
}
|
|
|
|
uint8_t *utils_read_file_alloc(const char *path, size_t *fileLength)
|
|
{
|
|
FILE *f = fopen(path, "rb");
|
|
|
|
if (!f) return nullptr;
|
|
|
|
fseek(f, 0, SEEK_END);
|
|
size_t length = (size_t)ftell(f);
|
|
rewind(f);
|
|
uint8_t *buffer = (uint8_t *)malloc(length + 1);
|
|
fread(buffer, 1, length, f);
|
|
buffer[length] = 0;
|
|
fclose(f);
|
|
|
|
if (fileLength) *fileLength = length;
|
|
|
|
return buffer;
|
|
}
|
|
|
|
static float read_axis(int16_t val)
|
|
{
|
|
float result = (float)val / 32767.0f;
|
|
|
|
if (result < 0.2f && result > -0.2f)
|
|
return 0.0f;
|
|
|
|
return result > 0.0f ? (result - 0.2f) / 0.8f : (result + 0.2f) / 0.8f;
|
|
}
|
|
|
|
float lerp(float a, float b, float amount)
|
|
{
|
|
return a + (b - a) * amount;
|
|
}
|
|
|
|
static void DebugPrint(const char *message)
|
|
{
|
|
if (message == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
printf("[SM64] %s\n", message);
|
|
fflush(stdout);
|
|
}
|
|
|
|
static void Rumble(int32_t marioId, int16_t level, int16_t time)
|
|
{
|
|
if (gHaptic == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
float strength = (float)level;
|
|
|
|
Uint32 duration = (Uint32)time * 2;
|
|
|
|
SDL_HapticRumblePlay(gHaptic, strength, duration);
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
size_t romSize;
|
|
|
|
uint8_t *rom = utils_read_file_alloc("baserom.us.z64", &romSize);
|
|
|
|
if (rom == nullptr)
|
|
{
|
|
printf("\nFailed to read ROM file \"baserom.us.z64\"\n\n");
|
|
return 1;
|
|
}
|
|
|
|
uint8_t *texture = (uint8_t *)malloc(4 * SM64_TEXTURE_WIDTH * SM64_TEXTURE_HEIGHT);
|
|
|
|
sm64_global_terminate();
|
|
sm64_global_init(rom, texture);
|
|
sm64_audio_init(rom);
|
|
|
|
// sm64_register_debug_print_function(DebugPrint);
|
|
sm64_register_rumble_callback_function(Rumble);
|
|
|
|
sm64_static_surfaces_load(surfaces, surfaces_count);
|
|
int32_t marioId = sm64_mario_create(0, 1000, 0);
|
|
|
|
printf("MarioID: %i\n", marioId);
|
|
free(rom);
|
|
|
|
RenderState renderState;
|
|
renderState.mario.index = nullptr;
|
|
vec3 cameraPos = {0, 0, 0};
|
|
float cameraRot = 0.0f;
|
|
|
|
struct Renderer *renderer;
|
|
|
|
int major, minor;
|
|
#ifdef GL33_CORE
|
|
major = 3; minor = 3;
|
|
renderer = &gl33core_renderer;
|
|
#else
|
|
major = 2;
|
|
minor = 0;
|
|
renderer = &gl20_renderer;
|
|
#endif
|
|
|
|
context_init("libsm64", 1280, 720, major, minor);
|
|
renderer->init(&renderState, texture);
|
|
|
|
struct SM64MarioInputs marioInputs;
|
|
struct SM64MarioState marioState;
|
|
struct SM64MarioGeometryBuffers marioGeometry;
|
|
|
|
// interpolation
|
|
float lastPos[3], currPos[3];
|
|
float lastGeoPos[9 * SM64_GEO_MAX_TRIANGLES], currGeoPos[9 * SM64_GEO_MAX_TRIANGLES];
|
|
|
|
marioGeometry.position = (float *)malloc(sizeof(float) * 9 * SM64_GEO_MAX_TRIANGLES);
|
|
marioGeometry.color = (float *)malloc(sizeof(float) * 9 * SM64_GEO_MAX_TRIANGLES);
|
|
marioGeometry.normal = (float *)malloc(sizeof(float) * 9 * SM64_GEO_MAX_TRIANGLES);
|
|
marioGeometry.uv = (float *)malloc(sizeof(float) * 6 * SM64_GEO_MAX_TRIANGLES);
|
|
marioGeometry.numTrianglesUsed = 0;
|
|
|
|
float tick = 0;
|
|
uint32_t lastTicks = SDL_GetTicks();
|
|
|
|
audio_init();
|
|
|
|
sm64_play_music(0, 0x05 | 0x80, 0); // from decomp/include/seq_ids.h: SEQ_LEVEL_WATER | SEQ_VARIATION
|
|
|
|
do
|
|
{
|
|
float dt = (SDL_GetTicks() - lastTicks) / 1000.f;
|
|
lastTicks = SDL_GetTicks();
|
|
tick += dt;
|
|
|
|
SDL_GameController *controller = context_get_controller();
|
|
InitHaptics(controller);
|
|
float x_axis, y_axis, x0_axis;
|
|
|
|
if (!controller) // keyboard
|
|
{
|
|
const Uint8 *state = SDL_GetKeyboardState(nullptr);
|
|
|
|
float dir;
|
|
float spd = 0;
|
|
if (state[SDL_SCANCODE_UP] && state[SDL_SCANCODE_RIGHT])
|
|
{
|
|
dir = -M_PI * 0.25f;
|
|
spd = 1;
|
|
}
|
|
else if (state[SDL_SCANCODE_UP] && state[SDL_SCANCODE_LEFT])
|
|
{
|
|
dir = -M_PI * 0.75f;
|
|
spd = 1;
|
|
}
|
|
else if (state[SDL_SCANCODE_DOWN] && state[SDL_SCANCODE_RIGHT])
|
|
{
|
|
dir = M_PI * 0.25f;
|
|
spd = 1;
|
|
}
|
|
else if (state[SDL_SCANCODE_DOWN] && state[SDL_SCANCODE_LEFT])
|
|
{
|
|
dir = M_PI * 0.75f;
|
|
spd = 1;
|
|
}
|
|
else if (state[SDL_SCANCODE_UP])
|
|
{
|
|
dir = -M_PI * 0.5f;
|
|
spd = 1;
|
|
}
|
|
else if (state[SDL_SCANCODE_DOWN])
|
|
{
|
|
dir = M_PI * 0.5f;
|
|
spd = 1;
|
|
}
|
|
else if (state[SDL_SCANCODE_LEFT])
|
|
{
|
|
dir = M_PI;
|
|
spd = 1;
|
|
}
|
|
else if (state[SDL_SCANCODE_RIGHT])
|
|
{
|
|
dir = 0;
|
|
spd = 1;
|
|
}
|
|
|
|
x_axis = cosf(dir) * spd;
|
|
y_axis = sinf(dir) * spd;
|
|
x0_axis = state[SDL_SCANCODE_LSHIFT] ? 1 : state[SDL_SCANCODE_RSHIFT] ? -1 : 0;
|
|
|
|
marioInputs.buttonA = state[SDL_SCANCODE_X];
|
|
marioInputs.buttonB = state[SDL_SCANCODE_C];
|
|
marioInputs.buttonZ = state[SDL_SCANCODE_Z];
|
|
}
|
|
else
|
|
{
|
|
x_axis = read_axis(SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_LEFTX));
|
|
y_axis = read_axis(SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_LEFTY));
|
|
x0_axis = read_axis(SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_RIGHTX));
|
|
|
|
marioInputs.buttonA = SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_A);
|
|
marioInputs.buttonB = SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_X);
|
|
marioInputs.buttonZ = SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_LEFTSHOULDER);
|
|
}
|
|
|
|
cameraRot += x0_axis * dt * 2;
|
|
cameraPos[0] = marioState.position[0] + 1000.0f * cosf(cameraRot);
|
|
cameraPos[1] = marioState.position[1] + 200.0f;
|
|
cameraPos[2] = marioState.position[2] + 1000.0f * sinf(cameraRot);
|
|
|
|
marioInputs.camLookX = marioState.position[0] - cameraPos[0];
|
|
marioInputs.camLookZ = marioState.position[2] - cameraPos[2];
|
|
marioInputs.stickX = x_axis;
|
|
marioInputs.stickY = y_axis;
|
|
|
|
while (tick >= 1.f / 30)
|
|
{
|
|
memcpy(lastPos, currPos, sizeof(currPos));
|
|
memcpy(lastGeoPos, currGeoPos, sizeof(currGeoPos));
|
|
|
|
tick -= 1.f / 30;
|
|
sm64_mario_tick(marioId, &marioInputs, &marioState, &marioGeometry);
|
|
|
|
memcpy(currPos, marioState.position, sizeof(currPos));
|
|
memcpy(currGeoPos, marioGeometry.position, sizeof(currGeoPos));
|
|
}
|
|
|
|
for (int i = 0; i < 3; i++) marioState.position[i] = lerp(lastPos[i], currPos[i], tick / (1.f / 30));
|
|
for (int i = 0; i < marioGeometry.numTrianglesUsed * 9; i++) marioGeometry.position[i] = lerp(lastGeoPos[i], currGeoPos[i], tick / (1.f / 30));
|
|
|
|
renderer->draw(&renderState, cameraPos, &marioState, &marioGeometry);
|
|
}
|
|
while (context_flip_frame_poll_events());
|
|
|
|
sm64_stop_background_music(sm64_get_current_background_music());
|
|
sm64_global_terminate();
|
|
context_terminate();
|
|
|
|
if (gHaptic != nullptr)
|
|
{
|
|
SDL_HapticClose(gHaptic);
|
|
gHaptic = nullptr;
|
|
}
|
|
|
|
return 0;
|
|
}
|