Retro/pcem
Watch
1
0
Fork
You've already forked pcem
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fixes to shader rendering. Patch from bit.

Browse source
This commit is contained in:
SarahW 2017-08-15 21:15:29 +01:00
commit 9eae781645
4 changed files with 2205 additions and 2184 deletions
Download patch file Download diff file Expand all files Collapse all files

313
src/wx-glsl.h
View file

@ -1,155 +1,158 @@
#ifndef SRC_WX_GLSL_H_ #ifndef SRC_WX_GLSL_H_
#define SRC_WX_GLSL_H_ #define SRC_WX_GLSL_H_
#define MAX_PREV 7 #define MAX_PREV 7
#define MAX_SHADERS 20 #define MAX_SHADERS 20
#define MAX_TEXTURES 20 #define MAX_TEXTURES 20
#define MAX_PARAMETERS 100 #define MAX_PARAMETERS 100
#define MAX_USER_SHADERS 20 #define MAX_USER_SHADERS 20
//#define SDL2_SHADER_DEBUG //#define SDL2_SHADER_DEBUG
struct shader_scale { struct shader_scale {
int mode[2]; int mode[2];
float value[2]; float value[2];
}; };
struct shader_state { struct shader_state {
float input_size[2]; float input_size[2];
float input_texture_size[2]; float input_texture_size[2];
float output_texture_size[2]; float output_texture_size[2];
float output_size[2]; float output_size[2];
float tex_coords[8]; float tex_coords[8];
}; };
struct shader_vbo { struct shader_vbo {
int vertex_coord; int vertex_coord;
int tex_coord; int tex_coord;
int color; int color;
}; };
struct shader_texture { struct shader_texture {
int id; int id;
int width; int width;
int height; int height;
int type; int type;
int internal_format; int internal_format;
int format; int format;
int min_filter; int min_filter;
int mag_filter; int mag_filter;
int wrap_mode; int wrap_mode;
void* data; void* data;
int mipmap; int mipmap;
}; };
struct shader_lut_texture { struct shader_lut_texture {
char name[50]; char name[50];
struct shader_texture texture; struct shader_texture texture;
}; };
struct shader_fbo { struct shader_fbo {
int id; int id;
struct shader_texture texture; struct shader_texture texture;
int srgb; int srgb;
}; int mipmap_input;
};
struct shader_prev {
struct shader_fbo fbo; struct shader_prev {
struct shader_vbo vbo; struct shader_fbo fbo;
}; struct shader_vbo vbo;
};
struct shader_input {
int texture; struct shader_input {
int input_size; int texture;
int texture_size; int input_size;
int tex_coord; int texture_size;
}; int tex_coord;
};
struct shader_uniforms {
int mvp_matrix; struct shader_uniforms {
int vertex_coord; int mvp_matrix;
int tex_coord; int vertex_coord;
int color; int tex_coord;
int color;
int texture;
int input_size; int texture;
int texture_size; int input_size;
int output_size; int texture_size;
int output_size;
int frame_count;
int frame_direction; int frame_count;
int frame_direction;
struct shader_input orig;
struct shader_input pass[MAX_SHADERS]; struct shader_input orig;
struct shader_input prev_pass[MAX_SHADERS]; struct shader_input pass[MAX_SHADERS];
struct shader_input prev[MAX_PREV]; struct shader_input prev_pass[MAX_SHADERS];
struct shader_input prev[MAX_PREV];
int parameters[MAX_PARAMETERS];
int lut_textures[MAX_TEXTURES]; int parameters[MAX_PARAMETERS];
}; int lut_textures[MAX_TEXTURES];
};
struct shader_program {
int vertex_shader; struct shader_program {
int fragment_shader; int vertex_shader;
int id; int fragment_shader;
}; int id;
};
struct shader_parameter {
char id[64]; struct shader_parameter {
char description[64]; char id[64];
float default_value; char description[64];
float value; float default_value;
float min; float value;
float max; float min;
float step; float max;
}; float step;
};
struct shader_pass {
int active; struct shader_pass {
char alias[64]; int active;
int vertex_array; char alias[64];
int frame_count_mod; int vertex_array;
struct shader_program program; int frame_count_mod;
struct shader_uniforms uniforms; struct shader_program program;
struct shader_fbo fbo; struct shader_uniforms uniforms;
struct shader_vbo vbo; struct shader_fbo fbo;
struct shader_state state; struct shader_vbo vbo;
struct shader_scale scale; struct shader_state state;
}; struct shader_scale scale;
};
struct glsl_shader {
int active; struct glsl_shader {
char name[64]; int active;
char name[64];
int num_passes;
struct shader_pass passes[MAX_SHADERS]; int num_passes;
struct shader_pass passes[MAX_SHADERS];
int num_lut_textures;
struct shader_lut_texture lut_textures[MAX_TEXTURES]; int num_lut_textures;
struct shader_lut_texture lut_textures[MAX_TEXTURES];
int num_parameters;
struct shader_parameter parameters[MAX_PARAMETERS]; int num_parameters;
struct shader_parameter parameters[MAX_PARAMETERS];
struct shader_pass prev_scene;
struct shader_prev prev[MAX_PREV+1]; struct shader_pass prev_scene;
struct shader_prev prev[MAX_PREV+1];
int last_prev_update;
int has_prev; int last_prev_update;
int has_prev;
float shader_refresh_rate;
}; float shader_refresh_rate;
typedef struct glsl_t { int input_filter_linear;
int num_shaders; };
struct glsl_shader shaders[MAX_USER_SHADERS];
struct shader_pass scene; typedef struct glsl_t {
struct shader_pass final_pass; int num_shaders;
struct shader_pass fs_color; struct glsl_shader shaders[MAX_USER_SHADERS];
#ifdef SDL2_SHADER_DEBUG struct shader_pass scene;
struct shader_pass debug; struct shader_pass final_pass;
#endif struct shader_pass fs_color;
int srgb; #ifdef SDL2_SHADER_DEBUG
} glsl_t; struct shader_pass debug;
#endif
#endif int srgb;
} glsl_t;
#endif

658
src/wx-glslp-parser.c
View file

@ -1,328 +1,330 @@
#include "wx-glslp-parser.h" #include "wx-glslp-parser.h"
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <ctype.h> #include <ctype.h>
#include "wx-utils.h" #include "wx-utils.h"
#define safe_strncpy(a,b,n) do { strncpy((a),(b),(n)-1); (a)[(n)-1] = 0; } while (0) #define safe_strncpy(a,b,n) do { strncpy((a),(b),(n)-1); (a)[(n)-1] = 0; } while (0)
extern char* get_filename(char*); extern char* get_filename(char*);
extern void pclog(const char *format, ...); extern void pclog(const char *format, ...);
static int endswith(const char* str, const char* ext) static int endswith(const char* str, const char* ext)
{ {
int i; int i;
const char* p; const char* p;
int elen = strlen(ext); int elen = strlen(ext);
int slen = strlen(str); int slen = strlen(str);
if (slen >= elen) if (slen >= elen)
{ {
p = &str[slen-elen]; p = &str[slen-elen];
for (i = 0; i < elen; ++i) for (i = 0; i < elen; ++i)
{ {
if (tolower(p[i]) != tolower(ext[i])) if (tolower(p[i]) != tolower(ext[i]))
return 0; return 0;
} }
return 1; return 1;
} }
return 0; return 0;
} }
static char* load_file(const char* fn) static char* load_file(const char* fn)
{ {
FILE* f = fopen(fn, "rb"); FILE* f = fopen(fn, "rb");
if (!f) if (!f)
return 0; return 0;
fseek(f, 0, SEEK_END); fseek(f, 0, SEEK_END);
long fsize = ftell(f); long fsize = ftell(f);
fseek(f, 0, SEEK_SET); fseek(f, 0, SEEK_SET);
char* data = malloc(fsize+1); char* data = malloc(fsize+1);
fread(data, fsize, 1, f); fread(data, fsize, 1, f);
fclose(f); fclose(f);
data[fsize] = 0; data[fsize] = 0;
return data; return data;
} }
static void strip_lines(const char* program, const char* starts_with) static void strip_lines(const char* program, const char* starts_with)
{ {
/* strip parameters */ /* strip parameters */
char* ptr = strstr(program, starts_with); char* ptr = strstr(program, starts_with);
while (ptr) while (ptr)
{ {
while (*ptr != '\n' && *ptr != '\0') while (*ptr != '\n' && *ptr != '\0')
*ptr++ = ' '; *ptr++ = ' ';
ptr = strstr(program, starts_with); ptr = strstr(program, starts_with);
} }
} }
static void strip_parameters(const char* program) static void strip_parameters(const char* program)
{ {
/* strip parameters */ /* strip parameters */
strip_lines(program, "#pragma parameter"); strip_lines(program, "#pragma parameter");
} }
static void strip_defines(const char* program) static void strip_defines(const char* program)
{ {
/* strip texture define */ /* strip texture define */
strip_lines(program, "#define texture"); strip_lines(program, "#define texture");
} }
static int has_parameter(glslp_t* glsl, char* id) static int has_parameter(glslp_t* glsl, char* id)
{ {
int i; int i;
for (i = 0; i < glsl->num_parameters; ++i) for (i = 0; i < glsl->num_parameters; ++i)
if (!strcmp(glsl->parameters[i].id, id)) if (!strcmp(glsl->parameters[i].id, id))
return 1; return 1;
return 0; return 0;
} }
static int get_parameters(glslp_t* glsl) static int get_parameters(glslp_t* glsl)
{ {
int i; int i;
struct parameter p; struct parameter p;
for (i = 0; i < glsl->num_shaders; ++i) for (i = 0; i < glsl->num_shaders; ++i)
{ {
struct shader* shader = &glsl->shaders[i]; struct shader* shader = &glsl->shaders[i];
FILE* f = fopen(shader->shader_fn, "rb"); FILE* f = fopen(shader->shader_fn, "rb");
if (!f) if (!f)
return 0; return 0;
char line[1024]; char line[1024];
while (fgets(line, sizeof(line)-1, f) && glsl->num_parameters < MAX_PARAMETERS) while (fgets(line, sizeof(line)-1, f) && glsl->num_parameters < MAX_PARAMETERS)
{ {
int num = sscanf(line, "#pragma parameter %63s \"%63[^\"]\" %f %f %f %f", p.id, p.description, &p.default_value, &p.min, &p.max, &p.step); int num = sscanf(line, "#pragma parameter %63s \"%63[^\"]\" %f %f %f %f", p.id, p.description, &p.default_value, &p.min, &p.max, &p.step);
if (num < 5) if (num < 5)
continue; continue;
p.id[63] = 0; p.id[63] = 0;
p.description[63] = 0; p.description[63] = 0;
if (num == 5) if (num == 5)
p.step = 0.1f * (p.max-p.min); p.step = 0.1f * (p.max-p.min);
p.value = p.default_value; p.value = p.default_value;
if (!has_parameter(glsl, p.id)) if (!has_parameter(glsl, p.id))
{ {
memcpy(&glsl->parameters[glsl->num_parameters++], &p, sizeof(struct parameter)); memcpy(&glsl->parameters[glsl->num_parameters++], &p, sizeof(struct parameter));
pclog("Read parameter: %s (%s) %f, %f -> %f (%f)\n", p.id, p.description, p.default_value, p.min, p.max, p.step); pclog("Read parameter: %s (%s) %f, %f -> %f (%f)\n", p.id, p.description, p.default_value, p.min, p.max, p.step);
} }
} }
fclose(f); fclose(f);
} }
return 1; return 1;
} }
static struct parameter* get_parameter(glslp_t* glslp, const char* id) static struct parameter* get_parameter(glslp_t* glslp, const char* id)
{ {
int i; int i;
for (i = 0; i < glslp->num_parameters; ++i) for (i = 0; i < glslp->num_parameters; ++i)
{ {
if (!strcmp(glslp->parameters[i].id, id)) { if (!strcmp(glslp->parameters[i].id, id)) {
return &glslp->parameters[i]; return &glslp->parameters[i];
} }
} }
return 0; return 0;
} }
static glslp_t* glsl_parse(const char* f) static glslp_t* glsl_parse(const char* f)
{ {
glslp_t* glslp = malloc(sizeof(glslp_t)); glslp_t* glslp = malloc(sizeof(glslp_t));
memset(glslp, 0, sizeof(glslp_t)); memset(glslp, 0, sizeof(glslp_t));
glslp->num_shaders = 1; glslp->num_shaders = 1;
struct shader* shader = &glslp->shaders[0]; struct shader* shader = &glslp->shaders[0];
strcpy(shader->shader_fn, f); strcpy(shader->shader_fn, f);
shader->shader_program = load_file(f); shader->shader_program = load_file(f);
if (!shader->shader_program) if (!shader->shader_program)
{ {
wx_simple_messagebox("GLSL error", "Could not load shader %s\n", shader->shader_fn); wx_simple_messagebox("GLSL error", "Could not load shader %s\n", shader->shader_fn);
glslp_free(glslp); glslp_free(glslp);
return 0; return 0;
} }
strip_parameters(shader->shader_program); strip_parameters(shader->shader_program);
strip_defines(shader->shader_program); strip_defines(shader->shader_program);
shader->scale_x = shader->scale_y = 1.0f; shader->scale_x = shader->scale_y = 1.0f;
strcpy(shader->scale_type_x, "source"); strcpy(shader->scale_type_x, "source");
strcpy(shader->scale_type_y, "source"); strcpy(shader->scale_type_y, "source");
get_parameters(glslp); get_parameters(glslp);
return glslp; return glslp;
} }
void get_glslp_name(const char* f, char* s, int size) void get_glslp_name(const char* f, char* s, int size)
{ {
safe_strncpy(s, get_filename((char*)f), size); safe_strncpy(s, get_filename((char*)f), size);
} }
glslp_t* glslp_parse(const char* f) glslp_t* glslp_parse(const char* f)
{ {
int i, j, len, sublen; int i, j, len, sublen;
char s[512], t[512], z[512]; char s[512], t[512], z[512];
s[511] = 0; s[511] = 0;
if (endswith(f, ".glsl")) if (endswith(f, ".glsl"))
return glsl_parse(f); return glsl_parse(f);
void* cfg = wx_config_load(f); void* cfg = wx_config_load(f);
if (!cfg) if (!cfg)
{ {
wx_simple_messagebox("GLSLP error", "Could not load GLSLP-file %s\n", f); wx_simple_messagebox("GLSLP error", "Could not load GLSLP-file %s\n", f);
return 0; return 0;
} }
glslp_t* glslp = malloc(sizeof(glslp_t)); glslp_t* glslp = malloc(sizeof(glslp_t));
memset(glslp, 0, sizeof(glslp_t)); memset(glslp, 0, sizeof(glslp_t));
get_glslp_name(f, glslp->name, sizeof(glslp->name)); get_glslp_name(f, glslp->name, sizeof(glslp->name));
wx_config_get_int(cfg, "shaders", &glslp->num_shaders, 0); wx_config_get_int(cfg, "shaders", &glslp->num_shaders, 0);
for (i = 0; i < glslp->num_shaders; ++i) wx_config_get_bool(cfg, "filter_linear0", &glslp->input_filter_linear, -1);
{
struct shader* shader = &glslp->shaders[i]; for (i = 0; i < glslp->num_shaders; ++i)
{
struct shader* shader = &glslp->shaders[i];
snprintf(s, sizeof(s)-1, "shader%d", i);
if (!wx_config_get_string(cfg, s, t, sizeof(t), 0))
{ snprintf(s, sizeof(s)-1, "shader%d", i);
/* shader doesn't exist, lets break here */ if (!wx_config_get_string(cfg, s, t, sizeof(t), 0))
glslp->num_shaders = i; {
break; /* shader doesn't exist, lets break here */
} glslp->num_shaders = i;
strcpy(s, f); break;
*get_filename(s) = 0; }
snprintf(shader->shader_fn, sizeof(shader->shader_fn)-1, "%s%s", s, t); strcpy(s, f);
shader->shader_program = load_file(shader->shader_fn); *get_filename(s) = 0;
if (!shader->shader_program) snprintf(shader->shader_fn, sizeof(shader->shader_fn)-1, "%s%s", s, t);
{ shader->shader_program = load_file(shader->shader_fn);
wx_simple_messagebox("GLSL error", "Could not load shader %s\n", shader->shader_fn); if (!shader->shader_program)
glslp_free(glslp); {
return 0; wx_simple_messagebox("GLSL error", "Could not load shader %s\n", shader->shader_fn);
} glslp_free(glslp);
strip_parameters(shader->shader_program); return 0;
strip_defines(shader->shader_program); }
strip_parameters(shader->shader_program);
snprintf(s, sizeof(s)-1, "alias%d", i); strip_defines(shader->shader_program);
wx_config_get_string(cfg, s, shader->alias, sizeof(shader->alias), 0);
snprintf(s, sizeof(s)-1, "alias%d", i);
snprintf(s, sizeof(s)-1, "filter_linear%d", i); wx_config_get_string(cfg, s, shader->alias, sizeof(shader->alias), 0);
wx_config_get_bool(cfg, s, &shader->filter_linear, 0);
snprintf(s, sizeof(s)-1, "filter_linear%d", i+1);
snprintf(s, sizeof(s)-1, "wrap_mode%d", i); wx_config_get_bool(cfg, s, &shader->filter_linear, 0);
wx_config_get_string(cfg, s, shader->wrap_mode, sizeof(shader->wrap_mode), 0);
snprintf(s, sizeof(s)-1, "wrap_mode%d", i);
snprintf(s, sizeof(s)-1, "float_framebuffer%d", i); wx_config_get_string(cfg, s, shader->wrap_mode, sizeof(shader->wrap_mode), 0);
wx_config_get_bool(cfg, s, &shader->float_framebuffer, 0);
snprintf(s, sizeof(s)-1, "srgb_framebuffer%d", i); snprintf(s, sizeof(s)-1, "float_framebuffer%d", i);
wx_config_get_bool(cfg, s, &shader->srgb_framebuffer, 0); wx_config_get_bool(cfg, s, &shader->float_framebuffer, 0);
snprintf(s, sizeof(s)-1, "srgb_framebuffer%d", i);
snprintf(s, sizeof(s)-1, "mipmap_input%d", i); wx_config_get_bool(cfg, s, &shader->srgb_framebuffer, 0);
wx_config_get_bool(cfg, s, &shader->mipmap_input, 0);
snprintf(s, sizeof(s)-1, "mipmap_input%d", i);
strcpy(shader->scale_type_x, "source"); wx_config_get_bool(cfg, s, &shader->mipmap_input, 0);
snprintf(s, sizeof(s)-1, "scale_type_x%d", i);
wx_config_get_string(cfg, s, shader->scale_type_x, sizeof(shader->scale_type_x), 0); strcpy(shader->scale_type_x, "source");
strcpy(shader->scale_type_y, "source"); snprintf(s, sizeof(s)-1, "scale_type_x%d", i);
snprintf(s, sizeof(s)-1, "scale_type_y%d", i); wx_config_get_string(cfg, s, shader->scale_type_x, sizeof(shader->scale_type_x), 0);
wx_config_get_string(cfg, s, shader->scale_type_y, sizeof(shader->scale_type_y), 0); strcpy(shader->scale_type_y, "source");
snprintf(s, sizeof(s)-1, "scale_type%d", i); snprintf(s, sizeof(s)-1, "scale_type_y%d", i);
if (wx_config_has_entry(cfg, s)) wx_config_get_string(cfg, s, shader->scale_type_y, sizeof(shader->scale_type_y), 0);
{ snprintf(s, sizeof(s)-1, "scale_type%d", i);
wx_config_get_string(cfg, s, shader->scale_type_x, sizeof(shader->scale_type_x), 0); if (wx_config_has_entry(cfg, s))
wx_config_get_string(cfg, s, shader->scale_type_y, sizeof(shader->scale_type_y), 0); {
} wx_config_get_string(cfg, s, shader->scale_type_x, sizeof(shader->scale_type_x), 0);
wx_config_get_string(cfg, s, shader->scale_type_y, sizeof(shader->scale_type_y), 0);
snprintf(s, sizeof(s)-1, "scale_x%d", i); }
wx_config_get_float(cfg, s, &shader->scale_x, 1.0f);
snprintf(s, sizeof(s)-1, "scale_y%d", i); snprintf(s, sizeof(s)-1, "scale_x%d", i);
wx_config_get_float(cfg, s, &shader->scale_y, 1.0f); wx_config_get_float(cfg, s, &shader->scale_x, 1.0f);
snprintf(s, sizeof(s)-1, "scale%d", i); snprintf(s, sizeof(s)-1, "scale_y%d", i);
if (wx_config_has_entry(cfg, s)) wx_config_get_float(cfg, s, &shader->scale_y, 1.0f);
{ snprintf(s, sizeof(s)-1, "scale%d", i);
wx_config_get_float(cfg, s, &shader->scale_x, 1.0f); if (wx_config_has_entry(cfg, s))
wx_config_get_float(cfg, s, &shader->scale_y, 1.0f); {
} wx_config_get_float(cfg, s, &shader->scale_x, 1.0f);
wx_config_get_float(cfg, s, &shader->scale_y, 1.0f);
snprintf(s, sizeof(s)-1, "frame_count_mod%d", i); }
wx_config_get_int(cfg, s, &shader->frame_count_mod, 0);
} snprintf(s, sizeof(s)-1, "frame_count_mod%d", i);
wx_config_get_int(cfg, s, &shader->frame_count_mod, 0);
/* textures */ }
glslp->num_textures = 0;
wx_config_get_string(cfg, "textures", t, sizeof(t), 0); /* textures */
glslp->num_textures = 0;
len = strlen(t); wx_config_get_string(cfg, "textures", t, sizeof(t), 0);
j = 0;
sublen = 0; len = strlen(t);
for (i = 0; i < len; ++i) j = 0;
{ sublen = 0;
if (t[i] == ';' || i == len-1) for (i = 0; i < len; ++i)
{ {
sublen = (i-j) + ((i == len-1) ? 1 : 0) + 1; if (t[i] == ';' || i == len-1)
safe_strncpy(s, t+j, sublen); {
s[511 < sublen ? 511 : sublen] = 0; sublen = (i-j) + ((i == len-1) ? 1 : 0) + 1;
safe_strncpy(s, t+j, sublen);
struct texture* tex = &glslp->textures[glslp->num_textures++]; s[511 < sublen ? 511 : sublen] = 0;
strcpy(tex->name, s); struct texture* tex = &glslp->textures[glslp->num_textures++];
wx_config_get_string(cfg, s, tex->path, sizeof(tex->path), 0);
strcpy(tex->name, s);
snprintf(z, sizeof(z)-1, "%s_linear", s); wx_config_get_string(cfg, s, tex->path, sizeof(tex->path), 0);
wx_config_get_bool(cfg, z, &tex->linear, 0);
snprintf(z, sizeof(z)-1, "%s_linear", s);
snprintf(z, sizeof(z)-1, "%s_mipmap", s); wx_config_get_bool(cfg, z, &tex->linear, 0);
wx_config_get_bool(cfg, z, &tex->mipmap, 0);
snprintf(z, sizeof(z)-1, "%s_mipmap", s);
snprintf(z, sizeof(z)-1, "%s_wrap_mode", s); wx_config_get_bool(cfg, z, &tex->mipmap, 0);
wx_config_get_string(cfg, z, tex->wrap_mode, sizeof(tex->wrap_mode), 0);
snprintf(z, sizeof(z)-1, "%s_wrap_mode", s);
j = i+1; wx_config_get_string(cfg, z, tex->wrap_mode, sizeof(tex->wrap_mode), 0);
}
} j = i+1;
}
/* parameters */ }
get_parameters(glslp);
/* parameters */
wx_config_get_string(cfg, "parameters", t, sizeof(t), 0); get_parameters(glslp);
len = strlen(t); wx_config_get_string(cfg, "parameters", t, sizeof(t), 0);
j = 0;
sublen = 0; len = strlen(t);
for (i = 0; i < len; ++i) j = 0;
{ sublen = 0;
if (t[i] == ';' || i == len-1) for (i = 0; i < len; ++i)
{ {
sublen = (i-j) + ((i == len-1) ? 1 : 0) + 1; if (t[i] == ';' || i == len-1)
safe_strncpy(s, t+j, sublen); {
s[511 < sublen ? 511 : sublen] = 0; sublen = (i-j) + ((i == len-1) ? 1 : 0) + 1;
safe_strncpy(s, t+j, sublen);
struct parameter* p = get_parameter(glslp, s); s[511 < sublen ? 511 : sublen] = 0;
if (p) struct parameter* p = get_parameter(glslp, s);
wx_config_get_float(cfg, s, &p->default_value, 0);
if (p)
j = i+1; wx_config_get_float(cfg, s, &p->default_value, 0);
}
} j = i+1;
}
wx_config_free(cfg); }
wx_config_free(cfg);
return glslp;
}
return glslp;
void glslp_free(glslp_t* p) }
{
int i; void glslp_free(glslp_t* p)
for (i = 0; i < p->num_shaders; ++i) {
if (p->shaders[i].shader_program) int i;
free(p->shaders[i].shader_program); for (i = 0; i < p->num_shaders; ++i)
free(p); if (p->shaders[i].shader_program)
} free(p->shaders[i].shader_program);
free(p);
}

110
src/wx-glslp-parser.h
View file

@ -1,54 +1,56 @@
#ifndef SRC_WX_GLSLP_PARSER_H_ #ifndef SRC_WX_GLSLP_PARSER_H_
#define SRC_WX_GLSLP_PARSER_H_ #define SRC_WX_GLSLP_PARSER_H_
#include "wx-glsl.h" #include "wx-glsl.h"
struct parameter { struct parameter {
char id[64]; char id[64];
char description[64]; char description[64];
float default_value; float default_value;
float value; float value;
float min; float min;
float max; float max;
float step; float step;
}; };
struct texture { struct texture {
char path[256]; char path[256];
char name[50]; char name[50];
int linear; int linear;
int mipmap; int mipmap;
char wrap_mode[50]; char wrap_mode[50];
}; };
struct shader { struct shader {
char shader_fn[512]; char shader_fn[512];
char* shader_program; char* shader_program;
char alias[64]; char alias[64];
int filter_linear; int filter_linear;
int float_framebuffer; int float_framebuffer;
int srgb_framebuffer; int srgb_framebuffer;
int mipmap_input; int mipmap_input;
int frame_count_mod; int frame_count_mod;
char wrap_mode[50]; char wrap_mode[50];
char scale_type_x[9], scale_type_y[9]; char scale_type_x[9], scale_type_y[9];
float scale_x, scale_y; float scale_x, scale_y;
}; };
typedef struct glslp_t { typedef struct glslp_t {
char name[64]; char name[64];
int num_shaders; int num_shaders;
struct shader shaders[MAX_SHADERS]; struct shader shaders[MAX_SHADERS];
int num_textures; int num_textures;
struct texture textures[MAX_TEXTURES]; struct texture textures[MAX_TEXTURES];
int num_parameters; int num_parameters;
struct parameter parameters[MAX_PARAMETERS]; struct parameter parameters[MAX_PARAMETERS];
} glslp_t;
int input_filter_linear;
void get_glslp_name(const char* f, char* s, int size); } glslp_t;
glslp_t* glslp_parse(const char* f);
void glslp_free(glslp_t* p); void get_glslp_name(const char* f, char* s, int size);
glslp_t* glslp_parse(const char* f);
#endif /* SRC_WX_GLSLP_PARSER_H_ */ void glslp_free(glslp_t* p);
#endif /* SRC_WX_GLSLP_PARSER_H_ */

3308
src/wx-sdl2-video-gl3.c
View file

File diff suppressed because it is too large Load diff