duuqnd/cave-story-solaris
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Extremely horrible terrible nightmare refactoring

Browse source 
Working on ridding CSE2 of its hard SDL2 dependency.

For now, I have a rudimentary GLFW3 backend.
This commit is contained in:
Clownacy 2020-03-31 21:56:10 +01:00
parent b4ec82d81b
commit 5dbca99e19
12 changed files with 901 additions and 253 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
CMakeLists.txt
View file

@ -18,6 +18,7 @@ option(DEBUG_SAVE "Re-enable the ability to drag-and-drop save files onto the wi
set(BACKEND_RENDERER "SDLTexture" CACHE STRING "Which renderer the game should use: 'OpenGL3' for an OpenGL 3.2 renderer, 'OpenGLES2' for an OpenGL ES 2.0 renderer, 'SDLTexture' for SDL2's hardware-accelerated Texture API, 'SDLSurface' for SDL2's software-rendered Surface API, or 'Software' for a handwritten software renderer")
set(BACKEND_AUDIO "SDL2" CACHE STRING "Which audio backend the game should use: 'SDL2' or 'miniaudio'")
set(BACKEND_CONTROLLER "SDL2" CACHE STRING "Which controller backend the game should use: 'SDL2' or 'GLFW3'")
set(BACKEND_PLATFORM "SDL2" CACHE STRING "Which platform backend the game should use: 'SDL2' or 'GLFW3'")
option(LTO "Enable link-time optimisation" OFF)
option(MSVC_LINK_STATIC_RUNTIME "Link the static MSVC runtime library" OFF)
@ -164,7 +165,6 @@ add_executable(CSE2 WIN32
"src/ValueView.cpp"
"src/ValueView.h"
"src/WindowsWrapper.h"
"src/Backends/Platform/SDL2.cpp"
"src/Backends/Audio.h"
"src/Backends/Controller.h"
"src/Backends/Platform.h"
@ -326,6 +326,20 @@ elseif(BACKEND_CONTROLLER MATCHES "GLFW3")
target_sources(CSE2 PRIVATE "src/Backends/Controller/GLFW3.cpp")
endif()
if(BACKEND_PLATFORM MATCHES "SDL2")
target_sources(CSE2 PRIVATE "src/Backends/Platform/SDL2.cpp")
elseif(BACKEND_PLATFORM MATCHES "GLFW3")
target_sources(CSE2 PRIVATE "src/Backends/Platform/GLFW3.cpp")
endif()
if(BACKEND_PLATFORM MATCHES "SDL2" AND BACKEND_RENDERER MATCHES "OpenGL3")
target_sources(CSE2 PRIVATE "src/Backends/Window/SDL2-OpenGL3.cpp")
elseif(BACKEND_PLATFORM MATCHES "GLFW3" AND BACKEND_RENDERER MATCHES "OpenGL3")
target_sources(CSE2 PRIVATE "src/Backends/Window/GLFW3-OpenGL3.cpp")
else()
message(FATAL_ERROR "Invalid BACKEND_PLATFORM/BACKEND_RENDERER combination")
endif()
##########
# Tweaks #
@ -381,6 +395,12 @@ set_target_properties(CSE2 PROPERTIES
# Dependencies #
################
if(BACKEND_PLATFORM MATCHES "GLFW3")
find_package(glfw3 REQUIRED)
target_link_libraries(CSE2 PRIVATE glfw)
endif()
if(BACKEND_PLATFORM MATCHES "SDL2" OR BACKEND_AUDIO MATCHES "SDL2")
if(NOT FORCE_LOCAL_LIBS)
find_package(SDL2)
endif()
@ -408,6 +428,7 @@ else()
add_subdirectory("external/SDL2" EXCLUDE_FROM_ALL)
target_link_libraries(CSE2 PRIVATE SDL2-static SDL2main)
endif()
endif()
if(NOT FORCE_LOCAL_LIBS)
find_package(Freetype)

8
src/Backends/Platform.h
View file

@ -5,11 +5,9 @@
extern BOOL bActive;
void PlatformBackend_Init(void);
void PlatformBackend_GetBasePath(char *string_buffer);
void PlatformBackend_Deinit(void);
BOOL PlatformBackend_GetBasePath(char *string_buffer);
BOOL PlatformBackend_SystemTask(void);
void PlatformBackend_ShowMessageBox(const char *title, const char *message);
unsigned long PlatformBackend_GetTicks(void);
void PlatformBackend_Delay(unsigned int ticks);

282
src/Backends/Platform/GLFW3.cpp Normal file
View file

@ -0,0 +1,282 @@
#include "../Platform.h"
#include <chrono>
#include <thread>
#include <GLFW/glfw3.h>
#include "../Rendering.h"
#include "../../WindowsWrapper.h"
#include "../../KeyControl.h"
#include "../../Main.h"
#include "../../Organya.h"
#include "../../Profile.h"
BOOL bActive = TRUE;
extern GLFWwindow *window;
void KeyCallback(GLFWwindow *window, int key, int scancode, int action, int mods)
{
(void)window;
(void)scancode;
(void)mods;
if (action == GLFW_PRESS)
{
switch (key)
{
case GLFW_KEY_ESCAPE:
gKey |= KEY_ESCAPE;
break;
case GLFW_KEY_W:
gKey |= KEY_MAP;
break;
case GLFW_KEY_LEFT:
gKey |= KEY_LEFT;
break;
case GLFW_KEY_RIGHT:
gKey |= KEY_RIGHT;
break;
case GLFW_KEY_UP:
gKey |= KEY_UP;
break;
case GLFW_KEY_DOWN:
gKey |= KEY_DOWN;
break;
case GLFW_KEY_X:
gKey |= KEY_X;
break;
case GLFW_KEY_Z:
gKey |= KEY_Z;
break;
case GLFW_KEY_S:
gKey |= KEY_ARMS;
break;
case GLFW_KEY_A:
gKey |= KEY_ARMSREV;
break;
case GLFW_KEY_LEFT_SHIFT:
case GLFW_KEY_RIGHT_SHIFT:
gKey |= KEY_SHIFT;
break;
case GLFW_KEY_F1:
gKey |= KEY_F1;
break;
case GLFW_KEY_F2:
gKey |= KEY_F2;
break;
case GLFW_KEY_Q:
gKey |= KEY_ITEM;
break;
case GLFW_KEY_COMMA:
gKey |= KEY_ALT_LEFT;
break;
case GLFW_KEY_PERIOD:
gKey |= KEY_ALT_DOWN;
break;
case GLFW_KEY_SLASH:
gKey |= KEY_ALT_RIGHT;
break;
case GLFW_KEY_L:
gKey |= KEY_L;
break;
case GLFW_KEY_EQUAL:
gKey |= KEY_PLUS;
break;
case GLFW_KEY_F5:
gbUseJoystick = FALSE;
break;
}
}
else if (action == GLFW_RELEASE)
{
switch (key)
{
case GLFW_KEY_ESCAPE:
gKey &= ~KEY_ESCAPE;
break;
case GLFW_KEY_W:
gKey &= ~KEY_MAP;
break;
case GLFW_KEY_LEFT:
gKey &= ~KEY_LEFT;
break;
case GLFW_KEY_RIGHT:
gKey &= ~KEY_RIGHT;
break;
case GLFW_KEY_UP:
gKey &= ~KEY_UP;
break;
case GLFW_KEY_DOWN:
gKey &= ~KEY_DOWN;
break;
case GLFW_KEY_X:
gKey &= ~KEY_X;
break;
case GLFW_KEY_Z:
gKey &= ~KEY_Z;
break;
case GLFW_KEY_S:
gKey &= ~KEY_ARMS;
break;
case GLFW_KEY_A:
gKey &= ~KEY_ARMSREV;
break;
case GLFW_KEY_LEFT_SHIFT:
case GLFW_KEY_RIGHT_SHIFT:
gKey &= ~KEY_SHIFT;
break;
case GLFW_KEY_F1:
gKey &= ~KEY_F1;
break;
case GLFW_KEY_F2:
gKey &= ~KEY_F2;
break;
case GLFW_KEY_Q:
gKey &= ~KEY_ITEM;
break;
case GLFW_KEY_COMMA:
gKey &= ~KEY_ALT_LEFT;
break;
case GLFW_KEY_PERIOD:
gKey &= ~KEY_ALT_DOWN;
break;
case GLFW_KEY_SLASH:
gKey &= ~KEY_ALT_RIGHT;
break;
case GLFW_KEY_L:
gKey &= ~KEY_L;
break;
case GLFW_KEY_EQUAL:
gKey &= ~KEY_PLUS;
break;
}
}
}
void WindowFocusCallback(GLFWwindow *window, int focused)
{
(void)window;
if (focused)
ActiveWindow();
else
InactiveWindow();
}
void WindowSizeCallback(GLFWwindow *window, int width, int height)
{
(void)window;
(void)width;
(void)height;
RenderBackend_HandleWindowResize();
}
void PlatformBackend_Init(void)
{
glfwInit();
}
void PlatformBackend_Deinit(void)
{
glfwTerminate();
}
BOOL PlatformBackend_GetBasePath(char *string_buffer)
{
return FALSE;
}
BOOL PlatformBackend_SystemTask(void)
{
if (glfwWindowShouldClose(window))
{
StopOrganyaMusic();
return FALSE;
}
while (!bActive)
glfwWaitEvents();
glfwPollEvents();
/*
while (SDL_PollEvent(NULL) || !bActive)
{
SDL_Event event;
if (!SDL_WaitEvent(&event))
return FALSE;
switch (event.type)
{
case SDL_DROPFILE:
LoadProfile(event.drop.file);
SDL_free(event.drop.file);
break;
case SDL_RENDER_TARGETS_RESET:
Backend_HandleRenderTargetLoss();
break;
}
}
*/
return TRUE;
}
void PlatformBackend_ShowMessageBox(const char *title, const char *message)
{
//SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, title, message, NULL);
}
unsigned long PlatformBackend_GetTicks(void)
{
return (unsigned long)(glfwGetTime() * 1000.0);
}
void PlatformBackend_Delay(unsigned int ticks)
{
std::this_thread::sleep_for(std::chrono::milliseconds(ticks));
}

16
src/Backends/Platform/SDL2.cpp
View file

@ -2,7 +2,7 @@
#include "SDL.h"
#include "../Rendering.h"
#include "../Window.h"
#include "../../WindowsWrapper.h"
@ -25,13 +25,20 @@ void PlatformBackend_Init(void)
SDL_InitSubSystem(SDL_INIT_VIDEO);
}
void PlatformBackend_GetBasePath(char *string_buffer)
void PlatformBackend_Deinit(void)
{
SDL_Quit();
}
BOOL PlatformBackend_GetBasePath(char *string_buffer)
{
char *base_path = SDL_GetBasePath();
size_t base_path_length = strlen(base_path);
base_path[base_path_length - 1] = '\0';
strcpy(string_buffer, base_path);
SDL_free(base_path);
return TRUE;
}
BOOL PlatformBackend_SystemTask(void)
@ -262,3 +269,8 @@ unsigned long PlatformBackend_GetTicks(void)
{
return SDL_GetTicks();
}
void PlatformBackend_Delay(unsigned int ticks)
{
SDL_Delay(ticks);
}

39
src/Backends/Rendering.h
View file

@ -1,27 +1,26 @@
#pragma once
#include "SDL.h"
#include "../WindowsWrapper.h"
typedef struct Backend_Surface Backend_Surface;
typedef struct Backend_Glyph Backend_Glyph;
Backend_Surface* Backend_Init(const char *window_title, int screen_width, int screen_height, BOOL fullscreen);
void Backend_Deinit(void);
void Backend_DrawScreen(void);
Backend_Surface* Backend_CreateSurface(unsigned int width, unsigned int height);
void Backend_FreeSurface(Backend_Surface *surface);
BOOL Backend_IsSurfaceLost(Backend_Surface *surface);
void Backend_RestoreSurface(Backend_Surface *surface);
unsigned char* Backend_LockSurface(Backend_Surface *surface, unsigned int *pitch, unsigned int width, unsigned int height);
void Backend_UnlockSurface(Backend_Surface *surface, unsigned int width, unsigned int height);
void Backend_Blit(Backend_Surface *source_surface, const RECT *rect, Backend_Surface *destination_surface, long x, long y, BOOL colour_key);
void Backend_ColourFill(Backend_Surface *surface, const RECT *rect, unsigned char red, unsigned char green, unsigned char blue);
Backend_Glyph* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch);
void Backend_UnloadGlyph(Backend_Glyph *glyph);
void Backend_PrepareToDrawGlyphs(Backend_Surface *destination_surface, const unsigned char *colour_channels);
void Backend_DrawGlyph(Backend_Glyph *glyph, long x, long y);
void Backend_FlushGlyphs(void);
void Backend_HandleRenderTargetLoss(void);
void Backend_HandleWindowResize(void);
Backend_Surface* RenderBackend_Init(int screen_width, int screen_height);
void RenderBackend_Deinit(void);
void RenderBackend_DrawScreen(void);
void RenderBackend_ClearScreen(void);
Backend_Surface* RenderBackend_CreateSurface(unsigned int width, unsigned int height);
void RenderBackend_FreeSurface(Backend_Surface *surface);
BOOL RenderBackend_IsSurfaceLost(Backend_Surface *surface);
void RenderBackend_RestoreSurface(Backend_Surface *surface);
unsigned char* RenderBackend_LockSurface(Backend_Surface *surface, unsigned int *pitch, unsigned int width, unsigned int height);
void RenderBackend_UnlockSurface(Backend_Surface *surface, unsigned int width, unsigned int height);
void RenderBackend_Blit(Backend_Surface *source_surface, const RECT *rect, Backend_Surface *destination_surface, long x, long y, BOOL colour_key);
void RenderBackend_ColourFill(Backend_Surface *surface, const RECT *rect, unsigned char red, unsigned char green, unsigned char blue);
Backend_Glyph* RenderBackend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch);
void RenderBackend_UnloadGlyph(Backend_Glyph *glyph);
void RenderBackend_PrepareToDrawGlyphs(Backend_Surface *destination_surface, const unsigned char *colour_channels);
void RenderBackend_DrawGlyph(Backend_Glyph *glyph, long x, long y);
void RenderBackend_FlushGlyphs(void);
void RenderBackend_HandleRenderTargetLoss(void);
void RenderBackend_HandleWindowResize(void);

139
src/Backends/Rendering/OpenGL3.cpp
View file

@ -13,13 +13,13 @@
#include "../../../external/glad/include/glad/glad.h"
#endif
#include "SDL.h"
#define SPRITEBATCH_IMPLEMENTATION
#include "../../../external/cute_spritebatch.h"
#include "../../WindowsWrapper.h"
#include "../Platform.h"
#include "../Window.h"
#include "../../Resource.h"
#define TOTAL_VBOS 8
@ -69,9 +69,6 @@ typedef struct VertexBufferSlot
Vertex vertices[2][3];
} VertexBufferSlot;
static SDL_Window *window;
static SDL_GLContext context;
static GLuint program_texture;
static GLuint program_texture_colour_key;
static GLuint program_colour_fill;
@ -275,7 +272,7 @@ static GLuint CompileShader(const char *vertex_shader_source, const char *fragme
{
char buffer[0x200];
glGetShaderInfoLog(vertex_shader, sizeof(buffer), NULL, buffer);
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Vertex shader error", buffer, window);
PlatformBackend_ShowMessageBox("Vertex shader error", buffer);
return 0;
}
@ -291,7 +288,7 @@ static GLuint CompileShader(const char *vertex_shader_source, const char *fragme
{
char buffer[0x200];
glGetShaderInfoLog(fragment_shader, sizeof(buffer), NULL, buffer);
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Fragment shader error", buffer, window);
PlatformBackend_ShowMessageBox("Fragment shader error", buffer);
return 0;
}
@ -308,7 +305,7 @@ static GLuint CompileShader(const char *vertex_shader_source, const char *fragme
{
char buffer[0x200];
glGetProgramInfoLog(program_id, sizeof(buffer), NULL, buffer);
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Shader linker error", buffer, window);
PlatformBackend_ShowMessageBox("Shader linker error", buffer);
return 0;
}
@ -516,56 +513,8 @@ static void GlyphBatch_DestroyTexture(SPRITEBATCH_U64 texture_id, void *udata)
// Render-backend initialisation
// ====================
Backend_Surface* Backend_Init(const char *window_title, int screen_width, int screen_height, BOOL fullscreen)
Backend_Surface* RenderBackend_Init(int screen_width, int screen_height)
{
puts("Available SDL2 video drivers:");
for (int i = 0; i < SDL_GetNumVideoDrivers(); ++i)
puts(SDL_GetVideoDriver(i));
printf("Selected SDL2 video driver: %s\n", SDL_GetCurrentVideoDriver());
#ifdef USE_OPENGLES2
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
#else
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
#endif
window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, screen_width, screen_height, SDL_WINDOW_OPENGL);
if (window != NULL)
{
#ifndef _WIN32 // On Windows, we use native icons instead (so we can give the taskbar and window separate icons, like the original EXE does)
size_t resource_size;
const unsigned char *resource_data = FindResource("ICON_MINI", "ICON", &resource_size);
SDL_RWops *rwops = SDL_RWFromConstMem(resource_data, resource_size);
SDL_Surface *icon_surface = SDL_LoadBMP_RW(rwops, 1);
SDL_SetWindowIcon(window, icon_surface);
SDL_FreeSurface(icon_surface);
#endif
if (fullscreen)
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);
context = SDL_GL_CreateContext(window);
if (context != NULL)
{
if (SDL_GL_MakeCurrent(window, context) == 0)
{
#ifndef USE_OPENGLES2
if (gladLoadGLLoader((GLADloadproc)SDL_GL_GetProcAddress))
{
// Check if the platform supports OpenGL 3.2
if (GLAD_GL_VERSION_3_2)
{
#endif
printf("GL_VENDOR = %s\n", glGetString(GL_VENDOR));
printf("GL_RENDERER = %s\n", glGetString(GL_RENDERER));
printf("GL_VERSION = %s\n", glGetString(GL_VERSION));
@ -661,42 +610,11 @@ Backend_Surface* Backend_Init(const char *window_title, int screen_width, int sc
#ifndef USE_OPENGLES2
glDeleteVertexArrays(1, &vertex_array_id);
#endif
#ifndef USE_OPENGLES2
}
else
{
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Fatal error (OpenGL rendering backend)", "Your system does not support OpenGL 3.2", window);
}
}
else
{
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Fatal error (OpenGL rendering backend)", "Could not load OpenGL functions", window);
}
#endif
}
else
{
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Fatal error (OpenGL rendering backend)", "SDL_GL_MakeCurrent failed", window);
}
SDL_GL_DeleteContext(context);
}
else
{
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Fatal error (OpenGL rendering backend)", "Could not create OpenGL context", window);
}
SDL_DestroyWindow(window);
}
else
{
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Fatal error (OpenGL rendering backend)", "Could not create window", NULL);
}
return NULL;
}
void Backend_Deinit(void)
void RenderBackend_Deinit(void)
{
free(local_vertex_buffer);
@ -712,11 +630,9 @@ void Backend_Deinit(void)
#ifndef USE_OPENGLES2
glDeleteVertexArrays(1, &vertex_array_id);
#endif
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(window);
}
void Backend_DrawScreen(void)
void RenderBackend_DrawScreen(void)
{
spritebatch_tick(&glyph_batcher);
@ -772,21 +688,22 @@ void Backend_DrawScreen(void)
FlushVertexBuffer();
SDL_GL_SwapWindow(window);
// Switch back to our framebuffer
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id);
}
void RenderBackend_ClearScreen(void)
{
// According to https://www.khronos.org/opengl/wiki/Common_Mistakes#Swap_Buffers
// the buffer should always be cleared, even if it seems unnecessary
glClear(GL_COLOR_BUFFER_BIT);
// Switch back to our framebuffer
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id);
}
// ====================
// Surface management
// ====================
Backend_Surface* Backend_CreateSurface(unsigned int width, unsigned int height)
Backend_Surface* RenderBackend_CreateSurface(unsigned int width, unsigned int height)
{
Backend_Surface *surface = (Backend_Surface*)malloc(sizeof(Backend_Surface));
@ -816,7 +733,7 @@ Backend_Surface* Backend_CreateSurface(unsigned int width, unsigned int height)
return surface;
}
void Backend_FreeSurface(Backend_Surface *surface)
void RenderBackend_FreeSurface(Backend_Surface *surface)
{
if (surface == NULL)
return;
@ -829,19 +746,19 @@ void Backend_FreeSurface(Backend_Surface *surface)
free(surface);
}
BOOL Backend_IsSurfaceLost(Backend_Surface *surface)
BOOL RenderBackend_IsSurfaceLost(Backend_Surface *surface)
{
(void)surface;
return FALSE;
}
void Backend_RestoreSurface(Backend_Surface *surface)
void RenderBackend_RestoreSurface(Backend_Surface *surface)
{
(void)surface;
}
unsigned char* Backend_LockSurface(Backend_Surface *surface, unsigned int *pitch, unsigned int width, unsigned int height)
unsigned char* RenderBackend_LockSurface(Backend_Surface *surface, unsigned int *pitch, unsigned int width, unsigned int height)
{
if (surface == NULL)
return NULL;
@ -851,7 +768,7 @@ unsigned char* Backend_LockSurface(Backend_Surface *surface, unsigned int *pitch
return surface->pixels;
}
void Backend_UnlockSurface(Backend_Surface *surface, unsigned int width, unsigned int height)
void RenderBackend_UnlockSurface(Backend_Surface *surface, unsigned int width, unsigned int height)
{
if (surface == NULL)
return;
@ -871,7 +788,7 @@ void Backend_UnlockSurface(Backend_Surface *surface, unsigned int width, unsigne
// Drawing
// ====================
void Backend_Blit(Backend_Surface *source_surface, const RECT *rect, Backend_Surface *destination_surface, long x, long y, BOOL colour_key)
void RenderBackend_Blit(Backend_Surface *source_surface, const RECT *rect, Backend_Surface *destination_surface, long x, long y, BOOL colour_key)
{
if (source_surface == NULL || destination_surface == NULL)
return;
@ -947,7 +864,7 @@ void Backend_Blit(Backend_Surface *source_surface, const RECT *rect, Backend_Sur
vertex_buffer_slot->vertices[1][2].vertex_coordinate.y = vertex_bottom;
}
void Backend_ColourFill(Backend_Surface *surface, const RECT *rect, unsigned char red, unsigned char green, unsigned char blue)
void RenderBackend_ColourFill(Backend_Surface *surface, const RECT *rect, unsigned char red, unsigned char green, unsigned char blue)
{
static unsigned char last_red;
static unsigned char last_green;
@ -1012,7 +929,7 @@ void Backend_ColourFill(Backend_Surface *surface, const RECT *rect, unsigned cha
// Glyph management
// ====================
Backend_Glyph* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch)
Backend_Glyph* RenderBackend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch)
{
Backend_Glyph *glyph = (Backend_Glyph*)malloc(sizeof(Backend_Glyph));
@ -1043,7 +960,7 @@ Backend_Glyph* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width
return NULL;
}
void Backend_UnloadGlyph(Backend_Glyph *glyph)
void RenderBackend_UnloadGlyph(Backend_Glyph *glyph)
{
if (glyph == NULL)
return;
@ -1052,19 +969,19 @@ void Backend_UnloadGlyph(Backend_Glyph *glyph)
free(glyph);
}
void Backend_PrepareToDrawGlyphs(Backend_Surface *destination_surface, const unsigned char *colour_channels)
void RenderBackend_PrepareToDrawGlyphs(Backend_Surface *destination_surface, const unsigned char *colour_channels)
{
glyph_destination_surface = destination_surface;
memcpy(glyph_colour_channels, colour_channels, sizeof(glyph_colour_channels));
}
void Backend_DrawGlyph(Backend_Glyph *glyph, long x, long y)
void RenderBackend_DrawGlyph(Backend_Glyph *glyph, long x, long y)
{
spritebatch_push(&glyph_batcher, (SPRITEBATCH_U64)glyph, glyph->pitch, glyph->height, x, y, 1.0f, 1.0f, 0.0f, 0.0f, 0);
}
void Backend_FlushGlyphs(void)
void RenderBackend_FlushGlyphs(void)
{
spritebatch_defrag(&glyph_batcher);
spritebatch_flush(&glyph_batcher);
@ -1074,12 +991,12 @@ void Backend_FlushGlyphs(void)
// Misc.
// ====================
void Backend_HandleRenderTargetLoss(void)
void RenderBackend_HandleRenderTargetLoss(void)
{
// No problem for us
}
void Backend_HandleWindowResize(void)
void RenderBackend_HandleWindowResize(void)
{
// No problem for us
}

25
src/Backends/Window.h Normal file
View file

@ -0,0 +1,25 @@
#pragma once
#include "../WindowsWrapper.h"
#include "Rendering.h"
Backend_Surface* Backend_Init(const char *window_title, int screen_width, int screen_height, BOOL fullscreen);
void Backend_Deinit(void);
void Backend_DrawScreen(void);
void Backend_ClearScreen(void);
Backend_Surface* Backend_CreateSurface(unsigned int width, unsigned int height);
void Backend_FreeSurface(Backend_Surface *surface);
BOOL Backend_IsSurfaceLost(Backend_Surface *surface);
void Backend_RestoreSurface(Backend_Surface *surface);
unsigned char* Backend_LockSurface(Backend_Surface *surface, unsigned int *pitch, unsigned int width, unsigned int height);
void Backend_UnlockSurface(Backend_Surface *surface, unsigned int width, unsigned int height);
void Backend_Blit(Backend_Surface *source_surface, const RECT *rect, Backend_Surface *destination_surface, long x, long y, BOOL colour_key);
void Backend_ColourFill(Backend_Surface *surface, const RECT *rect, unsigned char red, unsigned char green, unsigned char blue);
Backend_Glyph* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch);
void Backend_UnloadGlyph(Backend_Glyph *glyph);
void Backend_PrepareToDrawGlyphs(Backend_Surface *destination_surface, const unsigned char *colour_channels);
void Backend_DrawGlyph(Backend_Glyph *glyph, long x, long y);
void Backend_FlushGlyphs(void);
void Backend_HandleRenderTargetLoss(void);
void Backend_HandleWindowResize(void);

181
src/Backends/Window/GLFW3-OpenGL3.cpp Normal file
View file

@ -0,0 +1,181 @@
#include "../Window.h"
#ifdef USE_OPENGLES2
#include <GLES2/gl2.h>
#else
#include "../../../external/glad/include/glad/glad.h"
#endif
#include <GLFW/glfw3.h>
#include <stddef.h>
#include "../../WindowsWrapper.h"
#include "../Platform.h"
#include "../../Resource.h"
// Horrible hacks
GLFWwindow *window;
void KeyCallback(GLFWwindow *window, int key, int scancode, int action, int mods);
void WindowFocusCallback(GLFWwindow *window, int focused);
void WindowSizeCallback(GLFWwindow *window, int width, int height);
Backend_Surface* Backend_Init(const char *window_title, int screen_width, int screen_height, BOOL fullscreen)
{
#ifdef USE_OPENGLES2
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_ES);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
#else
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
#endif
window = glfwCreateWindow(screen_width, screen_height, window_title, NULL, NULL);
if (window != NULL)
{/*
#ifndef _WIN32 // On Windows, we use native icons instead (so we can give the taskbar and window separate icons, like the original EXE does)
size_t resource_size;
const unsigned char *resource_data = FindResource("ICON_MINI", "ICON", &resource_size);
SDL_RWops *rwops = SDL_RWFromConstMem(resource_data, resource_size);
SDL_Surface *icon_surface = SDL_LoadBMP_RW(rwops, 1);
SDL_SetWindowIcon(window, icon_surface);
SDL_FreeSurface(icon_surface);
#endif
*/
if (fullscreen)
glfwSetWindowMonitor(window, glfwGetPrimaryMonitor(), 0, 0, screen_width, screen_height, GLFW_DONT_CARE);
glfwMakeContextCurrent(window);
#ifndef USE_OPENGLES2
if (gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
{
// Check if the platform supports OpenGL 3.2
if (GLAD_GL_VERSION_3_2)
{
#endif
glfwSetKeyCallback(window, KeyCallback);
glfwSetWindowFocusCallback(window, WindowFocusCallback);
glfwSetWindowSizeCallback(window, WindowSizeCallback);
return RenderBackend_Init(screen_width, screen_height);
#ifndef USE_OPENGLES2
}
else
{
PlatformBackend_ShowMessageBox("Fatal error (OpenGL rendering backend)", "Your system does not support OpenGL 3.2");
}
}
else
{
PlatformBackend_ShowMessageBox("Fatal error (OpenGL rendering backend)", "Could not load OpenGL functions");
}
#endif
glfwDestroyWindow(window);
}
else
{
PlatformBackend_ShowMessageBox("Fatal error (OpenGL rendering backend)", "Could not create window");
}
return NULL;
}
void Backend_Deinit(void)
{
RenderBackend_Deinit();
glfwDestroyWindow(window);
}
void Backend_DrawScreen(void)
{
RenderBackend_DrawScreen();
glfwSwapBuffers(window);
RenderBackend_ClearScreen();
}
Backend_Surface* Backend_CreateSurface(unsigned int width, unsigned int height)
{
return RenderBackend_CreateSurface(width, height);
}
void Backend_FreeSurface(Backend_Surface *surface)
{
RenderBackend_FreeSurface(surface);
}
BOOL Backend_IsSurfaceLost(Backend_Surface *surface)
{
return RenderBackend_IsSurfaceLost(surface);
}
void Backend_RestoreSurface(Backend_Surface *surface)
{
RenderBackend_RestoreSurface(surface);
}
unsigned char* Backend_LockSurface(Backend_Surface *surface, unsigned int *pitch, unsigned int width, unsigned int height)
{
return RenderBackend_LockSurface(surface, pitch, width, height);
}
void Backend_UnlockSurface(Backend_Surface *surface, unsigned int width, unsigned int height)
{
RenderBackend_UnlockSurface(surface, width, height);
}
void Backend_Blit(Backend_Surface *source_surface, const RECT *rect, Backend_Surface *destination_surface, long x, long y, BOOL colour_key)
{
RenderBackend_Blit(source_surface, rect, destination_surface, x, y, colour_key);
}
void Backend_ColourFill(Backend_Surface *surface, const RECT *rect, unsigned char red, unsigned char green, unsigned char blue)
{
RenderBackend_ColourFill(surface, rect, red, green, blue);
}
Backend_Glyph* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch)
{
return RenderBackend_LoadGlyph(pixels, width, height, pitch);
}
void Backend_UnloadGlyph(Backend_Glyph *glyph)
{
RenderBackend_UnloadGlyph(glyph);
}
void Backend_PrepareToDrawGlyphs(Backend_Surface *destination_surface, const unsigned char *colour_channels)
{
RenderBackend_PrepareToDrawGlyphs(destination_surface, colour_channels);
}
void Backend_DrawGlyph(Backend_Glyph *glyph, long x, long y)
{
RenderBackend_DrawGlyph(glyph, x, y);
}
void Backend_FlushGlyphs(void)
{
RenderBackend_FlushGlyphs();
}
void Backend_HandleRenderTargetLoss(void)
{
RenderBackend_HandleRenderTargetLoss();
}
void Backend_HandleWindowResize(void)
{
RenderBackend_HandleWindowResize();
}

197
src/Backends/Window/SDL2-OpenGL3.cpp Normal file
View file

@ -0,0 +1,197 @@
#include "../Window.h"
#ifdef USE_OPENGLES2
#include <GLES2/gl2.h>
#else
#include "../../../external/glad/include/glad/glad.h"
#endif
#include "SDL.h"
#include <stddef.h>
#include "../../WindowsWrapper.h"
#include "../../Resource.h"
static SDL_Window *window;
static SDL_GLContext context;
Backend_Surface* Backend_Init(const char *window_title, int screen_width, int screen_height, BOOL fullscreen)
{
puts("Available SDL2 video drivers:");
for (int i = 0; i < SDL_GetNumVideoDrivers(); ++i)
puts(SDL_GetVideoDriver(i));
printf("Selected SDL2 video driver: %s\n", SDL_GetCurrentVideoDriver());
#ifdef USE_OPENGLES2
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
#else
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
#endif
window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, screen_width, screen_height, SDL_WINDOW_OPENGL);
if (window != NULL)
{
#ifndef _WIN32 // On Windows, we use native icons instead (so we can give the taskbar and window separate icons, like the original EXE does)
size_t resource_size;
const unsigned char *resource_data = FindResource("ICON_MINI", "ICON", &resource_size);
SDL_RWops *rwops = SDL_RWFromConstMem(resource_data, resource_size);
SDL_Surface *icon_surface = SDL_LoadBMP_RW(rwops, 1);
SDL_SetWindowIcon(window, icon_surface);
SDL_FreeSurface(icon_surface);
#endif
if (fullscreen)
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);
context = SDL_GL_CreateContext(window);
if (context != NULL)
{
if (SDL_GL_MakeCurrent(window, context) == 0)
{
#ifndef USE_OPENGLES2
if (gladLoadGLLoader((GLADloadproc)SDL_GL_GetProcAddress))
{
// Check if the platform supports OpenGL 3.2
if (GLAD_GL_VERSION_3_2)
{
#endif
return RenderBackend_Init(screen_width, screen_height);
#ifndef USE_OPENGLES2
}
else
{
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Fatal error (OpenGL rendering backend)", "Your system does not support OpenGL 3.2", window);
}
}
else
{
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Fatal error (OpenGL rendering backend)", "Could not load OpenGL functions", window);
}
#endif
}
else
{
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Fatal error (OpenGL rendering backend)", "SDL_GL_MakeCurrent failed", window);
}
SDL_GL_DeleteContext(context);
}
else
{
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Fatal error (OpenGL rendering backend)", "Could not create OpenGL context", window);
}
SDL_DestroyWindow(window);
}
else
{
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Fatal error (OpenGL rendering backend)", "Could not create window", NULL);
}
return NULL;
}
void Backend_Deinit(void)
{
RenderBackend_Deinit();
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(window);
}
void Backend_DrawScreen(void)
{
RenderBackend_DrawScreen();
SDL_GL_SwapWindow(window);
RenderBackend_ClearScreen();
}
Backend_Surface* Backend_CreateSurface(unsigned int width, unsigned int height)
{
return RenderBackend_CreateSurface(width, height);
}
void Backend_FreeSurface(Backend_Surface *surface)
{
RenderBackend_FreeSurface(surface);
}
BOOL Backend_IsSurfaceLost(Backend_Surface *surface)
{
return RenderBackend_IsSurfaceLost(surface);
}
void Backend_RestoreSurface(Backend_Surface *surface)
{
RenderBackend_RestoreSurface(surface);
}
unsigned char* Backend_LockSurface(Backend_Surface *surface, unsigned int *pitch, unsigned int width, unsigned int height)
{
return RenderBackend_LockSurface(surface, pitch, width, height);
}
void Backend_UnlockSurface(Backend_Surface *surface, unsigned int width, unsigned int height)
{
RenderBackend_UnlockSurface(surface, width, height);
}
void Backend_Blit(Backend_Surface *source_surface, const RECT *rect, Backend_Surface *destination_surface, long x, long y, BOOL colour_key)
{
RenderBackend_Blit(source_surface, rect, destination_surface, x, y, colour_key);
}
void Backend_ColourFill(Backend_Surface *surface, const RECT *rect, unsigned char red, unsigned char green, unsigned char blue)
{
RenderBackend_ColourFill(surface, rect, red, green, blue);
}
Backend_Glyph* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch)
{
return RenderBackend_LoadGlyph(pixels, width, height, pitch);
}
void Backend_UnloadGlyph(Backend_Glyph *glyph)
{
RenderBackend_UnloadGlyph(glyph);
}
void Backend_PrepareToDrawGlyphs(Backend_Surface *destination_surface, const unsigned char *colour_channels)
{
RenderBackend_PrepareToDrawGlyphs(destination_surface, colour_channels);
}
void Backend_DrawGlyph(Backend_Glyph *glyph, long x, long y)
{
RenderBackend_DrawGlyph(glyph, x, y);
}
void Backend_FlushGlyphs(void)
{
RenderBackend_FlushGlyphs();
}
void Backend_HandleRenderTargetLoss(void)
{
RenderBackend_HandleRenderTargetLoss();
}
void Backend_HandleWindowResize(void)
{
RenderBackend_HandleWindowResize();
}

11
src/Draw.cpp
View file

@ -7,7 +7,8 @@
#include "WindowsWrapper.h"
#include "Backends/Rendering.h"
#include "Backends/Platform.h"
#include "Backends/Window.h"
#include "Bitmap.h"
#include "CommonDefines.h"
#include "Ending.h"
@ -58,15 +59,15 @@ BOOL Flip_SystemTask(void)
return FALSE;
// Framerate limiter
timeNow = SDL_GetTicks();
timeNow = PlatformBackend_GetTicks();
if (SDL_TICKS_PASSED(timeNow, timePrev + 20))
if (timeNow >= timePrev + 20)
break;
SDL_Delay(1);
PlatformBackend_Delay(1);
}
if (SDL_TICKS_PASSED(timeNow, timePrev + 100))
if (timeNow >= timePrev + 100)
timePrev = timeNow; // If the timer is freakishly out of sync, panic and reset it, instead of spamming frames for who-knows how long
else
timePrev += 20;

2
src/Font.cpp
View file

@ -13,7 +13,7 @@
#include "Draw.h"
#include "File.h"
#include "Backends/Rendering.h"
#include "Backends/Window.h"
// Cave Story wasn't intended to use font anti-aliasing. It's only because Microsoft enabled it
// by default from Windows Vista onwards that the game started using it.

21
src/Main.cpp
View file

@ -63,11 +63,11 @@ unsigned long GetFramePerSecound(void)
if (need_new_base_tick)
{
base_tick = SDL_GetTicks();
base_tick = PlatformBackend_GetTicks();
need_new_base_tick = FALSE;
}
current_tick = SDL_GetTicks();
current_tick = PlatformBackend_GetTicks();
++current_frame;
if (base_tick + 1000 <= current_tick)
@ -91,7 +91,19 @@ int main(int argc, char *argv[])
PlatformBackend_Init();
// Get executable's path
PlatformBackend_GetBasePath(gModulePath);
if (!PlatformBackend_GetBasePath(gModulePath))
{
strcpy(gModulePath, argv[0]);
for (size_t i = strlen(gModulePath);; --i)
{
if (i == 0 || gModulePath[i] == '\\' || gModulePath[i] == '/')
{
gModulePath[i] = '\0';
break;
}
}
}
// Get path of the data folder
strcpy(gDataPath, gModulePath);
@ -308,6 +320,9 @@ int main(int argc, char *argv[])
SDL_FreeCursor(cursor);
SDL_FreeSurface(cursor_surface);
*/
PlatformBackend_Deinit();
return EXIT_SUCCESS;
}