1676 lines
68 KiB
C
1676 lines
68 KiB
C
#include <SDL2/SDL.h>
|
|
#define BITMAP WINDOWS_BITMAP
|
|
#include <SDL2/SDL_opengl.h>
|
|
#if SDL_VERSION_ATLEAST(2, 0, 4)
|
|
#include <SDL2/SDL_opengl_glext.h>
|
|
#endif
|
|
#undef BITMAP
|
|
#include "wx-sdl2-glw.h"
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include "video.h"
|
|
#include "wx-sdl2-video.h"
|
|
#include "wx-sdl2-video-renderer.h"
|
|
#include "ibm.h"
|
|
#include "wx-glslp-parser.h"
|
|
#include "wx-utils.h"
|
|
#include "config.h"
|
|
#include "wx-glsl.h"
|
|
|
|
extern char* get_filename(char*);
|
|
|
|
extern int take_screenshot;
|
|
extern void screenshot_taken(unsigned char* rgb, int width, int height);
|
|
|
|
#define SCALE_SOURCE 0
|
|
#define SCALE_VIEWPORT 1
|
|
#define SCALE_ABSOLUTE 2
|
|
|
|
float gl3_shader_refresh_rate = 0;
|
|
float gl3_input_scale = 1.0f;
|
|
int gl3_input_stretch = FULLSCR_SCALE_FULL;
|
|
char gl3_shader_file[MAX_USER_SHADERS][512];
|
|
|
|
static int max_texture_size;
|
|
|
|
static SDL_GLContext context = NULL;
|
|
static struct shader_texture scene_texture;
|
|
|
|
static glsl_t* active_shader;
|
|
|
|
static glw_t* glw;
|
|
|
|
static GLfloat matrix[] = {
|
|
1, 0, 0, 0,
|
|
0, 1, 0, 0,
|
|
0, 0, 1, 0,
|
|
0, 0, 0, 1
|
|
};
|
|
|
|
|
|
extern int video_scale_mode;
|
|
extern int video_vsync;
|
|
extern int video_focus_dim;
|
|
extern int video_refresh_rate;
|
|
|
|
static int glsl_version[2];
|
|
|
|
const char* vertex_shader_default_tex_src =
|
|
"#version 130\n"
|
|
"\n"
|
|
"in vec4 VertexCoord;\n"
|
|
"in vec2 TexCoord;\n"
|
|
"\n"
|
|
"out vec2 texCoord;\n"
|
|
"\n"
|
|
"void main()\n"
|
|
"{\n"
|
|
" gl_Position = VertexCoord;\n"
|
|
" texCoord = TexCoord;\n"
|
|
"}\n";
|
|
|
|
const char* fragment_shader_default_tex_src =
|
|
"#version 130\n"
|
|
"\n"
|
|
"in vec2 texCoord;\n"
|
|
"uniform sampler2D Texture;\n"
|
|
"\n"
|
|
"out vec4 color;"
|
|
"\n"
|
|
"void main()\n"
|
|
"{\n"
|
|
" color = texture(Texture, texCoord);\n"
|
|
"}\n";
|
|
|
|
const char* vertex_shader_default_color_src =
|
|
"#version 130\n"
|
|
"\n"
|
|
"in vec4 VertexCoord;\n"
|
|
"in vec4 Color;\n"
|
|
"\n"
|
|
"out vec4 color;\n"
|
|
"\n"
|
|
"void main()\n"
|
|
"{\n"
|
|
" gl_Position = VertexCoord;\n"
|
|
" color = Color;\n"
|
|
"}\n";
|
|
|
|
const char* fragment_shader_default_color_src =
|
|
"#version 130\n"
|
|
"\n"
|
|
"in vec4 color;\n"
|
|
"\n"
|
|
"out vec4 outColor;"
|
|
"\n"
|
|
"void main()\n"
|
|
"{\n"
|
|
" outColor = color;\n"
|
|
"}\n";
|
|
|
|
static int next_pow2(unsigned int n)
|
|
{
|
|
n--;
|
|
n |= n >> 1; // Divide by 2^k for consecutive doublings of k up to 32,
|
|
n |= n >> 2; // and then or the results.
|
|
n |= n >> 4;
|
|
n |= n >> 8;
|
|
n |= n >> 16;
|
|
n++;
|
|
|
|
return n;
|
|
}
|
|
|
|
static int compile_shader(GLenum shader_type, const char* prepend, const char* program, int* dst)
|
|
{
|
|
const char* source[3];
|
|
char version[50];
|
|
int ver = 0;
|
|
char *version_loc = strstr(program, "#version");
|
|
if (version_loc)
|
|
ver = (int)strtol(version_loc + 8, (char**)&program, 10);
|
|
else
|
|
{
|
|
ver = glsl_version[0] * 100 + glsl_version[1] * 10;
|
|
if (ver == 300)
|
|
ver = 130;
|
|
else if (ver == 310)
|
|
ver = 140;
|
|
else if (ver == 320)
|
|
ver = 150;
|
|
}
|
|
sprintf(version, "#version %d\n", ver);
|
|
source[0] = version;
|
|
source[1] = prepend ? prepend : "";
|
|
source[2] = program;
|
|
|
|
pclog("GLSL version %d\n", ver);
|
|
|
|
GLuint shader = glw->glCreateShader(shader_type);
|
|
glw->glShaderSource(shader, 3, source, NULL);
|
|
glw->glCompileShader(shader);
|
|
|
|
GLint status = 0;
|
|
glw->glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
|
|
if (!status)
|
|
{
|
|
GLint length;
|
|
glw->glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
|
|
char* log = malloc(length);
|
|
glw->glGetShaderInfoLog(shader, length, &length, log);
|
|
wx_simple_messagebox("GLSL Error", "Could not compile shader:\n%s", log);
|
|
pclog("Could not compile shader: %s\n", log);
|
|
// pclog("Shader: %s\n", program);
|
|
|
|
free(log);
|
|
return 0;
|
|
}
|
|
|
|
*dst = shader;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int create_program(struct shader_program* program)
|
|
{
|
|
GLint status;
|
|
program->id = glw->glCreateProgram();
|
|
glw->glAttachShader(program->id, program->vertex_shader);
|
|
glw->glAttachShader(program->id, program->fragment_shader);
|
|
|
|
glw->glLinkProgram(program->id);
|
|
|
|
glw->glDeleteShader(program->vertex_shader);
|
|
glw->glDeleteShader(program->fragment_shader);
|
|
|
|
program->vertex_shader = program->fragment_shader = 0;
|
|
|
|
glw->glGetProgramiv(program->id, GL_LINK_STATUS, &status);
|
|
|
|
if (!status)
|
|
{
|
|
int maxLength;
|
|
int length;
|
|
glw->glGetProgramiv(program->id, GL_INFO_LOG_LENGTH, &maxLength);
|
|
char* log = malloc(maxLength);
|
|
glw->glGetProgramInfoLog(program->id, maxLength, &length, log);
|
|
wx_simple_messagebox("GLSL Error", "Program not linked:\n%s", log);
|
|
free(log);
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static GLuint get_uniform(GLuint program, const char* name)
|
|
{
|
|
return glw->glGetUniformLocation(program, name);
|
|
}
|
|
|
|
static GLuint get_attrib(GLuint program, const char* name)
|
|
{
|
|
return glw->glGetAttribLocation(program, name);
|
|
}
|
|
|
|
static void find_uniforms(struct glsl_shader* glsl, int num_pass)
|
|
{
|
|
int i;
|
|
char s[50];
|
|
struct shader_pass* pass = &glsl->passes[num_pass];
|
|
int p = pass->program.id;
|
|
glw->glUseProgram(p);
|
|
|
|
struct shader_uniforms* u = &pass->uniforms;
|
|
|
|
u->mvp_matrix = get_uniform(p, "MVPMatrix");
|
|
u->vertex_coord = get_attrib(p, "VertexCoord");
|
|
u->tex_coord = get_attrib(p, "TexCoord");
|
|
u->color = get_attrib(p, "Color");
|
|
|
|
u->frame_count = get_uniform(p, "FrameCount");
|
|
u->frame_direction = get_uniform(p, "FrameDirection");
|
|
|
|
u->texture = get_uniform(p, "Texture");
|
|
u->input_size = get_uniform(p, "InputSize");
|
|
u->texture_size = get_uniform(p, "TextureSize");
|
|
u->output_size = get_uniform(p, "OutputSize");
|
|
|
|
u->orig.texture = get_uniform(p, "OrigTexture");
|
|
u->orig.input_size = get_uniform(p, "OrigInputSize");
|
|
u->orig.texture_size = get_uniform(p, "OrigTextureSize");
|
|
|
|
for (i = 0; i < glsl->num_passes; ++i)
|
|
{
|
|
sprintf(s, "Pass%dTexture", (i+1));
|
|
u->pass[i].texture = get_uniform(p, s);
|
|
sprintf(s, "Pass%dInputSize", (i+1));
|
|
u->pass[i].input_size = get_uniform(p, s);
|
|
sprintf(s, "Pass%dTextureSize", (i+1));
|
|
u->pass[i].texture_size = get_uniform(p, s);
|
|
|
|
sprintf(s, "PassPrev%dTexture", num_pass-i);
|
|
u->prev_pass[i].texture = get_uniform(p, s);
|
|
sprintf(s, "PassPrev%dInputSize", num_pass-i);
|
|
u->prev_pass[i].input_size = get_uniform(p, s);
|
|
sprintf(s, "PassPrev%dTextureSize", num_pass-i);
|
|
u->prev_pass[i].texture_size = get_uniform(p, s);
|
|
}
|
|
|
|
u->prev[0].texture = get_uniform(p, "PrevTexture");
|
|
u->prev[0].tex_coord = get_attrib(p, "PrevTexCoord");
|
|
for (i = 1; i < MAX_PREV; ++i)
|
|
{
|
|
sprintf(s, "Prev%dTexture", i);
|
|
u->prev[i].texture = get_uniform(p, s);
|
|
sprintf(s, "Prev%dTexCoord", i);
|
|
u->prev[i].tex_coord = get_attrib(p, s);
|
|
}
|
|
for (i = 0; i < MAX_PREV; ++i)
|
|
if (u->prev[i].texture >= 0) glsl->has_prev = 1;
|
|
|
|
for (i = 0; i < glsl->num_lut_textures; ++i)
|
|
u->lut_textures[i] = get_uniform(p, glsl->lut_textures[i].name);
|
|
|
|
for (i = 0; i < glsl->num_parameters; ++i)
|
|
u->parameters[i] = get_uniform(p, glsl->parameters[i].id);
|
|
|
|
glw->glUseProgram(0);
|
|
}
|
|
|
|
static void set_scale_mode(char* scale, int* dst)
|
|
{
|
|
if (!strcmp(scale, "viewport"))
|
|
*dst = SCALE_VIEWPORT;
|
|
else if (!strcmp(scale, "absolute"))
|
|
*dst = SCALE_ABSOLUTE;
|
|
else
|
|
*dst = SCALE_SOURCE;
|
|
}
|
|
|
|
static void setup_scale(struct shader* shader, struct shader_pass* pass)
|
|
{
|
|
set_scale_mode(shader->scale_type_x, &pass->scale.mode[0]);
|
|
set_scale_mode(shader->scale_type_y, &pass->scale.mode[1]);
|
|
pass->scale.value[0] = shader->scale_x;
|
|
pass->scale.value[1] = shader->scale_y;
|
|
}
|
|
|
|
static void create_texture(struct shader_texture* tex)
|
|
{
|
|
if (tex->width > max_texture_size)
|
|
tex->width = max_texture_size;
|
|
if (tex->height > max_texture_size)
|
|
tex->height = max_texture_size;
|
|
pclog("Create texture with size %dx%d\n", tex->width, tex->height);
|
|
glGenTextures(1, (GLuint *)&tex->id);
|
|
glBindTexture(GL_TEXTURE_2D, tex->id);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, tex->wrap_mode);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, tex->wrap_mode);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, tex->min_filter);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, tex->mag_filter);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, tex->internal_format, tex->width, tex->height, 0, tex->format, tex->type, tex->data);
|
|
if (tex->mipmap)
|
|
glw->glGenerateMipmap(GL_TEXTURE_2D);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
}
|
|
|
|
static void delete_texture(struct shader_texture* tex)
|
|
{
|
|
if (tex->id > 0)
|
|
glDeleteTextures(1, (GLuint *)&tex->id);
|
|
tex->id = 0;
|
|
}
|
|
|
|
static void delete_fbo(struct shader_fbo* fbo)
|
|
{
|
|
if (fbo->id >= 0)
|
|
{
|
|
glw->glDeleteFramebuffers(1, (GLuint *)&fbo->id);
|
|
delete_texture(&fbo->texture);
|
|
}
|
|
}
|
|
|
|
static void delete_program(struct shader_program* program)
|
|
{
|
|
if (program->vertex_shader) glw->glDeleteShader(program->vertex_shader);
|
|
if (program->fragment_shader) glw->glDeleteShader(program->fragment_shader);
|
|
glw->glDeleteProgram(program->id);
|
|
}
|
|
|
|
static void delete_vbo(struct shader_vbo* vbo)
|
|
{
|
|
if (vbo->color >= 0) glw->glDeleteBuffers(1, (GLuint *)&vbo->color);
|
|
glw->glDeleteBuffers(1, (GLuint *)&vbo->vertex_coord);
|
|
glw->glDeleteBuffers(1, (GLuint *)&vbo->tex_coord);
|
|
}
|
|
|
|
static void delete_pass(struct shader_pass* pass)
|
|
{
|
|
delete_fbo(&pass->fbo);
|
|
delete_vbo(&pass->vbo);
|
|
delete_program(&pass->program);
|
|
glw->glDeleteVertexArrays(1, (GLuint *)&pass->vertex_array);
|
|
}
|
|
|
|
static void delete_prev(struct shader_prev* prev)
|
|
{
|
|
delete_fbo(&prev->fbo);
|
|
delete_vbo(&prev->vbo);
|
|
}
|
|
|
|
static void delete_shader(struct glsl_shader* glsl)
|
|
{
|
|
int i;
|
|
for (i = 0; i < glsl->num_passes; ++i)
|
|
delete_pass(&glsl->passes[i]);
|
|
if (glsl->has_prev)
|
|
{
|
|
delete_pass(&glsl->prev_scene);
|
|
for (i = 0; i < MAX_PREV; ++i)
|
|
delete_prev(&glsl->prev[i]);
|
|
}
|
|
for (i = 0; i < glsl->num_lut_textures; ++i)
|
|
delete_texture(&glsl->lut_textures[i].texture);
|
|
}
|
|
|
|
static void delete_glsl(glsl_t* glsl)
|
|
{
|
|
int i;
|
|
for (i = 0; i < glsl->num_shaders; ++i)
|
|
delete_shader(&glsl->shaders[i]);
|
|
delete_pass(&glsl->scene);
|
|
delete_pass(&glsl->fs_color);
|
|
delete_pass(&glsl->final_pass);
|
|
#ifdef SDL2_SHADER_DEBUG
|
|
delete_pass(&glsl->debug);
|
|
#endif
|
|
}
|
|
|
|
static void create_fbo(struct shader_fbo* fbo)
|
|
{
|
|
create_texture(&fbo->texture);
|
|
|
|
glw->glGenFramebuffers(1, (GLuint *)&fbo->id);
|
|
glw->glBindFramebuffer(GL_FRAMEBUFFER, fbo->id);
|
|
glw->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fbo->texture.id, 0);
|
|
|
|
if (glw->glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
|
|
pclog("Could not create framebuffer!\n");
|
|
|
|
glw->glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
}
|
|
|
|
static void setup_fbo(struct shader* shader, struct shader_fbo* fbo)
|
|
{
|
|
fbo->texture.internal_format = GL_RGBA8;
|
|
fbo->texture.format = GL_RGBA;
|
|
fbo->texture.min_filter = fbo->texture.mag_filter = shader->filter_linear ? GL_LINEAR : GL_NEAREST;
|
|
fbo->texture.width = 1024;
|
|
fbo->texture.height = 1024;
|
|
fbo->texture.type = GL_UNSIGNED_BYTE;
|
|
if (!strcmp(shader->wrap_mode, "repeat"))
|
|
fbo->texture.wrap_mode = GL_REPEAT;
|
|
else if (!strcmp(shader->wrap_mode, "mirrored_repeat"))
|
|
fbo->texture.wrap_mode = GL_MIRRORED_REPEAT;
|
|
else if (!strcmp(shader->wrap_mode, "clamp_to_edge"))
|
|
fbo->texture.wrap_mode = GL_CLAMP_TO_EDGE;
|
|
else
|
|
fbo->texture.wrap_mode = GL_CLAMP_TO_BORDER;
|
|
fbo->srgb = 0;
|
|
if (shader->srgb_framebuffer)
|
|
{
|
|
fbo->texture.internal_format = GL_SRGB8_ALPHA8;
|
|
fbo->srgb = 1;
|
|
}
|
|
else if (shader->float_framebuffer)
|
|
{
|
|
fbo->texture.internal_format = GL_RGBA32F;
|
|
fbo->texture.type = GL_FLOAT;
|
|
}
|
|
|
|
if (fbo->texture.mipmap)
|
|
fbo->texture.min_filter = shader->filter_linear ? GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST;
|
|
|
|
create_fbo(fbo);
|
|
}
|
|
|
|
static void recreate_fbo(struct shader_fbo* fbo, int width, int height)
|
|
{
|
|
if (width != fbo->texture.width || height != fbo->texture.height)
|
|
{
|
|
glw->glDeleteFramebuffers(1, (GLuint *)&fbo->id);
|
|
glDeleteTextures(1, (GLuint *)&fbo->texture.id);
|
|
fbo->texture.width = width;
|
|
fbo->texture.height = height;
|
|
create_fbo(fbo);
|
|
}
|
|
}
|
|
|
|
static int create_default_shader_tex(struct shader_pass* pass)
|
|
{
|
|
if (
|
|
!compile_shader(GL_VERTEX_SHADER, 0, vertex_shader_default_tex_src, &pass->program.vertex_shader) ||
|
|
!compile_shader(GL_FRAGMENT_SHADER, 0, fragment_shader_default_tex_src, &pass->program.fragment_shader) ||
|
|
!create_program(&pass->program))
|
|
return 0;
|
|
glw->glGenVertexArrays(1, (GLuint *)&pass->vertex_array);
|
|
|
|
struct shader_uniforms* u = &pass->uniforms;
|
|
int p = pass->program.id;
|
|
memset(u, -1, sizeof(struct shader_uniforms));
|
|
u->vertex_coord = get_attrib(p, "VertexCoord");
|
|
u->tex_coord = get_attrib(p, "TexCoord");
|
|
u->texture = get_uniform(p, "Texture");
|
|
pass->scale.mode[0] = pass->scale.mode[1] = SCALE_SOURCE;
|
|
pass->scale.value[0] = pass->scale.value[1] = 1.0f;
|
|
pass->fbo.id = -1;
|
|
pass->active = 1;
|
|
return 1;
|
|
}
|
|
|
|
static int create_default_shader_color(struct shader_pass* pass)
|
|
{
|
|
if (
|
|
!compile_shader(GL_VERTEX_SHADER, 0, vertex_shader_default_color_src, &pass->program.vertex_shader) ||
|
|
!compile_shader(GL_FRAGMENT_SHADER, 0, fragment_shader_default_color_src, &pass->program.fragment_shader) ||
|
|
!create_program(&pass->program))
|
|
return 0;
|
|
glw->glGenVertexArrays(1, (GLuint *)&pass->vertex_array);
|
|
|
|
struct shader_uniforms* u = &pass->uniforms;
|
|
int p = pass->program.id;
|
|
memset(u, -1, sizeof(struct shader_uniforms));
|
|
u->vertex_coord = get_attrib(p, "VertexCoord");
|
|
u->color = get_attrib(p, "Color");
|
|
pass->scale.mode[0] = pass->scale.mode[1] = SCALE_SOURCE;
|
|
pass->scale.value[0] = pass->scale.value[1] = 1.0f;
|
|
pass->fbo.id = -1;
|
|
pass->active = 1;
|
|
return 1;
|
|
}
|
|
|
|
/* create the default scene shader */
|
|
static void create_scene_shader()
|
|
{
|
|
struct shader scene_shader_conf;
|
|
memset(&scene_shader_conf, 0, sizeof(struct shader));
|
|
create_default_shader_tex(&active_shader->scene);
|
|
scene_shader_conf.filter_linear = video_scale_mode;
|
|
if (active_shader->num_shaders > 0 && active_shader->shaders[0].input_filter_linear >= 0)
|
|
scene_shader_conf.filter_linear = active_shader->shaders[0].input_filter_linear;
|
|
setup_fbo(&scene_shader_conf, &active_shader->scene.fbo);
|
|
|
|
memset(&scene_shader_conf, 0, sizeof(struct shader));
|
|
create_default_shader_color(&active_shader->fs_color);
|
|
setup_fbo(&scene_shader_conf, &active_shader->fs_color.fbo);
|
|
}
|
|
|
|
static int load_texture(const char* f, struct shader_texture* tex)
|
|
{
|
|
void* img = wx_image_load(f);
|
|
if (!img)
|
|
return 0;
|
|
int width, height;
|
|
wx_image_get_size(img, &width, &height);
|
|
|
|
if (width != next_pow2(width) || height != next_pow2(height))
|
|
wx_image_rescale(img, next_pow2(width), next_pow2(height));
|
|
|
|
wx_image_get_size(img, &width, &height);
|
|
|
|
GLubyte* rgb = wx_image_get_data(img);
|
|
GLubyte* alpha = wx_image_get_alpha(img);
|
|
|
|
int bpp = alpha ? 4 : 3;
|
|
|
|
GLubyte* data = malloc(width*height*bpp);
|
|
|
|
int x, y, Y;
|
|
for (y = 0; y < height; ++y)
|
|
{
|
|
Y = height-y-1;
|
|
for (x = 0; x < width; x++)
|
|
{
|
|
data[(y*width+x)*bpp+0] = rgb[(Y*width+x)*3+0];
|
|
data[(y*width+x)*bpp+1] = rgb[(Y*width+x)*3+1];
|
|
data[(y*width+x)*bpp+2] = rgb[(Y*width+x)*3+2];
|
|
|
|
if (alpha)
|
|
data[(y*width+x)*bpp+3] = alpha[Y*width+x];
|
|
}
|
|
}
|
|
wx_image_free(img);
|
|
|
|
tex->width = width;
|
|
tex->height = height;
|
|
tex->internal_format = alpha ? GL_RGBA8 : GL_RGB8;
|
|
tex->format = alpha ? GL_RGBA : GL_RGB;
|
|
tex->type = GL_UNSIGNED_BYTE;
|
|
tex->data = data;
|
|
return 1;
|
|
}
|
|
|
|
static glsl_t* load_glslp(glsl_t* glsl, int num_shader, const char* f)
|
|
{
|
|
int i, j;
|
|
glslp_t* p = glslp_parse(f);
|
|
|
|
if (p)
|
|
{
|
|
char path[512];
|
|
char file[1024];
|
|
int failed = 0;
|
|
strcpy(path, f);
|
|
char* filename = get_filename(path);
|
|
|
|
struct glsl_shader* gshader = &glsl->shaders[num_shader];
|
|
|
|
strcpy(gshader->name, p->name);
|
|
*filename = 0;
|
|
|
|
gshader->num_lut_textures = p->num_textures;
|
|
|
|
for (i = 0; i < p->num_textures; ++i)
|
|
{
|
|
struct texture* texture = &p->textures[i];
|
|
|
|
sprintf(file, "%s%s", path, texture->path);
|
|
|
|
struct shader_lut_texture* tex = &gshader->lut_textures[i];
|
|
strcpy(tex->name, texture->name);
|
|
|
|
pclog("Load texture %s...\n", file);
|
|
|
|
if (!load_texture(file, &tex->texture))
|
|
{
|
|
wx_simple_messagebox("GLSL Error", "Could not load texture: %s", file);
|
|
pclog("Could not load texture %s!\n", file);
|
|
failed = 1;
|
|
break;
|
|
}
|
|
|
|
if (!strcmp(texture->wrap_mode, "repeat"))
|
|
tex->texture.wrap_mode = GL_REPEAT;
|
|
else if (!strcmp(texture->wrap_mode, "mirrored_repeat"))
|
|
tex->texture.wrap_mode = GL_MIRRORED_REPEAT;
|
|
else if (!strcmp(texture->wrap_mode, "clamp_to_edge"))
|
|
tex->texture.wrap_mode = GL_CLAMP_TO_EDGE;
|
|
else
|
|
tex->texture.wrap_mode = GL_CLAMP_TO_BORDER;
|
|
|
|
tex->texture.mipmap = texture->mipmap;
|
|
|
|
tex->texture.min_filter = tex->texture.mag_filter = texture->linear ? GL_LINEAR : GL_NEAREST;
|
|
if (tex->texture.mipmap)
|
|
tex->texture.min_filter = texture->linear ? GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST;
|
|
|
|
create_texture(&tex->texture);
|
|
free(tex->texture.data);
|
|
tex->texture.data = 0;
|
|
}
|
|
|
|
if (!failed)
|
|
{
|
|
gshader->input_filter_linear = p->input_filter_linear;
|
|
|
|
gshader->num_parameters = p->num_parameters;
|
|
for (j = 0; j < gshader->num_parameters; ++j)
|
|
memcpy(&gshader->parameters[j], &p->parameters[j], sizeof(struct shader_parameter));
|
|
|
|
gshader->num_passes = p->num_shaders;
|
|
|
|
for (i = 0; i < p->num_shaders; ++i)
|
|
{
|
|
struct shader* shader = &p->shaders[i];
|
|
struct shader_pass* pass = &gshader->passes[i];
|
|
|
|
strcpy(pass->alias, shader->alias);
|
|
if (!strlen(pass->alias))
|
|
sprintf(pass->alias, "Pass %u", (i+1));
|
|
|
|
pclog("Creating pass %u (%s)\n", (i+1), pass->alias);
|
|
pclog("Loading shader %s...\n", shader->shader_fn);
|
|
if (!shader->shader_program)
|
|
{
|
|
wx_simple_messagebox("GLSL Error", "Could not load shader: %s", shader->shader_fn);
|
|
pclog("Could not load shader %s\n", shader->shader_fn);
|
|
failed = 1;
|
|
break;
|
|
}
|
|
else
|
|
pclog("Shader %s loaded\n", shader->shader_fn);
|
|
failed =
|
|
!compile_shader(GL_VERTEX_SHADER, "#define VERTEX\n#define PARAMETER_UNIFORM\n", shader->shader_program, &pass->program.vertex_shader) ||
|
|
!compile_shader(GL_FRAGMENT_SHADER, "#define FRAGMENT\n#define PARAMETER_UNIFORM\n", shader->shader_program, &pass->program.fragment_shader);
|
|
if (failed)
|
|
break;
|
|
|
|
if (!create_program(&pass->program))
|
|
{
|
|
failed = 1;
|
|
break;
|
|
}
|
|
pass->frame_count_mod = shader->frame_count_mod;
|
|
pass->fbo.mipmap_input = shader->mipmap_input;
|
|
|
|
glw->glGenVertexArrays(1, (GLuint *)&pass->vertex_array);
|
|
find_uniforms(gshader, i);
|
|
setup_scale(shader, pass);
|
|
if (i == p->num_shaders-1) /* last pass may or may not be an fbo depending on scale */
|
|
{
|
|
if (num_shader == glsl->num_shaders-1)
|
|
{
|
|
pass->fbo.id = -1;
|
|
|
|
for (j = 0; j < 2; ++j)
|
|
{
|
|
if (pass->scale.mode[j] != SCALE_SOURCE || pass->scale.value[j] != 1)
|
|
{
|
|
setup_fbo(shader, &pass->fbo);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* check if next shaders' first pass wants the input mipmapped (will this ever happen?) */
|
|
pass->fbo.texture.mipmap = glsl->shaders[num_shader+1].num_passes > 0 && glsl->shaders[num_shader+1].passes[0].fbo.mipmap_input;
|
|
/* check if next shader wants the output of this pass to be filtered */
|
|
if (glsl->shaders[num_shader+1].num_passes > 0 && glsl->shaders[num_shader+1].input_filter_linear >= 0)
|
|
shader->filter_linear = glsl->shaders[num_shader+1].input_filter_linear;
|
|
setup_fbo(shader, &pass->fbo);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* check if next pass wants the input mipmapped, if so we need to generate mipmaps of this pass */
|
|
pass->fbo.texture.mipmap = (i+1) < p->num_shaders && p->shaders[i+1].mipmap_input;
|
|
setup_fbo(shader, &pass->fbo);
|
|
}
|
|
if (pass->fbo.srgb) glsl->srgb = 1;
|
|
pass->active = 1;
|
|
}
|
|
if (!failed)
|
|
{
|
|
if (gshader->has_prev)
|
|
{
|
|
struct shader scene_shader_conf;
|
|
memset(&scene_shader_conf, 0, sizeof(struct shader));
|
|
for (i = 0; i < MAX_PREV; ++i)
|
|
{
|
|
setup_fbo(&scene_shader_conf, &gshader->prev[i].fbo);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
glslp_free(p);
|
|
|
|
return glsl;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static glsl_t* load_shaders(int num, char shaders[MAX_USER_SHADERS][512])
|
|
{
|
|
int i;
|
|
glsl_t* glsl;
|
|
|
|
glsl = malloc(sizeof(glsl_t));
|
|
memset(glsl, 0, sizeof(glsl_t));
|
|
|
|
glsl->num_shaders = num;
|
|
int failed = 0;
|
|
for (i = num-1; i >= 0; --i)
|
|
{
|
|
const char* f = shaders[i];
|
|
if (f && strlen(f))
|
|
{
|
|
if (!load_glslp(glsl, i, f))
|
|
{
|
|
failed = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
if (failed)
|
|
{
|
|
delete_glsl(glsl);
|
|
memset(glsl, 0, sizeof(glsl_t));
|
|
}
|
|
return glsl;
|
|
}
|
|
|
|
static void read_shader_config()
|
|
{
|
|
char s[512];
|
|
int i, j;
|
|
for (i = 0; i < active_shader->num_shaders; ++i)
|
|
{
|
|
struct glsl_shader* shader = &active_shader->shaders[i];
|
|
char* name = shader->name;
|
|
sprintf(s, "GL3 Shaders - %s", name);
|
|
// shader->shader_refresh_rate = config_get_float(CFG_MACHINE, s, "shader_refresh_rate", -1);
|
|
for (j = 0; j < shader->num_parameters; ++j)
|
|
{
|
|
struct shader_parameter* param = &shader->parameters[j];
|
|
param->value = config_get_float(CFG_MACHINE, s, param->id, param->default_value);
|
|
}
|
|
}
|
|
}
|
|
|
|
int gl3_init(SDL_Window* window, sdl_render_driver requested_render_driver, SDL_Rect screen)
|
|
{
|
|
int i, j;
|
|
|
|
strcpy(current_render_driver_name, requested_render_driver.name);
|
|
|
|
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
|
|
#ifdef __APPLE__
|
|
// without an explicit request for the core profile 3.0 macOS falls back to default ancient 2.1
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
|
|
#endif
|
|
|
|
context = SDL_GL_CreateContext(window);
|
|
|
|
if (!context)
|
|
{
|
|
pclog("Could not create GL context.\n");
|
|
return FALSE;
|
|
}
|
|
|
|
SDL_GL_SetSwapInterval(video_vsync ? 1 : 0);
|
|
|
|
pclog("OpenGL information: [%s] %s (%s)\n", glGetString(GL_VENDOR), glGetString(GL_RENDERER), glGetString(GL_VERSION));
|
|
glsl_version[0] = glsl_version[1] = -1;
|
|
glGetIntegerv(GL_MAJOR_VERSION, &glsl_version[0]);
|
|
glGetIntegerv(GL_MINOR_VERSION, &glsl_version[1]);
|
|
if (glsl_version[0] < 3)
|
|
{
|
|
pclog("OpenGL 3.0 is not available.");
|
|
return SDL_FALSE;
|
|
}
|
|
pclog("Using OpenGL %s\n", glGetString(GL_VERSION));
|
|
pclog("Using Shading Language %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
|
|
|
|
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
|
|
pclog("Max texture size: %dx%d\n", max_texture_size, max_texture_size);
|
|
|
|
//SDL_GL_MakeCurrent(window, context);
|
|
|
|
glw = glw_init();
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
scene_texture.data = NULL;
|
|
scene_texture.width = screen.w;
|
|
scene_texture.height = screen.h;
|
|
scene_texture.internal_format = GL_RGBA8;
|
|
scene_texture.format = GL_RGBA;
|
|
scene_texture.type = GL_UNSIGNED_INT_8_8_8_8_REV;
|
|
scene_texture.wrap_mode = GL_CLAMP_TO_BORDER;
|
|
scene_texture.min_filter = scene_texture.mag_filter = video_scale_mode ? GL_LINEAR : GL_NEAREST;
|
|
scene_texture.mipmap = 0;
|
|
|
|
create_texture(&scene_texture);
|
|
|
|
/* load shader */
|
|
// const char* shaders[1];
|
|
// shaders[0] = gl3_shader_file;
|
|
//
|
|
// active_shader = load_shaders(1, shaders);
|
|
|
|
// const char* shaders[3];
|
|
// shaders[0] = "/home/phantasy/git/glsl-shaders/ntsc/ntsc-320px.glslp";
|
|
// shaders[1] = "/home/phantasy/git/glsl-shaders/motionblur/motionblur-simple.glslp";
|
|
// shaders[2] = "/home/phantasy/git/glsl-shaders/crt/crt-lottes-multipass.glslp";
|
|
//
|
|
// active_shader = load_shaders(3, shaders);
|
|
int num_shaders = 0;
|
|
for (i = 0; i < MAX_USER_SHADERS; ++i)
|
|
{
|
|
if (strlen(gl3_shader_file[i]))
|
|
++num_shaders;
|
|
else
|
|
break;
|
|
}
|
|
active_shader = load_shaders(num_shaders, gl3_shader_file);
|
|
|
|
create_scene_shader();
|
|
|
|
/* read config */
|
|
read_shader_config();
|
|
|
|
/* buffers */
|
|
|
|
GLfloat vertex[] = {
|
|
-1.0f, -1.0f,
|
|
-1.0f, 1.0f,
|
|
1.0f, -1.0f,
|
|
1.0f, 1.0f
|
|
};
|
|
|
|
GLfloat inv_vertex[] = {
|
|
-1.0f, 1.0f,
|
|
-1.0f, -1.0f,
|
|
1.0f, 1.0f,
|
|
1.0f, -1.0f
|
|
};
|
|
|
|
GLfloat tex_coords[] = {
|
|
0.0f, 0.0f,
|
|
0.0f, 1.0f,
|
|
1.0f, 0.0f,
|
|
1.0f, 1.0f
|
|
};
|
|
|
|
|
|
GLfloat colors[] = {
|
|
1.0f, 1.0f, 1.0f, 1.0f,
|
|
1.0f, 1.0f, 1.0f, 1.0f,
|
|
1.0f, 1.0f, 1.0f, 1.0f,
|
|
1.0f, 1.0f, 1.0f, 1.0f
|
|
};
|
|
|
|
|
|
/* set the scene shader buffers */
|
|
{
|
|
glw->glBindVertexArray(active_shader->scene.vertex_array);
|
|
|
|
struct shader_vbo* vbo = &active_shader->scene.vbo;
|
|
|
|
glw->glGenBuffers(1, (GLuint *)&vbo->vertex_coord);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, vbo->vertex_coord);
|
|
glw->glBufferData(GL_ARRAY_BUFFER, sizeof(inv_vertex), inv_vertex, GL_STATIC_DRAW);
|
|
glw->glVertexAttribPointer(active_shader->scene.uniforms.vertex_coord, 2, GL_FLOAT, GL_FALSE, 2*sizeof(GLfloat), (GLvoid*)0);
|
|
|
|
glw->glGenBuffers(1, (GLuint *)&vbo->tex_coord);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, vbo->tex_coord);
|
|
glw->glBufferData(GL_ARRAY_BUFFER, sizeof(tex_coords), tex_coords, GL_DYNAMIC_DRAW);
|
|
glw->glVertexAttribPointer(active_shader->scene.uniforms.tex_coord, 2, GL_FLOAT, GL_TRUE, 2*sizeof(GLfloat), (GLvoid*)0);
|
|
}
|
|
|
|
/* set buffers for all passes */
|
|
for (j = 0; j < active_shader->num_shaders; ++j)
|
|
{
|
|
struct glsl_shader* shader = &active_shader->shaders[j];
|
|
for (i = 0; i < shader->num_passes; ++i)
|
|
{
|
|
struct shader_uniforms* u = &shader->passes[i].uniforms;
|
|
|
|
glw->glBindVertexArray(shader->passes[i].vertex_array);
|
|
|
|
struct shader_vbo* vbo = &shader->passes[i].vbo;
|
|
|
|
glw->glGenBuffers(1, (GLuint *)&vbo->vertex_coord);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, vbo->vertex_coord);
|
|
glw->glBufferData(GL_ARRAY_BUFFER, sizeof(vertex), vertex, GL_STATIC_DRAW);
|
|
|
|
glw->glVertexAttribPointer(u->vertex_coord, 2, GL_FLOAT, GL_FALSE, 2*sizeof(GLfloat), (GLvoid*)0);
|
|
|
|
glw->glGenBuffers(1, (GLuint *)&vbo->tex_coord);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, vbo->tex_coord);
|
|
glw->glBufferData(GL_ARRAY_BUFFER, sizeof(tex_coords), tex_coords, GL_DYNAMIC_DRAW);
|
|
glw->glVertexAttribPointer(u->tex_coord, 2, GL_FLOAT, GL_TRUE, 2*sizeof(GLfloat), (GLvoid*)0);
|
|
|
|
if (u->color)
|
|
{
|
|
glw->glGenBuffers(1, (GLuint *)&vbo->color);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, vbo->color);
|
|
glw->glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW);
|
|
glw->glVertexAttribPointer(u->color, 4, GL_FLOAT, GL_FALSE, 4*sizeof(GLfloat), (GLvoid*)0);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < active_shader->num_shaders; ++i)
|
|
{
|
|
struct glsl_shader* shader = &active_shader->shaders[i];
|
|
if (shader->has_prev)
|
|
{
|
|
struct shader_pass* prev_pass = &shader->prev_scene;
|
|
create_default_shader_tex(prev_pass);
|
|
|
|
struct shader_vbo* vbo = &prev_pass->vbo;
|
|
|
|
glw->glBindVertexArray(prev_pass->vertex_array);
|
|
|
|
glw->glGenBuffers(1, (GLuint *)&vbo->vertex_coord);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, vbo->vertex_coord);
|
|
glw->glBufferData(GL_ARRAY_BUFFER, sizeof(vertex), vertex, GL_STATIC_DRAW);
|
|
glw->glVertexAttribPointer(prev_pass->uniforms.vertex_coord, 2, GL_FLOAT, GL_FALSE, 2*sizeof(GLfloat), (GLvoid*)0);
|
|
|
|
glw->glGenBuffers(1, (GLuint *)&vbo->tex_coord);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, vbo->tex_coord);
|
|
glw->glBufferData(GL_ARRAY_BUFFER, sizeof(tex_coords), tex_coords, GL_DYNAMIC_DRAW);
|
|
glw->glVertexAttribPointer(prev_pass->uniforms.tex_coord, 2, GL_FLOAT, GL_TRUE, 2*sizeof(GLfloat), (GLvoid*)0);
|
|
|
|
for (j = 0; j < MAX_PREV; ++j)
|
|
{
|
|
struct shader_prev* prev = &shader->prev[j];
|
|
struct shader_vbo* prev_vbo = &prev->vbo;
|
|
|
|
glw->glGenBuffers(1, (GLuint *)&prev_vbo->vertex_coord);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, prev_vbo->vertex_coord);
|
|
glw->glBufferData(GL_ARRAY_BUFFER, sizeof(vertex), vertex, GL_STATIC_DRAW);
|
|
|
|
glw->glGenBuffers(1, (GLuint *)&prev_vbo->tex_coord);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, prev_vbo->tex_coord);
|
|
glw->glBufferData(GL_ARRAY_BUFFER, sizeof(tex_coords), tex_coords, GL_DYNAMIC_DRAW);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* create final pass */
|
|
if (active_shader->num_shaders == 0 || active_shader->shaders[active_shader->num_shaders-1].passes[active_shader->shaders[active_shader->num_shaders-1].num_passes-1].fbo.id >= 0)
|
|
{
|
|
struct shader_pass* final_pass = &active_shader->final_pass;
|
|
create_default_shader_tex(final_pass);
|
|
|
|
glw->glBindVertexArray(final_pass->vertex_array);
|
|
|
|
struct shader_vbo* vbo = &final_pass->vbo;
|
|
|
|
glw->glGenBuffers(1, (GLuint *)&vbo->vertex_coord);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, vbo->vertex_coord);
|
|
glw->glBufferData(GL_ARRAY_BUFFER, sizeof(vertex), vertex, GL_STATIC_DRAW);
|
|
glw->glVertexAttribPointer(final_pass->uniforms.vertex_coord, 2, GL_FLOAT, GL_FALSE, 2*sizeof(GLfloat), (GLvoid*)0);
|
|
|
|
glw->glGenBuffers(1, (GLuint *)&vbo->tex_coord);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, vbo->tex_coord);
|
|
glw->glBufferData(GL_ARRAY_BUFFER, sizeof(tex_coords), tex_coords, GL_DYNAMIC_DRAW);
|
|
glw->glVertexAttribPointer(final_pass->uniforms.tex_coord, 2, GL_FLOAT, GL_TRUE, 2*sizeof(GLfloat), (GLvoid*)0);
|
|
}
|
|
|
|
{
|
|
struct shader_pass* color_pass = &active_shader->fs_color;
|
|
create_default_shader_color(color_pass);
|
|
|
|
glw->glBindVertexArray(color_pass->vertex_array);
|
|
|
|
struct shader_vbo* vbo = &color_pass->vbo;
|
|
|
|
glw->glGenBuffers(1, (GLuint *)&vbo->vertex_coord);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, vbo->vertex_coord);
|
|
glw->glBufferData(GL_ARRAY_BUFFER, sizeof(vertex), vertex, GL_STATIC_DRAW);
|
|
glw->glVertexAttribPointer(color_pass->uniforms.vertex_coord, 2, GL_FLOAT, GL_FALSE, 2*sizeof(GLfloat), (GLvoid*)0);
|
|
|
|
glw->glGenBuffers(1, (GLuint *)&vbo->color);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, vbo->color);
|
|
glw->glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_DYNAMIC_DRAW);
|
|
glw->glVertexAttribPointer(color_pass->uniforms.color, 4, GL_FLOAT, GL_TRUE, 4*sizeof(GLfloat), (GLvoid*)0);
|
|
|
|
}
|
|
#ifdef SDL2_SHADER_DEBUG
|
|
struct shader_pass* debug_pass = &active_shader->debug;
|
|
create_default_shader(debug_pass);
|
|
|
|
glBindVertexArray(debug_pass->vertex_array);
|
|
|
|
struct shader_vbo* vbo = &debug_pass->vbo;
|
|
|
|
glGenBuffers(1, &vbo->vertex_coord);
|
|
glBindBuffer(GL_ARRAY_BUFFER, vbo->vertex_coord);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(vertex), vertex, GL_STATIC_DRAW);
|
|
glVertexAttribPointer(debug_pass->uniforms.vertex_coord, 2, GL_FLOAT, GL_FALSE, 2*sizeof(GLfloat), (GLvoid*)0);
|
|
|
|
glGenBuffers(1, &vbo->tex_coord);
|
|
glBindBuffer(GL_ARRAY_BUFFER, vbo->tex_coord);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(tex_coords), tex_coords, GL_DYNAMIC_DRAW);
|
|
glVertexAttribPointer(debug_pass->uniforms.tex_coord, 2, GL_FLOAT, GL_TRUE, 2*sizeof(GLfloat), (GLvoid*)0);
|
|
#endif
|
|
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
glw->glBindVertexArray(0);
|
|
|
|
return SDL_TRUE;
|
|
}
|
|
|
|
void gl3_close()
|
|
{
|
|
if (context)
|
|
{
|
|
delete_texture(&scene_texture);
|
|
|
|
if (active_shader)
|
|
{
|
|
delete_glsl(active_shader);
|
|
free(active_shader);
|
|
}
|
|
active_shader = NULL;
|
|
|
|
SDL_GL_DeleteContext(context);
|
|
context = NULL;
|
|
}
|
|
glw_free(glw);
|
|
}
|
|
|
|
void gl3_update(SDL_Window* window, SDL_Rect updated_rect, BITMAP* screen)
|
|
{
|
|
if (!context)
|
|
return;
|
|
glBindTexture(GL_TEXTURE_2D, scene_texture.id);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, screen->w);
|
|
glTexSubImage2D(GL_TEXTURE_2D, 0, updated_rect.x, updated_rect.y, updated_rect.w, updated_rect.h, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, &((uint32_t*) screen->dat)[updated_rect.y * screen->w + updated_rect.x]);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
}
|
|
|
|
struct render_data {
|
|
int pass;
|
|
struct glsl_shader* shader;
|
|
struct shader_pass* shader_pass;
|
|
GLfloat* output_size;
|
|
struct shader_pass* orig_pass;
|
|
GLint texture;
|
|
int frame_count;
|
|
};
|
|
|
|
static void render_pass(struct render_data* data)
|
|
{
|
|
int i;
|
|
GLuint texture_unit = 0;
|
|
|
|
// pclog("pass %d: %gx%g, %gx%g -> %gx%g, %gx%g, %gx%g\n", num_pass, pass->state.input_size[0], pass->state.input_size[1], pass->state.input_texture_size[0], pass->state.input_texture_size[1], pass->state.output_size[0], pass->state.output_size[1], pass->state.output_texture_size[0], pass->state.output_texture_size[1], output_size[0], output_size[1]);
|
|
|
|
glw->glBindVertexArray(data->shader_pass->vertex_array);
|
|
|
|
GLint p = data->shader_pass->program.id;
|
|
struct shader_uniforms* u = &data->shader_pass->uniforms;
|
|
|
|
glw->glUseProgram(p);
|
|
|
|
if (data->texture)
|
|
{
|
|
glw->glActiveTexture(GL_TEXTURE0 + texture_unit);
|
|
glBindTexture(GL_TEXTURE_2D, data->texture);
|
|
glw->glUniform1i(u->texture, texture_unit);
|
|
texture_unit++;
|
|
}
|
|
|
|
if (u->color >= 0) glw->glEnableVertexAttribArray(u->color);
|
|
|
|
if (u->mvp_matrix >= 0) glw->glUniformMatrix4fv(u->mvp_matrix, 1, 0, matrix);
|
|
if (u->frame_direction >= 0) glw->glUniform1i(u->frame_direction, 1);
|
|
|
|
int framecnt = data->frame_count;
|
|
if (data->shader_pass->frame_count_mod > 0)
|
|
framecnt = framecnt%data->shader_pass->frame_count_mod;
|
|
if (u->frame_count >= 0) glw->glUniform1i(u->frame_count, framecnt);
|
|
|
|
if (u->input_size >= 0) glw->glUniform2fv(u->input_size, 1, data->shader_pass->state.input_size);
|
|
if (u->texture_size >= 0) glw->glUniform2fv(u->texture_size, 1, data->shader_pass->state.input_texture_size);
|
|
if (u->output_size >= 0) glw->glUniform2fv(u->output_size, 1, data->output_size);
|
|
|
|
if (data->shader)
|
|
{
|
|
/* parameters */
|
|
for (i = 0; i < data->shader->num_parameters; ++i)
|
|
if (u->parameters[i] >= 0) glw->glUniform1f(u->parameters[i], data->shader->parameters[i].value);
|
|
|
|
if (data->pass > 0)
|
|
{
|
|
struct shader_pass* passes = data->shader->passes;
|
|
struct shader_pass* orig = data->orig_pass;
|
|
if (u->orig.texture >= 0)
|
|
{
|
|
glw->glActiveTexture(GL_TEXTURE0 + texture_unit);
|
|
glBindTexture(GL_TEXTURE_2D, orig->fbo.texture.id);
|
|
glw->glUniform1i(u->orig.texture, texture_unit);
|
|
texture_unit++;
|
|
}
|
|
if (u->orig.input_size >= 0) glw->glUniform2fv(u->orig.input_size, 1, orig->state.input_size);
|
|
if (u->orig.texture_size >= 0) glw->glUniform2fv(u->orig.texture_size, 1, orig->state.input_texture_size);
|
|
|
|
for (i = 0; i < data->pass; ++i)
|
|
{
|
|
if (u->pass[i].texture >= 0)
|
|
{
|
|
glw->glActiveTexture(GL_TEXTURE0 + texture_unit);
|
|
glBindTexture(GL_TEXTURE_2D, passes[i].fbo.texture.id);
|
|
glw->glUniform1i(u->pass[i].texture, texture_unit);
|
|
texture_unit++;
|
|
}
|
|
if (u->pass[i].texture_size >= 0) glw->glUniform2fv(u->pass[i].texture_size, 1, passes[i].state.input_texture_size);
|
|
if (u->pass[i].input_size >= 0) glw->glUniform2fv(u->pass[i].input_size, 1, passes[i].state.input_size);
|
|
|
|
if (u->prev_pass[i].texture >= 0)
|
|
{
|
|
glw->glActiveTexture(GL_TEXTURE0 + texture_unit);
|
|
glBindTexture(GL_TEXTURE_2D, passes[i].fbo.texture.id);
|
|
glw->glUniform1i(u->prev_pass[i].texture, texture_unit);
|
|
texture_unit++;
|
|
}
|
|
if (u->prev_pass[i].texture_size >= 0) glw->glUniform2fv(u->prev_pass[i].texture_size, 1, passes[i].state.input_texture_size);
|
|
if (u->prev_pass[i].input_size >= 0) glw->glUniform2fv(u->prev_pass[i].input_size, 1, passes[i].state.input_size);
|
|
|
|
}
|
|
}
|
|
|
|
if (data->shader->has_prev)
|
|
{
|
|
/* loop through each previous frame */
|
|
for (i = 0; i < MAX_PREV; ++i)
|
|
{
|
|
if (u->prev[i].texture >= 0)
|
|
{
|
|
glw->glActiveTexture(GL_TEXTURE0 + texture_unit);
|
|
glBindTexture(GL_TEXTURE_2D, data->shader->prev[i].fbo.texture.id);
|
|
glw->glUniform1i(u->prev[i].texture, texture_unit);
|
|
texture_unit++;
|
|
}
|
|
if (u->prev[i].tex_coord >= 0)
|
|
{
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, data->shader->prev[i].vbo.tex_coord);
|
|
glw->glVertexAttribPointer(u->prev[i].tex_coord, 2, GL_FLOAT, GL_TRUE, 2*sizeof(GLfloat), (GLvoid*)0);
|
|
glw->glEnableVertexAttribArray(u->prev[i].tex_coord);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < data->shader->num_lut_textures; ++i)
|
|
{
|
|
if (u->lut_textures[i] >= 0)
|
|
{
|
|
glw->glActiveTexture(GL_TEXTURE0 + texture_unit);
|
|
glBindTexture(GL_TEXTURE_2D, data->shader->lut_textures[i].texture.id);
|
|
glw->glUniform1i(u->lut_textures[i], texture_unit);
|
|
texture_unit++;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
glw->glEnableVertexAttribArray(u->vertex_coord);
|
|
glw->glEnableVertexAttribArray(u->tex_coord);
|
|
|
|
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
|
|
|
|
glw->glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
glw->glDisableVertexAttribArray(data->shader_pass->uniforms.vertex_coord);
|
|
glw->glDisableVertexAttribArray(data->shader_pass->uniforms.tex_coord);
|
|
if (data->shader_pass->uniforms.color >= 0) glw->glDisableVertexAttribArray(data->shader_pass->uniforms.color);
|
|
|
|
if (data->shader && data->shader->has_prev)
|
|
{
|
|
for (i = 0; i < MAX_PREV; ++i)
|
|
{
|
|
if (u->prev[i].tex_coord >= 0)
|
|
glw->glDisableVertexAttribArray(u->prev[i].tex_coord);
|
|
|
|
}
|
|
}
|
|
|
|
glw->glBindVertexArray(0);
|
|
|
|
|
|
glw->glUseProgram(0);
|
|
}
|
|
|
|
void gl3_present(SDL_Window* window, SDL_Rect video_rect, SDL_Rect window_rect, SDL_Rect screen)
|
|
{
|
|
if (!context)
|
|
return;
|
|
|
|
int s, i, j;
|
|
|
|
Uint32 ticks = SDL_GetTicks();
|
|
|
|
GLfloat orig_output_size[] = {
|
|
window_rect.w, window_rect.h
|
|
};
|
|
|
|
if (active_shader->srgb) glEnable(GL_FRAMEBUFFER_SRGB);
|
|
|
|
struct render_data data;
|
|
|
|
/* render scene to texture */
|
|
{
|
|
struct shader_pass* pass = &active_shader->scene;
|
|
|
|
SDL_Rect rect;
|
|
rect.x = rect.y = 0;
|
|
rect.w = video_rect.w*gl3_input_scale;
|
|
rect.h = video_rect.h*gl3_input_scale;
|
|
sdl_scale(gl3_input_stretch, rect, &rect, video_rect.w, video_rect.h);
|
|
|
|
pass->state.input_size[0] = pass->state.output_size[0] = rect.w;
|
|
pass->state.input_size[1] = pass->state.output_size[1] = rect.h;
|
|
|
|
pass->state.input_texture_size[0] = pass->state.output_texture_size[0] = next_pow2(pass->state.output_size[0]);
|
|
pass->state.input_texture_size[1] = pass->state.output_texture_size[1] = next_pow2(pass->state.output_size[1]);
|
|
|
|
recreate_fbo(&active_shader->scene.fbo, pass->state.output_texture_size[0], pass->state.output_texture_size[1]);
|
|
|
|
glw->glBindFramebuffer(GL_FRAMEBUFFER, active_shader->scene.fbo.id);
|
|
glClearColor(0, 0, 0, 1);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
glViewport(0, 0, pass->state.output_size[0], pass->state.output_size[1]);
|
|
|
|
GLfloat minx = 0;
|
|
GLfloat miny = 0;
|
|
GLfloat maxx = pass->state.output_size[0]/(GLfloat)pass->state.output_texture_size[0];
|
|
GLfloat maxy = pass->state.output_size[1]/(GLfloat)pass->state.output_texture_size[1];
|
|
|
|
pass->state.tex_coords[0] = minx;
|
|
pass->state.tex_coords[1] = miny;
|
|
pass->state.tex_coords[2] = minx;
|
|
pass->state.tex_coords[3] = maxy;
|
|
pass->state.tex_coords[4] = maxx;
|
|
pass->state.tex_coords[5] = miny;
|
|
pass->state.tex_coords[6] = maxx;
|
|
pass->state.tex_coords[7] = maxy;
|
|
|
|
// create input tex coords
|
|
minx = video_rect.x/(float)screen.w;
|
|
miny = video_rect.y/(float)screen.h;
|
|
maxx = (video_rect.x+video_rect.w)/(float)screen.w;
|
|
maxy = (video_rect.y+video_rect.h)/(float)screen.h;
|
|
|
|
GLfloat tex_coords[] = {
|
|
minx, miny,
|
|
minx, maxy,
|
|
maxx, miny,
|
|
maxx, maxy
|
|
};
|
|
|
|
glw->glBindVertexArray(pass->vertex_array);
|
|
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, pass->vbo.tex_coord);
|
|
glw->glBufferSubData(GL_ARRAY_BUFFER, 0, 8*sizeof(GLfloat), tex_coords);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
|
|
memset(&data, 0, sizeof(struct render_data));
|
|
data.pass = -1;
|
|
data.shader_pass = &active_shader->scene;
|
|
data.texture = scene_texture.id;
|
|
data.output_size = orig_output_size;
|
|
render_pass(&data);
|
|
|
|
glw->glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
}
|
|
|
|
struct shader_pass* orig = &active_shader->scene;
|
|
struct shader_pass* input = &active_shader->scene;
|
|
|
|
for (s = 0; s < active_shader->num_shaders; ++s)
|
|
{
|
|
struct glsl_shader* shader = &active_shader->shaders[s];
|
|
|
|
// float refresh_rate = shader->shader_refresh_rate;
|
|
// if (refresh_rate < 0)
|
|
// refresh_rate = gl3_shader_refresh_rate;
|
|
float refresh_rate = gl3_shader_refresh_rate;
|
|
if (refresh_rate == 0)
|
|
refresh_rate = video_refresh_rate;
|
|
int frame_count = ticks/(1000.0f/refresh_rate);
|
|
|
|
/* loop through each pass */
|
|
for (i = 0; i < shader->num_passes; ++i)
|
|
{
|
|
struct shader_pass* pass = &shader->passes[i];
|
|
|
|
memcpy(pass->state.input_size, input->state.output_size, 2*sizeof(GLfloat));
|
|
memcpy(pass->state.input_texture_size, input->state.output_texture_size, 2*sizeof(GLfloat));
|
|
|
|
for (j = 0; j < 2; ++j)
|
|
{
|
|
if (pass->scale.mode[j] == SCALE_VIEWPORT)
|
|
pass->state.output_size[j] = orig_output_size[j]*pass->scale.value[j];
|
|
else if (pass->scale.mode[j] == SCALE_ABSOLUTE)
|
|
pass->state.output_size[j] = pass->scale.value[j];
|
|
else
|
|
pass->state.output_size[j] = pass->state.input_size[j]*pass->scale.value[j];
|
|
|
|
pass->state.output_texture_size[j] = next_pow2(pass->state.output_size[j]);
|
|
}
|
|
|
|
if (pass->fbo.id >= 0)
|
|
{
|
|
recreate_fbo(&pass->fbo, pass->state.output_texture_size[0], pass->state.output_texture_size[1]);
|
|
|
|
glw->glBindFramebuffer(GL_FRAMEBUFFER, pass->fbo.id);
|
|
glViewport(0, 0, pass->state.output_size[0], pass->state.output_size[1]);
|
|
}
|
|
else
|
|
glViewport(window_rect.x, window_rect.y, window_rect.w, window_rect.h);
|
|
|
|
glClearColor(0, 0, 0, 1);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
GLfloat minx = 0;
|
|
GLfloat miny = 0;
|
|
GLfloat maxx = pass->state.output_size[0]/(GLfloat)pass->state.output_texture_size[0];
|
|
GLfloat maxy = pass->state.output_size[1]/(GLfloat)pass->state.output_texture_size[1];
|
|
|
|
pass->state.tex_coords[0] = minx;
|
|
pass->state.tex_coords[1] = miny;
|
|
pass->state.tex_coords[2] = minx;
|
|
pass->state.tex_coords[3] = maxy;
|
|
pass->state.tex_coords[4] = maxx;
|
|
pass->state.tex_coords[5] = miny;
|
|
pass->state.tex_coords[6] = maxx;
|
|
pass->state.tex_coords[7] = maxy;
|
|
|
|
glw->glBindVertexArray(pass->vertex_array);
|
|
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, pass->vbo.tex_coord);
|
|
glw->glBufferSubData(GL_ARRAY_BUFFER, 0, 8*sizeof(GLfloat), input->state.tex_coords);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
|
|
memset(&data, 0, sizeof(struct render_data));
|
|
data.shader = shader;
|
|
data.pass = i;
|
|
data.shader_pass = pass;
|
|
data.texture = input->fbo.texture.id;
|
|
data.output_size = orig_output_size;
|
|
data.orig_pass = orig;
|
|
data.frame_count = frame_count;
|
|
|
|
render_pass(&data);
|
|
|
|
glw->glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
|
|
if (pass->fbo.texture.mipmap)
|
|
{
|
|
glw->glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, pass->fbo.texture.id);
|
|
glw->glGenerateMipmap(GL_TEXTURE_2D);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
|
|
}
|
|
|
|
input = pass;
|
|
}
|
|
|
|
if (shader->has_prev && (ticks-shader->last_prev_update) >= (1000.f/refresh_rate))
|
|
{
|
|
shader->last_prev_update = ticks;
|
|
|
|
/* shift array */
|
|
memmove(&shader->prev[1], &shader->prev[0], MAX_PREV*sizeof(struct shader_prev));
|
|
memcpy(&shader->prev[0], &shader->prev[MAX_PREV], sizeof(struct shader_prev));
|
|
|
|
struct shader_pass* pass = orig;
|
|
struct shader_pass* prev_pass = &shader->prev_scene;
|
|
struct shader_prev* prev = &shader->prev[0];
|
|
|
|
memcpy(&prev_pass->state, &pass->state, sizeof(struct shader_state));
|
|
|
|
recreate_fbo(&prev->fbo, prev_pass->state.output_texture_size[0], prev_pass->state.output_texture_size[1]);
|
|
|
|
memcpy(&prev_pass->fbo, &prev->fbo, sizeof(struct shader_fbo));
|
|
|
|
glw->glBindFramebuffer(GL_FRAMEBUFFER, prev->fbo.id);
|
|
glClearColor(0, 0, 0, 1);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
glViewport(0, 0, pass->state.output_size[0], pass->state.output_size[1]);
|
|
|
|
glw->glBindVertexArray(prev_pass->vertex_array);
|
|
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, prev->vbo.tex_coord);
|
|
glw->glBufferSubData(GL_ARRAY_BUFFER, 0, 8*sizeof(GLfloat), pass->state.tex_coords);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, prev_pass->vbo.tex_coord);
|
|
glw->glBufferSubData(GL_ARRAY_BUFFER, 0, 8*sizeof(GLfloat), pass->state.tex_coords);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
|
|
memset(&data, 0, sizeof(struct render_data));
|
|
data.shader = shader;
|
|
data.pass = -10;
|
|
data.shader_pass = prev_pass;
|
|
data.texture = pass->fbo.texture.id;
|
|
data.output_size = orig_output_size;
|
|
|
|
render_pass(&data);
|
|
|
|
glw->glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
}
|
|
|
|
orig = input;
|
|
}
|
|
|
|
if (active_shader->final_pass.active)
|
|
{
|
|
struct shader_pass* pass = &active_shader->final_pass;
|
|
|
|
memcpy(pass->state.input_size, input->state.output_size, 2*sizeof(GLfloat));
|
|
memcpy(pass->state.input_texture_size, input->state.output_texture_size, 2*sizeof(GLfloat));
|
|
|
|
for (j = 0; j < 2; ++j)
|
|
{
|
|
if (pass->scale.mode[j] == SCALE_VIEWPORT)
|
|
pass->state.output_size[j] = orig_output_size[j]*pass->scale.value[j];
|
|
else if (pass->scale.mode[j] == SCALE_ABSOLUTE)
|
|
pass->state.output_size[j] = pass->scale.value[j];
|
|
else
|
|
pass->state.output_size[j] = pass->state.input_size[j]*pass->scale.value[j];
|
|
|
|
pass->state.output_texture_size[j] = next_pow2(pass->state.output_size[j]);
|
|
}
|
|
|
|
glViewport(window_rect.x, window_rect.y, window_rect.w, window_rect.h);
|
|
|
|
glClearColor(0, 0, 0, 1);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
GLfloat minx = 0;
|
|
GLfloat miny = 0;
|
|
GLfloat maxx = pass->state.output_size[0]/(GLfloat)pass->state.output_texture_size[0];
|
|
GLfloat maxy = pass->state.output_size[1]/(GLfloat)pass->state.output_texture_size[1];
|
|
|
|
pass->state.tex_coords[0] = minx;
|
|
pass->state.tex_coords[1] = miny;
|
|
pass->state.tex_coords[2] = minx;
|
|
pass->state.tex_coords[3] = maxy;
|
|
pass->state.tex_coords[4] = maxx;
|
|
pass->state.tex_coords[5] = miny;
|
|
pass->state.tex_coords[6] = maxx;
|
|
pass->state.tex_coords[7] = maxy;
|
|
|
|
glw->glBindVertexArray(pass->vertex_array);
|
|
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, pass->vbo.tex_coord);
|
|
glw->glBufferSubData(GL_ARRAY_BUFFER, 0, 8*sizeof(GLfloat), input->state.tex_coords);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
|
|
memset(&data, 0, sizeof(struct render_data));
|
|
data.pass = -2;
|
|
data.shader_pass = pass;
|
|
data.texture = input->fbo.texture.id;
|
|
data.output_size = orig_output_size;
|
|
data.orig_pass = orig;
|
|
|
|
render_pass(&data);
|
|
}
|
|
|
|
if (!take_screenshot)
|
|
{
|
|
if (video_focus_dim && !(SDL_GetWindowFlags(window)&SDL_WINDOW_INPUT_FOCUS))
|
|
{
|
|
struct shader_pass* pass = &active_shader->fs_color;
|
|
GLfloat r = 0;
|
|
GLfloat g = 0;
|
|
GLfloat b = 0;
|
|
GLfloat a = 0x80/(float)0xff;
|
|
|
|
GLfloat colors[] = {
|
|
r, g, b, a,
|
|
r, g, b, a,
|
|
r, g, b, a,
|
|
r, g, b, a
|
|
};
|
|
|
|
glw->glBindVertexArray(pass->vertex_array);
|
|
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, pass->vbo.color);
|
|
glw->glBufferSubData(GL_ARRAY_BUFFER, 0, 16*sizeof(GLfloat), colors);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
|
|
memset(&data, 0, sizeof(struct render_data));
|
|
data.pass = -3;
|
|
data.shader_pass = pass;
|
|
data.texture = 0;
|
|
data.output_size = orig_output_size;
|
|
data.orig_pass = orig;
|
|
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glEnable(GL_BLEND);
|
|
render_pass(&data);
|
|
glDisable(GL_BLEND);
|
|
}
|
|
if (flash.enabled)
|
|
{
|
|
struct shader_pass* pass = &active_shader->fs_color;
|
|
GLfloat r = (flash.color[0]&0xff)/(float)0xff;
|
|
GLfloat g = (flash.color[1]&0xff)/(float)0xff;
|
|
GLfloat b = (flash.color[2]&0xff)/(float)0xff;
|
|
GLfloat a = (flash.color[3]&0xff)/(float)0xff;
|
|
|
|
GLfloat colors[] = {
|
|
r, g, b, a,
|
|
r, g, b, a,
|
|
r, g, b, a,
|
|
r, g, b, a
|
|
};
|
|
|
|
glw->glBindVertexArray(pass->vertex_array);
|
|
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, pass->vbo.color);
|
|
glw->glBufferSubData(GL_ARRAY_BUFFER, 0, 16*sizeof(GLfloat), colors);
|
|
glw->glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
|
|
memset(&data, 0, sizeof(struct render_data));
|
|
data.pass = -3;
|
|
data.shader_pass = pass;
|
|
data.texture = 0;
|
|
data.output_size = orig_output_size;
|
|
data.orig_pass = orig;
|
|
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glEnable(GL_BLEND);
|
|
render_pass(&data);
|
|
glDisable(GL_BLEND);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
take_screenshot = 0;
|
|
|
|
int width = window_rect.w;
|
|
int height = window_rect.h;
|
|
|
|
SDL_GetWindowSize(window, &width, &height);
|
|
|
|
unsigned char* rgba = (unsigned char*)malloc(width*height*4);
|
|
|
|
glFinish();
|
|
glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, rgba);
|
|
|
|
int x, y;
|
|
unsigned char* rgb = (unsigned char*)malloc(width*height*3);
|
|
|
|
for (x = 0; x < width; ++x)
|
|
{
|
|
for (y = 0; y < height; ++y)
|
|
{
|
|
rgb[(y*width+x)*3+0] = rgba[((height-y-1)*width+x)*4+0];
|
|
rgb[(y*width+x)*3+1] = rgba[((height-y-1)*width+x)*4+1];
|
|
rgb[(y*width+x)*3+2] = rgba[((height-y-1)*width+x)*4+2];
|
|
}
|
|
}
|
|
|
|
screenshot_taken(rgb, width, height);
|
|
|
|
free(rgb);
|
|
free(rgba);
|
|
}
|
|
|
|
// DEBUG: render FBO
|
|
#ifdef SDL2_SHADER_DEBUG
|
|
// GLint texture = scene_texture.id;
|
|
GLint texture = active_shader->lut_textures[0].texture.id;
|
|
// GLint texture = active_shader->scene.fbo.texture;
|
|
|
|
glClearColor(1, 1, 1, 1);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
glViewport(0, 0, orig_output_size[0], orig_output_size[1]);
|
|
|
|
struct shader_pass* pass = &active_shader->debug;
|
|
|
|
render_pass(-999, pass, orig_output_size, texture);
|
|
#endif
|
|
|
|
glDisable(GL_FRAMEBUFFER_SRGB);
|
|
|
|
SDL_GL_SwapWindow(window);
|
|
|
|
}
|
|
|
|
sdl_renderer_t* gl3_renderer_create()
|
|
{
|
|
sdl_renderer_t* renderer = malloc(sizeof(sdl_renderer_t));
|
|
renderer->init = gl3_init;
|
|
renderer->close = gl3_close;
|
|
renderer->update = gl3_update;
|
|
renderer->present = gl3_present;
|
|
renderer->always_update = 1;
|
|
return renderer;
|
|
}
|
|
|
|
void gl3_renderer_close(sdl_renderer_t* renderer)
|
|
{
|
|
free(renderer);
|
|
}
|
|
|
|
static int available = -1;
|
|
|
|
int gl3_renderer_available(struct sdl_render_driver* driver)
|
|
{
|
|
if (available < 0)
|
|
{
|
|
available = 0;
|
|
|
|
// GL SetAttribute should be done *before* window creation for the attributes to apply on
|
|
// context creation (seems to depend on OpenGL impl. but it souldn't hurt other platforms
|
|
// to do it here (earlier than before)
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
|
|
|
|
#ifdef __APPLE__
|
|
// without an explicit request for the core profile 3.0 macOS falls back to default ancient 2.1
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
|
|
#endif
|
|
|
|
SDL_Window* window = SDL_CreateWindow("GL3 test", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 1, 1, SDL_WINDOW_HIDDEN | SDL_WINDOW_OPENGL);
|
|
if (window)
|
|
{
|
|
SDL_GLContext context = SDL_GL_CreateContext(window);
|
|
if (context)
|
|
{
|
|
int version = -1;
|
|
glGetIntegerv(GL_MAJOR_VERSION, &version);
|
|
|
|
SDL_GL_DeleteContext(context);
|
|
|
|
available = version >= 3;
|
|
}
|
|
SDL_DestroyWindow(window);
|
|
}
|
|
|
|
}
|
|
return available;
|
|
}
|