shithub: cstory

Info  •  Files  •  Log  •  Branches

Move the font gamma-correction up to Font.cpp

Reduces duplicate code

--- a/src/Backends/Rendering.h

+++ b/src/Backends/Rendering.h

@@ -28,7 +28,7 @@

 void Backend_ColourFillToScreen(const RECT *rect, unsigned char red, unsigned char green, unsigned char blue);

 void Backend_ScreenToSurface(Backend_Surface *surface, const RECT *rect);

 BOOL Backend_SupportsSubpixelGlyph(void);

-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* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch, unsigned char 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_DrawGlyphToScreen(Backend_Glyph *glyph, long x, long y, const unsigned char *colours);

--- a/src/Backends/Rendering/OpenGL3.cpp

+++ b/src/Backends/Rendering/OpenGL3.cpp

@@ -3,6 +3,7 @@

 #include <stddef.h>

 #include <stdio.h>

 #include <stdlib.h>

+#include <string.h>

 #include <GL/glew.h>

 #include "SDL.h"

@@ -24,7 +25,7 @@

 	GLuint texture_id;

 	unsigned int width;

 	unsigned int height;

-	BOOL subpixel_mode;

+	unsigned char pixel_mode;

 } Backend_Glyph;

 typedef struct Coordinate2D

@@ -204,36 +205,6 @@

 	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);

@@ -553,7 +524,7 @@

 	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* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch, unsigned char pixel_mode)

 {

 	Backend_Glyph *glyph = (Backend_Glyph*)malloc(sizeof(Backend_Glyph));

@@ -560,47 +531,19 @@

 	if (glyph == NULL)

 		return NULL;

-	const BOOL subpixel_mode = pixel_mode == FONT_PIXEL_MODE_LCD;

+	const unsigned int destination_pitch = (width + 3) & ~3;	// Round up to the nearest 4 (OpenGL needs this)

-	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));

-				}

+				memcpy(destination_pointer, source_pointer, width);

 			}

 			break;

@@ -612,9 +555,7 @@

 				unsigned char *destination_pointer = buffer + y * destination_pitch;

 				for (unsigned int x = 0; x < width; ++x)

-				{

-					*destination_pointer++ = *source_pointer++ ? 0xFF : 0;

-				}

+					*destination_pointer++ = (*source_pointer++ ? 0xFF : 0);

 			}

 			break;

@@ -622,7 +563,10 @@

 	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);

+	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);

@@ -629,9 +573,9 @@

 	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->width = (pixel_mode == FONT_PIXEL_MODE_LCD ? width / 3 : width);

 	glyph->height = height;

-	glyph->subpixel_mode = subpixel_mode;

+	glyph->pixel_mode = pixel_mode;

 	free(buffer);

@@ -688,7 +632,7 @@

 	glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertex_buffer), &vertex_buffer);

-	if (glyph->subpixel_mode)

+	if (glyph->pixel_mode == FONT_PIXEL_MODE_LCD)

 	{

 		// Here we're going to draw with per-component alpha.

 		// Since OpenGL doesn't really support this, we have to do it manually:

--- a/src/Backends/Rendering/SDLSurface.cpp

+++ b/src/Backends/Rendering/SDLSurface.cpp

@@ -38,36 +38,6 @@

 		sdl_rect->h = 0;

 }

-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)

 {

 	return SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, 0);

@@ -189,7 +159,7 @@

 	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, unsigned short total_greys, unsigned char pixel_mode)

+Backend_Glyph* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch, unsigned char pixel_mode)

 {

 	Backend_Glyph *glyph = (Backend_Glyph*)malloc(sizeof(Backend_Glyph));

@@ -219,7 +189,7 @@

 					*destination_pointer++ = 0xFF;

 					*destination_pointer++ = 0xFF;

 					*destination_pointer++ = 0xFF;

-					*destination_pointer++ = GammaCorrect((*source_pointer++ * 0xFF) / (total_greys - 1));

+					*destination_pointer++ = *source_pointer++;

 				}

 			}

--- a/src/Backends/Rendering/SDLTexture.cpp

+++ b/src/Backends/Rendering/SDLTexture.cpp

@@ -81,36 +81,6 @@

 		sdl_rect->h = 0;

 }

-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)

 {

 	return SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, 0);

@@ -348,7 +318,7 @@

 	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, unsigned short total_greys, unsigned char pixel_mode)

+Backend_Glyph* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch, unsigned char pixel_mode)

 {

 	Backend_Glyph *glyph = (Backend_Glyph*)malloc(sizeof(Backend_Glyph));

@@ -381,7 +351,7 @@

 					*destination_pointer++ = 0xFF;

 					*destination_pointer++ = 0xFF;

 					*destination_pointer++ = 0xFF;

-					*destination_pointer++ = GammaCorrect((*source_pointer++ * 0xFF) / (total_greys - 1));

+					*destination_pointer++ = *source_pointer++;

 				}

 			}

--- a/src/Backends/Rendering/Software.cpp

+++ b/src/Backends/Rendering/Software.cpp

@@ -35,36 +35,6 @@

 static Backend_Surface framebuffer;

-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)

 {

 	return SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, 0);

@@ -306,7 +276,7 @@

 	return TRUE;	// It's a software renderer, baby

 }

-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* Backend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch, unsigned char pixel_mode)

 {

 	Backend_Glyph *glyph = (Backend_Glyph*)malloc(sizeof(Backend_Glyph));

@@ -316,36 +286,9 @@

 	switch (pixel_mode)

 	{

 		case FONT_PIXEL_MODE_LCD:

-		{

-			glyph->pixels = malloc(width * height * sizeof(double) * 3);

-

-			if (glyph->pixels == NULL)

-			{

-				free(glyph);

-				return NULL;

-			}

-

-			double *destination_pointer = (double*)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)

-				{

-					for (unsigned int i = 0; i < 3; ++i)

-					{

-						*destination_pointer++ = GammaCorrect(*source_pointer++);

-					}

-				}

-			}

-

-			break;

-		}

-

 		case FONT_PIXEL_MODE_GRAY:

 		{

-			glyph->pixels = malloc(width * height * sizeof(double));

+			glyph->pixels = malloc(width * height * sizeof(float));

 			if (glyph->pixels == NULL)

 			{

@@ -353,7 +296,7 @@

 				return NULL;

 			}

-			double *destination_pointer = (double*)glyph->pixels;

+			float *destination_pointer = (float*)glyph->pixels;

 			for (unsigned int y = 0; y < height; ++y)

 			{

@@ -360,9 +303,7 @@

 				const unsigned char *source_pointer = pixels + y * pitch;

 				for (unsigned int x = 0; x < width; ++x)

-				{

-					*destination_pointer++ = GammaCorrect((*source_pointer++ * 0xFF) / (total_greys - 1));

-				}

+					*destination_pointer++ = *source_pointer++ / 255.0f;

 			}

 			break;

@@ -390,7 +331,7 @@

 		}

 	}

-	glyph->width = width;

+	glyph->width = (pixel_mode == FONT_PIXEL_MODE_LCD ? width / 3 : width);

 	glyph->height = height;

 	glyph->pixel_mode = pixel_mode;

@@ -418,7 +359,7 @@

 			{

 				for (unsigned int ix = MAX(-x, 0); x + ix < MIN(x + glyph->width, surface->width); ++ix)

 				{

-					const double *font_pixel = (double*)glyph->pixels + (iy * glyph->width + ix) * 3;

+					const float *font_pixel = (float*)glyph->pixels + (iy * glyph->width + ix) * 3;

 					if (font_pixel[0] || font_pixel[1] || font_pixel[2])

 					{

@@ -426,8 +367,8 @@

 						for (unsigned int j = 0; j < 3; ++j)

 						{

-							const double alpha = font_pixel[j];

-							bitmap_pixel[j] = (unsigned char)((colours[j] * alpha) + (bitmap_pixel[j] * (1.0 - alpha)));	// Alpha blending

+							const float alpha = font_pixel[j];

+							bitmap_pixel[j] = (unsigned char)((colours[j] * alpha) + (bitmap_pixel[j] * (1.0f - alpha)));	// Alpha blending

 						}

 					}

 				}

@@ -440,7 +381,7 @@

 			{

 				for (unsigned int ix = MAX(-x, 0); x + ix < MIN(x + glyph->width, surface->width); ++ix)

 				{

-					const double alpha = ((double*)glyph->pixels)[iy * glyph->width + ix];

+					const float alpha = ((float*)glyph->pixels)[iy * glyph->width + ix];

 					if (alpha)

 					{

@@ -447,7 +388,7 @@

 						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.0 - alpha)));	// Alpha blending

+							bitmap_pixel[j] = (unsigned char)((colours[j] * alpha) + (bitmap_pixel[j] * (1.0f - alpha)));	// Alpha blending

 					}

 				}

 			}

--- a/src/Font.cpp

+++ b/src/Font.cpp

@@ -1709,6 +1709,36 @@

 }

 #endif

+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];

+}

+

 static CachedGlyph* GetGlyphCached(FontObject *font_object, unsigned long unicode_value)

 {

 	CachedGlyph *glyph;

@@ -1746,10 +1776,34 @@

 		{

 			case FT_PIXEL_MODE_LCD:

 				pixel_mode = FONT_PIXEL_MODE_LCD;

+

+				for (unsigned int y = 0; y < bitmap.rows; ++y)

+				{

+					unsigned char *pixel_pointer = bitmap.buffer + y * bitmap.pitch;

+

+					for (unsigned int x = 0; x < bitmap.width; ++x)

+					{

+						*pixel_pointer = GammaCorrect(*pixel_pointer);

+						++pixel_pointer;

+					}

+				}

+

 				break;

 			case FT_PIXEL_MODE_GRAY:

 				pixel_mode = FONT_PIXEL_MODE_GRAY;

+

+				for (unsigned int y = 0; y < bitmap.rows; ++y)

+				{

+					unsigned char *pixel_pointer = bitmap.buffer + y * bitmap.pitch;

+

+					for (unsigned int x = 0; x < bitmap.width; ++x)

+					{

+						*pixel_pointer = GammaCorrect((*pixel_pointer * 0xFF) / (bitmap.num_grays - 1));

+						++pixel_pointer;

+					}

+				}

+

 				break;

 			case FT_PIXEL_MODE_MONO:

@@ -1757,7 +1811,7 @@

 				break;

 		}

-		glyph->backend = Backend_LoadGlyph(bitmap.buffer, pixel_mode == FONT_PIXEL_MODE_LCD ? bitmap.width / 3 : bitmap.width, bitmap.rows, bitmap.pitch, bitmap.num_grays, pixel_mode);

+		glyph->backend = Backend_LoadGlyph(bitmap.buffer, bitmap.width, bitmap.rows, bitmap.pitch, pixel_mode);

 		FT_Bitmap_Done(font_object->library, &bitmap);

 	}