/**
* Graphics primitives with OpenGL (ES) 2
* Copyright (C) 2015 Sylvain Beucler
* This file is part of GNU FreeDink
* GNU FreeDink is free software: you can redistribute it and/or
* modify it under the terms of the GNU Affero General Public License
* as published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
* GNU FreeDink is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Affero General Public License for more details.
* You should have received a copy of the GNU Affero General Public
* License along with GNU FreeDink. If not, see
* .
*/
#ifdef HAVE_CONFIG_H
#include
#endif
#include "IOGfxDisplayGL2.h"
#include
#include
#include
#include
#include "log.h"
#include "IOGfxGLFuncs.h"
#include "IOGfxSurfaceGL2.h"
#include "gfx_palette.h"
#include "ImageLoader.h"
IOGfxDisplayGL2::IOGfxDisplayGL2(int w, int h, bool truecolor, Uint32 flags)
: IOGfxDisplay(w, h, truecolor, flags | SDL_WINDOW_OPENGL),
glcontext(NULL), gl(NULL), screen(NULL) {
palette = -1;
vboSpriteVertices = -1, vboSpriteTexcoords = -1, vboCroppedSpriteTexcoords = -1;
blit = NULL; fliprgb = NULL; flippal = NULL; fillRect = NULL;
}
IOGfxDisplayGL2::~IOGfxDisplayGL2() {
close();
}
bool IOGfxDisplayGL2::open() {
if (!IOGfxDisplay::open()) return false;
if (!createOpenGLContext()) return false;
if (!createSpriteVertices()) return false;
if (!createSpriteTexcoords()) return false;
if (!createCroppedSpriteTexcoords()) return false;
if (!createPrograms()) return false;
if (!createPalette()) return false;
return true;
}
void IOGfxDisplayGL2::close() {
if (gl != NULL) {
gl->DeleteProgram(blit->program);
gl->DeleteProgram(fillRect->program);
gl->DeleteProgram(flippal->program);
delete blit;
delete fillRect;
delete flippal;
gl->DeleteBuffers(1, &vboSpriteVertices);
gl->DeleteBuffers(1, &vboSpriteTexcoords);
gl->DeleteBuffers(1, &vboCroppedSpriteTexcoords);
gl->Clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
delete gl;
gl = NULL;
}
if (glcontext != NULL) SDL_GL_DeleteContext(glcontext);
glcontext = NULL;
IOGfxDisplay::close();
}
bool IOGfxDisplayGL2::createOpenGLContext() {
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
//SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
//SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
glcontext = SDL_GL_CreateContext(window);
if (glcontext == NULL) {
log_error("Could not create OpenGL context: %s", SDL_GetError());
return false;
}
if (SDL_GL_MakeCurrent(window, glcontext) < 0) {
SDL_GL_DeleteContext(glcontext);
log_error("Could not make OpenGL context current: %s", SDL_GetError());
return false;
}
// Let FramerateManager handle frame delay
// TODO: drop the extra SwapWindow/RenderPresent during speed mode
// TODO: ideally we should set to 1 to get VSync and avoid tearing, if achievable
// Commented out for emscripten to avoid "emscripten_set_main_loop_timing: Cannot set timing mode for main loop since a main loop does not exist! Call emscripten_set_main_loop first to set one up." warning
#ifndef __EMSCRIPTEN__
SDL_GL_SetSwapInterval(0);
#endif
gl = new IOGfxGLFuncs();
gl->Enable(GL_BLEND);
//gl->Enable(GL_DEPTH_TEST);
gl->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// buffer for glReadPixels, defaults to GL_BACK in double buffered mode
// This functions is not present in GLES2
//gl->ReadBuffer(GL_FRONT);
return true;
}
bool IOGfxDisplayGL2::createSpriteVertices() {
GLfloat spriteVertices[] = {
0, 0, 0, 1,
1, 0, 0, 1,
0, 1, 0, 1,
1, 1, 0, 1,
};
gl->GenBuffers(1, &vboSpriteVertices);
gl->BindBuffer(GL_ARRAY_BUFFER, vboSpriteVertices);
gl->BufferData(GL_ARRAY_BUFFER, sizeof(spriteVertices), spriteVertices, GL_STATIC_DRAW);
return true;
}
bool IOGfxDisplayGL2::createSpriteTexcoords() {
GLfloat spriteTexcoords[] = {
0.0, 0.0,
1.0, 0.0,
0.0, 1.0,
1.0, 1.0,
};
gl->GenBuffers(1, &vboSpriteTexcoords);
gl->BindBuffer(GL_ARRAY_BUFFER, vboSpriteTexcoords);
gl->BufferData(GL_ARRAY_BUFFER, sizeof(spriteTexcoords), spriteTexcoords, GL_STATIC_DRAW);
return true;
}
bool IOGfxDisplayGL2::createCroppedSpriteTexcoords() {
gl->GenBuffers(1, &vboCroppedSpriteTexcoords);
return true;
}
/**
* Compile vertex or fragment shader.
* 'name' is provided for debugging purposes only
*/
GLuint IOGfxDisplayGL2::createShader(const char* name, const char* source, GLenum type) {
GLuint res = gl->CreateShader(type);
// GLSL version
std::string version;
int profile;
SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile);
if (profile == SDL_GL_CONTEXT_PROFILE_ES)
version = "#version 100\n"; // OpenGL ES 2.0
else
version = "#version 120\n"; // OpenGL 2.1
// GLES2 precision specifiers
std::string precision =
"#ifdef GL_ES \n"
"# ifdef GL_FRAGMENT_PRECISION_HIGH \n"
" precision highp float; \n"
"# else \n"
" precision mediump float; \n"
"# endif \n"
"#else \n"
// Ignore unsupported precision specifiers
"# define lowp \n"
"# define mediump \n"
"# define highp \n"
"#endif \n";
// Concat instead of giving glShaderSource multiple strings.
// At least one setup complained that "#version 120" was an incomplete shader
// (VirtualBox 5.1 + Windows 7 guest) - so not taking chances.
std::string fullsource = version + precision + source;
const GLchar* sources[] = {
fullsource.c_str()
};
gl->ShaderSource(res, 1, sources, NULL);
gl->CompileShader(res);
GLint compile_ok = GL_FALSE;
gl->GetShaderiv(res, GL_COMPILE_STATUS, &compile_ok);
if (compile_ok == GL_FALSE) {
log_error("when compiling %s %s shader:", name, (type == GL_VERTEX_SHADER) ? "vertex" : "fragment");
infoLog(res);
gl->DeleteShader(res);
return 0;
}
return res;
}
void IOGfxDisplayGL2::infoLog(GLuint object) {
GLint log_length = 0;
if (gl->IsShader(object)) {
gl->GetShaderiv(object, GL_INFO_LOG_LENGTH, &log_length);
} else if (gl->IsProgram(object)) {
gl->GetProgramiv(object, GL_INFO_LOG_LENGTH, &log_length);
} else {
log_error("logShaderInfoLog: Not a shader or a program");
return;
}
char* log = (char*)malloc(log_length);
if (gl->IsShader(object))
gl->GetShaderInfoLog(object, log_length, NULL, log);
else if (gl->IsProgram(object))
gl->GetProgramInfoLog(object, log_length, NULL, log);
log_error("%s\n", log);
free(log);
}
bool IOGfxDisplayGL2::createPrograms() {
blit = new IOGfxGLProg();
blit->vshader =
"attribute vec4 v_coord; \n"
"attribute vec2 v_texcoord; \n"
"varying vec2 f_texcoord; \n"
"uniform mat4 mvp; \n"
" \n"
"void main(void) { \n"
" gl_Position = mvp * v_coord; \n"
" f_texcoord = v_texcoord; \n"
"} \n";
blit->fshader =
"varying vec2 f_texcoord; \n"
"uniform sampler2D texture; \n"
"uniform vec3 colorkey; \n"
" \n"
"void main(void) { \n"
" vec4 f = texture2D(texture, f_texcoord); \n"
" // don't need float comparison abs(a-b)<.001? \n"
" if (f.r == colorkey.r \n"
" && f.g == colorkey.g \n"
" && f.b == colorkey.b) \n"
" f.a = 0.0; \n"
" gl_FragColor = f; \n"
"} \n";
blit->program = createProgram("blit", blit->vshader, blit->fshader);
if ((blit->attributes["v_coord"] = getAttribLocation(blit->program, "v_coord")) == -1) return false;
if ((blit->attributes["v_texcoord"] = getAttribLocation(blit->program, "v_texcoord")) == -1) return false;
if ((blit->uniforms["mvp"] = getUniformLocation(blit->program, "mvp")) == -1) return false;
if ((blit->uniforms["texture"] = getUniformLocation(blit->program, "texture")) == -1) return false;
if ((blit->uniforms["colorkey"] = getUniformLocation(blit->program, "colorkey")) == -1) return false;
fillRect = new IOGfxGLProg();
fillRect->vshader =
"attribute vec4 v_coord; \n"
"uniform mat4 mvp; \n"
" \n"
"void main(void) { \n"
" gl_Position = mvp * v_coord; \n"
"} \n";
fillRect->fshader =
"uniform vec4 color; \n"
" \n"
"void main(void) { \n"
" gl_FragColor = color; \n"
"} \n";
fillRect->program = createProgram("fillRect", fillRect->vshader, fillRect->fshader);
if ((fillRect->attributes["v_coord"] = getAttribLocation(fillRect->program, "v_coord")) == -1) return false;
if ((fillRect->uniforms["mvp"] = getUniformLocation(fillRect->program, "mvp")) == -1) return false;
if ((fillRect->uniforms["color"] = getUniformLocation(fillRect->program, "color")) == -1) return false;
fliprgb = new IOGfxGLProg();
fliprgb->vshader =
"attribute vec4 v_coord; \n"
"attribute vec2 v_texcoord; \n"
"varying vec2 f_texcoord; \n"
"uniform mat4 mvp; \n"
" \n"
"void main(void) { \n"
" gl_Position = mvp * v_coord; \n"
" f_texcoord = v_texcoord; \n"
"} \n";
fliprgb->fshader =
"varying vec2 f_texcoord; \n"
"uniform sampler2D texture; \n"
"uniform float brightness; \n"
" \n"
"void main(void) { \n"
" vec4 f = texture2D(texture, f_texcoord); \n"
" if (f == vec4(1.0,1.0,1.0, 1.0)) \n"
" gl_FragColor = f; \n"
" else \n"
" gl_FragColor = vec4(f.rgb * brightness, 1.0);\n"
"} \n";
fliprgb->program = createProgram("pflip", fliprgb->vshader, fliprgb->fshader);
if ((fliprgb->attributes["v_coord"] = getAttribLocation(fliprgb->program, "v_coord")) == -1) return false;
if ((fliprgb->attributes["v_texcoord"] = getAttribLocation(fliprgb->program, "v_texcoord")) == -1) return false;
if ((fliprgb->uniforms["mvp"] = getUniformLocation(fliprgb->program, "mvp")) == -1) return false;
if ((fliprgb->uniforms["texture"] = getUniformLocation(fliprgb->program, "texture")) == -1) return false;
if ((fliprgb->uniforms["brightness"] = getUniformLocation(fliprgb->program, "brightness")) == -1) return false;
/* Palette emulation */
flippal = new IOGfxGLProg();
flippal->vshader =
"attribute vec4 v_coord; \n"
"attribute vec2 v_texcoord; \n"
"varying vec2 f_texcoord; \n"
"uniform mat4 mvp; \n"
" \n"
"void main(void) { \n"
" gl_Position = mvp * v_coord; \n"
" f_texcoord = v_texcoord; \n"
"} \n";
flippal->fshader =
"varying vec2 f_texcoord; \n"
"uniform sampler2D texture; \n"
"uniform sampler2D palette; \n"
" \n"
"void main(void) { \n"
" vec4 index = texture2D(texture, f_texcoord); \n"
" gl_FragColor = texture2D(palette, vec2(index.r, 0.5)); \n"
"} \n";
flippal->program = createProgram("i2rgb", flippal->vshader, flippal->fshader);
if ((flippal->attributes["v_coord"] = getAttribLocation(flippal->program, "v_coord")) == -1) return false;
if ((flippal->attributes["v_texcoord"] = getAttribLocation(flippal->program, "v_texcoord")) == -1) return false;
if ((flippal->uniforms["mvp"] = getUniformLocation(flippal->program, "mvp")) == -1) return false;
if ((flippal->uniforms["texture"] = getUniformLocation(flippal->program, "texture")) == -1) return false;
if ((flippal->uniforms["palette"] = getUniformLocation(flippal->program, "palette")) == -1) return false;
if (blit->program == 0 || fliprgb->program == 0 || fillRect->program == 0 || flippal->program == 0)
return false;
return true;
}
GLuint IOGfxDisplayGL2::createProgram(const char* name, const char* vertexShaderSource, const char* fragmentShaderSource) {
GLuint vs, fs;
if ((vs = createShader(name, vertexShaderSource, GL_VERTEX_SHADER)) == 0) return false;
if ((fs = createShader(name, fragmentShaderSource, GL_FRAGMENT_SHADER)) == 0) return false;
GLuint program = gl->CreateProgram();
if (program == 0) {
log_error("Could not allocate program");
return 0;
}
gl->AttachShader(program, vs);
gl->AttachShader(program, fs);
GLint link_ok = GL_FALSE;
gl->LinkProgram(program);
gl->GetProgramiv(program, GL_LINK_STATUS, &link_ok);
if (!link_ok) {
infoLog(program);
return 0;
}
return program;
}
GLint IOGfxDisplayGL2::getAttribLocation(GLuint program, const char* name) {
GLint attribute = gl->GetAttribLocation(program, name);
if (attribute == -1)
log_error("Could not locate attribute %s", name);
return attribute;
}
GLint IOGfxDisplayGL2::getUniformLocation(GLuint program, const char* name) {
GLint uniform = gl->GetUniformLocation(program, name);
if (uniform == -1)
log_error("Could not locate uniform %s", name);
return uniform;
}
bool IOGfxDisplayGL2::createPalette() {
gl->GenTextures(1, &palette);
gl->BindTexture(GL_TEXTURE_2D, palette);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
updatePalette();
return true; // I hereby thank OpenGL error reporting..
}
void IOGfxDisplayGL2::updatePalette() {
SDL_Color pal_phys[256];
gfx_palette_get_phys(pal_phys);
gl->BindTexture(GL_TEXTURE_2D, palette);
gl->TexImage2D(GL_TEXTURE_2D, // target
0, // level, 0 = base, no minimap,
GL_RGBA, // internalformat
256, // width
1, // height
0, // border, always 0 in OpenGL ES
GL_RGBA, // format
GL_UNSIGNED_BYTE, // type
pal_phys);
}
void IOGfxDisplayGL2::logOpenGLInfo() {
int major, minor, profile;
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major);
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &minor);
SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile);
const char* profile_str = "";
if (profile & SDL_GL_CONTEXT_PROFILE_CORE)
profile_str = "CORE";
if (profile & SDL_GL_CONTEXT_PROFILE_COMPATIBILITY)
profile_str = "COMPATIBILITY";
if (profile & SDL_GL_CONTEXT_PROFILE_ES)
profile_str = "ES";
log_info("OpenGL %d.%d %s", major, minor, profile_str);
int doublebuffer;
SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &doublebuffer);
log_info("Double buffered: %d", doublebuffer);
#ifndef __EMSCRIPTEN__
// Error: WebGL warning: getParameter: parameter: invalid enum value READ_BUFFER
int read_buffer;
gl->GetIntegerv(GL_READ_BUFFER, &read_buffer);
if (read_buffer == GL_FRONT)
log_info("Read buffer: GL_FRONT");
else if (read_buffer == GL_BACK)
log_info("Read buffer: GL_BACK");
else
log_info("Read buffer: 0x%04X", read_buffer);
#endif
}
void IOGfxDisplayGL2::logDisplayInfo() {
log_info("FreeDink graphics mode: IOGfxDisplayGL2");
IOGfxDisplay::logDisplayInfo();
logOpenGLInfo();
}
void IOGfxDisplayGL2::clear() {
gl->BindFramebuffer(GL_FRAMEBUFFER, 0);
gl->ClearColor(0,0,0,1);
gl->Clear(GL_COLOR_BUFFER_BIT);
}
SDL_Surface* IOGfxDisplayGL2::screenshot(SDL_Rect* rect) {
gl->BindFramebuffer(GL_FRAMEBUFFER, 0);
// assume 4-bytes alignment
SDL_Surface* image = SDL_CreateRGBSurface(0,
rect->w, rect->h, 32,
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff
#else
0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
#endif
);
unsigned char* pixels = (unsigned char*)image->pixels;
gl->ReadPixels(rect->x, h-rect->h-rect->y, rect->w, rect->h,
GL_RGBA, GL_UNSIGNED_BYTE, pixels);
// Flip vertically
unsigned int length = rect->w*4;
unsigned char* src = pixels + (rect->h-1)*length;
unsigned char* tmp = new unsigned char[length];
unsigned char* dst = pixels;
unsigned int rows = rect->h / 2;
while (rows--) {
memcpy(tmp, dst, length);
memcpy(dst, src, length);
memcpy(src, tmp, length);
dst += length;
src -= length;
}
delete[] tmp;
return image;
}
void IOGfxDisplayGL2::setVertexAttrib(IOGfxGLProg* prog, GLuint attribLocation, GLuint vbo, GLint size) {
gl->EnableVertexAttribArray(attribLocation);
// Describe our vertices array to OpenGL (it can't guess its format automatically)
gl->BindBuffer(GL_ARRAY_BUFFER, vbo);
gl->VertexAttribPointer(attribLocation, // attribute
size, // number of elements per vertex, e.g. (x,y,z,t)
GL_FLOAT, // the type of each element
GL_FALSE, // take our values as-is
0, // no extra data between each position
0 // offset of first element
);
}
void IOGfxDisplayGL2::flip(IOGfxSurface* backbuffer, SDL_Rect* dstrect,
bool interpolation, bool hwflip) {
if (backbuffer == NULL)
SDL_SetError("IOGfxDisplayGL2::flip: passed a NULL surface");
IOGfxSurfaceGL2* surf = dynamic_cast(backbuffer);
GLuint texture = surf->texture;
IOGfxGLProg* prog = truecolor ? fliprgb : flippal;
gl->UseProgram(prog->program);
setVertexAttrib(prog, prog->attributes["v_coord"], vboSpriteVertices, 4);
setVertexAttrib(prog, prog->attributes["v_texcoord"], vboSpriteTexcoords, 2);
gl->ActiveTexture(GL_TEXTURE0);
gl->Uniform1i(prog->uniforms["texture"], /*GL_TEXTURE*/0);
gl->BindTexture(GL_TEXTURE_2D, texture);
// GL_LINEAR's slight blur is closer to 90's CRT monitors
// GL_NEAREST is clean-pixellated and harder on the eyes
if (truecolor && interpolation) {
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
} else {
// but GL_LINEAR messes palette emulation
// TODO: implement 2-step flip: 1) i2rgb 2) interpolation
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
if (!truecolor) {
gl->ActiveTexture(GL_TEXTURE1);
gl->Uniform1i(prog->uniforms["palette"], /*GL_TEXTURE*/1);
gl->BindTexture(GL_TEXTURE_2D, palette);
updatePalette();
}
if (truecolor)
gl->Uniform1f(prog->uniforms["brightness"], brightness/256.0);
// Y-inversed projection for top-left origin and top-bottom textures
// Beware that rotation is reversed too
glm::mat4 projection = glm::ortho(0.0f, 1.0f*w, 1.0f*h, 0.0f);
glm::mat4 m_transform = glm::translate(glm::mat4(1.0f), glm::vec3(dstrect->x,dstrect->y, 0))
* glm::scale(glm::mat4(1.0f), glm::vec3(dstrect->w, dstrect->h, 0));
glm::mat4 mvp = projection * m_transform; // * view * model * anim;
gl->UniformMatrix4fv(prog->uniforms["mvp"], 1, GL_FALSE, glm::value_ptr(mvp));
/* Push each element in buffer_vertices to the vertex shader */
gl->BindFramebuffer(GL_FRAMEBUFFER, 0);
gl->DrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// gl->DisableVertexAttribArray(prog->attributes["v_coord"]);
// gl->DisableVertexAttribArray(blit->attributes["v_texcoord"]);
if (hwflip)
SDL_GL_SwapWindow(window);
}
void IOGfxDisplayGL2::onSizeChange(int w, int h) {
this->w = w;
this->h = h;
gl->Viewport(0, 0, w, h);
}
IOGfxSurface* IOGfxDisplayGL2::upload(SDL_Surface* surf) {
GLuint texture = -1;
gl->GenTextures(1, &texture);
gl->BindTexture(GL_TEXTURE_2D, texture);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
log_trace("surf->w=%d", surf->w);
log_trace("surf->h=%d", surf->h);
log_trace("surf->format->bits=%d", surf->format->BitsPerPixel);
// Save transparency color
SDL_Color colorkey = {0,0,0, 0};
Uint32 key;
if (SDL_GetColorKey(surf, &key) == -1) {
colorkey.a = SDL_ALPHA_OPAQUE; // no colorkey
} else {
if (truecolor)
SDL_GetRGBA(key, surf->format, &colorkey.r, &colorkey.g, &colorkey.b, &colorkey.a);
else
colorkey.r = colorkey.g = colorkey.b = key;
colorkey.a = SDL_ALPHA_TRANSPARENT;
}
if (truecolor) {
// Dink images get alpha disabled, so use 24-bit for simplicity
if (surf->format->BitsPerPixel != 24 || surf->format->format != SDL_PIXELFORMAT_RGB888) {
// don't black out transparent pixels, keep original color
SDL_SetColorKey(surf, SDL_FALSE, 0);
SDL_PixelFormat fmt;
fmt.BitsPerPixel = 24;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
fmt.Rmask = 0xFF000000;
fmt.Gmask = 0x00FF0000;
fmt.Bmask = 0x0000FF00;
fmt.Amask = 0x00000000;
#else
fmt.Rmask = 0x000000FF;
fmt.Gmask = 0x0000FF00;
fmt.Bmask = 0x00FF0000;
fmt.Amask = 0x00000000;
#endif
SDL_Surface* surf24 = SDL_CreateRGBSurface(0, surf->w, surf->h, fmt.BitsPerPixel,
fmt.Rmask, fmt.Gmask, fmt.Bmask, fmt.Amask);
SDL_BlitSurface(surf, NULL, surf24, NULL);
SDL_FreeSurface(surf);
surf = surf24;
}
gl->TexImage2D(GL_TEXTURE_2D, // target
0, // level, 0 = base, no minimap,
GL_RGB, // internalformat
surf->w, // width
surf->h, // height
0, // border, always 0 in OpenGL ES
GL_RGB, // format
GL_UNSIGNED_BYTE, // type
surf->pixels);
} else {
if (surf->format->BitsPerPixel != 8) {
log_error("IOGfxDisplayGL2::upload: format is not indexed");
SDL_FreeSurface(surf);
return NULL;
}
gl->TexImage2D(GL_TEXTURE_2D, // target
0, // level, 0 = base, no minimap,
GL_LUMINANCE, // internalformat
surf->w, // width
surf->h, // height
0, // border, always 0 in OpenGL ES
GL_LUMINANCE, // format
GL_UNSIGNED_BYTE, // type
surf->pixels);
}
int w = surf->w;
int h = surf->h;
SDL_FreeSurface(surf);
return new IOGfxSurfaceGL2(this, texture, w, h, colorkey);
}
IOGfxSurface* IOGfxDisplayGL2::allocBuffer(int surfW, int surfH) {
GLuint texture = -1;
gl->GenTextures(1, &texture);
gl->BindTexture(GL_TEXTURE_2D, texture);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// No color key
SDL_Color colorkey = {0,0,0, SDL_ALPHA_OPAQUE};
// Blank texture
// RGB even in indexed mode because some setup (Android) don't allow GL_LUMINANCE as framebuffer
unsigned char* pixels = new unsigned char[(surfW+(4-surfW%4))*4 * surfH];
gl->TexImage2D(GL_TEXTURE_2D, // target
0, // level, 0 = base, no minimap,
GL_RGB, // internalformat
surfW, // width
surfH, // height
0, // border, always 0 in OpenGL ES
GL_RGB, // format
GL_UNSIGNED_BYTE, // type
pixels);
delete[] pixels;
return new IOGfxSurfaceGL2(this, texture, surfW, surfH, colorkey);
}