{

std::string err;

switch(glErr)

{

case GL_INVALID_ENUM:

err = "GL_INVALID_ENUM";

break;

case GL_INVALID_VALUE:

err = "GL_INVALID_VALUE";

break;

case GL_INVALID_OPERATION:

err = "GL_INVALID_OPERATION";

break;

case GL_STACK_OVERFLOW:

err = "GL_STACK_OVERFLOW";

break;

case GL_STACK_UNDERFLOW:

err = "GL_STACK_UNDERFLOW";

break;

case GL_OUT_OF_MEMORY:

err = "GL_OUT_OF_MEMORY";

break;

case GL_NO_ERROR:

err = "No error! How did you even reach this code?";

break;

default:

err = "Unknown error code!";

break;

}

return err;

if(gltexture == 0) glGenTextures(1, &gltexture);

glErrorCheck();

iwidth = SDL_max(width, iwidth );

iheight = SDL_max(height, iheight);

if(buffer_surface) delete buffer_surface;

buffer_surface = new Surface(iwidth, iheight, 0, 0, ibpp); // use OpenXcom's Surface class to get an aligned buffer with bonus SDL_Surface

buffer = (uint32_t*) buffer_surface->getSurface()->pixels;

glBindTexture(GL_TEXTURE_2D, gltexture);

glErrorCheck();

glPixelStorei(GL_UNPACK_ROW_LENGTH, iwidth);

glErrorCheck();

glTexImage2D(GL_TEXTURE_2D,

/* mip-map level = */ 0, /* internal format = */ GL_RGB16_EXT,

width, height, /* border = */ 0, /* format = */ GL_BGRA,

iformat, buffer);

glErrorCheck();

memset(buffer, 0, iwidth * iheight * ibpp);

glClearColor(0.0, 0.0, 0.0, 1.0);

glClear(GL_COLOR_BUFFER_BIT);

glFlush();

while (glGetError() != GL_NO_ERROR); // clear possible error from who knows where

#ifndef __NO_SHADERS

if(shader_support && (fragmentshader || vertexshader)) {

glUseProgram(glprogram);

GLint location;

float inputSize[2] = { (float)inwidth, (float)inheight };

location = glGetUniformLocation(glprogram, "rubyInputSize");

glUniform2fv(location, 1, inputSize);

float outputSize[2] = { (float)outwidth, (float)outheight };

location = glGetUniformLocation(glprogram, "rubyOutputSize");

glUniform2fv(location, 1, outputSize);

float textureSize[2] = { (float)iwidth, (float)iheight };

location = glGetUniformLocation(glprogram, "rubyTextureSize");

glUniform2fv(location, 1, textureSize);

}

#endif

glErrorCheck();

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, smooth ? GL_LINEAR : GL_NEAREST);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, smooth ? GL_LINEAR : GL_NEAREST);

glErrorCheck();

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

glOrtho(0, outwidth, 0, outheight, -1.0, 1.0);

glViewport(0, 0, outwidth, outheight);

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

glErrorCheck();

glPixelStorei(GL_UNPACK_ROW_LENGTH, buffer_surface->getSurface()->pitch / buffer_surface->getSurface()->format->BytesPerPixel);

glErrorCheck();

glTexSubImage2D(GL_TEXTURE_2D,

/* mip-map level = */ 0, /* x = */ 0, /* y = */ 0,

iwidth, iheight, GL_BGRA, iformat, buffer);

//OpenGL projection sets 0,0 as *bottom-left* of screen.

//therefore, below vertices flip image to support top-left source.

//texture range = x1:0.0, y1:0.0, x2:1.0, y2:1.0

//vertex range = x1:0, y1:0, x2:width, y2:height

double w = double(inwidth) / double(iwidth);

double h = double(inheight) / double(iheight);

int u = outwidth;

int v = outheight;

glBegin(GL_TRIANGLE_STRIP);

glTexCoord2f(0, 0); glVertex3i(0, v, 0);

glTexCoord2f(w, 0); glVertex3i(u, v, 0);

glTexCoord2f(0, h); glVertex3i(0, 0, 0);

glTexCoord2f(w, h); glVertex3i(u, 0, 0);

glEnd();

glErrorCheck();

glFlush();

glErrorCheck();

#ifndef __NO_SHADERS

if(shader_support) {

glUseProgram(0);

}

#endif

#ifndef __NO_SHADERS

if(!shader_support) return;

if(fragmentshader) {

glDetachShader(glprogram, fragmentshader);

glDeleteShader(fragmentshader);

fragmentshader = 0;

}

if(vertexshader) {

glDetachShader(glprogram, vertexshader);

glDeleteShader(vertexshader);

vertexshader = 0;

}

if(source_yaml_filename && strlen(source_yaml_filename)) {

YAML::Node document = YAML::LoadFile(source_yaml_filename);

bool is_glsl;

std::string language = document["language"].as<std::string>();

is_glsl = (language == "GLSL");

linear = document["linear"].as<bool>(false); // some shaders want texture linear interpolation and some don't

std::string fragment_source = document["fragment"].as<std::string>("");

std::string vertex_source = document["vertex"].as<std::string>("");

if(is_glsl) {

if(fragment_source != "") set_fragment_shader(fragment_source.c_str());

if(vertex_source != "") set_vertex_shader(vertex_source.c_str());

}

}

glLinkProgram(glprogram);

#endif

#ifndef __NO_SHADERS

fragmentshader = glCreateShader(GL_FRAGMENT_SHADER);

glShaderSource(fragmentshader, 1, &source, 0);

glCompileShader(fragmentshader);

glAttachShader(glprogram, fragmentshader);

#endif

#ifndef __NO_SHADERS

vertexshader = glCreateShader(GL_VERTEX_SHADER);

glShaderSource(vertexshader, 1, &source, 0);

glCompileShader(vertexshader);

glAttachShader(glprogram, vertexshader);

#endif

//disable unused features

glDisable(GL_ALPHA_TEST);

glDisable(GL_BLEND);

glDisable(GL_DEPTH_TEST);

glDisable(GL_POLYGON_SMOOTH);

glDisable(GL_STENCIL_TEST);

//enable useful and required features

glEnable(GL_DITHER);

glEnable(GL_TEXTURE_2D);

#ifndef __NO_SHADERS

//bind shader functions

#ifndef __APPLE__

glCreateProgram = (PFNGLCREATEPROGRAMPROC)glGetProcAddress("glCreateProgram");

glUseProgram = (PFNGLUSEPROGRAMPROC)glGetProcAddress("glUseProgram");

glCreateShader = (PFNGLCREATESHADERPROC)glGetProcAddress("glCreateShader");

glDeleteShader = (PFNGLDELETESHADERPROC)glGetProcAddress("glDeleteShader");

glShaderSource = (PFNGLSHADERSOURCEPROC)glGetProcAddress("glShaderSource");

glCompileShader = (PFNGLCOMPILESHADERPROC)glGetProcAddress("glCompileShader");

glAttachShader = (PFNGLATTACHSHADERPROC)glGetProcAddress("glAttachShader");

glDetachShader = (PFNGLDETACHSHADERPROC)glGetProcAddress("glDetachShader");

glLinkProgram = (PFNGLLINKPROGRAMPROC)glGetProcAddress("glLinkProgram");

glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)glGetProcAddress("glGetUniformLocation");

glUniform1i = (PFNGLUNIFORM1IPROC)glGetProcAddress("glUniform1i");

glUniform2fv = (PFNGLUNIFORM2FVPROC)glGetProcAddress("glUniform2fv");

glUniform4fv = (PFNGLUNIFORM4FVPROC)glGetProcAddress("glUniform4fv");

#endif

glXGetCurrentDisplay = (void* (APIENTRYP)())glGetProcAddress("glXGetCurrentDisplay");

glXGetCurrentDrawable = (Uint32 (APIENTRYP)())glGetProcAddress("glXGetCurrentDrawable");

glXSwapIntervalEXT = (void (APIENTRYP)(void*, Uint32, int))glGetProcAddress("glXSwapIntervalEXT");

wglSwapIntervalEXT = (Uint32 (APIENTRYP)(int))glGetProcAddress("wglSwapIntervalEXT");

shader_support = glCreateProgram && glUseProgram && glCreateShader

&& glDeleteShader && glShaderSource && glCompileShader && glAttachShader

&& glDetachShader && glLinkProgram && glGetUniformLocation

&& glUniform1i && glUniform2fv && glUniform4fv;

if(shader_support) glprogram = glCreateProgram();

#endif

//create surface texture

resize(w, h);

{

#ifndef __NO_SHADERS

const int interval = sync ? 1 : 0;

if (glXGetCurrentDisplay && glXGetCurrentDrawable && glXSwapIntervalEXT)

{

void *dpy = glXGetCurrentDisplay();

Uint32 drawable = glXGetCurrentDrawable();

if (drawable) {

glXSwapIntervalEXT(dpy, drawable, interval);

// Log(LOG_INFO) << "Made an attempt to set vsync via GLX.";

}

} else if (wglSwapIntervalEXT)

{

wglSwapIntervalEXT(interval);

// Log(LOG_INFO) << "Made an attempt to set vsync via WGL.";

}

#endif

if(gltexture) {

glDeleteTextures(1, &gltexture);

gltexture = 0;

}

if(buffer) {

buffer = 0;

iwidth = 0;

iheight = 0;

}

delete buffer_surface;

buffer(NULL), buffer_surface(NULL), iwidth(0), iheight(0),

iformat(GL_UNSIGNED_INT_8_8_8_8_REV), // this didn't seem to be set anywhere before...

ibpp(32) // ...nor this