static void
init_group(const struct fv_gl_group *group)
{
int minor_gl_version = fv_gl.minor_version;
const char *suffix;
struct fv_buffer buffer;
void *func;
int gl_version;
int i;
if (minor_gl_version >= 10)
minor_gl_version = 9;
gl_version = fv_gl.major_version * 10 + minor_gl_version;
if (group->minimum_gl_version >= 0 &&
gl_version >= group->minimum_gl_version)
suffix = "";
else if (group->extension &&
SDL_GL_ExtensionSupported(group->extension))
suffix = group->extension_suffix;
else
return;
fv_buffer_init(&buffer);
for (i = 0; group->funcs[i].name; i++) {
fv_buffer_set_length(&buffer, 0);
fv_buffer_append_string(&buffer, group->funcs[i].name);
fv_buffer_append_string(&buffer, suffix);
func = SDL_GL_GetProcAddress((char *) buffer.data);
*(void **) ((char *) &fv_gl + group->funcs[i].offset) = func;
}
fv_buffer_destroy(&buffer);
}
// Sets up OpenGL
void _Graphics::SetupOpenGL() {
// Anisotropic filtering
if(SDL_GL_ExtensionSupported("GL_EXT_texture_filter_anisotropic")) {
GLfloat MaxAnisotropy;
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &MaxAnisotropy);
if(Anisotropy > (int)MaxAnisotropy)
Anisotropy = (int)MaxAnisotropy;
}
// Default state
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnableVertexAttribArray(0);
// Set ortho matrix
Ortho = glm::ortho(0.0f, (float)WindowSize.x, (float)WindowSize.y, 0.0f, -1.0f, 1.0f);
// Build vertex buffers
BuildVertexBuffers();
// Clear screen
ClearScreen();
Flip(0);
}
void Context::GetVersion(uint8_t &major, uint8_t &minor, Render::Context::Profile&profile)
{
int value;
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &value); major = value;
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &value); minor = value;
SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &value);
if ( (major == 3 && minor >= 1) || major > 3)
profile = SDL_GL_ExtensionSupported("GL_ARB_compatibility")?Profile::Compatibility:Profile::Core;
else
profile = Profile::Compatibility;
}
void
fv_gl_init(void)
{
int sample_buffers = 0;
int max_vertex_attribs;
int i;
memset(&fv_gl, 0, sizeof fv_gl);
fv_gl.glGetString = SDL_GL_GetProcAddress("glGetString");
get_gl_version();
for (i = 0; i < FV_N_ELEMENTS(gl_groups); i++)
init_group(gl_groups + i);
fv_gl.have_map_buffer_range = fv_gl.glMapBufferRange != NULL;
fv_gl.have_vertex_array_objects = fv_gl.glGenVertexArrays != NULL;
/* On GLES2 (and thus WebGL) non-power-of-two textures are
* only supported if no mipmaps are used and the repeat mode
* is CLAMP_TO_EDGE.
*/
#ifdef EMSCRIPTEN
fv_gl.have_npot_mipmaps = false;
#else
fv_gl.have_npot_mipmaps = true;
#endif
fv_gl.have_texture_2d_array =
SDL_GL_ExtensionSupported("GL_EXT_texture_array");
fv_gl.glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &max_vertex_attribs);
fv_gl.have_instanced_arrays =
fv_gl.glVertexAttribDivisor != NULL &&
fv_gl.glDrawElementsInstanced != NULL &&
max_vertex_attribs >= 11;
#ifndef EMSCRIPTEN
fv_gl.glGetIntegerv(GL_SAMPLE_BUFFERS_ARB, &sample_buffers);
#endif
fv_gl.have_multisampling = sample_buffers != 0;
}
pd::simple_texture::simple_texture(SDL_Surface *surface)
{
m_width = surface->w;
m_height = surface->h;
if (SDL_GL_ExtensionSupported("GL_ARB_texture_non_power_of_two")) {
m_stored_width = m_width;
m_stored_height = m_height;
} else {
m_stored_width = pd::next_power_of_two(m_width);
m_stored_height = pd::next_power_of_two(m_height);
}
glGenTextures(1, &m_id);
glBindTexture(GL_TEXTURE_2D, m_id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_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);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_stored_width,
m_stored_height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
surface->pixels);
}
/*
* @overload extension_supported?(extension)
* Return true if the current context supports **extension**
*
* @param extension [String] the name of an extension
* @example
* SDL2::GL.extension_supported?("GL_EXT_framebuffer_blit")
*/
static VALUE GL_s_extension_supported_p(VALUE self, VALUE extension)
{
return INT2BOOL(SDL_GL_ExtensionSupported(StringValueCStr(extension)));
}
SDL_Renderer *
GL_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
GL_RenderData *data;
const char *hint;
GLint value;
Uint32 window_flags;
window_flags = SDL_GetWindowFlags(window);
if (!(window_flags & SDL_WINDOW_OPENGL)) {
if (SDL_RecreateWindow(window, window_flags | SDL_WINDOW_OPENGL) < 0) {
return NULL;
}
}
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
data = (GL_RenderData *) SDL_calloc(1, sizeof(*data));
if (!data) {
GL_DestroyRenderer(renderer);
SDL_OutOfMemory();
return NULL;
}
renderer->WindowEvent = GL_WindowEvent;
renderer->CreateTexture = GL_CreateTexture;
renderer->UpdateTexture = GL_UpdateTexture;
renderer->LockTexture = GL_LockTexture;
renderer->UnlockTexture = GL_UnlockTexture;
renderer->UpdateViewport = GL_UpdateViewport;
renderer->RenderClear = GL_RenderClear;
renderer->RenderDrawPoints = GL_RenderDrawPoints;
renderer->RenderDrawLines = GL_RenderDrawLines;
renderer->RenderFillRects = GL_RenderFillRects;
renderer->RenderCopy = GL_RenderCopy;
renderer->RenderReadPixels = GL_RenderReadPixels;
renderer->RenderPresent = GL_RenderPresent;
renderer->DestroyTexture = GL_DestroyTexture;
renderer->DestroyRenderer = GL_DestroyRenderer;
renderer->info = GL_RenderDriver.info;
renderer->info.flags = SDL_RENDERER_ACCELERATED;
renderer->driverdata = data;
data->context = SDL_GL_CreateContext(window);
if (!data->context) {
GL_DestroyRenderer(renderer);
return NULL;
}
if (SDL_GL_MakeCurrent(window, data->context) < 0) {
GL_DestroyRenderer(renderer);
return NULL;
}
if (GL_LoadFunctions(data) < 0) {
GL_DestroyRenderer(renderer);
return NULL;
}
#ifdef __MACOSX__
/* Enable multi-threaded rendering */
/* Disabled until Ryan finishes his VBO/PBO code...
CGLEnable(CGLGetCurrentContext(), kCGLCEMPEngine);
*/
#endif
if (flags & SDL_RENDERER_PRESENTVSYNC) {
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
if (SDL_GL_GetSwapInterval() > 0) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_height = value;
if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle")
|| SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")) {
data->GL_ARB_texture_rectangle_supported = SDL_TRUE;
}
if (SDL_GL_ExtensionSupported("GL_APPLE_texture_range")) {
data->glTextureRangeAPPLE =
(void (*)(GLenum, GLsizei, const GLvoid *))
SDL_GL_GetProcAddress("glTextureRangeAPPLE");
}
/* Check for multitexture support */
if (SDL_GL_ExtensionSupported("GL_ARB_multitexture")) {
data->glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) SDL_GL_GetProcAddress("glActiveTextureARB");
if (data->glActiveTextureARB) {
data->GL_ARB_multitexture_supported = SDL_TRUE;
data->glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &data->num_texture_units);
}
}
/* Check for shader support */
hint = SDL_GetHint(SDL_HINT_RENDER_OPENGL_SHADERS);
if (!hint || *hint != '0') {
data->shaders = GL_CreateShaderContext();
}
SDL_LogInfo(SDL_LOG_CATEGORY_RENDER, "OpenGL shaders: %s",
data->shaders ? "ENABLED" : "DISABLED");
/* We support YV12 textures using 3 textures and a shader */
if (data->shaders && data->num_texture_units >= 3) {
renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_YV12;
renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_IYUV;
}
/* Set up parameters for rendering */
GL_ResetState(renderer);
return renderer;
}
SDL_Renderer *
GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
GLES_RenderData *data;
GLint value;
int doublebuffer;
if (!(window->flags & SDL_WINDOW_OPENGL)) {
if (SDL_RecreateWindow(window, window->flags | SDL_WINDOW_OPENGL) < 0) {
return NULL;
}
}
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
data = (GLES_RenderData *) SDL_calloc(1, sizeof(*data));
if (!data) {
GLES_DestroyRenderer(renderer);
SDL_OutOfMemory();
return NULL;
}
renderer->ActivateRenderer = GLES_ActivateRenderer;
renderer->DisplayModeChanged = GLES_DisplayModeChanged;
renderer->CreateTexture = GLES_CreateTexture;
renderer->QueryTexturePixels = GLES_QueryTexturePixels;
renderer->SetTexturePalette = GLES_SetTexturePalette;
renderer->GetTexturePalette = GLES_GetTexturePalette;
renderer->SetTextureColorMod = GLES_SetTextureColorMod;
renderer->SetTextureAlphaMod = GLES_SetTextureAlphaMod;
renderer->SetTextureBlendMode = GLES_SetTextureBlendMode;
renderer->SetTextureScaleMode = GLES_SetTextureScaleMode;
renderer->UpdateTexture = GLES_UpdateTexture;
renderer->LockTexture = GLES_LockTexture;
renderer->UnlockTexture = GLES_UnlockTexture;
renderer->DirtyTexture = GLES_DirtyTexture;
renderer->RenderDrawPoints = GLES_RenderDrawPoints;
renderer->RenderDrawLines = GLES_RenderDrawLines;
renderer->RenderDrawRects = GLES_RenderDrawRects;
renderer->RenderFillRects = GLES_RenderFillRects;
renderer->RenderCopy = GLES_RenderCopy;
renderer->RenderPresent = GLES_RenderPresent;
renderer->DestroyTexture = GLES_DestroyTexture;
renderer->DestroyRenderer = GLES_DestroyRenderer;
renderer->info = GL_ES_RenderDriver.info;
renderer->window = window;
renderer->driverdata = data;
renderer->info.flags =
(SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_ACCELERATED);
#if defined(__QNXNTO__)
#if _NTO_VERSION<=641
/* QNX's OpenGL ES implementation is broken regarding */
/* packed textures support, affected versions 6.3.2, 6.4.0, 6.4.1 */
renderer->info.num_texture_formats = 2;
renderer->info.texture_formats[0] = SDL_PIXELFORMAT_ABGR8888;
renderer->info.texture_formats[1] = SDL_PIXELFORMAT_BGR24;
#endif /* _NTO_VERSION */
#endif /* __QNXNTO__ */
if (GLES_LoadFunctions(data) < 0) {
GLES_DestroyRenderer(renderer);
return NULL;
}
data->context = SDL_GL_CreateContext(window);
if (!data->context) {
GLES_DestroyRenderer(renderer);
return NULL;
}
if (SDL_GL_MakeCurrent(window, data->context) < 0) {
GLES_DestroyRenderer(renderer);
return NULL;
}
if (flags & SDL_RENDERER_PRESENTVSYNC) {
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
if (SDL_GL_GetSwapInterval() > 0) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
if (SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &doublebuffer) == 0) {
if (!doublebuffer) {
renderer->info.flags |= SDL_RENDERER_SINGLEBUFFER;
}
}
#if SDL_VIDEO_DRIVER_PANDORA
data->GL_OES_draw_texture_supported = SDL_FALSE;
data->useDrawTexture = SDL_FALSE;
#else
if (SDL_GL_ExtensionSupported("GL_OES_draw_texture")) {
data->GL_OES_draw_texture_supported = SDL_TRUE;
data->useDrawTexture = SDL_TRUE;
} else {
data->GL_OES_draw_texture_supported = SDL_FALSE;
data->useDrawTexture = SDL_FALSE;
}
#endif
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_height = value;
/* Set up parameters for rendering */
data->blendMode = -1;
data->glDisable(GL_DEPTH_TEST);
data->glDisable(GL_CULL_FACE);
data->updateSize = SDL_TRUE;
return renderer;
}
GLuint compileShader(const char* sourceOrFilename, GLuint shaderType, int is_source) {
//DONT CHANGE
#define SHADER_TYPE(shaderType) (shaderType == GL_VERTEX_SHADER ? "VERTEX" : "FRAGMENT")
char *pShaderBuffer;
char *source = (char*)sourceOrFilename;
char *ptr = NULL;
if(!is_source)
source = readShaderFile(sourceOrFilename, shaderType);
size_t sourceLen = strlen(source)*2;
pShaderBuffer = malloc(sourceLen);
memset(pShaderBuffer,0, sourceLen);
#if !GLES
sprintf(pShaderBuffer,"#version %d%02d\r\n",glslversion_major, glslversion_minor);
#else
sprintf(pShaderBuffer,"#version %d%02d %s\r\n", glslversion_major, glslversion_minor, glslversion_major >= 3 ? "es" : "");
if( SDL_GL_ExtensionSupported("GL_OES_standard_derivatives") )
sprintf(pShaderBuffer,"%s#extension GL_OES_standard_derivatives : enable\r\n",pShaderBuffer);
if( SDL_GL_ExtensionSupported("GL_EXT_shader_texture_lod") )
sprintf(pShaderBuffer,"%s#extension GL_EXT_shader_texture_lod : enable\r\n",pShaderBuffer);
// should be deduced via GL_ES/GL_FRAGMENT_PRECISION_HIGH combination since both is predefined
// but unknown why manual define is a must for WebGL2
if( glslversion_major >= 3 )
sprintf(pShaderBuffer,"%sprecision highp float;\r\n",pShaderBuffer);
#endif
#if SUPPORT_PARAMETER_UNIFORM
sprintf(pShaderBuffer,"%s#define PARAMETER_UNIFORM\r\n",pShaderBuffer);
#endif
// remove #pragma parameter from glsl, avoid glsl compiler（ I mean you, atom ) complains
while((ptr = strstr(source, "#pragma parameter"))!= NULL) {
char *ptrEnd = strchr(ptr, '\r');
if( ptrEnd == NULL ) ptrEnd = strchr(ptr, '\n');
glslp_add_parameter(ptr, ptrEnd-ptr, &gGLSLP);
while(ptr!=ptrEnd) *ptr++=' ';
}
sprintf(pShaderBuffer,"%s#define %s\r\n%s\r\n",pShaderBuffer,SHADER_TYPE(shaderType),is_source ? source : skip_version(source));
if(!is_source)
free((void*)source);
// Create ID for shader
GLuint result = glCreateShader(shaderType);
// Define shader text
glShaderSource(result, 1, (const GLchar *const*)&pShaderBuffer, NULL);
// Compile shader
glCompileShader(result);
//Check vertex shader for errors
GLint shaderCompiled = GL_FALSE;
glGetShaderiv( result, GL_COMPILE_STATUS, &shaderCompiled );
if( shaderCompiled != GL_TRUE ) {
GLint logLength;
glGetShaderiv(result, GL_INFO_LOG_LENGTH, &logLength);
if (logLength > 0)
{
GLchar *log = (GLchar*)malloc(logLength);
glGetShaderInfoLog(result, logLength, &logLength, log);
UTIL_LogOutput(LOGLEVEL_FATAL, "shader %s compilation error:%s\n", is_source ? "stock" : sourceOrFilename,log);
free(log);
}
glDeleteShader(result);
result = 0;
}else
UTIL_LogOutput(LOGLEVEL_DEBUG, "%s shader %s compilation succeed!\n", SHADER_TYPE(shaderType), is_source ? "stock" : sourceOrFilename );
free(pShaderBuffer);
return result;
}
/* ------------------------------------------------------- Load Functions */
static void s_LoadGL() {
SDL_memset(&PL_GL, 0, sizeof(PL_GL));
PL_GL.glEnable = SDL_GL_GetProcAddress("glEnable");
PL_GL.glDisable = SDL_GL_GetProcAddress("glDisable");
PL_GL.glEnableClientState = SDL_GL_GetProcAddress("glEnableClientState");
PL_GL.glDisableClientState = SDL_GL_GetProcAddress("glDisableClientState");
PL_GL.glGetError = SDL_GL_GetProcAddress("glGetError");
PL_GL.glPixelStorei = SDL_GL_GetProcAddress("glPixelStorei");
PL_GL.glFinish = SDL_GL_GetProcAddress("glFinish");
PL_GL.glGetIntegerv = SDL_GL_GetProcAddress("glGetIntegerv");
PL_GL.glMatrixMode = SDL_GL_GetProcAddress("glMatrixMode");
PL_GL.glLoadIdentity = SDL_GL_GetProcAddress("glLoadIdentity");
PL_GL.glPushMatrix = SDL_GL_GetProcAddress("glPushMatrix");
PL_GL.glPopMatrix = SDL_GL_GetProcAddress("glPopMatrix");
PL_GL.glOrtho = SDL_GL_GetProcAddress("glOrtho");
PL_GL.glGenTextures = SDL_GL_GetProcAddress("glGenTextures");
PL_GL.glDeleteTextures = SDL_GL_GetProcAddress("glDeleteTextures");
PL_GL.glClientActiveTexture = SDL_GL_GetProcAddress("glClientActiveTexture");
PL_GL.glActiveTexture = SDL_GL_GetProcAddress("glActiveTexture");
PL_GL.glBindTexture = SDL_GL_GetProcAddress("glBindTexture");
PL_GL.glTexParameteri = SDL_GL_GetProcAddress("glTexParameteri");
PL_GL.glTexImage2D = SDL_GL_GetProcAddress("glTexImage2D");
PL_GL.glTexSubImage2D = SDL_GL_GetProcAddress("glTexSubImage2D");
PL_GL.glReadPixels = SDL_GL_GetProcAddress("glReadPixels");
PL_GL.glClearColor = SDL_GL_GetProcAddress("glClearColor");
PL_GL.glClear = SDL_GL_GetProcAddress("glClear");
PL_GL.glColor4f = SDL_GL_GetProcAddress("glColor4f");
PL_GL.glLineWidth = SDL_GL_GetProcAddress("glLineWidth");
PL_GL.glTexEnvf = SDL_GL_GetProcAddress("glTexEnvf");
PL_GL.glTexEnvi = SDL_GL_GetProcAddress("glTexEnvi");
PL_GL.glBlendFuncSeparate = SDL_GL_GetProcAddress("glBlendFuncSeparate");
PL_GL.glBlendFunc = SDL_GL_GetProcAddress("glBlendFunc");
PL_GL.glBlendEquationSeparate = SDL_GL_GetProcAddress("glBlendEquationSeparate");
PL_GL.glBlendEquation = SDL_GL_GetProcAddress("glBlendEquation");
PL_GL.glViewport = SDL_GL_GetProcAddress("glViewport");
PL_GL.glScissor = SDL_GL_GetProcAddress("glScissor");
PL_GL.glDrawArrays = SDL_GL_GetProcAddress("glDrawArrays");
PL_GL.glVertexPointer = SDL_GL_GetProcAddress("glVertexPointer");
PL_GL.glColorPointer = SDL_GL_GetProcAddress("glColorPointer");
PL_GL.glTexCoordPointer = SDL_GL_GetProcAddress("glTexCoordPointer");
if (SDL_GL_ExtensionSupported("GL_EXT_framebuffer_object")) {
PL_GL.hasFramebufferSupport = DXTRUE;
PL_GL.glFramebufferTexture2DEXT = SDL_GL_GetProcAddress("glFramebufferTexture2DEXT");
PL_GL.glBindFramebufferEXT = SDL_GL_GetProcAddress("glBindFramebufferEXT");
PL_GL.glDeleteFramebuffersEXT = SDL_GL_GetProcAddress("glDeleteFramebuffersEXT");
PL_GL.glGenFramebuffersEXT = SDL_GL_GetProcAddress("glGenFramebuffersEXT");
PL_GL.glCheckFramebufferStatusEXT = SDL_GL_GetProcAddress("glCheckFramebufferStatusEXT");
}
if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle")
|| SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")
) {
GLint size;
PL_GL.glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, &size);
PL_GL.hasTextureRectangleSupport = DXTRUE;
PL_GL.maxTextureWidth = size;
PL_GL.maxTextureHeight = size;
} else {
GLint size;
PL_GL.glGetIntegerv(GL_MAX_TEXTURE_SIZE, &size);
PL_GL.hasTextureRectangleSupport = DXFALSE;
PL_GL.maxTextureWidth = size;
PL_GL.maxTextureHeight = size;
}
PL_GL.isInitialized = DXTRUE;
}
SDL_Renderer *
GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
GLES_RenderData *data;
GLint value;
Uint32 windowFlags;
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
windowFlags = SDL_GetWindowFlags(window);
if (!(windowFlags & SDL_WINDOW_OPENGL)) {
if (SDL_RecreateWindow(window, windowFlags | SDL_WINDOW_OPENGL) < 0) {
/* Uh oh, better try to put it back... */
SDL_RecreateWindow(window, windowFlags);
return NULL;
}
}
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
data = (GLES_RenderData *) SDL_calloc(1, sizeof(*data));
if (!data) {
GLES_DestroyRenderer(renderer);
SDL_OutOfMemory();
return NULL;
}
renderer->WindowEvent = GLES_WindowEvent;
renderer->CreateTexture = GLES_CreateTexture;
renderer->UpdateTexture = GLES_UpdateTexture;
renderer->LockTexture = GLES_LockTexture;
renderer->UnlockTexture = GLES_UnlockTexture;
renderer->SetRenderTarget = GLES_SetRenderTarget;
renderer->UpdateViewport = GLES_UpdateViewport;
renderer->RenderClear = GLES_RenderClear;
renderer->RenderDrawPoints = GLES_RenderDrawPoints;
renderer->RenderDrawLines = GLES_RenderDrawLines;
renderer->RenderFillRects = GLES_RenderFillRects;
renderer->RenderCopy = GLES_RenderCopy;
renderer->RenderReadPixels = GLES_RenderReadPixels;
renderer->RenderPresent = GLES_RenderPresent;
renderer->DestroyTexture = GLES_DestroyTexture;
renderer->DestroyRenderer = GLES_DestroyRenderer;
renderer->info = GLES_RenderDriver.info;
renderer->info.flags = SDL_RENDERER_ACCELERATED;
renderer->driverdata = data;
renderer->window = window;
data->context = SDL_GL_CreateContext(window);
if (!data->context) {
GLES_DestroyRenderer(renderer);
return NULL;
}
if (SDL_GL_MakeCurrent(window, data->context) < 0) {
GLES_DestroyRenderer(renderer);
return NULL;
}
if (GLES_LoadFunctions(data) < 0) {
GLES_DestroyRenderer(renderer);
return NULL;
}
if (flags & SDL_RENDERER_PRESENTVSYNC) {
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
if (SDL_GL_GetSwapInterval() > 0) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
#if SDL_VIDEO_DRIVER_PANDORA
data->GL_OES_draw_texture_supported = SDL_FALSE;
data->useDrawTexture = SDL_FALSE;
#else
if (SDL_GL_ExtensionSupported("GL_OES_draw_texture")) {
data->GL_OES_draw_texture_supported = SDL_TRUE;
data->useDrawTexture = SDL_TRUE;
} else {
data->GL_OES_draw_texture_supported = SDL_FALSE;
data->useDrawTexture = SDL_FALSE;
}
#endif
value = 0;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value;
value = 0;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_height = value;
if (SDL_GL_ExtensionSupported("GL_OES_framebuffer_object")) {
data->GL_OES_framebuffer_object_supported = SDL_TRUE;
renderer->info.flags |= SDL_RENDERER_TARGETTEXTURE;
value = 0;
data->glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, &value);
data->window_framebuffer = (GLuint)value;
}
data->framebuffers = NULL;
/* Set up parameters for rendering */
GLES_ResetState(renderer);
return renderer;
}
bool Context::CheckExtension(const char*name)
{
return SDL_GL_ExtensionSupported(name);
}
bool ImGui_ImplSdlGLES2_CreateDeviceObjects() {
g_DrawElemWorkaround =
(SDL_GL_ExtensionSupported("GL_OES_element_index_uint") != SDL_TRUE) && (sizeof(ImDrawIdx) > sizeof(GLushort));
if (g_DrawElemWorkaround)
SDL_Log("[ImGui] Warning: GL_OES_element_index_uint not supported. Using glDrawArrays(). This will be slower.");
// Backup GL state
GLint last_texture, last_array_buffer;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
const GLchar *vertex_shader =
"precision mediump float;\n"
"attribute vec2 Position;\n"
"attribute vec2 UV;\n"
"attribute vec4 Color;\n"
"varying vec2 Frag_UV;\n"
"varying vec4 Frag_Color;\n"
"uniform mat4 ProjMtx;\n"
"void main()\n"
"{\n"
" Frag_UV = UV;\n"
" Frag_Color = Color;\n"
" gl_Position = ProjMtx * vec4(Position.xy, 0, 1);\n"
"}\n";
const GLchar *fragment_shader =
"precision mediump float;\n"
"varying vec2 Frag_UV;\n"
"varying vec4 Frag_Color;\n"
"uniform sampler2D Texture;\n"
"void main()\n"
"{\n"
" gl_FragColor = Frag_Color * texture2D( Texture, Frag_UV.st);\n"
"}\n";
g_ShaderHandle = glCreateProgram();
g_VertHandle = glCreateShader(GL_VERTEX_SHADER);
g_FragHandle = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(g_VertHandle, 1, &vertex_shader, 0);
glShaderSource(g_FragHandle, 1, &fragment_shader, 0);
glCompileShader(g_VertHandle);
GLint logLength;
glGetShaderiv(g_VertHandle, GL_INFO_LOG_LENGTH, &logLength);
if (logLength > 1) {
GLchar *log = (GLchar *)malloc(logLength);
glGetShaderInfoLog(g_VertHandle, logLength, &logLength, log);
SDL_LogError(SDL_LOG_CATEGORY_ERROR, "VERTEX Shader compile log:\n%s", log);
free(log);
}
glCompileShader(g_FragHandle);
glGetShaderiv(g_FragHandle, GL_INFO_LOG_LENGTH, &logLength);
if (logLength > 1) {
GLchar *log = (GLchar *)malloc(logLength);
glGetShaderInfoLog(g_FragHandle, logLength, &logLength, log);
SDL_LogError(SDL_LOG_CATEGORY_ERROR, "FRAGMENT Shader compile log:\n%s", log);
free(log);
}
glAttachShader(g_ShaderHandle, g_VertHandle);
glAttachShader(g_ShaderHandle, g_FragHandle);
glLinkProgram(g_ShaderHandle);
g_AttribLocationTex = glGetUniformLocation(g_ShaderHandle, "Texture");
g_AttribLocationProjMtx = glGetUniformLocation(g_ShaderHandle, "ProjMtx");
g_AttribLocationPosition = glGetAttribLocation(g_ShaderHandle, "Position");
g_AttribLocationUV = glGetAttribLocation(g_ShaderHandle, "UV");
g_AttribLocationColor = glGetAttribLocation(g_ShaderHandle, "Color");
glGenBuffers(1, &g_VboHandle);
glGenBuffers(1, &g_ElementsHandle);
glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
glEnableVertexAttribArray(g_AttribLocationPosition);
glEnableVertexAttribArray(g_AttribLocationUV);
glEnableVertexAttribArray(g_AttribLocationColor);
#define OFFSETOF(TYPE, ELEMENT) ((size_t) & (((TYPE *)0)->ELEMENT))
glVertexAttribPointer(g_AttribLocationPosition, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid *)OFFSETOF(ImDrawVert, pos));
glVertexAttribPointer(g_AttribLocationUV, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid *)OFFSETOF(ImDrawVert, uv));
glVertexAttribPointer(
g_AttribLocationColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid *)OFFSETOF(ImDrawVert, col));
#undef OFFSETOF
ImGui_ImplSdlGLES2_CreateFontsTexture();
// Restore modified GL state
glBindTexture(GL_TEXTURE_2D, last_texture);
glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
return true;
}
/*
* SDL.glExtensionSupported(name)
*
* Arguments:
* name the extension requested
*
* Returns:
* True if supported
*/
static int
l_glExtensionSupported(lua_State *L)
{
return commonPush(L, "b", SDL_GL_ExtensionSupported(luaL_checkstring(L, 1)));
}
static int sdl_extension_supported(const char *ext)
{
return SDL_GL_ExtensionSupported(ext);
}
void GLES_Init(void)
{
gl_renderer = (const char *)qglGetString(GL_RENDERER);
gl_vendor = (const char *)qglGetString(GL_VENDOR);
gl_version = (const char *)qglGetString(GL_VERSION);
gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
if (!gl_extensions)
gl_extensions = "";
if (!gl_platformextensions)
gl_platformextensions = "";
Con_Printf("GL_VENDOR: %s\n", gl_vendor);
Con_Printf("GL_RENDERER: %s\n", gl_renderer);
Con_Printf("GL_VERSION: %s\n", gl_version);
Con_DPrintf("GL_EXTENSIONS: %s\n", gl_extensions);
Con_DPrintf("%s_EXTENSIONS: %s\n", gl_platform, gl_platformextensions);
// LordHavoc: report supported extensions
Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
// GLES devices in general do not like GL_BGRA, so use GL_RGBA
vid.forcetextype = TEXTYPE_RGBA;
vid.support.gl20shaders = true;
vid.support.amd_texture_texture4 = false;
vid.support.arb_depth_texture = false;
vid.support.arb_draw_buffers = false;
vid.support.arb_multitexture = false;
vid.support.arb_occlusion_query = false;
vid.support.arb_shadow = false;
vid.support.arb_texture_compression = SDL_GL_ExtensionSupported("GL_EXT_texture_compression_s3tc");
vid.support.arb_texture_cube_map = true;
vid.support.arb_texture_env_combine = false;
vid.support.arb_texture_gather = false;
vid.support.arb_texture_non_power_of_two = strstr(gl_extensions, "GL_OES_texture_npot") != NULL;
vid.support.arb_vertex_buffer_object = true;
vid.support.arb_uniform_buffer_object = false;
vid.support.ati_separate_stencil = false;
vid.support.ext_blend_minmax = false;
vid.support.ext_blend_subtract = true;
vid.support.ext_draw_range_elements = true;
vid.support.ext_framebuffer_object = false;
// FIXME remove this workaround once FBO + npot texture mapping is fixed
if(!vid.support.arb_texture_non_power_of_two)
{
vid.support.arb_framebuffer_object = false;
vid.support.ext_framebuffer_object = false;
}
vid.support.ext_packed_depth_stencil = false;
vid.support.ext_stencil_two_side = false;
vid.support.ext_texture_3d = SDL_GL_ExtensionSupported("GL_OES_texture_3D");
vid.support.ext_texture_compression_s3tc = SDL_GL_ExtensionSupported("GL_EXT_texture_compression_s3tc");
vid.support.ext_texture_edge_clamp = true;
vid.support.ext_texture_filter_anisotropic = false; // probably don't want to use it...
vid.support.ext_texture_srgb = false;
qglGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_2d);
if (vid.support.ext_texture_filter_anisotropic)
qglGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, (GLint*)&vid.max_anisotropy);
if (vid.support.arb_texture_cube_map)
qglGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, (GLint*)&vid.maxtexturesize_cubemap);
Con_Printf("GL_MAX_CUBE_MAP_TEXTURE_SIZE = %i\n", vid.maxtexturesize_cubemap);
Con_Printf("GL_MAX_3D_TEXTURE_SIZE = %i\n", vid.maxtexturesize_3d);
{
#define GL_ALPHA_BITS 0x0D55
#define GL_RED_BITS 0x0D52
#define GL_GREEN_BITS 0x0D53
#define GL_BLUE_BITS 0x0D54
#define GL_DEPTH_BITS 0x0D56
#define GL_STENCIL_BITS 0x0D57
int fb_r = -1, fb_g = -1, fb_b = -1, fb_a = -1, fb_d = -1, fb_s = -1;
qglGetIntegerv(GL_RED_BITS , &fb_r);
qglGetIntegerv(GL_GREEN_BITS , &fb_g);
qglGetIntegerv(GL_BLUE_BITS , &fb_b);
qglGetIntegerv(GL_ALPHA_BITS , &fb_a);
qglGetIntegerv(GL_DEPTH_BITS , &fb_d);
qglGetIntegerv(GL_STENCIL_BITS, &fb_s);
if ((fb_r+fb_g+fb_b+fb_a)>=24) is32bit=1;
Con_Printf("Framebuffer depth is R%iG%iB%iA%iD%iS%i\n", fb_r, fb_g, fb_b, fb_a, fb_d, fb_s);
}
// verify that cubemap textures are really supported
if (vid.support.arb_texture_cube_map && vid.maxtexturesize_cubemap < 256)
vid.support.arb_texture_cube_map = false;
// verify that 3d textures are really supported
if (vid.support.ext_texture_3d && vid.maxtexturesize_3d < 32)
{
vid.support.ext_texture_3d = false;
Con_Printf("GL_OES_texture_3d reported bogus GL_MAX_3D_TEXTURE_SIZE, disabled\n");
}
vid.texunits = 4;
vid.teximageunits = 8;
vid.texarrayunits = 5;
vid.texunits = bound(1, vid.texunits, MAX_TEXTUREUNITS);
vid.teximageunits = bound(1, vid.teximageunits, MAX_TEXTUREUNITS);
vid.texarrayunits = bound(1, vid.texarrayunits, MAX_TEXTUREUNITS);
Con_DPrintf("Using GLES2.0 rendering path - %i texture matrix, %i texture images, %i texcoords%s\n", vid.texunits, vid.teximageunits, vid.texarrayunits, vid.support.ext_framebuffer_object ? ", shadowmapping supported" : "");
vid.renderpath = RENDERPATH_GLES2;
vid.useinterleavedarrays = false;
vid.sRGBcapable2D = false;
vid.sRGBcapable3D = false;
// VorteX: set other info (maybe place them in VID_InitMode?)
extern cvar_t gl_info_vendor;
extern cvar_t gl_info_renderer;
extern cvar_t gl_info_version;
extern cvar_t gl_info_platform;
extern cvar_t gl_info_driver;
Cvar_SetQuick(&gl_info_vendor, gl_vendor);
Cvar_SetQuick(&gl_info_renderer, gl_renderer);
Cvar_SetQuick(&gl_info_version, gl_version);
Cvar_SetQuick(&gl_info_platform, gl_platform ? gl_platform : "");
Cvar_SetQuick(&gl_info_driver, gl_driver);
}
SDL_Renderer *
GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
GLES_RenderData *data;
GLint value;
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
data = (GLES_RenderData *) SDL_calloc(1, sizeof(*data));
if (!data) {
GLES_DestroyRenderer(renderer);
SDL_OutOfMemory();
return NULL;
}
renderer->WindowEvent = GLES_WindowEvent;
renderer->CreateTexture = GLES_CreateTexture;
renderer->UpdateTexture = GLES_UpdateTexture;
renderer->LockTexture = GLES_LockTexture;
renderer->UnlockTexture = GLES_UnlockTexture;
renderer->UpdateViewport = GLES_UpdateViewport;
renderer->RenderClear = GLES_RenderClear;
renderer->RenderDrawPoints = GLES_RenderDrawPoints;
renderer->RenderDrawLines = GLES_RenderDrawLines;
renderer->RenderFillRects = GLES_RenderFillRects;
renderer->RenderCopy = GLES_RenderCopy;
renderer->RenderPresent = GLES_RenderPresent;
renderer->DestroyTexture = GLES_DestroyTexture;
renderer->DestroyRenderer = GLES_DestroyRenderer;
renderer->info = GLES_RenderDriver.info;
renderer->info.flags = SDL_RENDERER_ACCELERATED;
renderer->driverdata = data;
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
data->context = SDL_GL_CreateContext(window);
if (!data->context) {
GLES_DestroyRenderer(renderer);
return NULL;
}
if (SDL_GL_MakeCurrent(window, data->context) < 0) {
GLES_DestroyRenderer(renderer);
return NULL;
}
if (flags & SDL_RENDERER_PRESENTVSYNC) {
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
if (SDL_GL_GetSwapInterval() > 0) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
#if SDL_VIDEO_DRIVER_PANDORA
data->GL_OES_draw_texture_supported = SDL_FALSE;
data->useDrawTexture = SDL_FALSE;
#else
if (SDL_GL_ExtensionSupported("GL_OES_draw_texture")) {
data->GL_OES_draw_texture_supported = SDL_TRUE;
data->useDrawTexture = SDL_TRUE;
} else {
data->GL_OES_draw_texture_supported = SDL_FALSE;
data->useDrawTexture = SDL_FALSE;
}
#endif
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_height = value;
/* Set up parameters for rendering */
GLES_ResetState(renderer);
return renderer;
}
int32_t init_shader() {
int32_t ret = 0;
// - we don't actually need this, but I want to check anyways because ubo's are
// so useful and I would like to known when I can't use them in the future
if( ! SDL_GL_ExtensionSupported("GL_ARB_uniform_buffer_object") ) {
log_fail(__FILE__, __LINE__, "uniform_buffer_object extension not found!\n");
ret = 1;
}
GLint max_vertex_attribs = 0;
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &max_vertex_attribs);
log_info(__FILE__, __LINE__, "gl maximum vertex attribs: %d\n", max_vertex_attribs);
log_assert( MAX_SHADER_ATTRIBUTES < max_vertex_attribs );
GLint max_fragment_texture_image_units = 0;
GLint max_vertex_texture_image_units = 0;
GLint max_combined_texture_image_units = 0;
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_fragment_texture_image_units);
glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &max_vertex_texture_image_units);
glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &max_combined_texture_image_units);
log_info(__FILE__, __LINE__, "gl maximum fragment texture image units: %d\n", max_fragment_texture_image_units);
log_info(__FILE__, __LINE__, "gl maximum vertex texture image units: %d\n", max_vertex_texture_image_units);
log_info(__FILE__, __LINE__, "gl maximum combined texture image units: %d\n", max_combined_texture_image_units);
for( size_t i = 0; i < MAX_SHADER_ATTRIBUTE_NAMES; i++ ) {
for( size_t j = 0; j < MAX_SHADER_ATTRIBUTES; j++ ) {
global_shader_attribute_names[i][j] = "invalid_attribute";
}
}
for( size_t i = 0; i < MAX_SHADER_UNIFORMS; i++ ) {
global_shader_uniform_names[i] = "invalid_uniform";
}
for( size_t i = 0; i < MAX_SHADER_SAMPLER; i++ ) {
global_shader_sampler_names[i] = "invalid_sampler";
}
// - initialize the first four attribute names of every set to be the names of the default geometry
// attributes
for( size_t i = 0; i < MAX_SHADER_ATTRIBUTE_NAMES; i++ ) {
global_shader_attribute_names[i][SHADER_ATTRIBUTE_VERTEX] = "vertex";
global_shader_attribute_names[i][SHADER_ATTRIBUTE_VERTEX_TEXCOORD] = "vertex_texcoord";
global_shader_attribute_names[i][SHADER_ATTRIBUTE_VERTEX_NORMAL] = "vertex_normal";
global_shader_attribute_names[i][SHADER_ATTRIBUTE_VERTEX_COLOR] = "vertex_color";
}
// - we can set custom attribute name sets like so
global_shader_attribute_names[SHADER_CANVAS_NAMES][SHADER_ATTRIBUTE_INSTANCE_ID] = "instance_id";
global_shader_attribute_names[SHADER_CANVAS_NAMES][SHADER_ATTRIBUTE_PREV_VERTEX] = "prev_vertex";
global_shader_attribute_names[SHADER_CANVAS_NAMES][SHADER_ATTRIBUTE_NEXT_VERTEX] = "next_vertex";
global_shader_attribute_names[SHADER_CANVAS_NAMES][SHADER_ATTRIBUTE_LINE_THICKNESS] = "line_thickness";
global_shader_uniform_names[SHADER_UNIFORM_MVP_MATRIX] = "mvp_matrix";
global_shader_uniform_names[SHADER_UNIFORM_MODEL_MATRIX] = "model_matrix";
global_shader_uniform_names[SHADER_UNIFORM_VIEW_MATRIX] = "view_matrix";
global_shader_uniform_names[SHADER_UNIFORM_PROJECTION_MATRIX] = "projection_matrix";
global_shader_uniform_names[SHADER_UNIFORM_NORMAL_MATRIX] = "normal_matrix";
global_shader_uniform_names[SHADER_UNIFORM_DIFFUSE_LIGHT] = "diffuse_light";
global_shader_uniform_names[SHADER_UNIFORM_AMBIENT_LIGHT] = "ambient_light";
global_shader_uniform_names[SHADER_UNIFORM_SPECULAR_LIGHT] = "specular_light";
global_shader_uniform_names[SHADER_UNIFORM_LIGHT_DIRECTION] = "light_direction";
global_shader_uniform_names[SHADER_UNIFORM_LIGHT_POSITION] = "light_position";
global_shader_uniform_names[SHADER_UNIFORM_LIGHT_ATTENUATION] = "light_attenuation";
global_shader_uniform_names[SHADER_UNIFORM_MATERIAL_SHININESS] = "material_shininess";
global_shader_uniform_names[SHADER_UNIFORM_MATERIAL_COEFFICIENTS] = "material_coefficients";
global_shader_uniform_names[SHADER_UNIFORM_EYE_POSITION] = "eye_position";
global_shader_uniform_names[SHADER_UNIFORM_ASPECT_RATIO] = "aspect_ratio";
global_shader_uniform_names[SHADER_UNIFORM_ENABLE_TEXTURE] = "enable_texture";
global_shader_uniform_names[SHADER_UNIFORM_LINE_ATTENUATION] = "line_attenuation";
global_shader_sampler_names[SHADER_SAMPLER_DIFFUSE_TEXTURE] = "diffuse_texture";
return ret;
}
int
main(int argc, char *argv[])
{
SDL_Window *window; /* main window */
SDL_GLContext context;
//int w, h;
Uint32 startFrame; /* time frame began to process */
Uint32 endFrame; /* time frame ended processing */
Uint32 delay; /* time to pause waiting to draw next frame */
int done; /* should we clean up and exit? */
/* initialize SDL */
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
fatalError("Could not initialize SDL");
}
/* seed the random number generator */
srand(time(NULL));
/*
request some OpenGL parameters
that may speed drawing
*/
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, 0);
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
//SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
/* create main window and renderer */
window = SDL_CreateWindow(NULL, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT,
SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN |
SDL_WINDOW_BORDERLESS);
context = SDL_GL_CreateContext(window);
/* load the particle texture */
initializeTexture();
/* check if GL_POINT_SIZE_ARRAY_OES is supported
this is used to give each particle its own size
*/
pointSizeExtensionSupported = SDL_GL_ExtensionSupported("GL_OES_point_size_array");
/* set up some OpenGL state */
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
SDL_GetWindowSize(window, &screen_w, &screen_h);
glViewport(0, 0, screen_w, screen_h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrthof((GLfloat) 0,
(GLfloat) screen_w,
(GLfloat) screen_h,
(GLfloat) 0, 0.0, 1.0);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glEnable(GL_POINT_SPRITE_OES);
glTexEnvi(GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, 1);
if (pointSizeExtensionSupported) {
/* we use this to set the sizes of all the particles */
glEnableClientState(GL_POINT_SIZE_ARRAY_OES);
} else {
/* if extension not available then all particles have size 10 */
glPointSize(10);
}
done = 0;
/* enter main loop */
while (!done) {
startFrame = SDL_GetTicks();
SDL_Event event;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
done = 1;
}
if (event.type == SDL_MOUSEBUTTONDOWN) {
int x, y;
SDL_GetMouseState(&x, &y);
spawnEmitterParticle(x, y);
}
}
stepParticles();
drawParticles();
SDL_GL_SwapWindow(window);
endFrame = SDL_GetTicks();
/* figure out how much time we have left, and then sleep */
delay = MILLESECONDS_PER_FRAME - (endFrame - startFrame);
if (delay > MILLESECONDS_PER_FRAME) {
delay = MILLESECONDS_PER_FRAME;
}
if (delay > 0) {
SDL_Delay(delay);
}
}
/* delete textures */
glDeleteTextures(1, &particleTextureID);
/* shutdown SDL */
SDL_Quit();
return 0;
}
SDL_Renderer *
GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
GLES_RenderData *data;
GLint value;
Uint32 window_flags;
int profile_mask = 0, major = 0, minor = 0;
SDL_bool changed_window = SDL_FALSE;
SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile_mask);
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major);
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &minor);
window_flags = SDL_GetWindowFlags(window);
if (!(window_flags & SDL_WINDOW_OPENGL) ||
profile_mask != SDL_GL_CONTEXT_PROFILE_ES || major != RENDERER_CONTEXT_MAJOR || minor != RENDERER_CONTEXT_MINOR) {
changed_window = SDL_TRUE;
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR);
if (SDL_RecreateWindow(window, window_flags | SDL_WINDOW_OPENGL) < 0) {
goto error;
}
}
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
goto error;
}
data = (GLES_RenderData *) SDL_calloc(1, sizeof(*data));
if (!data) {
GLES_DestroyRenderer(renderer);
SDL_OutOfMemory();
goto error;
}
renderer->WindowEvent = GLES_WindowEvent;
renderer->GetOutputSize = GLES_GetOutputSize;
renderer->SupportsBlendMode = GLES_SupportsBlendMode;
renderer->CreateTexture = GLES_CreateTexture;
renderer->UpdateTexture = GLES_UpdateTexture;
renderer->LockTexture = GLES_LockTexture;
renderer->UnlockTexture = GLES_UnlockTexture;
renderer->SetRenderTarget = GLES_SetRenderTarget;
renderer->UpdateViewport = GLES_UpdateViewport;
renderer->UpdateClipRect = GLES_UpdateClipRect;
renderer->RenderClear = GLES_RenderClear;
renderer->RenderDrawPoints = GLES_RenderDrawPoints;
renderer->RenderDrawLines = GLES_RenderDrawLines;
renderer->RenderFillRects = GLES_RenderFillRects;
renderer->RenderCopy = GLES_RenderCopy;
renderer->RenderCopyEx = GLES_RenderCopyEx;
renderer->RenderReadPixels = GLES_RenderReadPixels;
renderer->RenderPresent = GLES_RenderPresent;
renderer->DestroyTexture = GLES_DestroyTexture;
renderer->DestroyRenderer = GLES_DestroyRenderer;
renderer->GL_BindTexture = GLES_BindTexture;
renderer->GL_UnbindTexture = GLES_UnbindTexture;
renderer->info = GLES_RenderDriver.info;
renderer->info.flags = SDL_RENDERER_ACCELERATED;
renderer->driverdata = data;
renderer->window = window;
data->context = SDL_GL_CreateContext(window);
if (!data->context) {
GLES_DestroyRenderer(renderer);
goto error;
}
if (SDL_GL_MakeCurrent(window, data->context) < 0) {
GLES_DestroyRenderer(renderer);
goto error;
}
if (GLES_LoadFunctions(data) < 0) {
GLES_DestroyRenderer(renderer);
goto error;
}
if (flags & SDL_RENDERER_PRESENTVSYNC) {
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
if (SDL_GL_GetSwapInterval() > 0) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
value = 0;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value;
value = 0;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_height = value;
/* Android does not report GL_OES_framebuffer_object but the functionality seems to be there anyway */
if (SDL_GL_ExtensionSupported("GL_OES_framebuffer_object") || data->glGenFramebuffersOES) {
data->GL_OES_framebuffer_object_supported = SDL_TRUE;
renderer->info.flags |= SDL_RENDERER_TARGETTEXTURE;
value = 0;
data->glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, &value);
data->window_framebuffer = (GLuint)value;
}
data->framebuffers = NULL;
if (SDL_GL_ExtensionSupported("GL_OES_blend_func_separate")) {
data->GL_OES_blend_func_separate_supported = SDL_TRUE;
}
if (SDL_GL_ExtensionSupported("GL_OES_blend_equation_separate")) {
data->GL_OES_blend_equation_separate_supported = SDL_TRUE;
}
if (SDL_GL_ExtensionSupported("GL_OES_blend_subtract")) {
data->GL_OES_blend_subtract_supported = SDL_TRUE;
}
/* Set up parameters for rendering */
GLES_ResetState(renderer);
return renderer;
error:
if (changed_window) {
/* Uh oh, better try to put it back... */
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile_mask);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, major);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minor);
SDL_RecreateWindow(window, window_flags);
}
return NULL;
}
/*
===============
GLimp_InitExtensions
===============
*/
static void GLimp_InitExtensions( void )
{
if ( !r_allowExtensions->integer )
{
ri.Printf( PRINT_ALL, "* IGNORING OPENGL EXTENSIONS *\n" );
return;
}
ri.Printf( PRINT_ALL, "Initializing OpenGL extensions\n" );
glConfig.textureCompression = TC_NONE;
// GL_EXT_texture_compression_s3tc
if ( SDL_GL_ExtensionSupported( "GL_ARB_texture_compression" ) &&
SDL_GL_ExtensionSupported( "GL_EXT_texture_compression_s3tc" ) )
{
if ( r_ext_compressed_textures->value )
{
glConfig.textureCompression = TC_S3TC_ARB;
ri.Printf( PRINT_ALL, "...using GL_EXT_texture_compression_s3tc\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_compression_s3tc\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_texture_compression_s3tc not found\n" );
}
// GL_S3_s3tc ... legacy extension before GL_EXT_texture_compression_s3tc.
if (glConfig.textureCompression == TC_NONE)
{
if ( SDL_GL_ExtensionSupported( "GL_S3_s3tc" ) )
{
if ( r_ext_compressed_textures->value )
{
glConfig.textureCompression = TC_S3TC;
ri.Printf( PRINT_ALL, "...using GL_S3_s3tc\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_S3_s3tc\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_S3_s3tc not found\n" );
}
}
// GL_EXT_texture_env_add
glConfig.textureEnvAddAvailable = qfalse;
if ( SDL_GL_ExtensionSupported( "EXT_texture_env_add" ) )
{
if ( r_ext_texture_env_add->integer )
{
glConfig.textureEnvAddAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_EXT_texture_env_add\n" );
}
else
{
glConfig.textureEnvAddAvailable = qfalse;
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_env_add\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_texture_env_add not found\n" );
}
// GL_ARB_multitexture
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
if ( SDL_GL_ExtensionSupported( "GL_ARB_multitexture" ) )
{
if ( r_ext_multitexture->value )
{
qglMultiTexCoord2fARB = SDL_GL_GetProcAddress( "glMultiTexCoord2fARB" );
qglActiveTextureARB = SDL_GL_GetProcAddress( "glActiveTextureARB" );
qglClientActiveTextureARB = SDL_GL_GetProcAddress( "glClientActiveTextureARB" );
if ( qglActiveTextureARB )
{
GLint glint = 0;
qglGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &glint );
glConfig.numTextureUnits = (int) glint;
if ( glConfig.numTextureUnits > 1 )
{
ri.Printf( PRINT_ALL, "...using GL_ARB_multitexture\n" );
}
else
{
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
ri.Printf( PRINT_ALL, "...not using GL_ARB_multitexture, < 2 texture units\n" );
}
}
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_multitexture\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_ARB_multitexture not found\n" );
}
// GL_EXT_compiled_vertex_array
if ( SDL_GL_ExtensionSupported( "GL_EXT_compiled_vertex_array" ) )
{
if ( r_ext_compiled_vertex_array->value )
{
ri.Printf( PRINT_ALL, "...using GL_EXT_compiled_vertex_array\n" );
qglLockArraysEXT = ( void ( APIENTRY * )( GLint, GLint ) ) SDL_GL_GetProcAddress( "glLockArraysEXT" );
qglUnlockArraysEXT = ( void ( APIENTRY * )( void ) ) SDL_GL_GetProcAddress( "glUnlockArraysEXT" );
if (!qglLockArraysEXT || !qglUnlockArraysEXT)
{
ri.Error (ERR_FATAL, "bad getprocaddress");
}
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_compiled_vertex_array\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n" );
}
textureFilterAnisotropic = qfalse;
if ( SDL_GL_ExtensionSupported( "GL_EXT_texture_filter_anisotropic" ) )
{
if ( r_ext_texture_filter_anisotropic->integer ) {
qglGetIntegerv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, (GLint *)&maxAnisotropy );
if ( maxAnisotropy <= 0 ) {
ri.Printf( PRINT_ALL, "...GL_EXT_texture_filter_anisotropic not properly supported!\n" );
maxAnisotropy = 0;
}
else
{
ri.Printf( PRINT_ALL, "...using GL_EXT_texture_filter_anisotropic (max: %i)\n", maxAnisotropy );
textureFilterAnisotropic = qtrue;
}
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_filter_anisotropic\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_texture_filter_anisotropic not found\n" );
}
}
