mirror of
https://github.com/libretro/RetroArch.git
synced 2024-12-05 06:57:19 +00:00
1176 lines
33 KiB
C
1176 lines
33 KiB
C
/* SSNES - A Super Nintendo Entertainment System (SNES) Emulator frontend for libsnes.
|
|
* Copyright (C) 2010-2011 - Hans-Kristian Arntzen
|
|
*
|
|
* Some code herein may be based on code found in BSNES.
|
|
*
|
|
* SSNES is free software: you can redistribute it and/or modify it under the terms
|
|
* of the GNU General Public License as published by the Free Software Found-
|
|
* ation, either version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* SSNES is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with SSNES.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
#include "general.h"
|
|
#include "shader_glsl.h"
|
|
#include "strl.h"
|
|
#include "snes_state.h"
|
|
#include "dynamic.h"
|
|
|
|
#ifdef __APPLE__
|
|
#include <OpenGL/gl.h>
|
|
#else
|
|
#define GL_GLEXT_PROTOTYPES
|
|
#include <GL/gl.h>
|
|
#include <GL/glext.h>
|
|
#endif
|
|
|
|
|
|
#define NO_SDL_GLEXT
|
|
#include "SDL.h"
|
|
#include "SDL_opengl.h"
|
|
#include <stdlib.h>
|
|
#include <libxml/parser.h>
|
|
#include <libxml/tree.h>
|
|
|
|
#include "gl_common.h"
|
|
#include "image.h"
|
|
|
|
|
|
#ifdef __APPLE__
|
|
#define pglCreateProgram glCreateProgram
|
|
#define pglUseProgram glUseProgram
|
|
#define pglCreateShader glCreateShader
|
|
#define pglDeleteShader glDeleteShader
|
|
#define pglShaderSource glShaderSource
|
|
#define pglCompileShader glCompileShader
|
|
#define pglAttachShader glAttachShader
|
|
#define pglDetachShader glDetachShader
|
|
#define pglLinkProgram glLinkProgram
|
|
#define pglGetUniformLocation glGetUniformLocation
|
|
#define pglUniform1i glUniform1i
|
|
#define pglUniform2fv glUniform2fv
|
|
#define pglUniform4fv glUniform4fv
|
|
#define pglGetShaderiv glGetShaderiv
|
|
#define pglGetShaderInfoLog glGetShaderInfoLog
|
|
#define pglGetProgramiv glGetProgramiv
|
|
#define pglGetProgramInfoLog glGetProgramInfoLog
|
|
#define pglDeleteProgram glDeleteProgram
|
|
#define pglGetAttachedShaders glGetAttachedShaders
|
|
#define pglGetAttribLocation glGetAttribLocation
|
|
#define pglEnableVertexAttribArray glEnableVertexAttribArray
|
|
#define pglVertexAttribPointer glVertexAttribPointer
|
|
#else
|
|
static PFNGLCREATEPROGRAMPROC pglCreateProgram = NULL;
|
|
static PFNGLUSEPROGRAMPROC pglUseProgram = NULL;
|
|
static PFNGLCREATESHADERPROC pglCreateShader = NULL;
|
|
static PFNGLDELETESHADERPROC pglDeleteShader = NULL;
|
|
static PFNGLSHADERSOURCEPROC pglShaderSource = NULL;
|
|
static PFNGLCOMPILESHADERPROC pglCompileShader = NULL;
|
|
static PFNGLATTACHSHADERPROC pglAttachShader = NULL;
|
|
static PFNGLDETACHSHADERPROC pglDetachShader = NULL;
|
|
static PFNGLLINKPROGRAMPROC pglLinkProgram = NULL;
|
|
static PFNGLGETUNIFORMLOCATIONPROC pglGetUniformLocation = NULL;
|
|
static PFNGLUNIFORM1IPROC pglUniform1i = NULL;
|
|
static PFNGLUNIFORM2FVPROC pglUniform2fv = NULL;
|
|
static PFNGLUNIFORM4FVPROC pglUniform4fv = NULL;
|
|
static PFNGLGETSHADERIVPROC pglGetShaderiv = NULL;
|
|
static PFNGLGETSHADERINFOLOGPROC pglGetShaderInfoLog = NULL;
|
|
static PFNGLGETPROGRAMIVPROC pglGetProgramiv = NULL;
|
|
static PFNGLGETPROGRAMINFOLOGPROC pglGetProgramInfoLog = NULL;
|
|
static PFNGLDELETEPROGRAMPROC pglDeleteProgram = NULL;
|
|
static PFNGLGETATTACHEDSHADERSPROC pglGetAttachedShaders = NULL;
|
|
static PFNGLGETATTRIBLOCATIONPROC pglGetAttribLocation = NULL;
|
|
static PFNGLENABLEVERTEXATTRIBARRAYPROC pglEnableVertexAttribArray = NULL;
|
|
static PFNGLVERTEXATTRIBPOINTERPROC pglVertexAttribPointer = NULL;
|
|
#endif
|
|
|
|
#define MAX_PROGRAMS 16
|
|
#define MAX_TEXTURES 8
|
|
#define MAX_VARIABLES 256
|
|
|
|
enum filter_type
|
|
{
|
|
SSNES_GL_NOFORCE,
|
|
SSNES_GL_LINEAR,
|
|
SSNES_GL_NEAREST
|
|
};
|
|
|
|
static bool glsl_enable = false;
|
|
static GLuint gl_program[MAX_PROGRAMS] = {0};
|
|
static enum filter_type gl_filter_type[MAX_PROGRAMS] = {SSNES_GL_NOFORCE};
|
|
static struct gl_fbo_scale gl_scale[MAX_PROGRAMS];
|
|
static unsigned gl_num_programs = 0;
|
|
static unsigned active_index = 0;
|
|
|
|
static GLuint gl_teximage[MAX_TEXTURES];
|
|
static unsigned gl_teximage_cnt = 0;
|
|
static char gl_teximage_uniforms[MAX_TEXTURES][64];
|
|
|
|
static snes_tracker_t *gl_snes_tracker = NULL;
|
|
static struct snes_tracker_uniform_info gl_tracker_info[MAX_VARIABLES];
|
|
static unsigned gl_tracker_info_cnt = 0;
|
|
static char gl_tracker_script[256];
|
|
static char gl_tracker_script_class[64];
|
|
static xmlChar *gl_script_program = NULL;
|
|
|
|
struct shader_program
|
|
{
|
|
char *vertex;
|
|
char *fragment;
|
|
enum filter_type filter;
|
|
|
|
float scale_x;
|
|
float scale_y;
|
|
unsigned abs_x;
|
|
unsigned abs_y;
|
|
enum gl_scale_type type_x;
|
|
enum gl_scale_type type_y;
|
|
|
|
bool valid_scale;
|
|
};
|
|
|
|
static bool get_xml_attrs(struct shader_program *prog, xmlNodePtr ptr)
|
|
{
|
|
prog->scale_x = 1.0;
|
|
prog->scale_y = 1.0;
|
|
prog->type_x = prog->type_y = SSNES_SCALE_INPUT;
|
|
prog->valid_scale = false;
|
|
|
|
// Check if shader forces a certain texture filtering.
|
|
xmlChar *attr = xmlGetProp(ptr, (const xmlChar*)"filter");
|
|
if (attr)
|
|
{
|
|
if (strcmp((const char*)attr, "nearest") == 0)
|
|
{
|
|
prog->filter = SSNES_GL_NEAREST;
|
|
SSNES_LOG("XML: Shader forces GL_NEAREST.\n");
|
|
}
|
|
else if (strcmp((const char*)attr, "linear") == 0)
|
|
{
|
|
prog->filter = SSNES_GL_LINEAR;
|
|
SSNES_LOG("XML: Shader forces GL_LINEAR.\n");
|
|
}
|
|
else
|
|
SSNES_WARN("XML: Invalid property for filter.\n");
|
|
|
|
xmlFree(attr);
|
|
}
|
|
else
|
|
prog->filter = SSNES_GL_NOFORCE;
|
|
|
|
// Check for scaling attributes *lots of code <_<*
|
|
xmlChar *attr_scale = xmlGetProp(ptr, (const xmlChar*)"scale");
|
|
xmlChar *attr_scale_x = xmlGetProp(ptr, (const xmlChar*)"scale_x");
|
|
xmlChar *attr_scale_y = xmlGetProp(ptr, (const xmlChar*)"scale_y");
|
|
xmlChar *attr_size = xmlGetProp(ptr, (const xmlChar*)"size");
|
|
xmlChar *attr_size_x = xmlGetProp(ptr, (const xmlChar*)"size_x");
|
|
xmlChar *attr_size_y = xmlGetProp(ptr, (const xmlChar*)"size_y");
|
|
xmlChar *attr_outscale = xmlGetProp(ptr, (const xmlChar*)"outscale");
|
|
xmlChar *attr_outscale_x = xmlGetProp(ptr, (const xmlChar*)"outscale_x");
|
|
xmlChar *attr_outscale_y = xmlGetProp(ptr, (const xmlChar*)"outscale_y");
|
|
|
|
unsigned x_attr_cnt = 0, y_attr_cnt = 0;
|
|
|
|
if (attr_scale)
|
|
{
|
|
float scale = strtod((const char*)attr_scale, NULL);
|
|
prog->scale_x = scale;
|
|
prog->scale_y = scale;
|
|
prog->valid_scale = true;
|
|
prog->type_x = prog->type_y = SSNES_SCALE_INPUT;
|
|
SSNES_LOG("Got scale attr: %.1f\n", scale);
|
|
x_attr_cnt++;
|
|
y_attr_cnt++;
|
|
}
|
|
|
|
if (attr_scale_x)
|
|
{
|
|
float scale = strtod((const char*)attr_scale_x, NULL);
|
|
prog->scale_x = scale;
|
|
prog->valid_scale = true;
|
|
prog->type_x = SSNES_SCALE_INPUT;
|
|
SSNES_LOG("Got scale_x attr: %.1f\n", scale);
|
|
x_attr_cnt++;
|
|
}
|
|
|
|
if (attr_scale_y)
|
|
{
|
|
float scale = strtod((const char*)attr_scale_y, NULL);
|
|
prog->scale_y = scale;
|
|
prog->valid_scale = true;
|
|
prog->type_y = SSNES_SCALE_INPUT;
|
|
SSNES_LOG("Got scale_y attr: %.1f\n", scale);
|
|
y_attr_cnt++;
|
|
}
|
|
|
|
if (attr_size)
|
|
{
|
|
prog->abs_x = prog->abs_y = strtoul((const char*)attr_size, NULL, 0);
|
|
prog->valid_scale = true;
|
|
prog->type_x = prog->type_y = SSNES_SCALE_ABSOLUTE;
|
|
SSNES_LOG("Got size attr: %u\n", prog->abs_x);
|
|
x_attr_cnt++;
|
|
y_attr_cnt++;
|
|
}
|
|
|
|
if (attr_size_x)
|
|
{
|
|
prog->abs_x = strtoul((const char*)attr_size_x, NULL, 0);
|
|
prog->valid_scale = true;
|
|
prog->type_x = SSNES_SCALE_ABSOLUTE;
|
|
SSNES_LOG("Got size_x attr: %u\n", prog->abs_x);
|
|
x_attr_cnt++;
|
|
}
|
|
|
|
if (attr_size_y)
|
|
{
|
|
prog->abs_y = strtoul((const char*)attr_size_y, NULL, 0);
|
|
prog->valid_scale = true;
|
|
prog->type_y = SSNES_SCALE_ABSOLUTE;
|
|
SSNES_LOG("Got size_y attr: %u\n", prog->abs_y);
|
|
y_attr_cnt++;
|
|
}
|
|
|
|
if (attr_outscale)
|
|
{
|
|
float scale = strtod((const char*)attr_outscale, NULL);
|
|
prog->scale_x = scale;
|
|
prog->scale_y = scale;
|
|
prog->valid_scale = true;
|
|
prog->type_x = prog->type_y = SSNES_SCALE_VIEWPORT;
|
|
SSNES_LOG("Got outscale attr: %.1f\n", scale);
|
|
x_attr_cnt++;
|
|
y_attr_cnt++;
|
|
}
|
|
|
|
if (attr_outscale_x)
|
|
{
|
|
float scale = strtod((const char*)attr_outscale_x, NULL);
|
|
prog->scale_x = scale;
|
|
prog->valid_scale = true;
|
|
prog->type_x = SSNES_SCALE_VIEWPORT;
|
|
SSNES_LOG("Got outscale_x attr: %.1f\n", scale);
|
|
x_attr_cnt++;
|
|
}
|
|
|
|
if (attr_outscale_y)
|
|
{
|
|
float scale = strtod((const char*)attr_outscale_y, NULL);
|
|
prog->scale_y = scale;
|
|
prog->valid_scale = true;
|
|
prog->type_y = SSNES_SCALE_VIEWPORT;
|
|
SSNES_LOG("Got outscale_y attr: %.1f\n", scale);
|
|
y_attr_cnt++;
|
|
}
|
|
|
|
if (attr_scale)
|
|
xmlFree(attr_scale);
|
|
if (attr_scale_x)
|
|
xmlFree(attr_scale_x);
|
|
if (attr_scale_y)
|
|
xmlFree(attr_scale_y);
|
|
if (attr_size)
|
|
xmlFree(attr_size);
|
|
if (attr_size_x)
|
|
xmlFree(attr_size_x);
|
|
if (attr_size_y)
|
|
xmlFree(attr_size_y);
|
|
if (attr_outscale)
|
|
xmlFree(attr_outscale);
|
|
if (attr_outscale_x)
|
|
xmlFree(attr_outscale_x);
|
|
if (attr_outscale_y)
|
|
xmlFree(attr_outscale_y);
|
|
|
|
if (x_attr_cnt > 1)
|
|
return false;
|
|
if (y_attr_cnt > 1)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool get_texture_image(const char *shader_path, xmlNodePtr ptr)
|
|
{
|
|
if (gl_teximage_cnt >= MAX_TEXTURES)
|
|
{
|
|
SSNES_WARN("Too many texture images! Ignoring ...\n");
|
|
return true;
|
|
}
|
|
|
|
bool linear = true;
|
|
xmlChar *filename = xmlGetProp(ptr, (const xmlChar*)"file");
|
|
xmlChar *filter = xmlGetProp(ptr, (const xmlChar*)"filter");
|
|
xmlChar *id = xmlGetProp(ptr, (const xmlChar*)"id");
|
|
|
|
if (!id)
|
|
{
|
|
SSNES_ERR("Could not find ID in texture.\n");
|
|
goto error;
|
|
}
|
|
|
|
if (!filename)
|
|
{
|
|
SSNES_ERR("Could not find filename in texture.\n");
|
|
goto error;
|
|
}
|
|
|
|
if (filter && strcmp((const char*)filter, "nearest") == 0)
|
|
linear = false;
|
|
|
|
char tex_path[256];
|
|
strlcpy(tex_path, shader_path, sizeof(tex_path));
|
|
|
|
char *last = strrchr(tex_path, '/');
|
|
if (!last) last = strrchr(tex_path, '\\');
|
|
if (last) last[1] = '\0';
|
|
|
|
strlcat(tex_path, (const char*)filename, sizeof(tex_path));
|
|
|
|
struct texture_image img;
|
|
SSNES_LOG("Loading texture image from: \"%s\" ...\n", tex_path);
|
|
if (!texture_image_load(tex_path, &img))
|
|
{
|
|
SSNES_ERR("Failed to load texture image from: \"%s\"\n", tex_path);
|
|
goto error;
|
|
}
|
|
|
|
strlcpy(gl_teximage_uniforms[gl_teximage_cnt], (const char*)id, sizeof(gl_teximage_uniforms[0]));
|
|
|
|
glGenTextures(1, &gl_teximage[gl_teximage_cnt]);
|
|
|
|
pglActiveTexture(GL_TEXTURE0 + gl_teximage_cnt + 1);
|
|
glBindTexture(GL_TEXTURE_2D, gl_teximage[gl_teximage_cnt]);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, linear ? GL_LINEAR : GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, linear ? GL_LINEAR : GL_NEAREST);
|
|
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, img.width);
|
|
glTexImage2D(GL_TEXTURE_2D,
|
|
0, GL_RGBA, img.width, img.height, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, img.pixels);
|
|
|
|
pglActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
free(img.pixels);
|
|
|
|
xmlFree(filename);
|
|
xmlFree(id);
|
|
if (filter)
|
|
xmlFree(filter);
|
|
|
|
gl_teximage_cnt++;
|
|
|
|
return true;
|
|
|
|
error:
|
|
if (filename)
|
|
xmlFree(filename);
|
|
if (filter)
|
|
xmlFree(filter);
|
|
if (filter)
|
|
xmlFree(id);
|
|
return false;
|
|
}
|
|
|
|
#ifdef HAVE_PYTHON
|
|
static bool get_script(const char *path, xmlNodePtr ptr)
|
|
{
|
|
if (*gl_tracker_script || gl_script_program)
|
|
{
|
|
SSNES_ERR("Script already imported.\n");
|
|
return false;
|
|
}
|
|
|
|
xmlChar *script_class = xmlGetProp(ptr, (const xmlChar*)"class");
|
|
if (script_class)
|
|
{
|
|
strlcpy(gl_tracker_script_class, (const char*)script_class, sizeof(gl_tracker_script_class));
|
|
xmlFree(script_class);
|
|
}
|
|
|
|
xmlChar *language = xmlGetProp(ptr, (const xmlChar*)"language");
|
|
if (!language || strcmp((const char*)language, "python") != 0)
|
|
{
|
|
SSNES_ERR("Script language is not Python!\n");
|
|
if (language)
|
|
xmlFree(language);
|
|
return false;
|
|
}
|
|
|
|
if (language)
|
|
xmlFree(language);
|
|
|
|
xmlChar *src = xmlGetProp(ptr, (const xmlChar*)"src");
|
|
if (src)
|
|
{
|
|
strlcpy(gl_tracker_script, path, sizeof(gl_tracker_script));
|
|
char *dir_ptr = strrchr(gl_tracker_script, '/');
|
|
if (!dir_ptr) dir_ptr = strrchr(gl_tracker_script, '\\');
|
|
if (dir_ptr) dir_ptr[1] = '\0';
|
|
strlcat(gl_tracker_script, (const char*)src, sizeof(gl_tracker_script));
|
|
|
|
xmlFree(src);
|
|
}
|
|
else
|
|
{
|
|
xmlChar *script = xmlNodeGetContent(ptr);
|
|
if (!script)
|
|
{
|
|
SSNES_ERR("No content in script!\n");
|
|
return false;
|
|
}
|
|
gl_script_program = script;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
static bool get_import_value(xmlNodePtr ptr)
|
|
{
|
|
if (gl_tracker_info_cnt >= MAX_VARIABLES)
|
|
{
|
|
SSNES_ERR("Too many import variables ...\n");
|
|
return false;
|
|
}
|
|
|
|
xmlChar *id = xmlGetProp(ptr, (const xmlChar*)"id");
|
|
xmlChar *semantic = xmlGetProp(ptr, (const xmlChar*)"semantic");
|
|
xmlChar *wram = xmlGetProp(ptr, (const xmlChar*)"wram");
|
|
xmlChar *input = xmlGetProp(ptr, (const xmlChar*)"input_slot");
|
|
xmlChar *apuram = xmlGetProp(ptr, (const xmlChar*)"apuram");
|
|
xmlChar *vram = xmlGetProp(ptr, (const xmlChar*)"vram");
|
|
xmlChar *oam = xmlGetProp(ptr, (const xmlChar*)"oam");
|
|
xmlChar *cgram = xmlGetProp(ptr, (const xmlChar*)"cgram");
|
|
xmlChar *bitmask = xmlGetProp(ptr, (const xmlChar*)"mask");
|
|
|
|
if (!semantic || !id)
|
|
{
|
|
SSNES_ERR("No semantic or ID for import value!\n");
|
|
goto error;
|
|
}
|
|
|
|
enum snes_tracker_type tracker_type;
|
|
|
|
if (strcmp((const char*)semantic, "capture") == 0)
|
|
tracker_type = SSNES_STATE_CAPTURE;
|
|
else if (strcmp((const char*)semantic, "capture_previous") == 0)
|
|
tracker_type = SSNES_STATE_CAPTURE_PREV;
|
|
else if (strcmp((const char*)semantic, "transition") == 0)
|
|
tracker_type = SSNES_STATE_TRANSITION;
|
|
else if (strcmp((const char*)semantic, "transition_count") == 0)
|
|
tracker_type = SSNES_STATE_TRANSITION_COUNT;
|
|
else if (strcmp((const char*)semantic, "transition_previous") == 0)
|
|
tracker_type = SSNES_STATE_TRANSITION_PREV;
|
|
#ifdef HAVE_PYTHON
|
|
else if (strcmp((const char*)semantic, "python") == 0)
|
|
tracker_type = SSNES_STATE_PYTHON;
|
|
#endif
|
|
else
|
|
{
|
|
SSNES_ERR("Invalid semantic for import value.\n");
|
|
goto error;
|
|
}
|
|
|
|
enum snes_ram_type ram_type = SSNES_STATE_WRAM;
|
|
uint32_t addr = 0;
|
|
|
|
#ifdef HAVE_PYTHON
|
|
if (tracker_type != SSNES_STATE_PYTHON)
|
|
{
|
|
#endif
|
|
if (input)
|
|
{
|
|
unsigned slot = strtoul((const char*)input, NULL, 0);
|
|
switch (slot)
|
|
{
|
|
case 1:
|
|
ram_type = SSNES_STATE_INPUT_SLOT1;
|
|
break;
|
|
case 2:
|
|
ram_type = SSNES_STATE_INPUT_SLOT2;
|
|
break;
|
|
|
|
default:
|
|
SSNES_ERR("Invalid input slot for import!\n");
|
|
goto error;
|
|
}
|
|
}
|
|
else if (wram) { addr = strtoul((const char*)wram, NULL, 16); ram_type = SSNES_STATE_WRAM; }
|
|
else if (apuram) { addr = strtoul((const char*)apuram, NULL, 16); ram_type = SSNES_STATE_APURAM; }
|
|
else if (vram) { addr = strtoul((const char*)vram, NULL, 16); ram_type = SSNES_STATE_VRAM; }
|
|
else if (oam) { addr = strtoul((const char*)oam, NULL, 16); ram_type = SSNES_STATE_OAM; }
|
|
else if (cgram) { addr = strtoul((const char*)cgram, NULL, 16); ram_type = SSNES_STATE_CGRAM; }
|
|
else
|
|
{
|
|
SSNES_ERR("No RAM address specificed for import value.\n");
|
|
goto error;
|
|
}
|
|
#ifdef HAVE_PYTHON
|
|
}
|
|
#endif
|
|
|
|
int memtype = 0;
|
|
switch (ram_type)
|
|
{
|
|
case SSNES_STATE_WRAM:
|
|
memtype = SNES_MEMORY_WRAM;
|
|
break;
|
|
case SSNES_STATE_APURAM:
|
|
memtype = SNES_MEMORY_APURAM;
|
|
break;
|
|
case SSNES_STATE_VRAM:
|
|
memtype = SNES_MEMORY_VRAM;
|
|
break;
|
|
case SSNES_STATE_OAM:
|
|
memtype = SNES_MEMORY_OAM;
|
|
break;
|
|
case SSNES_STATE_CGRAM:
|
|
memtype = SNES_MEMORY_CGRAM;
|
|
break;
|
|
|
|
default:
|
|
memtype = SNES_MEMORY_WRAM;
|
|
}
|
|
|
|
if (addr >= psnes_get_memory_size(memtype))
|
|
{
|
|
SSNES_ERR("Address out of bounds.\n");
|
|
goto error;
|
|
}
|
|
|
|
unsigned mask_value = 0;
|
|
if (bitmask)
|
|
mask_value = strtoul((const char*)bitmask, NULL, 16);
|
|
|
|
strlcpy(gl_tracker_info[gl_tracker_info_cnt].id, (const char*)id, sizeof(gl_tracker_info[0].id));
|
|
gl_tracker_info[gl_tracker_info_cnt].addr = addr;
|
|
gl_tracker_info[gl_tracker_info_cnt].type = tracker_type;
|
|
gl_tracker_info[gl_tracker_info_cnt].ram_type = ram_type;
|
|
gl_tracker_info[gl_tracker_info_cnt].mask = mask_value;
|
|
gl_tracker_info_cnt++;
|
|
|
|
if (id) xmlFree(id);
|
|
if (semantic) xmlFree(semantic);
|
|
if (wram) xmlFree(wram);
|
|
if (input) xmlFree(input);
|
|
if (apuram) xmlFree(apuram);
|
|
if (vram) xmlFree(vram);
|
|
if (oam) xmlFree(oam);
|
|
if (cgram) xmlFree(cgram);
|
|
if (bitmask) xmlFree(bitmask);
|
|
return true;
|
|
|
|
error:
|
|
if (id) xmlFree(id);
|
|
if (semantic) xmlFree(semantic);
|
|
if (wram) xmlFree(wram);
|
|
if (input) xmlFree(input);
|
|
if (apuram) xmlFree(apuram);
|
|
if (vram) xmlFree(vram);
|
|
if (oam) xmlFree(oam);
|
|
if (cgram) xmlFree(cgram);
|
|
if (bitmask) xmlFree(bitmask);
|
|
return false;
|
|
}
|
|
|
|
static unsigned get_xml_shaders(const char *path, struct shader_program *prog, size_t size)
|
|
{
|
|
LIBXML_TEST_VERSION;
|
|
|
|
xmlParserCtxtPtr ctx = xmlNewParserCtxt();
|
|
if (!ctx)
|
|
{
|
|
SSNES_ERR("Failed to load libxml2 context.\n");
|
|
return false;
|
|
}
|
|
|
|
SSNES_LOG("Loading XML shader: %s\n", path);
|
|
xmlDocPtr doc = xmlCtxtReadFile(ctx, path, NULL, 0);
|
|
if (!doc)
|
|
{
|
|
SSNES_ERR("Failed to parse XML file: %s\n", path);
|
|
goto error;
|
|
}
|
|
|
|
if (ctx->valid == 0)
|
|
{
|
|
SSNES_ERR("Cannot validate XML shader: %s\n", path);
|
|
goto error;
|
|
}
|
|
|
|
xmlNodePtr head = xmlDocGetRootElement(doc);
|
|
xmlNodePtr cur = NULL;
|
|
for (cur = head; cur; cur = cur->next)
|
|
{
|
|
if (cur->type == XML_ELEMENT_NODE && strcmp((const char*)cur->name, "shader") == 0)
|
|
{
|
|
xmlChar *attr;
|
|
attr = xmlGetProp(cur, (const xmlChar*)"language");
|
|
if (attr && strcmp((const char*)attr, "GLSL") == 0)
|
|
{
|
|
xmlFree(attr);
|
|
break;
|
|
}
|
|
|
|
if (attr)
|
|
xmlFree(attr);
|
|
}
|
|
}
|
|
|
|
if (!cur) // We couldn't find any GLSL shader :(
|
|
goto error;
|
|
|
|
unsigned num = 0;
|
|
memset(prog, 0, sizeof(struct shader_program) * size);
|
|
|
|
// Iterate to check if we find fragment and/or vertex shaders.
|
|
for (cur = cur->children; cur && num < size; cur = cur->next)
|
|
{
|
|
if (cur->type != XML_ELEMENT_NODE)
|
|
continue;
|
|
|
|
xmlChar *content = xmlNodeGetContent(cur);
|
|
if (!content)
|
|
continue;
|
|
|
|
if (strcmp((const char*)cur->name, "vertex") == 0)
|
|
{
|
|
if (prog[num].vertex)
|
|
{
|
|
SSNES_ERR("Cannot have more than one vertex shader in a program.\n");
|
|
xmlFree(content);
|
|
goto error;
|
|
}
|
|
|
|
prog[num].vertex = (char*)content;
|
|
}
|
|
else if (strcmp((const char*)cur->name, "fragment") == 0)
|
|
{
|
|
prog[num].fragment = (char*)content;
|
|
if (!get_xml_attrs(&prog[num], cur))
|
|
{
|
|
SSNES_ERR("XML shader attributes do not comply with specifications.\n");
|
|
goto error;
|
|
}
|
|
num++;
|
|
}
|
|
else if (strcmp((const char*)cur->name, "texture") == 0)
|
|
{
|
|
if (!get_texture_image(path, cur))
|
|
{
|
|
SSNES_ERR("Texture image failed to load.\n");
|
|
goto error;
|
|
}
|
|
}
|
|
else if (strcmp((const char*)cur->name, "import") == 0)
|
|
{
|
|
if (!get_import_value(cur))
|
|
{
|
|
SSNES_ERR("Import value is invalid.\n");
|
|
goto error;
|
|
}
|
|
}
|
|
#ifdef HAVE_PYTHON
|
|
else if (strcmp((const char*)cur->name, "script") == 0)
|
|
{
|
|
if (!get_script(path, cur))
|
|
{
|
|
SSNES_ERR("Script is invalid.\n");
|
|
goto error;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if (num == 0)
|
|
{
|
|
SSNES_ERR("Couldn't find vertex shader nor fragment shader in XML file.\n");
|
|
goto error;
|
|
}
|
|
|
|
xmlFreeDoc(doc);
|
|
xmlFreeParserCtxt(ctx);
|
|
return num;
|
|
|
|
error:
|
|
SSNES_ERR("Failed to load XML shader ...\n");
|
|
if (doc)
|
|
xmlFreeDoc(doc);
|
|
xmlFreeParserCtxt(ctx);
|
|
return 0;
|
|
}
|
|
|
|
static void print_shader_log(GLuint obj)
|
|
{
|
|
int info_len = 0;
|
|
int max_len;
|
|
|
|
pglGetShaderiv(obj, GL_INFO_LOG_LENGTH, &max_len);
|
|
|
|
char info_log[max_len];
|
|
pglGetShaderInfoLog(obj, max_len, &info_len, info_log);
|
|
|
|
if (info_len > 0)
|
|
SSNES_LOG("Shader log: %s\n", info_log);
|
|
}
|
|
|
|
static void print_linker_log(GLuint obj)
|
|
{
|
|
int info_len = 0;
|
|
int max_len;
|
|
|
|
pglGetProgramiv(obj, GL_INFO_LOG_LENGTH, &max_len);
|
|
|
|
char info_log[max_len];
|
|
pglGetProgramInfoLog(obj, max_len, &info_len, info_log);
|
|
|
|
if (info_len > 0)
|
|
SSNES_LOG("Linker log: %s\n", info_log);
|
|
}
|
|
|
|
static bool compile_shader(GLuint shader, const char *program)
|
|
{
|
|
pglShaderSource(shader, 1, &program, 0);
|
|
pglCompileShader(shader);
|
|
|
|
GLint status;
|
|
pglGetShaderiv(shader, GL_COMPILE_STATUS, &status);
|
|
print_shader_log(shader);
|
|
|
|
return status == GL_TRUE;
|
|
}
|
|
|
|
static bool link_program(GLuint prog)
|
|
{
|
|
pglLinkProgram(prog);
|
|
|
|
GLint status;
|
|
pglGetProgramiv(prog, GL_LINK_STATUS, &status);
|
|
print_linker_log(prog);
|
|
|
|
if (status == GL_TRUE)
|
|
{
|
|
pglUseProgram(prog);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
static bool compile_programs(GLuint *gl_prog, struct shader_program *progs, size_t num)
|
|
{
|
|
for (unsigned i = 0; i < num; i++)
|
|
{
|
|
gl_prog[i] = pglCreateProgram();
|
|
|
|
if (gl_prog[i] == 0)
|
|
{
|
|
SSNES_ERR("Failed to create GL program #%u.\n", i);
|
|
return false;
|
|
}
|
|
|
|
if (progs[i].vertex)
|
|
{
|
|
SSNES_LOG("Found GLSL vertex shader.\n");
|
|
GLuint shader = pglCreateShader(GL_VERTEX_SHADER);
|
|
if (!compile_shader(shader, progs[i].vertex))
|
|
{
|
|
SSNES_ERR("Failed to compile vertex shader #%u\n", i);
|
|
return false;
|
|
}
|
|
|
|
pglAttachShader(gl_prog[i], shader);
|
|
free(progs[i].vertex);
|
|
}
|
|
|
|
if (progs[i].fragment)
|
|
{
|
|
SSNES_LOG("Found GLSL fragment shader.\n");
|
|
GLuint shader = pglCreateShader(GL_FRAGMENT_SHADER);
|
|
if (!compile_shader(shader, progs[i].fragment))
|
|
{
|
|
SSNES_ERR("Failed to compile fragment shader #%u\n", i);
|
|
return false;
|
|
}
|
|
|
|
pglAttachShader(gl_prog[i], shader);
|
|
free(progs[i].fragment);
|
|
}
|
|
|
|
if (progs[i].vertex || progs[i].fragment)
|
|
{
|
|
SSNES_LOG("Linking GLSL program.\n");
|
|
if (!link_program(gl_prog[i]))
|
|
{
|
|
SSNES_ERR("Failed to link program #%u\n", i);
|
|
return false;
|
|
}
|
|
|
|
GLint location = pglGetUniformLocation(gl_prog[i], "rubyTexture");
|
|
pglUniform1i(location, 0);
|
|
pglUseProgram(0);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#define LOAD_GL_SYM(SYM) if (!pgl##SYM) { SDL_SYM_WRAP(pgl##SYM, "gl" #SYM) }
|
|
|
|
bool gl_glsl_init(const char *path)
|
|
{
|
|
#ifndef __APPLE__
|
|
// Load shader functions.
|
|
LOAD_GL_SYM(CreateProgram);
|
|
LOAD_GL_SYM(UseProgram);
|
|
LOAD_GL_SYM(CreateShader);
|
|
LOAD_GL_SYM(DeleteShader);
|
|
LOAD_GL_SYM(ShaderSource);
|
|
LOAD_GL_SYM(CompileShader);
|
|
LOAD_GL_SYM(AttachShader);
|
|
LOAD_GL_SYM(DetachShader);
|
|
LOAD_GL_SYM(LinkProgram);
|
|
LOAD_GL_SYM(GetUniformLocation);
|
|
LOAD_GL_SYM(Uniform1i);
|
|
LOAD_GL_SYM(Uniform2fv);
|
|
LOAD_GL_SYM(Uniform4fv);
|
|
LOAD_GL_SYM(GetShaderiv);
|
|
LOAD_GL_SYM(GetShaderInfoLog);
|
|
LOAD_GL_SYM(GetProgramiv);
|
|
LOAD_GL_SYM(GetProgramInfoLog);
|
|
LOAD_GL_SYM(DeleteProgram);
|
|
LOAD_GL_SYM(GetAttachedShaders);
|
|
LOAD_GL_SYM(GetAttribLocation);
|
|
LOAD_GL_SYM(EnableVertexAttribArray);
|
|
LOAD_GL_SYM(VertexAttribPointer);
|
|
#endif
|
|
|
|
SSNES_LOG("Checking GLSL shader support ...\n");
|
|
#ifdef __APPLE__
|
|
const bool shader_support = true;
|
|
#else
|
|
bool shader_support = pglCreateProgram && pglUseProgram && pglCreateShader
|
|
&& pglDeleteShader && pglShaderSource && pglCompileShader && pglAttachShader
|
|
&& pglDetachShader && pglLinkProgram && pglGetUniformLocation
|
|
&& pglUniform1i && pglUniform2fv && pglUniform4fv
|
|
&& pglGetShaderiv && pglGetShaderInfoLog && pglGetProgramiv && pglGetProgramInfoLog
|
|
&& pglDeleteProgram && pglGetAttachedShaders
|
|
&& pglGetAttribLocation && pglEnableVertexAttribArray
|
|
&& pglVertexAttribPointer;
|
|
#endif
|
|
|
|
if (!shader_support)
|
|
{
|
|
SSNES_ERR("GLSL shaders aren't supported by your GL driver.\n");
|
|
return false;
|
|
}
|
|
|
|
struct shader_program progs[MAX_PROGRAMS];
|
|
unsigned num_progs = get_xml_shaders(path, progs, MAX_PROGRAMS - 1);
|
|
|
|
if (num_progs == 0)
|
|
{
|
|
SSNES_ERR("Couldn't find any valid shaders in XML file.\n");
|
|
return false;
|
|
}
|
|
|
|
for (unsigned i = 0; i < num_progs; i++)
|
|
{
|
|
gl_filter_type[i + 1] = progs[i].filter;
|
|
gl_scale[i + 1].type_x = progs[i].type_x;
|
|
gl_scale[i + 1].type_y = progs[i].type_y;
|
|
gl_scale[i + 1].scale_x = progs[i].scale_x;
|
|
gl_scale[i + 1].scale_y = progs[i].scale_y;
|
|
gl_scale[i + 1].abs_x = progs[i].abs_x;
|
|
gl_scale[i + 1].abs_y = progs[i].abs_y;
|
|
gl_scale[i + 1].valid = progs[i].valid_scale;
|
|
}
|
|
|
|
if (!compile_programs(&gl_program[1], progs, num_progs))
|
|
return false;
|
|
|
|
// SSNES custom two-pass with two different files.
|
|
if (num_progs == 1 && *g_settings.video.second_pass_shader)
|
|
{
|
|
unsigned secondary_progs = get_xml_shaders(g_settings.video.second_pass_shader, progs, 1);
|
|
if (secondary_progs == 1)
|
|
{
|
|
compile_programs(&gl_program[2], progs, 1);
|
|
num_progs++;
|
|
}
|
|
else
|
|
{
|
|
SSNES_ERR("Did not find valid shader in secondary shader file.\n");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//if (!gl_check_error())
|
|
// SSNES_WARN("Detected GL error!\n");
|
|
|
|
if (gl_tracker_info_cnt > 0)
|
|
{
|
|
struct snes_tracker_info info = {
|
|
.wram = psnes_get_memory_data(SNES_MEMORY_WRAM),
|
|
.vram = psnes_get_memory_data(SNES_MEMORY_VRAM),
|
|
.cgram = psnes_get_memory_data(SNES_MEMORY_CGRAM),
|
|
.apuram = psnes_get_memory_data(SNES_MEMORY_APURAM),
|
|
.oam = psnes_get_memory_data(SNES_MEMORY_OAM),
|
|
.info = gl_tracker_info,
|
|
.info_elem = gl_tracker_info_cnt,
|
|
};
|
|
|
|
#ifdef HAVE_PYTHON
|
|
if (*gl_tracker_script)
|
|
info.script = gl_tracker_script;
|
|
else if (gl_script_program)
|
|
info.script = (const char*)gl_script_program;
|
|
else
|
|
info.script = NULL;
|
|
|
|
info.script_class = *gl_tracker_script_class ? gl_tracker_script_class : NULL;
|
|
info.script_is_file = *gl_tracker_script;
|
|
#endif
|
|
|
|
gl_snes_tracker = snes_tracker_init(&info);
|
|
if (!gl_snes_tracker)
|
|
SSNES_WARN("Failed to init SNES tracker!\n");
|
|
}
|
|
|
|
glsl_enable = true;
|
|
gl_num_programs = num_progs;
|
|
return true;
|
|
}
|
|
|
|
void gl_glsl_deinit(void)
|
|
{
|
|
if (glsl_enable)
|
|
{
|
|
pglUseProgram(0);
|
|
for (int i = 1; i < MAX_PROGRAMS; i++)
|
|
{
|
|
if (gl_program[i] == 0)
|
|
break;
|
|
|
|
GLsizei count;
|
|
GLuint shaders[2];
|
|
|
|
pglGetAttachedShaders(gl_program[i], 2, &count, shaders);
|
|
for (GLsizei j = 0; j < count; j++)
|
|
{
|
|
pglDetachShader(gl_program[i], shaders[j]);
|
|
pglDeleteShader(shaders[j]);
|
|
}
|
|
|
|
pglDeleteProgram(gl_program[i]);
|
|
}
|
|
|
|
glDeleteTextures(gl_teximage_cnt, gl_teximage);
|
|
gl_teximage_cnt = 0;
|
|
memset(gl_teximage_uniforms, 0, sizeof(gl_teximage_uniforms));
|
|
}
|
|
|
|
memset(gl_program, 0, sizeof(gl_program));
|
|
glsl_enable = false;
|
|
active_index = 0;
|
|
|
|
gl_tracker_info_cnt = 0;
|
|
memset(gl_tracker_info, 0, sizeof(gl_tracker_info));
|
|
memset(gl_tracker_script, 0, sizeof(gl_tracker_script));
|
|
memset(gl_tracker_script_class, 0, sizeof(gl_tracker_script_class));
|
|
if (gl_script_program)
|
|
{
|
|
xmlFree(gl_script_program);
|
|
gl_script_program = NULL;
|
|
}
|
|
if (gl_snes_tracker)
|
|
{
|
|
snes_tracker_free(gl_snes_tracker);
|
|
gl_snes_tracker = NULL;
|
|
}
|
|
}
|
|
|
|
void gl_glsl_set_params(unsigned width, unsigned height,
|
|
unsigned tex_width, unsigned tex_height,
|
|
unsigned out_width, unsigned out_height,
|
|
unsigned frame_count,
|
|
const struct gl_tex_info *info,
|
|
const struct gl_tex_info *fbo_info, unsigned fbo_info_cnt)
|
|
{
|
|
if (glsl_enable && gl_program[active_index] > 0)
|
|
{
|
|
GLint location;
|
|
|
|
float inputSize[2] = {width, height};
|
|
location = pglGetUniformLocation(gl_program[active_index], "rubyInputSize");
|
|
pglUniform2fv(location, 1, inputSize);
|
|
|
|
float outputSize[2] = {out_width, out_height};
|
|
location = pglGetUniformLocation(gl_program[active_index], "rubyOutputSize");
|
|
pglUniform2fv(location, 1, outputSize);
|
|
|
|
float textureSize[2] = {tex_width, tex_height};
|
|
location = pglGetUniformLocation(gl_program[active_index], "rubyTextureSize");
|
|
pglUniform2fv(location, 1, textureSize);
|
|
|
|
location = pglGetUniformLocation(gl_program[active_index], "rubyFrameCount");
|
|
pglUniform1i(location, frame_count);
|
|
|
|
for (unsigned i = 0; i < gl_teximage_cnt; i++)
|
|
{
|
|
location = pglGetUniformLocation(gl_program[active_index], gl_teximage_uniforms[i]);
|
|
pglUniform1i(location, i + 1);
|
|
}
|
|
|
|
// Set original texture unless we're in first pass (pointless).
|
|
if (active_index > 1)
|
|
{
|
|
// Bind original texture.
|
|
pglActiveTexture(GL_TEXTURE0 + gl_teximage_cnt + 1);
|
|
glBindTexture(GL_TEXTURE_2D, info->tex);
|
|
|
|
location = pglGetUniformLocation(gl_program[active_index], "rubyOrigTexture");
|
|
pglUniform1i(location, gl_teximage_cnt + 1);
|
|
|
|
location = pglGetUniformLocation(gl_program[active_index], "rubyOrigTextureSize");
|
|
pglUniform2fv(location, 1, info->tex_size);
|
|
location = pglGetUniformLocation(gl_program[active_index], "rubyOrigInputSize");
|
|
pglUniform2fv(location, 1, info->input_size);
|
|
|
|
// Pass texture coordinates.
|
|
location = pglGetAttribLocation(gl_program[active_index], "rubyOrigTexCoord");
|
|
if (location >= 0)
|
|
{
|
|
pglEnableVertexAttribArray(location);
|
|
pglVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, 0, info->coord);
|
|
}
|
|
|
|
GLuint base_tex = GL_TEXTURE0 + gl_teximage_cnt + 2;
|
|
|
|
// Bind new texture in the chain.
|
|
if (fbo_info_cnt > 0)
|
|
{
|
|
pglActiveTexture(base_tex + fbo_info_cnt - 1);
|
|
glBindTexture(GL_TEXTURE_2D, fbo_info[fbo_info_cnt - 1].tex);
|
|
}
|
|
|
|
// Bind FBO textures.
|
|
for (unsigned i = 0; i < fbo_info_cnt; i++)
|
|
{
|
|
char attrib_buf[64];
|
|
|
|
snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uTexture", i + 1);
|
|
location = pglGetUniformLocation(gl_program[active_index], attrib_buf);
|
|
pglUniform1i(location, base_tex + i - GL_TEXTURE0);
|
|
|
|
snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uTextureSize", i + 1);
|
|
location = pglGetUniformLocation(gl_program[active_index], attrib_buf);
|
|
pglUniform2fv(location, 1, fbo_info[i].tex_size);
|
|
|
|
snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uInputSize", i + 1);
|
|
location = pglGetUniformLocation(gl_program[active_index], attrib_buf);
|
|
pglUniform2fv(location, 1, fbo_info[i].input_size);
|
|
|
|
snprintf(attrib_buf, sizeof(attrib_buf), "rubyPass%uTexCoord", i + 1);
|
|
location = pglGetAttribLocation(gl_program[active_index], attrib_buf);
|
|
if (location >= 0)
|
|
{
|
|
pglEnableVertexAttribArray(location);
|
|
pglVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, 0, fbo_info[i].coord);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// First pass, so unbind everything to avoid collitions.
|
|
pglActiveTexture(GL_TEXTURE0 + gl_teximage_cnt + 1);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
GLuint base_tex = GL_TEXTURE0 + gl_teximage_cnt + 2;
|
|
// Unbind any lurking FBO passes.
|
|
// Rendering to a texture that is bound to a texture unit
|
|
// sounds very shaky ... ;)
|
|
for (int i = 0; i < gl_num_programs; i++)
|
|
{
|
|
pglActiveTexture(GL_TEXTURE0 + base_tex + i);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
}
|
|
}
|
|
|
|
pglActiveTexture(GL_TEXTURE0);
|
|
|
|
if (gl_snes_tracker)
|
|
{
|
|
static struct snes_tracker_uniform info[MAX_VARIABLES];
|
|
static unsigned cnt = 0;
|
|
|
|
if (active_index == 1)
|
|
cnt = snes_get_uniform(gl_snes_tracker, info, MAX_VARIABLES, frame_count);
|
|
|
|
for (unsigned i = 0; i < cnt; i++)
|
|
{
|
|
location = pglGetUniformLocation(gl_program[active_index], info[i].id);
|
|
pglUniform1i(location, info[i].value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void gl_glsl_set_proj_matrix(void)
|
|
{}
|
|
|
|
void gl_glsl_use(unsigned index)
|
|
{
|
|
if (glsl_enable)
|
|
{
|
|
active_index = index;
|
|
pglUseProgram(gl_program[index]);
|
|
}
|
|
}
|
|
|
|
unsigned gl_glsl_num(void)
|
|
{
|
|
return gl_num_programs;
|
|
}
|
|
|
|
bool gl_glsl_filter_type(unsigned index, bool *smooth)
|
|
{
|
|
if (!glsl_enable)
|
|
return false;
|
|
|
|
switch (gl_filter_type[index])
|
|
{
|
|
case SSNES_GL_NOFORCE:
|
|
return false;
|
|
|
|
case SSNES_GL_NEAREST:
|
|
*smooth = false;
|
|
return true;
|
|
|
|
case SSNES_GL_LINEAR:
|
|
*smooth = true;
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void gl_glsl_shader_scale(unsigned index, struct gl_fbo_scale *scale)
|
|
{
|
|
if (glsl_enable)
|
|
*scale = gl_scale[index];
|
|
else
|
|
scale->valid = false;
|
|
}
|