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

Mostly ASM-accurate Draw.cpp

Browse source 
See #74
This commit is contained in:
Clownacy 2019-08-31 17:43:45 +01:00
parent 03e513365b
commit f956eb9264
13 changed files with 771 additions and 3529 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
msvc2003/CSE2.vcproj
View file

@ -34,7 +34,7 @@
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="SDL2/lib/SDL2.lib SDL2/lib/SDL2main.lib freetype/lib/freetype.lib Version.lib dsound.lib WinMM.lib dxguid.lib dinput.lib"
AdditionalDependencies="SDL2/lib/SDL2.lib SDL2/lib/SDL2main.lib freetype/lib/freetype.lib Version.lib dsound.lib WinMM.lib dxguid.lib dinput.lib ddraw.lib"
OutputFile="$(OutDir)\$(ProjectName).exe"
LinkIncremental="2"
AdditionalLibraryDirectories=""
@ -85,7 +85,7 @@
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="SDL2/lib/SDL2.lib SDL2/lib/SDL2main.lib freetype/lib/freetype.lib Version.lib dsound.lib WinMM.lib dxguid.lib dinput.lib"
AdditionalDependencies="SDL2/lib/SDL2.lib SDL2/lib/SDL2main.lib freetype/lib/freetype.lib Version.lib dsound.lib WinMM.lib dxguid.lib dinput.lib ddraw.lib"
OutputFile="$(OutDir)\$(ProjectName).exe"
LinkIncremental="1"
IgnoreAllDefaultLibraries="FALSE"
@ -135,7 +135,7 @@
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="SDL2/lib/SDL2.lib SDL2/lib/SDL2main.lib freetype/lib/freetype.lib Version.lib dsound.lib WinMM.lib dxguid.lib dinput.lib"
AdditionalDependencies="SDL2/lib/SDL2.lib SDL2/lib/SDL2main.lib freetype/lib/freetype.lib Version.lib dsound.lib WinMM.lib dxguid.lib dinput.lib ddraw.lib"
OutputFile="$(OutDir)\$(ProjectName).exe"
LinkIncremental="1"
IgnoreAllDefaultLibraries="FALSE"
@ -186,7 +186,7 @@
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="SDL2/lib/SDL2.lib SDL2/lib/SDL2main.lib freetype/lib/freetype.lib Version.lib dsound.lib WinMM.lib dxguid.lib dinput.lib"
AdditionalDependencies="SDL2/lib/SDL2.lib SDL2/lib/SDL2main.lib freetype/lib/freetype.lib Version.lib dsound.lib WinMM.lib dxguid.lib dinput.lib ddraw.lib"
OutputFile="$(OutDir)\$(ProjectName).exe"
LinkIncremental="2"
AdditionalLibraryDirectories=""
@ -298,21 +298,6 @@
<File
RelativePath="..\src\Flash.cpp">
</File>
<File
RelativePath="..\src\Font.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="3"/>
</FileConfiguration>
<FileConfiguration
Name="Release (Japanese)|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\src\Frame.cpp">
</File>
@ -424,9 +409,6 @@
<File
RelativePath="..\src\Profile.cpp">
</File>
<File
RelativePath="..\src\Backends\Rendering\SDLTexture.cpp">
</File>
<File
RelativePath="..\src\SelStage.cpp">
</File>
@ -534,9 +516,6 @@
<File
RelativePath="..\src\Flash.h">
</File>
<File
RelativePath="..\src\Font.h">
</File>
<File
RelativePath="..\src\Frame.h">
</File>
@ -597,9 +576,6 @@
<File
RelativePath="..\src\Profile.h">
</File>
<File
RelativePath="..\src\Backends\Rendering.h">
</File>
<File
RelativePath=".\resource1.h">
</File>

94
msvc2003/devilution/comparer-config.toml
View file

@ -371,6 +371,100 @@ addr = 0x40B1D0
name = "QuitDialog"
addr = 0x40B290
[[func]]
name = "SetWindowPadding"
addr = 0x40B320
[[func]]
name = "Flip_SystemTask"
addr = 0x40B340
[[func]]
name = "StartDirectDraw"
addr = 0x40B450
[[func]]
name = "EndDirectDraw"
addr = 0x40B6C0
[[func]]
name = "ReleaseSurface"
addr = 0x40B7A0
[[func]]
name = "MakeSurface_Resource"
addr = 0x40B800
size = 0x2BB
[[func]]
name = "MakeSurface_File"
addr = 0x40BAC0
size = 0x34F
[[func]]
name = "ReloadBitmap_Resource"
addr = 0x40BE10
[[func]]
name = "ReloadBitmap_File"
addr = 0x40BFD0
[[func]]
name = "MakeSurface_Generic"
addr = 0x40C1D0
[[func]]
name = "BackupSurface"
addr = 0x40C320
[[func]]
name = "PutBitmap3"
addr = 0x40C3C0
[[func]]
name = "PutBitmap4"
addr = 0x40C5B0
[[func]]
name = "Surface2Surface"
addr = 0x40C7A0
[[func]]
name = "GetCortBoxColor"
addr = 0x40C8B0
[[func]]
name = "CortBox"
addr = 0x40C9E0
[[func]]
name = "CortBox2"
addr = 0x40CA80
[[func]]
name = "DummiedOutLogFunction"
addr = 0x40CB30
[[func]]
name = "RestoreSurfaces"
addr = 0x40CB60
[[func]]
name = "InitTextObject"
addr = 0x40CD50
[[func]]
name = "PutText"
addr = 0x40CE00
[[func]]
name = "PutText2"
addr = 0x40CEB0
[[func]]
name = "EndTextObject"
addr = 0x40CF70
[[func]]
name = "ActionStripper"
addr = 0x40CF90

32
src/Backends/Rendering.h
View file

@ -1,32 +0,0 @@
#pragma once
#include "SDL.h"
#include "../WindowsWrapper.h"
typedef enum FontPixelMode
{
FONT_PIXEL_MODE_LCD,
FONT_PIXEL_MODE_GRAY,
FONT_PIXEL_MODE_MONO,
} FontPixelMode;
typedef struct Backend_Surface Backend_Surface;
typedef struct Backend_Glyph Backend_Glyph;
SDL_Window* Backend_CreateWindow(const char *title, int width, int height);
Backend_Surface* Backend_Init(SDL_Window *window);
void Backend_Deinit(void);
void Backend_DrawScreen(void);
Backend_Surface* Backend_CreateSurface(unsigned int width, unsigned int height);
void Backend_FreeSurface(Backend_Surface *surface);
unsigned char* Backend_LockSurface(Backend_Surface *surface, unsigned int *pitch);
void Backend_UnlockSurface(Backend_Surface *surface);
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);
BOOL Backend_SupportsSubpixelGlyphs(void);
Backend_Glyph* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch, FontPixelMode pixel_mode);
void Backend_UnloadGlyph(Backend_Glyph *glyph);
void Backend_DrawGlyph(Backend_Surface *surface, Backend_Glyph *glyph, long x, long y, const unsigned char *colours);
void Backend_HandleDeviceLoss(void);
void Backend_HandleWindowResize(void);

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

@ -1,797 +0,0 @@
#include "../Rendering.h"
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <GL/glew.h>
#include "SDL.h"
#include "../../WindowsWrapper.h"
typedef enum RenderMode
{
MODE_BLANK,
MODE_DRAW_SURFACE,
MODE_DRAW_SURFACE_WITH_TRANSPARENCY,
MODE_COLOUR_FILL,
MODE_DRAW_GLYPH,
MODE_DRAW_GLYPH_LCD
} RenderMode;
typedef struct Backend_Surface
{
GLuint texture_id;
unsigned int width;
unsigned int height;
unsigned char *pixels;
} Backend_Surface;
typedef struct Backend_Glyph
{
GLuint texture_id;
unsigned int width;
unsigned int height;
unsigned char pixel_mode;
} Backend_Glyph;
typedef struct Coordinate2D
{
GLfloat x;
GLfloat y;
} Coordinate2D;
typedef struct Vertex
{
Coordinate2D vertex_coordinate;
Coordinate2D texture_coordinate;
} Vertex;
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;
static GLuint program_glyph_normal;
static GLuint program_glyph_subpixel_part1;
static GLuint program_glyph_subpixel_part2;
static GLint program_colour_fill_uniform_colour;
static GLint program_glyph_normal_uniform_colour;
static GLint program_glyph_subpixel_part2_uniform_colour;
static GLuint vertex_array_id;
static GLuint vertex_buffer_id;
static GLuint framebuffer_id;
static VertexBufferSlot *vertex_buffer;
static unsigned long current_vertex_buffer_slot;
static RenderMode last_render_mode;
static Backend_Surface framebuffer;
static const GLchar *vertex_shader_plain = " \
#version 150 core\n \
in vec2 input_vertex_coordinates; \
void main() \
{ \
gl_Position = vec4(input_vertex_coordinates.x, input_vertex_coordinates.y, 0.0, 1.0); \
} \
";
static const GLchar *vertex_shader_texture = " \
#version 150 core\n \
in vec2 input_vertex_coordinates; \
in vec2 input_texture_coordinates; \
out vec2 texture_coordinates; \
void main() \
{ \
texture_coordinates = input_texture_coordinates; \
gl_Position = vec4(input_vertex_coordinates.x, input_vertex_coordinates.y, 0.0, 1.0); \
} \
";
static const GLchar *fragment_shader_texture = " \
#version 150 core\n \
uniform sampler2D tex; \
in vec2 texture_coordinates; \
out vec4 fragment; \
void main() \
{ \
fragment = texture(tex, texture_coordinates); \
} \
";
static const GLchar *fragment_shader_texture_colour_key = " \
#version 150 core\n \
uniform sampler2D tex; \
in vec2 texture_coordinates; \
out vec4 fragment; \
void main() \
{ \
vec4 colour = texture(tex, texture_coordinates); \
\
if (colour.xyz == vec3(0.0f, 0.0f, 0.0f)) \
discard; \
\
fragment = colour; \
} \
";
static const GLchar *fragment_shader_colour_fill = " \
#version 150 core\n \
uniform vec4 colour; \
out vec4 fragment; \
void main() \
{ \
fragment = colour; \
} \
";
static const GLchar *fragment_shader_glyph_normal = " \
#version 150 core\n \
uniform sampler2D tex; \
uniform vec4 colour; \
in vec2 texture_coordinates; \
out vec4 fragment; \
void main() \
{ \
fragment = colour * vec4(1.0, 1.0, 1.0, texture(tex, texture_coordinates).r); \
} \
";
static const GLchar *fragment_shader_glyph_subpixel_part1 = " \
#version 150 core\n \
uniform sampler2D tex; \
in vec2 texture_coordinates; \
out vec4 fragment; \
void main() \
{ \
fragment = texture(tex, texture_coordinates); \
} \
";
static const GLchar *fragment_shader_glyph_subpixel_part2 = " \
#version 150 core\n \
uniform sampler2D tex; \
uniform vec4 colour; \
in vec2 texture_coordinates; \
out vec4 fragment; \
void main() \
{ \
fragment = colour * texture(tex, texture_coordinates); \
} \
";
static void GLAPIENTRY MessageCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void* userParam)
{
(void)source;
(void)type;
(void)id;
(void)length;
(void)userParam;
if (severity != GL_DEBUG_SEVERITY_NOTIFICATION)
printf("OpenGL debug: %s\n", message);
}
static GLuint CompileShader(const char *vertex_shader_source, const char *fragment_shader_source)
{
GLint shader_status;
GLuint program_id = glCreateProgram();
GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL);
glCompileShader(vertex_shader);
glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &shader_status);
if (shader_status != GL_TRUE)
return 0;
glAttachShader(program_id, vertex_shader);
GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL);
glCompileShader(fragment_shader);
glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &shader_status);
if (shader_status != GL_TRUE)
return 0;
glAttachShader(program_id, fragment_shader);
glBindAttribLocation(program_id, 1, "input_vertex_coordinates");
glBindAttribLocation(program_id, 2, "input_texture_coordinates");
glLinkProgram(program_id);
glGetProgramiv(program_id, GL_LINK_STATUS, &shader_status);
if (shader_status != GL_TRUE)
return 0;
return program_id;
}
static VertexBufferSlot* GetVertexBufferSlot(void)
{
static unsigned long max_slots = 0;
if (current_vertex_buffer_slot >= max_slots)
{
if (max_slots == 0)
max_slots = 1;
else
max_slots <<= 1;
vertex_buffer = (VertexBufferSlot*)realloc(vertex_buffer, max_slots * sizeof(VertexBufferSlot));
glBufferData(GL_ARRAY_BUFFER, max_slots * sizeof(VertexBufferSlot), NULL, GL_STREAM_DRAW);
}
return &vertex_buffer[current_vertex_buffer_slot++];
}
static void FlushVertexBuffer(void)
{
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(VertexBufferSlot) * current_vertex_buffer_slot, vertex_buffer);
if (last_render_mode == MODE_DRAW_GLYPH_LCD)
{
// Here we're going to draw with per-component alpha.
// Since OpenGL doesn't really support this, we have to do it manually:
// Step one: attenuate the destination pixels by the alpha
glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
glUseProgram(program_glyph_subpixel_part1);
glDrawArrays(GL_TRIANGLES, 0, 6 * current_vertex_buffer_slot);
// Step two: add the new pixels on top of them
glBlendFunc(GL_ONE, GL_ONE);
glUseProgram(program_glyph_subpixel_part2);
}
else if (last_render_mode == MODE_DRAW_GLYPH)
{
// Here, we just use a regular alpha channel
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUseProgram(program_glyph_normal);
}
glDrawArrays(GL_TRIANGLES, 0, 6 * current_vertex_buffer_slot);
current_vertex_buffer_slot = 0;
}
SDL_Window* Backend_CreateWindow(const char *title, int width, int height)
{
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);
return SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_OPENGL);
}
Backend_Surface* Backend_Init(SDL_Window *p_window)
{
window = p_window;
int window_width, window_height;
SDL_GetWindowSize(window, &window_width, &window_height);
context = SDL_GL_CreateContext(window);
if (glewInit() != GLEW_OK)
return FALSE;
// Check if the platform supports OpenGL 3.2
if (!GLEW_VERSION_3_2)
return FALSE;
glEnable(GL_DEBUG_OUTPUT);
glDebugMessageCallback(MessageCallback, 0);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Set up Vertex Array Object
glGenVertexArrays(1, &vertex_array_id);
glBindVertexArray(vertex_array_id);
// Set up Vertex Buffer Object
glGenBuffers(1, &vertex_buffer_id);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_id);
glBufferData(GL_ARRAY_BUFFER, 1 * sizeof(VertexBufferSlot), NULL, GL_STREAM_DRAW);
// Set up the vertex attributes
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)offsetof(Vertex, vertex_coordinate));
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)offsetof(Vertex, texture_coordinate));
// Set up our shaders
program_texture = CompileShader(vertex_shader_texture, fragment_shader_texture);
program_texture_colour_key = CompileShader(vertex_shader_texture, fragment_shader_texture_colour_key);
program_colour_fill = CompileShader(vertex_shader_plain, fragment_shader_colour_fill);
program_glyph_normal = CompileShader(vertex_shader_texture, fragment_shader_glyph_normal);
program_glyph_subpixel_part1 = CompileShader(vertex_shader_texture, fragment_shader_glyph_subpixel_part1);
program_glyph_subpixel_part2 = CompileShader(vertex_shader_texture, fragment_shader_glyph_subpixel_part2);
if (program_texture == 0 || program_texture_colour_key == 0 || program_colour_fill == 0 || program_glyph_normal == 0 || program_glyph_subpixel_part1 == 0 || program_glyph_subpixel_part2 == 0)
printf("Failed to compile shaders\n");
// Get shader uniforms
program_colour_fill_uniform_colour = glGetUniformLocation(program_colour_fill, "colour");
program_glyph_normal_uniform_colour = glGetUniformLocation(program_glyph_normal, "colour");
program_glyph_subpixel_part2_uniform_colour = glGetUniformLocation(program_glyph_subpixel_part2, "colour");
// Set up framebuffer (used for surface-to-surface blitting)
glGenFramebuffers(1, &framebuffer_id);
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id);
// Set up framebuffer screen texture (used for screen-to-surface blitting)
glGenTextures(1, &framebuffer.texture_id);
glBindTexture(GL_TEXTURE_2D, framebuffer.texture_id);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, window_width, window_height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
framebuffer.width = window_width;
framebuffer.height = window_height;
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, framebuffer.texture_id, 0);
glViewport(0, 0, framebuffer.width, framebuffer.height);
return &framebuffer;
}
void Backend_Deinit(void)
{
glDeleteTextures(1, &framebuffer.texture_id);
glDeleteFramebuffers(1, &framebuffer_id);
glDeleteProgram(program_glyph_subpixel_part2);
glDeleteProgram(program_glyph_subpixel_part1);
glDeleteProgram(program_glyph_normal);
glDeleteProgram(program_colour_fill);
glDeleteProgram(program_texture_colour_key);
glDeleteProgram(program_texture);
glDeleteBuffers(1, &vertex_buffer_id);
glDeleteVertexArrays(1, &vertex_array_id);
SDL_GL_DeleteContext(context);
}
void Backend_DrawScreen(void)
{
FlushVertexBuffer();
last_render_mode = MODE_BLANK;
glUseProgram(program_texture);
glDisable(GL_BLEND);
// Enable texture coordinates, since this uses textures
glEnableVertexAttribArray(2);
// Target actual screen, and not our framebuffer
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport(0, 0, framebuffer.width, framebuffer.height);
// Draw framebuffer to screen
glBindTexture(GL_TEXTURE_2D, framebuffer.texture_id);
VertexBufferSlot *vertex_buffer_slot = GetVertexBufferSlot();
vertex_buffer_slot->vertices[0][0].texture_coordinate.x = 0.0f;
vertex_buffer_slot->vertices[0][0].texture_coordinate.y = 1.0f;
vertex_buffer_slot->vertices[0][1].texture_coordinate.x = 1.0f;
vertex_buffer_slot->vertices[0][1].texture_coordinate.y = 1.0f;
vertex_buffer_slot->vertices[0][2].texture_coordinate.x = 1.0f;
vertex_buffer_slot->vertices[0][2].texture_coordinate.y = 0.0f;
vertex_buffer_slot->vertices[1][0].texture_coordinate.x = 0.0f;
vertex_buffer_slot->vertices[1][0].texture_coordinate.y = 1.0f;
vertex_buffer_slot->vertices[1][1].texture_coordinate.x = 1.0f;
vertex_buffer_slot->vertices[1][1].texture_coordinate.y = 0.0f;
vertex_buffer_slot->vertices[1][2].texture_coordinate.x = 0.0f;
vertex_buffer_slot->vertices[1][2].texture_coordinate.y = 0.0f;
vertex_buffer_slot->vertices[0][0].vertex_coordinate.x = -1.0f;
vertex_buffer_slot->vertices[0][0].vertex_coordinate.y = -1.0f;
vertex_buffer_slot->vertices[0][1].vertex_coordinate.x = 1.0f;
vertex_buffer_slot->vertices[0][1].vertex_coordinate.y = -1.0f;
vertex_buffer_slot->vertices[0][2].vertex_coordinate.x = 1.0f;
vertex_buffer_slot->vertices[0][2].vertex_coordinate.y = 1.0f;
vertex_buffer_slot->vertices[1][0].vertex_coordinate.x = -1.0f;
vertex_buffer_slot->vertices[1][0].vertex_coordinate.y = -1.0f;
vertex_buffer_slot->vertices[1][1].vertex_coordinate.x = 1.0f;
vertex_buffer_slot->vertices[1][1].vertex_coordinate.y = 1.0f;
vertex_buffer_slot->vertices[1][2].vertex_coordinate.x = -1.0f;
vertex_buffer_slot->vertices[1][2].vertex_coordinate.y = 1.0f;
FlushVertexBuffer();
SDL_GL_SwapWindow(window);
// 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);
}
Backend_Surface* Backend_CreateSurface(unsigned int width, unsigned int height)
{
Backend_Surface *surface = (Backend_Surface*)malloc(sizeof(Backend_Surface));
if (surface == NULL)
return NULL;
glGenTextures(1, &surface->texture_id);
glBindTexture(GL_TEXTURE_2D, surface->texture_id);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
surface->width = width;
surface->height = height;
return surface;
}
void Backend_FreeSurface(Backend_Surface *surface)
{
if (surface == NULL)
return;
glDeleteTextures(1, &surface->texture_id);
free(surface);
}
unsigned char* Backend_LockSurface(Backend_Surface *surface, unsigned int *pitch)
{
if (surface == NULL)
return NULL;
surface->pixels = (unsigned char*)malloc(surface->width * surface->height * 3);
*pitch = surface->width * 3;
return surface->pixels;
}
void Backend_UnlockSurface(Backend_Surface *surface)
{
if (surface == NULL)
return;
GLint previously_bound_texture;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &previously_bound_texture);
glBindTexture(GL_TEXTURE_2D, surface->texture_id);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, surface->width, surface->height, GL_RGB, GL_UNSIGNED_BYTE, surface->pixels);
free(surface->pixels);
glBindTexture(GL_TEXTURE_2D, previously_bound_texture);
}
void Backend_Blit(Backend_Surface *source_surface, const RECT *rect, Backend_Surface *destination_surface, long x, long y, BOOL colour_key)
{
static Backend_Surface *last_source_surface;
static Backend_Surface *last_destination_surface;
if (source_surface == NULL || destination_surface == NULL)
return;
if (rect->right - rect->left < 0 || rect->bottom - rect->top < 0)
return;
const RenderMode render_mode = (colour_key ? MODE_DRAW_SURFACE_WITH_TRANSPARENCY : MODE_DRAW_SURFACE);
if (last_render_mode != render_mode || last_source_surface != source_surface || last_destination_surface != destination_surface)
{
FlushVertexBuffer();
last_render_mode = render_mode;
last_source_surface = source_surface;
last_destination_surface = destination_surface;
// Point our framebuffer to the destination texture
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, destination_surface->texture_id, 0);
glViewport(0, 0, destination_surface->width, destination_surface->height);
// Switch to colour-key shader if we have to
glUseProgram(colour_key ? program_texture_colour_key : program_texture);
glDisable(GL_BLEND);
// Enable texture coordinates, since this uses textures
glEnableVertexAttribArray(2);
glBindTexture(GL_TEXTURE_2D, source_surface->texture_id);
}
const GLfloat texture_left = (GLfloat)rect->left / (GLfloat)source_surface->width;
const GLfloat texture_right = (GLfloat)rect->right / (GLfloat)source_surface->width;
const GLfloat texture_top = (GLfloat)rect->top / (GLfloat)source_surface->height;
const GLfloat texture_bottom = (GLfloat)rect->bottom / (GLfloat)source_surface->height;
const GLfloat vertex_left = (x * (2.0f / destination_surface->width)) - 1.0f;
const GLfloat vertex_right = ((x + (rect->right - rect->left)) * (2.0f / destination_surface->width)) - 1.0f;
const GLfloat vertex_top = (y * (2.0f / destination_surface->height)) - 1.0f;
const GLfloat vertex_bottom = ((y + (rect->bottom - rect->top)) * (2.0f / destination_surface->height)) - 1.0f;
VertexBufferSlot *vertex_buffer_slot = GetVertexBufferSlot();
vertex_buffer_slot->vertices[0][0].texture_coordinate.x = texture_left;
vertex_buffer_slot->vertices[0][0].texture_coordinate.y = texture_top;
vertex_buffer_slot->vertices[0][1].texture_coordinate.x = texture_right;
vertex_buffer_slot->vertices[0][1].texture_coordinate.y = texture_top;
vertex_buffer_slot->vertices[0][2].texture_coordinate.x = texture_right;
vertex_buffer_slot->vertices[0][2].texture_coordinate.y = texture_bottom;
vertex_buffer_slot->vertices[1][0].texture_coordinate.x = texture_left;
vertex_buffer_slot->vertices[1][0].texture_coordinate.y = texture_top;
vertex_buffer_slot->vertices[1][1].texture_coordinate.x = texture_right;
vertex_buffer_slot->vertices[1][1].texture_coordinate.y = texture_bottom;
vertex_buffer_slot->vertices[1][2].texture_coordinate.x = texture_left;
vertex_buffer_slot->vertices[1][2].texture_coordinate.y = texture_bottom;
vertex_buffer_slot->vertices[0][0].vertex_coordinate.x = vertex_left;
vertex_buffer_slot->vertices[0][0].vertex_coordinate.y = vertex_top;
vertex_buffer_slot->vertices[0][1].vertex_coordinate.x = vertex_right;
vertex_buffer_slot->vertices[0][1].vertex_coordinate.y = vertex_top;
vertex_buffer_slot->vertices[0][2].vertex_coordinate.x = vertex_right;
vertex_buffer_slot->vertices[0][2].vertex_coordinate.y = vertex_bottom;
vertex_buffer_slot->vertices[1][0].vertex_coordinate.x = vertex_left;
vertex_buffer_slot->vertices[1][0].vertex_coordinate.y = vertex_top;
vertex_buffer_slot->vertices[1][1].vertex_coordinate.x = vertex_right;
vertex_buffer_slot->vertices[1][1].vertex_coordinate.y = vertex_bottom;
vertex_buffer_slot->vertices[1][2].vertex_coordinate.x = vertex_left;
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)
{
static Backend_Surface *last_surface;
static unsigned char last_red;
static unsigned char last_green;
static unsigned char last_blue;
if (surface == NULL)
return;
if (rect->right - rect->left < 0 || rect->bottom - rect->top < 0)
return;
if (last_render_mode != MODE_COLOUR_FILL || last_surface != surface || last_red != red || last_green != green || last_blue != blue)
{
FlushVertexBuffer();
last_render_mode = MODE_COLOUR_FILL;
last_surface = surface;
last_red = red;
last_green = green;
last_blue = blue;
// Point our framebuffer to the destination texture
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, surface->texture_id, 0);
glViewport(0, 0, surface->width, surface->height);
glUseProgram(program_colour_fill);
glDisable(GL_BLEND);
// Disable texture coordinate array, since this doesn't use textures
glDisableVertexAttribArray(2);
glUniform4f(program_colour_fill_uniform_colour, red / 255.0f, green / 255.0f, blue / 255.0f, 1.0f);
current_vertex_buffer_slot = 0;
}
const GLfloat vertex_left = (rect->left * (2.0f / surface->width)) - 1.0f;
const GLfloat vertex_right = (rect->right * (2.0f / surface->width)) - 1.0f;
const GLfloat vertex_top = (rect->top * (2.0f / surface->height)) - 1.0f;
const GLfloat vertex_bottom = (rect->bottom * (2.0f / surface->height)) - 1.0f;
VertexBufferSlot *vertex_buffer_slot = GetVertexBufferSlot();
vertex_buffer_slot->vertices[0][0].vertex_coordinate.x = vertex_left;
vertex_buffer_slot->vertices[0][0].vertex_coordinate.y = vertex_top;
vertex_buffer_slot->vertices[0][1].vertex_coordinate.x = vertex_right;
vertex_buffer_slot->vertices[0][1].vertex_coordinate.y = vertex_top;
vertex_buffer_slot->vertices[0][2].vertex_coordinate.x = vertex_right;
vertex_buffer_slot->vertices[0][2].vertex_coordinate.y = vertex_bottom;
vertex_buffer_slot->vertices[1][0].vertex_coordinate.x = vertex_left;
vertex_buffer_slot->vertices[1][0].vertex_coordinate.y = vertex_top;
vertex_buffer_slot->vertices[1][1].vertex_coordinate.x = vertex_right;
vertex_buffer_slot->vertices[1][1].vertex_coordinate.y = vertex_bottom;
vertex_buffer_slot->vertices[1][2].vertex_coordinate.x = vertex_left;
vertex_buffer_slot->vertices[1][2].vertex_coordinate.y = vertex_bottom;
}
BOOL Backend_SupportsSubpixelGlyphs(void)
{
return TRUE;
}
Backend_Glyph* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch, FontPixelMode pixel_mode)
{
Backend_Glyph *glyph = (Backend_Glyph*)malloc(sizeof(Backend_Glyph));
if (glyph == NULL)
return NULL;
const unsigned int destination_pitch = (width + 3) & ~3; // Round up to the nearest 4 (OpenGL needs this)
unsigned char *buffer = (unsigned char*)malloc(destination_pitch * height);
switch (pixel_mode)
{
case FONT_PIXEL_MODE_LCD:
case FONT_PIXEL_MODE_GRAY:
for (unsigned int y = 0; y < height; ++y)
{
const unsigned char *source_pointer = pixels + y * pitch;
unsigned char *destination_pointer = buffer + y * destination_pitch;
memcpy(destination_pointer, source_pointer, width);
}
break;
case FONT_PIXEL_MODE_MONO:
for (unsigned int y = 0; y < height; ++y)
{
const unsigned char *source_pointer = pixels + y * pitch;
unsigned char *destination_pointer = buffer + y * destination_pitch;
for (unsigned int x = 0; x < width; ++x)
*destination_pointer++ = (*source_pointer++ ? 0xFF : 0);
}
break;
}
GLint previously_bound_texture;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &previously_bound_texture);
glGenTextures(1, &glyph->texture_id);
glBindTexture(GL_TEXTURE_2D, glyph->texture_id);
if (pixel_mode == FONT_PIXEL_MODE_LCD)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, width / 3, height, 0, GL_RGB, GL_UNSIGNED_BYTE, buffer);
else
glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, width, height, 0, GL_RED, GL_UNSIGNED_BYTE, buffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glyph->width = (pixel_mode == FONT_PIXEL_MODE_LCD ? width / 3 : width);
glyph->height = height;
glyph->pixel_mode = pixel_mode;
free(buffer);
glBindTexture(GL_TEXTURE_2D, previously_bound_texture);
return glyph;
}
void Backend_UnloadGlyph(Backend_Glyph *glyph)
{
if (glyph == NULL)
return;
glDeleteTextures(1, &glyph->texture_id);
free(glyph);
}
void Backend_DrawGlyph(Backend_Surface *surface, Backend_Glyph *glyph, long x, long y, const unsigned char *colours)
{
static Backend_Surface *last_surface;
static Backend_Glyph *last_glyph;
static unsigned char last_red;
static unsigned char last_green;
static unsigned char last_blue;
if (glyph == NULL || surface == NULL)
return;
const RenderMode render_mode = (glyph->pixel_mode == FONT_PIXEL_MODE_LCD ? MODE_DRAW_GLYPH_LCD : MODE_DRAW_GLYPH);
if (last_render_mode != render_mode || last_surface != surface || last_glyph != glyph || last_red != colours[0] || last_green != colours[1] || last_blue != colours[2])
{
FlushVertexBuffer();
last_render_mode = render_mode;
last_surface = surface;
last_glyph = glyph;
last_red = colours[0];
last_green = colours[1];
last_blue = colours[2];
if (glyph->pixel_mode == FONT_PIXEL_MODE_LCD)
{
glUseProgram(program_glyph_subpixel_part2);
glUniform4f(program_glyph_subpixel_part2_uniform_colour, colours[0] / 255.0f, colours[1] / 255.0f, colours[2] / 255.0f, 1.0f);
}
else
{
glUseProgram(program_glyph_normal);
glUniform4f(program_glyph_normal_uniform_colour, colours[0] / 255.0f, colours[1] / 255.0f, colours[2] / 255.0f, 1.0f);
}
// Point our framebuffer to the destination texture
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, surface->texture_id, 0);
glViewport(0, 0, surface->width, surface->height);
glEnable(GL_BLEND);
// Enable texture coordinates, since this uses textures
glEnableVertexAttribArray(2);
glBindTexture(GL_TEXTURE_2D, glyph->texture_id);
}
const GLfloat vertex_left = (x * (2.0f / surface->width)) - 1.0f;
const GLfloat vertex_right = ((x + glyph->width) * (2.0f / surface->width)) - 1.0f;
const GLfloat vertex_top = (y * (2.0f / surface->height)) - 1.0f;
const GLfloat vertex_bottom = ((y + glyph->height) * (2.0f / surface->height)) - 1.0f;
VertexBufferSlot *vertex_buffer_slot = GetVertexBufferSlot();
vertex_buffer_slot->vertices[0][0].texture_coordinate.x = 0.0f;
vertex_buffer_slot->vertices[0][0].texture_coordinate.y = 0.0f;
vertex_buffer_slot->vertices[0][1].texture_coordinate.x = 1.0f;
vertex_buffer_slot->vertices[0][1].texture_coordinate.y = 0.0f;
vertex_buffer_slot->vertices[0][2].texture_coordinate.x = 1.0f;
vertex_buffer_slot->vertices[0][2].texture_coordinate.y = 1.0f;
vertex_buffer_slot->vertices[1][0].texture_coordinate.x = 0.0f;
vertex_buffer_slot->vertices[1][0].texture_coordinate.y = 0.0f;
vertex_buffer_slot->vertices[1][1].texture_coordinate.x = 1.0f;
vertex_buffer_slot->vertices[1][1].texture_coordinate.y = 1.0f;
vertex_buffer_slot->vertices[1][2].texture_coordinate.x = 0.0f;
vertex_buffer_slot->vertices[1][2].texture_coordinate.y = 1.0f;
vertex_buffer_slot->vertices[0][0].vertex_coordinate.x = vertex_left;
vertex_buffer_slot->vertices[0][0].vertex_coordinate.y = vertex_top;
vertex_buffer_slot->vertices[0][1].vertex_coordinate.x = vertex_right;
vertex_buffer_slot->vertices[0][1].vertex_coordinate.y = vertex_top;
vertex_buffer_slot->vertices[0][2].vertex_coordinate.x = vertex_right;
vertex_buffer_slot->vertices[0][2].vertex_coordinate.y = vertex_bottom;
vertex_buffer_slot->vertices[1][0].vertex_coordinate.x = vertex_left;
vertex_buffer_slot->vertices[1][0].vertex_coordinate.y = vertex_top;
vertex_buffer_slot->vertices[1][1].vertex_coordinate.x = vertex_right;
vertex_buffer_slot->vertices[1][1].vertex_coordinate.y = vertex_bottom;
vertex_buffer_slot->vertices[1][2].vertex_coordinate.x = vertex_left;
vertex_buffer_slot->vertices[1][2].vertex_coordinate.y = vertex_bottom;
}
void Backend_HandleDeviceLoss(void)
{
// No problem for us
}
void Backend_HandleWindowResize(void)
{
// No problem for us
}

239
src/Backends/Rendering/SDLSurface.cpp
View file

@ -1,239 +0,0 @@
#include "../Rendering.h"
#include <stddef.h>
#include <stdlib.h>
#include "SDL.h"
#include "../../WindowsWrapper.h"
typedef struct Backend_Surface
{
SDL_Surface *sdlsurface;
} Backend_Surface;
typedef struct Backend_Glyph
{
SDL_Surface *sdlsurface;
} Backend_Glyph;
static SDL_Window *window;
static SDL_Surface *window_sdlsurface;
static Backend_Surface framebuffer;
static void RectToSDLRect(const RECT *rect, SDL_Rect *sdl_rect)
{
sdl_rect->x = (int)rect->left;
sdl_rect->y = (int)rect->top;
sdl_rect->w = (int)(rect->right - rect->left);
sdl_rect->h = (int)(rect->bottom - rect->top);
if (sdl_rect->w < 0)
sdl_rect->w = 0;
if (sdl_rect->h < 0)
sdl_rect->h = 0;
}
SDL_Window* Backend_CreateWindow(const char *title, int width, int height)
{
return SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, 0);
}
Backend_Surface* Backend_Init(SDL_Window *p_window)
{
window = p_window;
window_sdlsurface = SDL_GetWindowSurface(window);
framebuffer.sdlsurface = SDL_CreateRGBSurfaceWithFormat(0, window_sdlsurface->w, window_sdlsurface->h, 0, SDL_PIXELFORMAT_RGB24);
if (framebuffer.sdlsurface == NULL)
return NULL;
return &framebuffer;
}
void Backend_Deinit(void)
{
SDL_FreeSurface(framebuffer.sdlsurface);
}
void Backend_DrawScreen(void)
{
SDL_BlitSurface(framebuffer.sdlsurface, NULL, window_sdlsurface, NULL);
SDL_UpdateWindowSurface(window);
}
Backend_Surface* Backend_CreateSurface(unsigned int width, unsigned int height)
{
Backend_Surface *surface = (Backend_Surface*)malloc(sizeof(Backend_Surface));
if (surface == NULL)
return NULL;
surface->sdlsurface = SDL_CreateRGBSurfaceWithFormat(0, width, height, 0, SDL_PIXELFORMAT_RGB24);
if (surface->sdlsurface == NULL)
{
free(surface);
return NULL;
}
return surface;
}
void Backend_FreeSurface(Backend_Surface *surface)
{
if (surface == NULL)
return;
SDL_FreeSurface(surface->sdlsurface);
free(surface);
}
unsigned char* Backend_LockSurface(Backend_Surface *surface, unsigned int *pitch)
{
if (surface == NULL)
return NULL;
*pitch = surface->sdlsurface->pitch;
return (unsigned char*)surface->sdlsurface->pixels;
}
void Backend_UnlockSurface(Backend_Surface *surface)
{
(void)surface;
}
void Backend_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;
SDL_Rect source_rect;
RectToSDLRect(rect, &source_rect);
SDL_Rect destination_rect;
destination_rect.x = x;
destination_rect.y = y;
destination_rect.w = source_rect.w;
destination_rect.h = source_rect.h;
SDL_SetColorKey(source_surface->sdlsurface, colour_key ? SDL_TRUE : SDL_FALSE, SDL_MapRGB(source_surface->sdlsurface->format, 0, 0, 0)); // Assumes the colour key will always be #000000 (black)
SDL_BlitSurface(source_surface->sdlsurface, &source_rect, destination_surface->sdlsurface, &destination_rect);
}
void Backend_ColourFill(Backend_Surface *surface, const RECT *rect, unsigned char red, unsigned char green, unsigned char blue)
{
if (surface == NULL)
return;
SDL_Rect destination_rect;
RectToSDLRect(rect, &destination_rect);
SDL_FillRect(surface->sdlsurface, &destination_rect, SDL_MapRGB(surface->sdlsurface->format, red, green, blue));
}
BOOL Backend_SupportsSubpixelGlyphs(void)
{
return FALSE; // SDL_Surfaces don't have per-component alpha
}
Backend_Glyph* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch, FontPixelMode pixel_mode)
{
Backend_Glyph *glyph = (Backend_Glyph*)malloc(sizeof(Backend_Glyph));
if (glyph == NULL)
return NULL;
glyph->sdlsurface = SDL_CreateRGBSurfaceWithFormat(0, width, height, 0, SDL_PIXELFORMAT_RGBA32);
if (glyph->sdlsurface == NULL)
{
free(glyph);
return NULL;
}
switch (pixel_mode)
{
case FONT_PIXEL_MODE_LCD:
// Unsupported
break;
case FONT_PIXEL_MODE_GRAY:
for (unsigned int y = 0; y < height; ++y)
{
const unsigned char *source_pointer = pixels + y * pitch;
unsigned char *destination_pointer = (unsigned char*)glyph->sdlsurface->pixels + y * glyph->sdlsurface->pitch;
for (unsigned int x = 0; x < width; ++x)
{
*destination_pointer++ = 0xFF;
*destination_pointer++ = 0xFF;
*destination_pointer++ = 0xFF;
*destination_pointer++ = *source_pointer++;
}
}
break;
case FONT_PIXEL_MODE_MONO:
for (unsigned int y = 0; y < height; ++y)
{
const unsigned char *source_pointer = pixels + y * pitch;
unsigned char *destination_pointer = (unsigned char*)glyph->sdlsurface->pixels + y * glyph->sdlsurface->pitch;
for (unsigned int x = 0; x < width; ++x)
{
*destination_pointer++ = 0xFF;
*destination_pointer++ = 0xFF;
*destination_pointer++ = 0xFF;
*destination_pointer++ = *source_pointer++ ? 0xFF : 0;
}
}
break;
}
return glyph;
}
void Backend_UnloadGlyph(Backend_Glyph *glyph)
{
if (glyph == NULL)
return;
SDL_FreeSurface(glyph->sdlsurface);
free(glyph);
}
void Backend_DrawGlyph(Backend_Surface *surface, Backend_Glyph *glyph, long x, long y, const unsigned char *colours)
{
if (glyph == NULL || surface == NULL)
return;
SDL_Rect rect;
rect.x = x;
rect.y = y;
rect.w = glyph->sdlsurface->w;
rect.h = glyph->sdlsurface->h;
SDL_SetSurfaceColorMod(glyph->sdlsurface, colours[0], colours[1], colours[2]);
SDL_BlitSurface(glyph->sdlsurface, NULL, surface->sdlsurface, &rect);
}
void Backend_HandleDeviceLoss(void)
{
// No problem for us
}
void Backend_HandleWindowResize(void)
{
// https://wiki.libsdl.org/SDL_GetWindowSurface
// We need to fetch a new surface pointer
window_sdlsurface = SDL_GetWindowSurface(window);
}

320
src/Backends/Rendering/SDLTexture.cpp
View file

@ -1,320 +0,0 @@
#include "../Rendering.h"
#include <stddef.h>
#include <stdlib.h>
#include "SDL.h"
#include "../../WindowsWrapper.h"
#include "../../Draw.h"
#include "../../Ending.h"
#include "../../MapName.h"
#include "../../TextScr.h"
typedef struct Backend_Surface
{
SDL_Texture *texture;
unsigned char *pixels;
unsigned int width;
unsigned int height;
} Backend_Surface;
typedef struct Backend_Glyph
{
SDL_Texture *texture;
unsigned int width;
unsigned int height;
} Backend_Glyph;
static SDL_Renderer *renderer;
static Backend_Surface framebuffer;
static void RectToSDLRect(const RECT *rect, SDL_Rect *sdl_rect)
{
sdl_rect->x = (int)rect->left;
sdl_rect->y = (int)rect->top;
sdl_rect->w = (int)(rect->right - rect->left);
sdl_rect->h = (int)(rect->bottom - rect->top);
if (sdl_rect->w < 0)
sdl_rect->w = 0;
if (sdl_rect->h < 0)
sdl_rect->h = 0;
}
SDL_Window* Backend_CreateWindow(const char *title, int width, int height)
{
return SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, 0);
}
Backend_Surface* Backend_Init(SDL_Window *window)
{
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE);
if (renderer == NULL)
return NULL;
int width, height;
SDL_GetRendererOutputSize(renderer, &width, &height);
framebuffer.texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA32, SDL_TEXTUREACCESS_TARGET, width, height);
if (framebuffer.texture == NULL)
{
SDL_DestroyRenderer(renderer);
return NULL;
}
framebuffer.width = width;
framebuffer.height = height;
return &framebuffer;
}
void Backend_Deinit(void)
{
SDL_DestroyTexture(framebuffer.texture);
SDL_DestroyRenderer(renderer);
}
void Backend_DrawScreen(void)
{
SDL_SetRenderTarget(renderer, NULL);
SDL_RenderCopy(renderer, framebuffer.texture, NULL, NULL);
SDL_RenderPresent(renderer);
}
Backend_Surface* Backend_CreateSurface(unsigned int width, unsigned int height)
{
Backend_Surface *surface = (Backend_Surface*)malloc(sizeof(Backend_Surface));
if (surface == NULL)
return NULL;
surface->texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA32, SDL_TEXTUREACCESS_TARGET, width, height);
if (surface->texture == NULL)
{
free(surface);
return NULL;
}
surface->width = width;
surface->height = height;
return surface;
}
void Backend_FreeSurface(Backend_Surface *surface)
{
if (surface == NULL)
return;
SDL_DestroyTexture(surface->texture);
free(surface);
}
unsigned char* Backend_LockSurface(Backend_Surface *surface, unsigned int *pitch)
{
if (surface == NULL)
return NULL;
*pitch = surface->width * 3;
surface->pixels = (unsigned char*)malloc(surface->width * surface->height * 3);
return surface->pixels;
}
void Backend_UnlockSurface(Backend_Surface *surface)
{
if (surface == NULL)
return;
unsigned char *buffer = (unsigned char*)malloc(surface->width * surface->height * 4);
unsigned char *buffer_pointer = buffer;
const unsigned char *src_pixel = surface->pixels;
// Convert the SDL_Surface's colour-keyed pixels to RGBA32
for (unsigned int y = 0; y < surface->height; ++y)
{
for (unsigned int x = 0; x < surface->width; ++x)
{
*buffer_pointer++ = src_pixel[0];
*buffer_pointer++ = src_pixel[1];
*buffer_pointer++ = src_pixel[2];
if (src_pixel[0] == 0 && src_pixel[1] == 0 && src_pixel[2] == 0) // Assumes the colour key will always be #000000 (black)
*buffer_pointer++ = 0;
else
*buffer_pointer++ = 0xFF;
src_pixel += 3;
}
}
free(surface->pixels);
SDL_UpdateTexture(surface->texture, NULL, buffer, surface->width * 4);
free(buffer);
}
void Backend_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;
SDL_Rect source_rect;
RectToSDLRect(rect, &source_rect);
SDL_Rect destination_rect = {(int)x, (int)y, source_rect.w, source_rect.h};
// Blit the texture
SDL_SetTextureBlendMode(source_surface->texture, colour_key ? SDL_BLENDMODE_BLEND : SDL_BLENDMODE_NONE);
SDL_SetRenderTarget(renderer, destination_surface->texture);
SDL_RenderCopy(renderer, source_surface->texture, &source_rect, &destination_rect);
}
void Backend_ColourFill(Backend_Surface *surface, const RECT *rect, unsigned char red, unsigned char green, unsigned char blue)
{
if (surface == NULL)
return;
SDL_Rect sdl_rect;
RectToSDLRect(rect, &sdl_rect);
// Check colour-key
if (red == 0 && green == 0 && blue == 0)
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
else
SDL_SetRenderDrawColor(renderer, red, green, blue, SDL_ALPHA_OPAQUE);
// Draw colour
SDL_SetRenderTarget(renderer, surface->texture);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
SDL_RenderFillRect(renderer, &sdl_rect);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
}
BOOL Backend_SupportsSubpixelGlyphs(void)
{
return FALSE; // SDL_Textures don't have per-component alpha
}
Backend_Glyph* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch, FontPixelMode pixel_mode)
{
Backend_Glyph *glyph = (Backend_Glyph*)malloc(sizeof(Backend_Glyph));
if (glyph == NULL)
return NULL;
glyph->texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA32, SDL_TEXTUREACCESS_STATIC, width, height);
if (glyph->texture == NULL)
{
free(glyph);
return NULL;
}
unsigned char *buffer = (unsigned char*)malloc(width * height * 4);
if (buffer == NULL)
{
SDL_DestroyTexture(glyph->texture);
free(glyph);
return NULL;
}
unsigned char *destination_pointer = buffer;
switch (pixel_mode)
{
case FONT_PIXEL_MODE_LCD:
// Unsupported
break;
case FONT_PIXEL_MODE_GRAY:
for (unsigned int y = 0; y < height; ++y)
{
const unsigned char *source_pointer = pixels + y * pitch;
for (unsigned int x = 0; x < width; ++x)
{
*destination_pointer++ = 0xFF;
*destination_pointer++ = 0xFF;
*destination_pointer++ = 0xFF;
*destination_pointer++ = *source_pointer++;
}
}
break;
case FONT_PIXEL_MODE_MONO:
for (unsigned int y = 0; y < height; ++y)
{
const unsigned char *source_pointer = pixels + y * pitch;
for (unsigned int x = 0; x < width; ++x)
{
*destination_pointer++ = 0xFF;
*destination_pointer++ = 0xFF;
*destination_pointer++ = 0xFF;
*destination_pointer++ = *source_pointer++ ? 0xFF : 0;
}
}
break;
}
SDL_UpdateTexture(glyph->texture, NULL, buffer, width * 4);
glyph->width = width;
glyph->height = height;
return glyph;
}
void Backend_UnloadGlyph(Backend_Glyph *glyph)
{
if (glyph == NULL)
return;
SDL_DestroyTexture(glyph->texture);
free(glyph);
}
void Backend_DrawGlyph(Backend_Surface *surface, Backend_Glyph *glyph, long x, long y, const unsigned char *colours)
{
// The SDL_Texture side of things uses alpha, not a colour-key, so the bug where the font is blended
// with the colour key doesn't occur.
if (glyph == NULL || surface == NULL)
return;
SDL_Rect destination_rect = {(int)x, (int)y, (int)glyph->width, (int)glyph->height};
// Blit the texture
SDL_SetTextureColorMod(glyph->texture, colours[0], colours[1], colours[2]);
SDL_SetTextureBlendMode(glyph->texture, SDL_BLENDMODE_BLEND);
SDL_SetRenderTarget(renderer, surface->texture);
SDL_RenderCopy(renderer, glyph->texture, NULL, &destination_rect);
}
void Backend_HandleDeviceLoss(void)
{
// All of our target-textures have been lost, so regenerate them
RestoreSurfaces();
RestoreStripper();
RestoreMapName();
RestoreTextScript();
}
void Backend_HandleWindowResize(void)
{
// No problem for us
}

411
src/Backends/Rendering/Software.cpp
View file

@ -1,411 +0,0 @@
#include "../Rendering.h"
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "SDL.h"
#include "../../WindowsWrapper.h"
#undef MIN
#undef MAX
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#define MAX(a,b) ((a) > (b) ? (a) : (b))
typedef struct Backend_Surface
{
unsigned char *pixels;
unsigned int width;
unsigned int height;
unsigned int pitch;
} Backend_Surface;
typedef struct Backend_Glyph
{
void *pixels;
unsigned int width;
unsigned int height;
FontPixelMode pixel_mode;
} Backend_Glyph;
static SDL_Window *window;
static SDL_Surface *window_sdlsurface;
static SDL_Surface *framebuffer_sdlsurface;
static Backend_Surface framebuffer;
SDL_Window* Backend_CreateWindow(const char *title, int width, int height)
{
return SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, 0);
}
Backend_Surface* Backend_Init(SDL_Window *p_window)
{
window = p_window;
window_sdlsurface = SDL_GetWindowSurface(window);
framebuffer_sdlsurface = SDL_CreateRGBSurfaceWithFormat(0, window_sdlsurface->w, window_sdlsurface->h, 0, SDL_PIXELFORMAT_RGB24);
if (framebuffer_sdlsurface == NULL)
return NULL;
framebuffer.pixels = (unsigned char*)framebuffer_sdlsurface->pixels;
framebuffer.width = framebuffer_sdlsurface->w;
framebuffer.height = framebuffer_sdlsurface->h;
framebuffer.pitch = framebuffer_sdlsurface->pitch;
return &framebuffer;
}
void Backend_Deinit(void)
{
SDL_FreeSurface(framebuffer_sdlsurface);
}
void Backend_DrawScreen(void)
{
SDL_BlitSurface(framebuffer_sdlsurface, NULL, window_sdlsurface, NULL);
SDL_UpdateWindowSurface(window);
}
Backend_Surface* Backend_CreateSurface(unsigned int width, unsigned int height)
{
Backend_Surface *surface = (Backend_Surface*)malloc(sizeof(Backend_Surface));
if (surface == NULL)
return NULL;
surface->pixels = (unsigned char*)malloc(width * height * 3);
if (surface->pixels == NULL)
{
free(surface);
return NULL;
}
surface->width = width;
surface->height = height;
surface->pitch = width * 3;
return surface;
}
void Backend_FreeSurface(Backend_Surface *surface)
{
if (surface == NULL)
return;
free(surface->pixels);
free(surface);
}
unsigned char* Backend_LockSurface(Backend_Surface *surface, unsigned int *pitch)
{
if (surface == NULL)
return NULL;
*pitch = surface->pitch;
return surface->pixels;
}
void Backend_UnlockSurface(Backend_Surface *surface)
{
(void)surface;
}
void Backend_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;
RECT rect_clamped;
rect_clamped.left = rect->left;
rect_clamped.top = rect->top;
rect_clamped.right = rect->right;
rect_clamped.bottom = rect->bottom;
// Clamp the rect and coordinates so we don't write outside the pixel buffer
long overflow;
overflow = 0 - x;
if (overflow > 0)
{
rect_clamped.left += overflow;
x += overflow;
}
overflow = 0 - y;
if (overflow > 0)
{
rect_clamped.top += overflow;
y += overflow;
}
overflow = (x + (rect_clamped.right - rect_clamped.left)) - destination_surface->width;
if (overflow > 0)
{
rect_clamped.right -= overflow;
}
overflow = (y + (rect_clamped.bottom - rect_clamped.top)) - destination_surface->height;
if (overflow > 0)
{
rect_clamped.bottom -= overflow;
}
if (rect_clamped.bottom - rect_clamped.top <= 0)
return;
if (rect_clamped.right - rect_clamped.left <= 0)
return;
// Do the actual blitting
if (colour_key)
{
for (long j = 0; j < rect_clamped.bottom - rect_clamped.top; ++j)
{
unsigned char *source_pointer = &source_surface->pixels[((rect_clamped.top + j) * source_surface->pitch) + (rect_clamped.left * 3)];
unsigned char *destination_pointer = &destination_surface->pixels[((y + j) * destination_surface->pitch) + (x * 3)];
for (long i = 0; i < rect_clamped.right - rect_clamped.left; ++i)
{
if (source_pointer[0] == 0 && source_pointer[1] == 0 && source_pointer[2] == 0) // Assumes the colour key will always be #000000 (black)
{
source_pointer += 3;
destination_pointer += 3;
}
else
{
*destination_pointer++ = *source_pointer++;
*destination_pointer++ = *source_pointer++;
*destination_pointer++ = *source_pointer++;
}
}
}
}
else
{
for (long j = 0; j < rect_clamped.bottom - rect_clamped.top; ++j)
{
unsigned char *source_pointer = &source_surface->pixels[((rect_clamped.top + j) * source_surface->pitch) + (rect_clamped.left * 3)];
unsigned char *destination_pointer = &destination_surface->pixels[((y + j) * destination_surface->pitch) + (x * 3)];
memcpy(destination_pointer, source_pointer, (rect_clamped.right - rect_clamped.left) * 3);
}
}
}
void Backend_ColourFill(Backend_Surface *surface, const RECT *rect, unsigned char red, unsigned char green, unsigned char blue)
{
if (surface == NULL)
return;
RECT rect_clamped;
rect_clamped.left = rect->left;
rect_clamped.top = rect->top;
rect_clamped.right = rect->right;
rect_clamped.bottom = rect->bottom;
// Clamp the rect so it doesn't write outside the pixel buffer
long overflow;
overflow = 0 - rect_clamped.left;
if (overflow > 0)
{
rect_clamped.left += overflow;
}
overflow = 0 - rect_clamped.top;
if (overflow > 0)
{
rect_clamped.top += overflow;
}
overflow = rect_clamped.right - surface->width;
if (overflow > 0)
{
rect_clamped.right -= overflow;
}
overflow = rect_clamped.bottom - surface->height;
if (overflow > 0)
{
rect_clamped.bottom -= overflow;
}
if (rect_clamped.bottom - rect_clamped.top <= 0)
return;
if (rect_clamped.right - rect_clamped.left <= 0)
return;
for (long j = 0; j < rect_clamped.bottom - rect_clamped.top; ++j)
{
unsigned char *destination_pointer = &surface->pixels[((rect_clamped.top + j) * surface->pitch) + (rect_clamped.left * 3)];
for (long i = 0; i < rect_clamped.right - rect_clamped.left; ++i)
{
*destination_pointer++ = red;
*destination_pointer++ = green;
*destination_pointer++ = blue;
}
}
}
BOOL Backend_SupportsSubpixelGlyphs(void)
{
return TRUE; // It's a software renderer, baby
}
Backend_Glyph* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch, FontPixelMode pixel_mode)
{
Backend_Glyph *glyph = (Backend_Glyph*)malloc(sizeof(Backend_Glyph));
if (glyph == NULL)
return NULL;
switch (pixel_mode)
{
case FONT_PIXEL_MODE_LCD:
case FONT_PIXEL_MODE_GRAY:
{
glyph->pixels = malloc(width * height * sizeof(float));
if (glyph->pixels == NULL)
{
free(glyph);
return NULL;
}
float *destination_pointer = (float*)glyph->pixels;
for (unsigned int y = 0; y < height; ++y)
{
const unsigned char *source_pointer = pixels + y * pitch;
for (unsigned int x = 0; x < width; ++x)
*destination_pointer++ = *source_pointer++ / 255.0f;
}
break;
}
case FONT_PIXEL_MODE_MONO:
{
glyph->pixels = malloc(width * height);
if (glyph->pixels == NULL)
{
free(glyph);
return NULL;
}
for (unsigned int y = 0; y < height; ++y)
{
const unsigned char *source_pointer = pixels + y * pitch;
unsigned char *destination_pointer = (unsigned char*)glyph->pixels + y * width;
memcpy(destination_pointer, source_pointer, width);
}
break;
}
}
glyph->width = (pixel_mode == FONT_PIXEL_MODE_LCD ? width / 3 : width);
glyph->height = height;
glyph->pixel_mode = pixel_mode;
return glyph;
}
void Backend_UnloadGlyph(Backend_Glyph *glyph)
{
if (glyph == NULL)
return;
free(glyph->pixels);
free(glyph);
}
void Backend_DrawGlyph(Backend_Surface *surface, Backend_Glyph *glyph, long x, long y, const unsigned char *colours)
{
if (glyph == NULL || surface == NULL)
return;
switch (glyph->pixel_mode)
{
case FONT_PIXEL_MODE_LCD:
for (unsigned int iy = MAX(-y, 0); y + iy < MIN(y + glyph->height, surface->height); ++iy)
{
for (unsigned int ix = MAX(-x, 0); x + ix < MIN(x + glyph->width, surface->width); ++ix)
{
const float *font_pixel = (float*)glyph->pixels + (iy * glyph->width + ix) * 3;
if (font_pixel[0] || font_pixel[1] || font_pixel[2])
{
unsigned char *bitmap_pixel = surface->pixels + (y + iy) * surface->pitch + (x + ix) * 3;
for (unsigned int j = 0; j < 3; ++j)
{
const float alpha = font_pixel[j];
bitmap_pixel[j] = (unsigned char)((colours[j] * alpha) + (bitmap_pixel[j] * (1.0f - alpha))); // Alpha blending
}
}
}
}
break;
case FONT_PIXEL_MODE_GRAY:
for (unsigned int iy = MAX(-y, 0); y + iy < MIN(y + glyph->height, surface->height); ++iy)
{
for (unsigned int ix = MAX(-x, 0); x + ix < MIN(x + glyph->width, surface->width); ++ix)
{
const float alpha = ((float*)glyph->pixels)[iy * glyph->width + ix];
if (alpha)
{
unsigned char *bitmap_pixel = surface->pixels + (y + iy) * surface->pitch + (x + ix) * 3;
for (unsigned int j = 0; j < 3; ++j)
bitmap_pixel[j] = (unsigned char)((colours[j] * alpha) + (bitmap_pixel[j] * (1.0f - alpha))); // Alpha blending
}
}
}
break;
case FONT_PIXEL_MODE_MONO:
for (unsigned int iy = MAX(-y, 0); y + iy < MIN(y + glyph->height, surface->height); ++iy)
{
for (unsigned int ix = MAX(-x, 0); x + ix < MIN(x + glyph->width, surface->width); ++ix)
{
if (((unsigned char*)glyph->pixels)[iy * glyph->width + ix])
{
unsigned char *bitmap_pixel = surface->pixels + (y + iy) * surface->pitch + (x + ix) * 3;
for (unsigned int j = 0; j < 3; ++j)
bitmap_pixel[j] = colours[j];
}
}
}
break;
}
}
void Backend_HandleDeviceLoss(void)
{
// No problem for us
}
void Backend_HandleWindowResize(void)
{
// https://wiki.libsdl.org/SDL_GetWindowSurface
// We need to fetch a new surface pointer
window_sdlsurface = SDL_GetWindowSurface(window);
}

1120
src/Draw.cpp
View file

File diff suppressed because it is too large Load diff

19
src/Draw.h
View file

@ -51,26 +51,23 @@ typedef enum SurfaceID
} SurfaceID;
BOOL Flip_SystemTask(HWND hWnd);
SDL_Window* CreateWindow(const char *title, int width, int height);
BOOL StartDirectDraw(int lMagnification, int lColourDepth);
void EndDirectDraw();
void ReleaseSurface(int s);
BOOL StartDirectDraw(HWND hWnd, int lMagnification, int lColourDepth);
void EndDirectDraw(HWND hWnd);
void ReleaseSurface(SurfaceID s);
BOOL MakeSurface_Resource(const char *name, SurfaceID surf_no);
BOOL MakeSurface_File(const char *name, SurfaceID surf_no);
BOOL MakeSurface_Resource(const char *res, SurfaceID surf_no);
BOOL ReloadBitmap_Resource(const char *name, SurfaceID surf_no);
BOOL ReloadBitmap_File(const char *name, SurfaceID surf_no);
BOOL ReloadBitmap_Resource(const char *res, SurfaceID surf_no);
BOOL MakeSurface_Generic(int bxsize, int bysize, SurfaceID surf_no, BOOL bSystem);
void BackupSurface(SurfaceID surf_no, const RECT *rect);
void PutBitmap3(const RECT *rcView, int x, int y, const RECT *rect, SurfaceID surf_no);
void PutBitmap4(const RECT *rcView, int x, int y, const RECT *rect, SurfaceID surf_no);
void Surface2Surface(int x, int y, const RECT *rect, int to, int from);
unsigned long GetCortBoxColor(unsigned long col);
unsigned long GetCortBoxColor(COLORREF col);
void CortBox(const RECT *rect, unsigned long col);
void CortBox2(const RECT *rect, unsigned long col, SurfaceID surf_no);
void RestoreSurfaces();
int RestoreSurfaces(void);
void InitTextObject(const char *font_name);
void PutText(int x, int y, const char *text, unsigned long color);
void PutText2(int x, int y, const char *text, unsigned long color, SurfaceID surf_no);
void EndTextObject();
void HandleDeviceLoss();
void HandleWindowResize();
void EndTextObject(void);

1176
src/Font.cpp
View file

File diff suppressed because it is too large Load diff

12
src/Font.h
View file

@ -1,12 +0,0 @@
#pragma once
#include <stddef.h>
#include "Backends/Rendering.h"
typedef struct FontObject FontObject;
FontObject* LoadFontFromData(const unsigned char *data, size_t data_size, unsigned int cell_width, unsigned int cell_height);
FontObject* LoadFont(const char *font_filename, unsigned int cell_width, unsigned int cell_height);
void DrawText(FontObject *font_object, Backend_Surface *surface, int x, int y, unsigned long colour, const char *string, size_t string_length);
void UnloadFont(FontObject *font_object);

46
src/Main.cpp
View file

@ -23,8 +23,7 @@
#include "Triangle.h"
// These two are defined in Draw.cpp. This is a bit of a hack.
extern SDL_Window *gWindow;
extern SDL_Renderer *gRenderer;
SDL_Window *gWindow;
char gModulePath[MAX_PATH];
char gDataPath[MAX_PATH];
@ -243,6 +242,8 @@ int main(int argc, char *argv[])
int windowHeight;
int depth;
HINSTANCE hinstance;
switch (conf.display_mode)
{
case 1:
@ -260,14 +261,20 @@ int main(int argc, char *argv[])
}
// Create window
gWindow = CreateWindow(lpWindowName, windowWidth, windowHeight);
gWindow = SDL_CreateWindow(lpWindowName, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, windowWidth, windowHeight, 0);
if (gWindow)
{
SDL_SysWMinfo wmInfo;
SDL_VERSION(&wmInfo.version);
SDL_GetWindowWMInfo(gWindow, &wmInfo);
ghWnd = wmInfo.info.win.window;
hinstance = wmInfo.info.win.hinstance;
if (conf.display_mode == 1)
StartDirectDraw(0, 0);
StartDirectDraw(ghWnd, 0, 0);
else
StartDirectDraw(1, 0);
StartDirectDraw(ghWnd, 1, 0);
}
break;
@ -280,7 +287,7 @@ int main(int argc, char *argv[])
windowHeight = WINDOW_HEIGHT * 2;
// Create window
gWindow = CreateWindow(lpWindowName, windowWidth, windowHeight);
gWindow = SDL_CreateWindow(lpWindowName, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, windowWidth, windowHeight, 0);
if (gWindow)
{
@ -298,7 +305,13 @@ int main(int argc, char *argv[])
break;
}
StartDirectDraw(2, depth);
SDL_SysWMinfo wmInfo;
SDL_VERSION(&wmInfo.version);
SDL_GetWindowWMInfo(gWindow, &wmInfo);
ghWnd = wmInfo.info.win.window;
hinstance = wmInfo.info.win.hinstance;
StartDirectDraw(ghWnd, 2, depth);
bFullscreen = TRUE;
SDL_ShowCursor(0);
@ -350,12 +363,6 @@ int main(int argc, char *argv[])
CortBox(&rcFull, 0x000000);
PutBitmap3(&rcFull, (WINDOW_WIDTH - 64) / 2, (WINDOW_HEIGHT - 8) / 2, &rcLoading, SURFACE_ID_LOADING);
SDL_SysWMinfo wmInfo;
SDL_VERSION(&wmInfo.version);
SDL_GetWindowWMInfo(gWindow, &wmInfo);
ghWnd = wmInfo.info.win.window;
HINSTANCE hinstance = wmInfo.info.win.hinstance;
// Draw to screen
if (Flip_SystemTask(ghWnd))
{
@ -379,7 +386,7 @@ int main(int argc, char *argv[])
// End stuff
EndDirectSound();
EndTextObject();
EndDirectDraw();
EndDirectDraw(ghWnd);
}
SDL_DestroyWindow(gWindow);
@ -469,21 +476,10 @@ BOOL SystemTask()
{
case SDL_QUIT:
return FALSE;
break;
case SDL_RENDER_TARGETS_RESET:
case SDL_RENDER_DEVICE_RESET:
HandleDeviceLoss();
break;
case SDL_WINDOWEVENT:
switch (event.window.event)
{
case SDL_WINDOWEVENT_RESIZED:
case SDL_WINDOWEVENT_SIZE_CHANGED:
HandleWindowResize();
break;
case SDL_WINDOWEVENT_FOCUS_GAINED:
focusGained = TRUE;
ActiveWindow();

2
src/TextScr.cpp
View file

@ -87,7 +87,7 @@ void EndTextScript()
//Release buffers
ReleaseSurface(SURFACE_ID_TEXT_BOX);
for (int i = 0; i < 4; i++)
ReleaseSurface(i + 30);
ReleaseSurface((SurfaceID)(i + SURFACE_ID_TEXT_LINE1));
}
//Decrypt .tsc