ref: 7e926451def20e69909b199adba48e7dceee608d
dir: /src/Backends/Rendering/OpenGL3.cpp/
#include "../Rendering.h"
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <GL/glew.h>
#include "SDL.h"
#include "../../WindowsWrapper.h"
#include "../../Font.h"
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;
BOOL subpixel_mode;
} Backend_Glyph;
typedef struct Coordinate2D
{
GLfloat x;
GLfloat y;
} Coordinate2D;
typedef struct VertexBuffer
{
Coordinate2D vertexes[4];
Coordinate2D texture_coordinates[4];
} VertexBuffer;
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 VertexBuffer vertex_buffer;
static Backend_Surface framebuffer_surface;
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 = texture2D(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 = texture2D(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, texture2D(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 = texture2D(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 * texture2D(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)id;
(void)severity;
(void)length;
(void)userParam;
if (type == GL_DEBUG_TYPE_ERROR)
printf("OpenGL error: %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 unsigned char GammaCorrect(unsigned char value)
{
/*
Generated with...
for (unsigned int i = 0; i < 0x100; ++i)
lookup[i] = pow(i / 255.0, 1.0 / 1.8) * 255.0;
*/
const unsigned char lookup[0x100] = {
0x00, 0x0B, 0x11, 0x15, 0x19, 0x1C, 0x1F, 0x22, 0x25, 0x27, 0x2A, 0x2C, 0x2E, 0x30, 0x32, 0x34,
0x36, 0x38, 0x3A, 0x3C, 0x3D, 0x3F, 0x41, 0x43, 0x44, 0x46, 0x47, 0x49, 0x4A, 0x4C, 0x4D, 0x4F,
0x50, 0x51, 0x53, 0x54, 0x55, 0x57, 0x58, 0x59, 0x5B, 0x5C, 0x5D, 0x5E, 0x60, 0x61, 0x62, 0x63,
0x64, 0x65, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x84,
0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93,
0x94, 0x95, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0x9F, 0xA0,
0xA1, 0xA2, 0xA3, 0xA3, 0xA4, 0xA5, 0xA6, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAA, 0xAB, 0xAC, 0xAD,
0xAD, 0xAE, 0xAF, 0xB0, 0xB0, 0xB1, 0xB2, 0xB3, 0xB3, 0xB4, 0xB5, 0xB6, 0xB6, 0xB7, 0xB8, 0xB8,
0xB9, 0xBA, 0xBB, 0xBB, 0xBC, 0xBD, 0xBD, 0xBE, 0xBF, 0xBF, 0xC0, 0xC1, 0xC2, 0xC2, 0xC3, 0xC4,
0xC4, 0xC5, 0xC6, 0xC6, 0xC7, 0xC8, 0xC8, 0xC9, 0xCA, 0xCA, 0xCB, 0xCC, 0xCC, 0xCD, 0xCE, 0xCE,
0xCF, 0xD0, 0xD0, 0xD1, 0xD2, 0xD2, 0xD3, 0xD4, 0xD4, 0xD5, 0xD6, 0xD6, 0xD7, 0xD7, 0xD8, 0xD9,
0xD9, 0xDA, 0xDB, 0xDB, 0xDC, 0xDC, 0xDD, 0xDE, 0xDE, 0xDF, 0xE0, 0xE0, 0xE1, 0xE1, 0xE2, 0xE3,
0xE3, 0xE4, 0xE4, 0xE5, 0xE6, 0xE6, 0xE7, 0xE7, 0xE8, 0xE9, 0xE9, 0xEA, 0xEA, 0xEB, 0xEC, 0xEC,
0xED, 0xED, 0xEE, 0xEF, 0xEF, 0xF0, 0xF0, 0xF1, 0xF1, 0xF2, 0xF3, 0xF3, 0xF4, 0xF4, 0xF5, 0xF5,
0xF6, 0xF7, 0xF7, 0xF8, 0xF8, 0xF9, 0xF9, 0xFA, 0xFB, 0xFB, 0xFC, 0xFC, 0xFD, 0xFD, 0xFE, 0xFF
}
return lookup[value];
}
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);
}
BOOL 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, sizeof(vertex_buffer), NULL, GL_DYNAMIC_DRAW);
// Set up the vertex attributes
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (GLvoid*)offsetof(VertexBuffer, vertexes));
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, (GLvoid*)offsetof(VertexBuffer, texture_coordinates));
// 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_surface.texture_id);
glBindTexture(GL_TEXTURE_2D, framebuffer_surface.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_surface.width = window_width;
framebuffer_surface.height = window_height;
return TRUE;
}
void Backend_Deinit(void)
{
glDeleteTextures(1, &framebuffer_surface.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)
{
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_surface.width, framebuffer_surface.height);
// Draw framebuffer to screen
glBindTexture(GL_TEXTURE_2D, framebuffer_surface.texture_id);
vertex_buffer.texture_coordinates[0].x = 0.0f;
vertex_buffer.texture_coordinates[0].y = 1.0f;
vertex_buffer.texture_coordinates[1].x = 1.0f;
vertex_buffer.texture_coordinates[1].y = 1.0f;
vertex_buffer.texture_coordinates[2].x = 1.0f;
vertex_buffer.texture_coordinates[2].y = 0.0f;
vertex_buffer.texture_coordinates[3].x = 0.0f;
vertex_buffer.texture_coordinates[3].y = 0.0f;
vertex_buffer.vertexes[0].x = -1.0f;
vertex_buffer.vertexes[0].y = -1.0f;
vertex_buffer.vertexes[1].x = 1.0f;
vertex_buffer.vertexes[1].y = -1.0f;
vertex_buffer.vertexes[2].x = 1.0f;
vertex_buffer.vertexes[2].y = 1.0f;
vertex_buffer.vertexes[3].x = -1.0f;
vertex_buffer.vertexes[3].y = 1.0f;
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertex_buffer), &vertex_buffer);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
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_Lock(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_Unlock(Backend_Surface *surface)
{
if (surface == NULL)
return;
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);
}
static void BlitCommon(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;
if (rect->right - rect->left < 0 || rect->bottom - rect->top < 0)
return;
// 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;
vertex_buffer.texture_coordinates[0].x = texture_left;
vertex_buffer.texture_coordinates[0].y = texture_top;
vertex_buffer.texture_coordinates[1].x = texture_right;
vertex_buffer.texture_coordinates[1].y = texture_top;
vertex_buffer.texture_coordinates[2].x = texture_right;
vertex_buffer.texture_coordinates[2].y = texture_bottom;
vertex_buffer.texture_coordinates[3].x = texture_left;
vertex_buffer.texture_coordinates[3].y = texture_bottom;
vertex_buffer.vertexes[0].x = vertex_left;
vertex_buffer.vertexes[0].y = vertex_top;
vertex_buffer.vertexes[1].x = vertex_right;
vertex_buffer.vertexes[1].y = vertex_top;
vertex_buffer.vertexes[2].x = vertex_right;
vertex_buffer.vertexes[2].y = vertex_bottom;
vertex_buffer.vertexes[3].x = vertex_left;
vertex_buffer.vertexes[3].y = vertex_bottom;
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertex_buffer), &vertex_buffer);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
void Backend_Blit(Backend_Surface *source_surface, const RECT *rect, Backend_Surface *destination_surface, long x, long y, BOOL colour_key)
{
BlitCommon(source_surface, rect, destination_surface, x, y, colour_key);
}
void Backend_BlitToScreen(Backend_Surface *source_surface, const RECT *rect, long x, long y, BOOL colour_key)
{
BlitCommon(source_surface, rect, &framebuffer_surface, x, y, colour_key);
}
static void ColourFillCommon(Backend_Surface *surface, const RECT *rect, unsigned char red, unsigned char green, unsigned char blue)
{
if (surface == NULL)
return;
if (rect->right - rect->left < 0 || rect->bottom - rect->top < 0)
return;
// 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);
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;
vertex_buffer.vertexes[0].x = vertex_left;
vertex_buffer.vertexes[0].y = vertex_top;
vertex_buffer.vertexes[1].x = vertex_right;
vertex_buffer.vertexes[1].y = vertex_top;
vertex_buffer.vertexes[2].x = vertex_right;
vertex_buffer.vertexes[2].y = vertex_bottom;
vertex_buffer.vertexes[3].x = vertex_left;
vertex_buffer.vertexes[3].y = vertex_bottom;
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertex_buffer.vertexes), &vertex_buffer);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
void Backend_ColourFill(Backend_Surface *surface, const RECT *rect, unsigned char red, unsigned char green, unsigned char blue)
{
ColourFillCommon(surface, rect, red, green, blue);
}
void Backend_ColourFillToScreen(const RECT *rect, unsigned char red, unsigned char green, unsigned char blue)
{
ColourFillCommon(&framebuffer_surface, rect, red, green, blue);
}
void Backend_ScreenToSurface(Backend_Surface *surface, const RECT *rect)
{
BlitCommon(&framebuffer_surface, rect, surface, rect->left, rect->top, FALSE);
}
BOOL Backend_SupportsSubpixelGlyph(void)
{
return TRUE;
}
Backend_Glyph* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch, unsigned short total_greys, unsigned char pixel_mode)
{
Backend_Glyph *glyph = (Backend_Glyph*)malloc(sizeof(Backend_Glyph));
if (glyph == NULL)
return NULL;
const BOOL subpixel_mode = pixel_mode == FONT_PIXEL_MODE_LCD;
const int destination_pitch = ((subpixel_mode ? width * 3 : width) + 3) & ~3; // Round up to the nearest 4 (OpenGL needs this)
unsigned char *buffer = (unsigned char*)malloc(destination_pitch * height);
if (buffer == NULL)
{
free(glyph);
return NULL;
}
switch (pixel_mode)
{
case FONT_PIXEL_MODE_LCD:
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)
{
for (unsigned int i = 0; i < 3; ++i)
{
*destination_pointer++ = GammaCorrect(*source_pointer++);
}
}
}
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 = buffer + y * destination_pitch;
for (unsigned int x = 0; x < width; ++x)
{
*destination_pointer++ = GammaCorrect((*source_pointer++ * 0xFF) / (total_greys - 1));
}
}
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;
}
glGenTextures(1, &glyph->texture_id);
glBindTexture(GL_TEXTURE_2D, glyph->texture_id);
glTexImage2D(GL_TEXTURE_2D, 0, subpixel_mode ? GL_RGB8 : GL_R8, width, height, 0, subpixel_mode ? GL_RGB : 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 = width;
glyph->height = height;
glyph->subpixel_mode = subpixel_mode;
free(buffer);
return glyph;
}
void Backend_UnloadGlyph(Backend_Glyph *glyph)
{
if (glyph == NULL)
return;
glDeleteTextures(1, &glyph->texture_id);
free(glyph);
}
static void DrawGlyphCommon(Backend_Surface *surface, Backend_Glyph *glyph, long x, long y, const unsigned char *colours)
{
if (glyph == NULL || surface == NULL)
return;
// 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;
vertex_buffer.texture_coordinates[0].x = 0.0f;
vertex_buffer.texture_coordinates[0].y = 0.0f;
vertex_buffer.texture_coordinates[1].x = 1.0f;
vertex_buffer.texture_coordinates[1].y = 0.0f;
vertex_buffer.texture_coordinates[2].x = 1.0f;
vertex_buffer.texture_coordinates[2].y = 1.0f;
vertex_buffer.texture_coordinates[3].x = 0.0f;
vertex_buffer.texture_coordinates[3].y = 1.0f;
vertex_buffer.vertexes[0].x = vertex_left;
vertex_buffer.vertexes[0].y = vertex_top;
vertex_buffer.vertexes[1].x = vertex_right;
vertex_buffer.vertexes[1].y = vertex_top;
vertex_buffer.vertexes[2].x = vertex_right;
vertex_buffer.vertexes[2].y = vertex_bottom;
vertex_buffer.vertexes[3].x = vertex_left;
vertex_buffer.vertexes[3].y = vertex_bottom;
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertex_buffer), &vertex_buffer);
if (glyph->subpixel_mode)
{
// 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_TRIANGLE_FAN, 0, 4);
// Step two: add the new pixels on top of them
glBlendFunc(GL_ONE, GL_ONE);
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);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
else
{
// Here, we just use a regular alpha channel
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUseProgram(program_glyph_normal);
glUniform4f(program_glyph_normal_uniform_colour, colours[0] / 255.0f, colours[1] / 255.0f, colours[2] / 255.0f, 1.0f);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
}
void Backend_DrawGlyph(Backend_Surface *surface, Backend_Glyph *glyph, long x, long y, const unsigned char *colours)
{
DrawGlyphCommon(surface, glyph, x, y, colours);
}
void Backend_DrawGlyphToScreen(Backend_Glyph *glyph, long x, long y, const unsigned char *colours)
{
DrawGlyphCommon(&framebuffer_surface, glyph, x, y, colours);
}
void Backend_HandleDeviceLoss(void)
{
// No problem for us
}
void Backend_HandleWindowResize(void)
{
// No problem for us
}