mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-03 04:14:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

(gl_core/gl3) Rename gl_core internally to gl3

Browse Source
This commit is contained in:
twinaphex 2021-11-23 08:45:54 +01:00
parent 8a83ebec28
commit 0a40e1f771
12 changed files with 546 additions and 546 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
gfx/common/gl3_common.h
View File

@ -42,18 +42,18 @@ RETRO_BEGIN_DECLS
#define GL_CORE_NUM_PBOS 4
#define GL_CORE_NUM_VBOS 256
#define GL_CORE_NUM_FENCES 8
struct gl_core_streamed_texture
struct gl3_streamed_texture
{
GLuint tex;
unsigned width;
unsigned height;
};
typedef struct gl_core
typedef struct gl3
{
const gfx_ctx_driver_t *ctx_driver;
void *ctx_data;
gl_core_filter_chain_t *filter_chain;
gl3_filter_chain_t *filter_chain;
GLuint *overlay_tex;
float *overlay_vertex_coord;
float *overlay_tex_coord;
@ -64,8 +64,8 @@ typedef struct gl_core
video_info_t video_info;
video_viewport_t vp;
struct gl_core_viewport filter_chain_vp;
struct gl_core_streamed_texture textures[GL_CORE_NUM_TEXTURES];
struct gl3_viewport filter_chain_vp;
struct gl3_streamed_texture textures[GL_CORE_NUM_TEXTURES];
GLuint vao;
GLuint menu_texture;
@ -80,13 +80,13 @@ typedef struct gl_core
GLuint snow_simple;
GLuint snow;
GLuint bokeh;
struct gl_core_buffer_locations alpha_blend_loc;
struct gl_core_buffer_locations font_loc;
struct gl_core_buffer_locations ribbon_loc;
struct gl_core_buffer_locations ribbon_simple_loc;
struct gl_core_buffer_locations snow_simple_loc;
struct gl_core_buffer_locations snow_loc;
struct gl_core_buffer_locations bokeh_loc;
struct gl3_buffer_locations alpha_blend_loc;
struct gl3_buffer_locations font_loc;
struct gl3_buffer_locations ribbon_loc;
struct gl3_buffer_locations ribbon_simple_loc;
struct gl3_buffer_locations snow_simple_loc;
struct gl3_buffer_locations snow_loc;
struct gl3_buffer_locations bokeh_loc;
} pipelines;
@ -129,15 +129,15 @@ typedef struct gl_core
bool quitting;
bool should_resize;
bool keep_aspect;
} gl_core_t;
} gl3_t;
void gl_core_bind_scratch_vbo(gl_core_t *gl, const void *data, size_t size);
void gl3_bind_scratch_vbo(gl3_t *gl, const void *data, size_t size);
GLuint gl_core_compile_shader(GLenum stage, const char *source);
GLuint gl3_compile_shader(GLenum stage, const char *source);
void gl_core_framebuffer_clear(GLuint id);
void gl3_framebuffer_clear(GLuint id);
void gl_core_framebuffer_copy(
void gl3_framebuffer_copy(
GLuint fb_id,
GLuint quad_program,
GLuint quad_vbo,
@ -145,7 +145,7 @@ void gl_core_framebuffer_copy(
struct Size2D size,
GLuint image);
void gl_core_framebuffer_copy_partial(
void gl3_framebuffer_copy_partial(
GLuint fb_id,
GLuint quad_program,
GLint flat_ubo_vertex,
@ -153,9 +153,9 @@ void gl_core_framebuffer_copy_partial(
GLuint image,
float rx, float ry);
void gl_core_build_default_matrix(float *data);
void gl3_build_default_matrix(float *data);
uint32_t gl_core_get_cross_compiler_target_version(void);
uint32_t gl3_get_cross_compiler_target_version(void);
RETRO_END_DECLS

502
gfx/drivers/gl3.c
View File

File diff suppressed because it is too large Load Diff

78
gfx/drivers_display/gfx_display_gl3.c
View File

@ -27,46 +27,46 @@
#include "../font_driver.h"
#include "../../retroarch.h"
static const float gl_core_vertexes[] = {
static const float gl3_vertexes[] = {
0, 0,
1, 0,
0, 1,
1, 1
};
static const float gl_core_tex_coords[] = {
static const float gl3_tex_coords[] = {
0, 1,
1, 1,
0, 0,
1, 0
};
static const float gl_core_colors[] = {
static const float gl3_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,
};
static void *gfx_display_gl_core_get_default_mvp(void *data)
static void *gfx_display_gl3_get_default_mvp(void *data)
{
gl_core_t *gl_core = (gl_core_t*)data;
if (!gl_core)
gl3_t *gl3 = (gl3_t*)data;
if (!gl3)
return NULL;
return &gl_core->mvp_no_rot;
return &gl3->mvp_no_rot;
}
static const float *gfx_display_gl_core_get_default_vertices(void)
static const float *gfx_display_gl3_get_default_vertices(void)
{
return &gl_core_vertexes[0];
return &gl3_vertexes[0];
}
static const float *gfx_display_gl_core_get_default_tex_coords(void)
static const float *gfx_display_gl3_get_default_tex_coords(void)
{
return &gl_core_tex_coords[0];
return &gl3_tex_coords[0];
}
static void gfx_display_gl_core_draw_pipeline(
static void gfx_display_gl3_draw_pipeline(
gfx_display_ctx_draw_t *draw,
gfx_display_t *p_disp,
void *data,
@ -80,7 +80,7 @@ static void gfx_display_gl_core_draw_pipeline(
static float t = 0.0f;
float yflip = 0.0f;
video_coord_array_t *ca = NULL;
gl_core_t *gl = (gl_core_t*)data;
gl3_t *gl = (gl3_t*)data;
if (!gl || !draw)
return;
@ -142,16 +142,16 @@ static void gfx_display_gl_core_draw_pipeline(
#endif
}
static void gfx_display_gl_core_draw(gfx_display_ctx_draw_t *draw,
static void gfx_display_gl3_draw(gfx_display_ctx_draw_t *draw,
void *data, unsigned video_width, unsigned video_height)
{
const float *vertex = NULL;
const float *tex_coord = NULL;
const float *color = NULL;
GLuint texture = 0;
gl_core_t *gl = (gl_core_t*)data;
gl3_t *gl = (gl3_t*)data;
const struct
gl_core_buffer_locations
gl3_buffer_locations
*loc = NULL;
if (!gl || !draw)
@ -163,11 +163,11 @@ static void gfx_display_gl_core_draw(gfx_display_ctx_draw_t *draw,
color = draw->coords->color;
if (!vertex)
vertex = gfx_display_gl_core_get_default_vertices();
vertex = gfx_display_gl3_get_default_vertices();
if (!tex_coord)
tex_coord = &gl_core_tex_coords[0];
tex_coord = &gl3_tex_coords[0];
if (!color)
color = &gl_core_colors[0];
color = &gl3_colors[0];
glViewport(draw->x, draw->y, draw->width, draw->height);
@ -245,15 +245,15 @@ static void gfx_display_gl_core_draw(gfx_display_ctx_draw_t *draw,
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
gl_core_bind_scratch_vbo(gl, vertex,
gl3_bind_scratch_vbo(gl, vertex,
2 * sizeof(float) * draw->coords->vertices);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE,
2 * sizeof(float), (void *)(uintptr_t)0);
gl_core_bind_scratch_vbo(gl, tex_coord,
gl3_bind_scratch_vbo(gl, tex_coord,
2 * sizeof(float) * draw->coords->vertices);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE,
2 * sizeof(float), (void *)(uintptr_t)0);
gl_core_bind_scratch_vbo(gl, color,
gl3_bind_scratch_vbo(gl, color,
4 * sizeof(float) * draw->coords->vertices);
glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE,
4 * sizeof(float), (void *)(uintptr_t)0);
@ -279,21 +279,21 @@ static void gfx_display_gl_core_draw(gfx_display_ctx_draw_t *draw,
glBindTexture(GL_TEXTURE_2D, 0);
}
static void gfx_display_gl_core_blend_begin(void *data)
static void gfx_display_gl3_blend_begin(void *data)
{
gl_core_t *gl = (gl_core_t*)data;
gl3_t *gl = (gl3_t*)data;
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUseProgram(gl->pipelines.alpha_blend);
}
static void gfx_display_gl_core_blend_end(void *data)
static void gfx_display_gl3_blend_end(void *data)
{
glDisable(GL_BLEND);
}
static bool gfx_display_gl_core_font_init_first(
static bool gfx_display_gl3_font_init_first(
void **font_handle, void *video_data, const char *font_path,
float menu_font_size, bool is_threaded)
{
@ -309,7 +309,7 @@ static bool gfx_display_gl_core_font_init_first(
return false;
}
static void gfx_display_gl_core_scissor_begin(void *data,
static void gfx_display_gl3_scissor_begin(void *data,
unsigned video_width,
unsigned video_height,
int x, int y, unsigned width, unsigned height)
@ -318,7 +318,7 @@ static void gfx_display_gl_core_scissor_begin(void *data,
glEnable(GL_SCISSOR_TEST);
}
static void gfx_display_gl_core_scissor_end(
static void gfx_display_gl3_scissor_end(
void *data,
unsigned video_width,
unsigned video_height)
@ -326,18 +326,18 @@ static void gfx_display_gl_core_scissor_end(
glDisable(GL_SCISSOR_TEST);
}
gfx_display_ctx_driver_t gfx_display_ctx_gl_core = {
gfx_display_gl_core_draw,
gfx_display_gl_core_draw_pipeline,
gfx_display_gl_core_blend_begin,
gfx_display_gl_core_blend_end,
gfx_display_gl_core_get_default_mvp,
gfx_display_gl_core_get_default_vertices,
gfx_display_gl_core_get_default_tex_coords,
gfx_display_gl_core_font_init_first,
gfx_display_ctx_driver_t gfx_display_ctx_gl3 = {
gfx_display_gl3_draw,
gfx_display_gl3_draw_pipeline,
gfx_display_gl3_blend_begin,
gfx_display_gl3_blend_end,
gfx_display_gl3_get_default_mvp,
gfx_display_gl3_get_default_vertices,
gfx_display_gl3_get_default_tex_coords,
gfx_display_gl3_font_init_first,
GFX_VIDEO_DRIVER_OPENGL_CORE,
"glcore",
false,
gfx_display_gl_core_scissor_begin,
gfx_display_gl_core_scissor_end
gfx_display_gl3_scissor_begin,
gfx_display_gl3_scissor_end
};

106
gfx/drivers_font/gl3_raster_font.c
View File

@ -42,7 +42,7 @@
typedef struct
{
gl_core_t *gl;
gl3_t *gl;
GLuint tex;
const font_renderer_driver_t *font_driver;
@ -50,12 +50,12 @@ typedef struct
struct font_atlas *atlas;
video_font_raster_block_t *block;
} gl_core_raster_t;
} gl3_raster_t;
static void gl_core_raster_font_free_font(void *data,
static void gl3_raster_font_free_font(void *data,
bool is_threaded)
{
gl_core_raster_t *font = (gl_core_raster_t*)data;
gl3_raster_t *font = (gl3_raster_t*)data;
if (!font)
return;
@ -74,7 +74,7 @@ static void gl_core_raster_font_free_font(void *data,
free(font);
}
static bool gl_core_raster_font_upload_atlas(gl_core_raster_t *font)
static bool gl3_raster_font_upload_atlas(gl3_raster_t *font)
{
if (font->tex)
glDeleteTextures(1, &font->tex);
@ -96,16 +96,16 @@ static bool gl_core_raster_font_upload_atlas(gl_core_raster_t *font)
return true;
}
static void *gl_core_raster_font_init_font(void *data,
static void *gl3_raster_font_init_font(void *data,
const char *font_path, float font_size,
bool is_threaded)
{
gl_core_raster_t *font = (gl_core_raster_t*)calloc(1, sizeof(*font));
gl3_raster_t *font = (gl3_raster_t*)calloc(1, sizeof(*font));
if (!font)
return NULL;
font->gl = (gl_core_t*)data;
font->gl = (gl3_t*)data;
if (!font_renderer_create_default(
&font->font_driver,
@ -125,21 +125,21 @@ static void *gl_core_raster_font_init_font(void *data,
font->atlas = font->font_driver->get_atlas(font->font_data);
if (!gl_core_raster_font_upload_atlas(font))
if (!gl3_raster_font_upload_atlas(font))
goto error;
font->atlas->dirty = false;
return font;
error:
gl_core_raster_font_free_font(font, is_threaded);
gl3_raster_font_free_font(font, is_threaded);
return NULL;
}
static int gl_core_get_message_width(void *data, const char *msg,
static int gl3_get_message_width(void *data, const char *msg,
unsigned msg_len, float scale)
{
gl_core_raster_t *font = (gl_core_raster_t*)data;
gl3_raster_t *font = (gl3_raster_t*)data;
const char* msg_end = msg + msg_len;
int delta_x = 0;
@ -166,12 +166,12 @@ static int gl_core_get_message_width(void *data, const char *msg,
return delta_x * scale;
}
static void gl_core_raster_font_draw_vertices(gl_core_raster_t *font,
static void gl3_raster_font_draw_vertices(gl3_raster_t *font,
const video_coords_t *coords)
{
if (font->atlas->dirty)
{
gl_core_raster_font_upload_atlas(font);
gl3_raster_font_upload_atlas(font);
font->atlas->dirty = false;
}
@ -187,13 +187,13 @@ static void gl_core_raster_font_draw_vertices(gl_core_raster_t *font,
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
gl_core_bind_scratch_vbo(font->gl, coords->vertex, 2 * sizeof(float) * coords->vertices);
gl3_bind_scratch_vbo(font->gl, coords->vertex, 2 * sizeof(float) * coords->vertices);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void *)(uintptr_t)0);
gl_core_bind_scratch_vbo(font->gl, coords->tex_coord, 2 * sizeof(float) * coords->vertices);
gl3_bind_scratch_vbo(font->gl, coords->tex_coord, 2 * sizeof(float) * coords->vertices);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void *)(uintptr_t)0);
gl_core_bind_scratch_vbo(font->gl, coords->color, 4 * sizeof(float) * coords->vertices);
gl3_bind_scratch_vbo(font->gl, coords->color, 4 * sizeof(float) * coords->vertices);
glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void *)(uintptr_t)0);
glDrawArrays(GL_TRIANGLES, 0, coords->vertices);
@ -204,8 +204,8 @@ static void gl_core_raster_font_draw_vertices(gl_core_raster_t *font,
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
static void gl_core_raster_font_render_line(
gl_core_raster_t *font, const char *msg, unsigned msg_len,
static void gl3_raster_font_render_line(
gl3_raster_t *font, const char *msg, unsigned msg_len,
GLfloat scale, const GLfloat color[4], GLfloat pos_x,
GLfloat pos_y, unsigned text_align)
{
@ -214,7 +214,7 @@ static void gl_core_raster_font_render_line(
GLfloat font_tex_coords[2 * 6 * MAX_MSG_LEN_CHUNK];
GLfloat font_vertex[2 * 6 * MAX_MSG_LEN_CHUNK];
GLfloat font_color[4 * 6 * MAX_MSG_LEN_CHUNK];
gl_core_t *gl = font->gl;
gl3_t *gl = font->gl;
const char* msg_end = msg + msg_len;
int x = roundf(pos_x * gl->vp.width);
int y = roundf(pos_y * gl->vp.height);
@ -228,10 +228,10 @@ static void gl_core_raster_font_render_line(
switch (text_align)
{
case TEXT_ALIGN_RIGHT:
x -= gl_core_get_message_width(font, msg, msg_len, scale);
x -= gl3_get_message_width(font, msg, msg_len, scale);
break;
case TEXT_ALIGN_CENTER:
x -= gl_core_get_message_width(font, msg, msg_len, scale) / 2.0;
x -= gl3_get_message_width(font, msg, msg_len, scale) / 2.0;
break;
}
@ -281,12 +281,12 @@ static void gl_core_raster_font_render_line(
if (font->block)
video_coord_array_append(&font->block->carr, &coords, coords.vertices);
else
gl_core_raster_font_draw_vertices(font, &coords);
gl3_raster_font_draw_vertices(font, &coords);
}
}
static void gl_core_raster_font_render_message(
gl_core_raster_t *font, const char *msg, GLfloat scale,
static void gl3_raster_font_render_message(
gl3_raster_t *font, const char *msg, GLfloat scale,
const GLfloat color[4], GLfloat pos_x, GLfloat pos_y,
unsigned text_align)
{
@ -298,7 +298,7 @@ static void gl_core_raster_font_render_message(
if (!font->font_driver->get_line_metrics ||
!font->font_driver->get_line_metrics(font->font_data, &line_metrics))
{
gl_core_raster_font_render_line(font,
gl3_raster_font_render_line(font,
msg, (unsigned)strlen(msg), scale, color, pos_x,
pos_y, text_align);
return;
@ -313,7 +313,7 @@ static void gl_core_raster_font_render_message(
? (unsigned)(delim - msg) : (unsigned)strlen(msg);
/* Draw the line */
gl_core_raster_font_render_line(font,
gl3_raster_font_render_line(font,
msg, msg_len, scale, color, pos_x,
pos_y - (float)lines*line_height, text_align);
@ -325,8 +325,8 @@ static void gl_core_raster_font_render_message(
}
}
static void gl_core_raster_font_setup_viewport(unsigned width, unsigned height,
gl_core_raster_t *font, bool full_screen)
static void gl3_raster_font_setup_viewport(unsigned width, unsigned height,
gl3_raster_t *font, bool full_screen)
{
video_driver_set_viewport(width, height, full_screen, false);
@ -337,7 +337,7 @@ static void gl_core_raster_font_setup_viewport(unsigned width, unsigned height,
glUseProgram(font->gl->pipelines.font);
}
static void gl_core_raster_font_render_msg(
static void gl3_raster_font_render_msg(
void *userdata,
void *data,
const char *msg,
@ -348,7 +348,7 @@ static void gl_core_raster_font_render_msg(
GLfloat x, y, scale, drop_mod, drop_alpha;
enum text_alignment text_align = TEXT_ALIGN_LEFT;
bool full_screen = false ;
gl_core_raster_t *font = (gl_core_raster_t*)data;
gl3_raster_t *font = (gl3_raster_t*)data;
unsigned width = font->gl->video_width;
unsigned height = font->gl->video_height;
settings_t *settings = config_get_ptr();
@ -404,7 +404,7 @@ static void gl_core_raster_font_render_msg(
if (font->block)
font->block->fullscreen = full_screen;
else
gl_core_raster_font_setup_viewport(width, height, font, full_screen);
gl3_raster_font_setup_viewport(width, height, font, full_screen);
if (font->gl)
{
@ -420,12 +420,12 @@ static void gl_core_raster_font_render_msg(
color_dark[2] = color[2] * drop_mod;
color_dark[3] = color[3] * drop_alpha;
gl_core_raster_font_render_message(font, msg, scale, color_dark,
gl3_raster_font_render_message(font, msg, scale, color_dark,
x + scale * drop_x / font->gl->vp.width, y +
scale * drop_y / font->gl->vp.height, text_align);
}
gl_core_raster_font_render_message(font, msg, scale, color,
gl3_raster_font_render_message(font, msg, scale, color,
x, y, text_align);
}
@ -437,10 +437,10 @@ static void gl_core_raster_font_render_msg(
}
}
static const struct font_glyph *gl_core_raster_font_get_glyph(
static const struct font_glyph *gl3_raster_font_get_glyph(
void *data, uint32_t code)
{
gl_core_raster_t *font = (gl_core_raster_t*)data;
gl3_raster_t *font = (gl3_raster_t*)data;
if (!font || !font->font_driver)
return NULL;
@ -449,17 +449,17 @@ static const struct font_glyph *gl_core_raster_font_get_glyph(
return font->font_driver->get_glyph((void*)font->font_driver, code);
}
static void gl_core_raster_font_flush_block(unsigned width, unsigned height,
static void gl3_raster_font_flush_block(unsigned width, unsigned height,
void *data)
{
gl_core_raster_t *font = (gl_core_raster_t*)data;
gl3_raster_t *font = (gl3_raster_t*)data;
video_font_raster_block_t *block = font ? font->block : NULL;
if (!font || !block || !block->carr.coords.vertices)
return;
gl_core_raster_font_setup_viewport(width, height, font, block->fullscreen);
gl_core_raster_font_draw_vertices(font, (video_coords_t*)&block->carr.coords);
gl3_raster_font_setup_viewport(width, height, font, block->fullscreen);
gl3_raster_font_draw_vertices(font, (video_coords_t*)&block->carr.coords);
if (font->gl)
{
@ -468,18 +468,18 @@ static void gl_core_raster_font_flush_block(unsigned width, unsigned height,
}
}
static void gl_core_raster_font_bind_block(void *data, void *userdata)
static void gl3_raster_font_bind_block(void *data, void *userdata)
{
gl_core_raster_t *font = (gl_core_raster_t*)data;
gl3_raster_t *font = (gl3_raster_t*)data;
video_font_raster_block_t *block = (video_font_raster_block_t*)userdata;
if (font)
font->block = block;
}
static bool gl_core_get_line_metrics(void* data, struct font_line_metrics **metrics)
static bool gl3_get_line_metrics(void* data, struct font_line_metrics **metrics)
{
gl_core_raster_t *font = (gl_core_raster_t*)data;
gl3_raster_t *font = (gl3_raster_t*)data;
if (!font || !font->font_driver || !font->font_data)
return -1;
@ -487,14 +487,14 @@ static bool gl_core_get_line_metrics(void* data, struct font_line_metrics **metr
return font->font_driver->get_line_metrics(font->font_data, metrics);
}
font_renderer_t gl_core_raster_font = {
gl_core_raster_font_init_font,
gl_core_raster_font_free_font,
gl_core_raster_font_render_msg,
font_renderer_t gl3_raster_font = {
gl3_raster_font_init_font,
gl3_raster_font_free_font,
gl3_raster_font_render_msg,
"GLCore raster",
gl_core_raster_font_get_glyph,
gl_core_raster_font_bind_block,
gl_core_raster_font_flush_block,
gl_core_get_message_width,
gl_core_get_line_metrics
gl3_raster_font_get_glyph,
gl3_raster_font_bind_block,
gl3_raster_font_flush_block,
gl3_get_message_width,
gl3_get_line_metrics
};

250
gfx/drivers_shader/shader_gl3.cpp
View File

@ -37,10 +37,10 @@
#include "../../verbosity.h"
#include "../../msg_hash.h"
GLuint gl_core_cross_compile_program(
GLuint gl3_cross_compile_program(
const uint32_t *vertex, size_t vertex_size,
const uint32_t *fragment, size_t fragment_size,
gl_core_buffer_locations *loc, bool flatten)
gl3_buffer_locations *loc, bool flatten)
{
GLuint program = 0;
try
@ -55,7 +55,7 @@ GLuint gl_core_cross_compile_program(
#else
opts.es = false;
#endif
opts.version = gl_core_get_cross_compiler_target_version();
opts.version = gl3_get_cross_compiler_target_version();
opts.fragment.default_float_precision = spirv_cross::CompilerGLSL::Options::Precision::Highp;
opts.fragment.default_int_precision = spirv_cross::CompilerGLSL::Options::Precision::Highp;
opts.enable_420pack_extension = false;
@ -163,8 +163,8 @@ GLuint gl_core_cross_compile_program(
auto vertex_source = vertex_compiler.compile();
auto fragment_source = fragment_compiler.compile();
GLuint vertex_shader = gl_core_compile_shader(GL_VERTEX_SHADER, vertex_source.c_str());
GLuint fragment_shader = gl_core_compile_shader(GL_FRAGMENT_SHADER, fragment_source.c_str());
GLuint vertex_shader = gl3_compile_shader(GL_VERTEX_SHADER, vertex_source.c_str());
GLuint fragment_shader = gl3_compile_shader(GL_FRAGMENT_SHADER, fragment_source.c_str());
#if 0
RARCH_LOG("[GLCore]: Vertex shader:\n========\n%s\n=======\n", vertex_source.c_str());
@ -264,7 +264,7 @@ GLuint gl_core_cross_compile_program(
return program;
}
namespace gl_core_shader
namespace gl3_shader
{
static const uint32_t opaque_vert[] =
#include "../drivers/vulkan_shaders/opaque.vert.inc"
@ -276,7 +276,7 @@ static const uint32_t opaque_frag[] =
struct Texture
{
gl_core_filter_chain_texture texture;
gl3_filter_chain_texture texture;
glslang_filter_chain_filter filter;
glslang_filter_chain_filter mip_filter;
glslang_filter_chain_address address;
@ -473,7 +473,7 @@ struct CommonResources
GLuint quad_program = 0;
GLuint quad_vbo = 0;
gl_core_buffer_locations quad_loc = {};
gl3_buffer_locations quad_loc = {};
};
CommonResources::CommonResources()
@ -490,7 +490,7 @@ CommonResources::CommonResources()
glBufferData(GL_ARRAY_BUFFER, sizeof(quad_data), quad_data, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
quad_program = gl_core_cross_compile_program(
quad_program = gl3_cross_compile_program(
opaque_vert, sizeof(opaque_vert),
opaque_frag, sizeof(opaque_frag), &quad_loc, true);
}
@ -679,7 +679,7 @@ public:
return framebuffer_feedback.get();
}
void set_pass_info(const gl_core_filter_chain_pass_info &info);
void set_pass_info(const gl3_filter_chain_pass_info &info);
void set_shader(GLenum stage,
const uint32_t *spirv,
@ -691,7 +691,7 @@ public:
void build_commands(
const Texture &original,
const Texture &source,
const gl_core_viewport &vp,
const gl3_viewport &vp,
const float *mvp);
void set_frame_count(uint64_t count)
@ -764,8 +764,8 @@ private:
CommonResources *common = nullptr;
Size2D current_framebuffer_size = {};
gl_core_viewport current_viewport;
gl_core_filter_chain_pass_info pass_info;
gl3_viewport current_viewport;
gl3_filter_chain_pass_info pass_info;
std::vector<uint32_t> vertex_shader;
std::vector<uint32_t> fragment_shader;
@ -821,7 +821,7 @@ private:
std::vector<Parameter> parameters;
std::vector<Parameter> filtered_parameters;
std::vector<uint8_t> push_constant_buffer;
gl_core_buffer_locations locations = {};
gl3_buffer_locations locations = {};
UBORing ubo_ring;
void reflect_parameter(const std::string &name, slang_semantic_meta &meta);
@ -970,7 +970,7 @@ void Pass::reflect_parameter_array(const char *name, std::vector<slang_texture_s
bool Pass::init_pipeline()
{
pipeline = gl_core_cross_compile_program(
pipeline = gl3_cross_compile_program(
vertex_shader.data(), vertex_shader.size() * sizeof(uint32_t),
fragment_shader.data(), fragment_shader.size() * sizeof(uint32_t),
&locations, false);
@ -1024,7 +1024,7 @@ bool Pass::init_pipeline()
return true;
}
void Pass::set_pass_info(const gl_core_filter_chain_pass_info &info)
void Pass::set_pass_info(const gl3_filter_chain_pass_info &info)
{
pass_info = info;
}
@ -1400,7 +1400,7 @@ void Pass::build_semantics(uint8_t *buffer,
memcpy(buffer + offset,
mvp, sizeof(float) * 16);
else
gl_core_build_default_matrix(reinterpret_cast<float *>(
gl3_build_default_matrix(reinterpret_cast<float *>(
buffer + offset));
}
@ -1413,7 +1413,7 @@ void Pass::build_semantics(uint8_t *buffer,
memcpy(push_constant_buffer.data() + offset,
mvp, sizeof(float) * 16);
else
gl_core_build_default_matrix(reinterpret_cast<float *>(
gl3_build_default_matrix(reinterpret_cast<float *>(
push_constant_buffer.data() + offset));
}
@ -1476,7 +1476,7 @@ void Pass::build_semantics(uint8_t *buffer,
void Pass::build_commands(
const Texture &original,
const Texture &source,
const gl_core_viewport &vp,
const gl3_viewport &vp,
const float *mvp)
{
current_viewport = vp;
@ -1597,10 +1597,10 @@ void Pass::build_commands(
}
struct gl_core_filter_chain
struct gl3_filter_chain
{
public:
gl_core_filter_chain(unsigned num_passes) { set_num_passes(num_passes); }
gl3_filter_chain(unsigned num_passes) { set_num_passes(num_passes); }
inline void set_shader_preset(std::unique_ptr<video_shader> shader)
{
@ -1613,15 +1613,15 @@ public:
}
void set_pass_info(unsigned pass,
const gl_core_filter_chain_pass_info &info);
const gl3_filter_chain_pass_info &info);
void set_shader(unsigned pass, GLenum stage,
const uint32_t *spirv, size_t spirv_words);
bool init();
void set_input_texture(const gl_core_filter_chain_texture &texture);
void build_offscreen_passes(const gl_core_viewport &vp);
void build_viewport_pass(const gl_core_viewport &vp, const float *mvp);
void set_input_texture(const gl3_filter_chain_texture &texture);
void build_offscreen_passes(const gl3_viewport &vp);
void build_viewport_pass(const gl3_viewport &vp, const float *mvp);
void end_frame();
void set_frame_count(uint64_t count);
@ -1629,23 +1629,23 @@ public:
void set_frame_direction(int32_t direction);
void set_pass_name(unsigned pass, const char *name);
void add_static_texture(std::unique_ptr<gl_core_shader::StaticTexture> texture);
void add_static_texture(std::unique_ptr<gl3_shader::StaticTexture> texture);
void add_parameter(unsigned pass, unsigned parameter_index, const std::string &id);
void set_num_passes(unsigned passes);
private:
std::vector<std::unique_ptr<gl_core_shader::Pass>> passes;
std::vector<gl_core_filter_chain_pass_info> pass_info;
std::vector<std::unique_ptr<gl3_shader::Pass>> passes;
std::vector<gl3_filter_chain_pass_info> pass_info;
std::vector<std::vector<std::function<void ()>>> deferred_calls;
std::unique_ptr<gl_core_shader::Framebuffer> copy_framebuffer;
gl_core_shader::CommonResources common;
std::unique_ptr<gl3_shader::Framebuffer> copy_framebuffer;
gl3_shader::CommonResources common;
gl_core_filter_chain_texture input_texture = {};
gl3_filter_chain_texture input_texture = {};
bool init_history();
bool init_feedback();
bool init_alias();
std::vector<std::unique_ptr<gl_core_shader::Framebuffer>> original_history;
std::vector<std::unique_ptr<gl3_shader::Framebuffer>> original_history;
bool require_clear = false;
void clear_history_and_feedback();
void update_feedback_info();
@ -1653,13 +1653,13 @@ private:
};
void gl_core_filter_chain::update_history_info()
void gl3_filter_chain::update_history_info()
{
unsigned i;
for (i = 0; i < original_history.size(); i++)
{
gl_core_shader::Texture *source = (gl_core_shader::Texture*)
gl3_shader::Texture *source = (gl3_shader::Texture*)
&common.original_history[i];
if (!source)
@ -1674,17 +1674,17 @@ void gl_core_filter_chain::update_history_info()
}
}
void gl_core_filter_chain::update_feedback_info()
void gl3_filter_chain::update_feedback_info()
{
unsigned i;
for (i = 0; i < passes.size() - 1; i++)
{
gl_core_shader::Framebuffer *fb = passes[i]->get_feedback_framebuffer();
gl3_shader::Framebuffer *fb = passes[i]->get_feedback_framebuffer();
if (!fb)
continue;
gl_core_shader::Texture *source = (gl_core_shader::Texture*)
gl3_shader::Texture *source = (gl3_shader::Texture*)
&common.framebuffer_feedback[i];
if (!source)
@ -1699,7 +1699,7 @@ void gl_core_filter_chain::update_feedback_info()
}
}
void gl_core_filter_chain::build_offscreen_passes(const gl_core_viewport &vp)
void gl3_filter_chain::build_offscreen_passes(const gl3_viewport &vp)
{
unsigned i;
@ -1715,19 +1715,19 @@ void gl_core_filter_chain::build_offscreen_passes(const gl_core_viewport &vp)
if (!common.framebuffer_feedback.empty())
update_feedback_info();
const gl_core_shader::Texture original = {
const gl3_shader::Texture original = {
input_texture,
passes.front()->get_source_filter(),
passes.front()->get_mip_filter(),
passes.front()->get_address_mode(),
};
gl_core_shader::Texture source = original;
gl3_shader::Texture source = original;
for (i = 0; i < passes.size() - 1; i++)
{
passes[i]->build_commands(original, source, vp, nullptr);
const gl_core_shader::Framebuffer &fb = passes[i]->get_framebuffer();
const gl3_shader::Framebuffer &fb = passes[i]->get_framebuffer();
source.texture.image = fb.get_image();
source.texture.width = fb.get_size().width;
@ -1740,7 +1740,7 @@ void gl_core_filter_chain::build_offscreen_passes(const gl_core_viewport &vp)
}
}
void gl_core_filter_chain::end_frame()
void gl3_filter_chain::end_frame()
{
/* If we need to keep old frames, copy it after fragment is complete.
* TODO: We can improve pipelining by figuring out which
@ -1749,8 +1749,8 @@ void gl_core_filter_chain::end_frame()
if (!original_history.empty())
{
/* Update history */
std::unique_ptr<gl_core_shader::Framebuffer> tmp;
std::unique_ptr<gl_core_shader::Framebuffer> &back = original_history.back();
std::unique_ptr<gl3_shader::Framebuffer> tmp;
std::unique_ptr<gl3_shader::Framebuffer> &back = original_history.back();
swap(back, tmp);
if (input_texture.width != tmp->get_size().width ||
@ -1760,7 +1760,7 @@ void gl_core_filter_chain::end_frame()
tmp->set_size({ input_texture.width, input_texture.height }, input_texture.format);
if (tmp->is_complete())
gl_core_framebuffer_copy(
gl3_framebuffer_copy(
tmp->get_framebuffer(),
common.quad_program,
common.quad_vbo,
@ -1774,8 +1774,8 @@ void gl_core_filter_chain::end_frame()
}
}
void gl_core_filter_chain::build_viewport_pass(
const gl_core_viewport &vp, const float *mvp)
void gl3_filter_chain::build_viewport_pass(
const gl3_viewport &vp, const float *mvp)
{
unsigned i;
/* First frame, make sure our history and
@ -1786,8 +1786,8 @@ void gl_core_filter_chain::build_viewport_pass(
require_clear = false;
}
gl_core_shader::Texture source;
const gl_core_shader::Texture original = {
gl3_shader::Texture source;
const gl3_shader::Texture original = {
input_texture,
passes.front()->get_source_filter(),
passes.front()->get_mip_filter(),
@ -1805,7 +1805,7 @@ void gl_core_filter_chain::build_viewport_pass(
}
else
{
const gl_core_shader::Framebuffer &fb = passes[passes.size() - 2]
const gl3_shader::Framebuffer &fb = passes[passes.size() - 2]
->get_framebuffer();
source.texture.image = fb.get_image();
source.texture.width = fb.get_size().width;
@ -1820,13 +1820,13 @@ void gl_core_filter_chain::build_viewport_pass(
/* For feedback FBOs, swap current and previous. */
for (i = 0; i < passes.size(); i++)
{
gl_core_shader::Framebuffer *fb = passes[i]->get_feedback_framebuffer();
gl3_shader::Framebuffer *fb = passes[i]->get_feedback_framebuffer();
if (fb)
passes[i]->end_frame();
}
}
bool gl_core_filter_chain::init_history()
bool gl3_filter_chain::init_history()
{
unsigned i;
size_t required_images = 0;
@ -1853,7 +1853,7 @@ bool gl_core_filter_chain::init_history()
common.original_history.resize(required_images);
for (i = 0; i < required_images; i++)
original_history.emplace_back(new gl_core_shader::Framebuffer(0, 1));
original_history.emplace_back(new gl3_shader::Framebuffer(0, 1));
RARCH_LOG("[GLCore]: Using history of %u frames.\n", unsigned(required_images));
@ -1865,7 +1865,7 @@ bool gl_core_filter_chain::init_history()
return true;
}
bool gl_core_filter_chain::init_feedback()
bool gl3_filter_chain::init_feedback()
{
unsigned i;
bool use_feedbacks = false;
@ -1907,7 +1907,7 @@ bool gl_core_filter_chain::init_feedback()
return true;
}
bool gl_core_filter_chain::init_alias()
bool gl3_filter_chain::init_alias()
{
unsigned i, j;
common.texture_semantic_map.clear();
@ -1958,14 +1958,14 @@ bool gl_core_filter_chain::init_alias()
return true;
}
void gl_core_filter_chain::set_pass_info(unsigned pass, const gl_core_filter_chain_pass_info &info)
void gl3_filter_chain::set_pass_info(unsigned pass, const gl3_filter_chain_pass_info &info)
{
if (pass >= pass_info.size())
pass_info.resize(pass + 1);
pass_info[pass] = info;
}
void gl_core_filter_chain::set_num_passes(unsigned num_passes)
void gl3_filter_chain::set_num_passes(unsigned num_passes)
{
unsigned i;
@ -1974,24 +1974,24 @@ void gl_core_filter_chain::set_num_passes(unsigned num_passes)
for (i = 0; i < num_passes; i++)
{
passes.emplace_back(new gl_core_shader::Pass(i + 1 == num_passes));
passes.emplace_back(new gl3_shader::Pass(i + 1 == num_passes));
passes.back()->set_common_resources(&common);
passes.back()->set_pass_number(i);
}
}
void gl_core_filter_chain::set_shader(unsigned pass, GLenum stage, const uint32_t *spirv, size_t spirv_words)
void gl3_filter_chain::set_shader(unsigned pass, GLenum stage, const uint32_t *spirv, size_t spirv_words)
{
passes[pass]->set_shader(stage, spirv, spirv_words);
}
void gl_core_filter_chain::add_parameter(unsigned pass,
void gl3_filter_chain::add_parameter(unsigned pass,
unsigned index, const std::string &id)
{
passes[pass]->add_parameter(index, id);
}
bool gl_core_filter_chain::init()
bool gl3_filter_chain::init()
{
unsigned i;
@ -2019,24 +2019,24 @@ bool gl_core_filter_chain::init()
return true;
}
void gl_core_filter_chain::clear_history_and_feedback()
void gl3_filter_chain::clear_history_and_feedback()
{
unsigned i;
for (i = 0; i < original_history.size(); i++)
{
if (original_history[i]->is_complete())
gl_core_framebuffer_clear(original_history[i]->get_framebuffer());
gl3_framebuffer_clear(original_history[i]->get_framebuffer());
}
for (i = 0; i < passes.size(); i++)
{
gl_core_shader::Framebuffer *fb = passes[i]->get_feedback_framebuffer();
gl3_shader::Framebuffer *fb = passes[i]->get_feedback_framebuffer();
if (fb && fb->is_complete())
gl_core_framebuffer_clear(fb->get_framebuffer());
gl3_framebuffer_clear(fb->get_framebuffer());
}
}
void gl_core_filter_chain::set_input_texture(
const gl_core_filter_chain_texture &texture)
void gl3_filter_chain::set_input_texture(
const gl3_filter_chain_texture &texture)
{
input_texture = texture;
@ -2046,7 +2046,7 @@ void gl_core_filter_chain::set_input_texture(
input_texture.padded_height != input_texture.height)
{
if (!copy_framebuffer)
copy_framebuffer.reset(new gl_core_shader::Framebuffer(texture.format, 1));
copy_framebuffer.reset(new gl3_shader::Framebuffer(texture.format, 1));
if (input_texture.width != copy_framebuffer->get_size().width ||
input_texture.height != copy_framebuffer->get_size().height ||
@ -2055,7 +2055,7 @@ void gl_core_filter_chain::set_input_texture(
copy_framebuffer->set_size({ input_texture.width, input_texture.height }, input_texture.format);
if (copy_framebuffer->is_complete())
gl_core_framebuffer_copy_partial(
gl3_framebuffer_copy_partial(
copy_framebuffer->get_framebuffer(),
common.quad_program,
common.quad_loc.flat_ubo_vertex,
@ -2069,37 +2069,37 @@ void gl_core_filter_chain::set_input_texture(
}
}
void gl_core_filter_chain::add_static_texture(std::unique_ptr<gl_core_shader::StaticTexture> texture)
void gl3_filter_chain::add_static_texture(std::unique_ptr<gl3_shader::StaticTexture> texture)
{
common.luts.push_back(std::move(texture));
}
void gl_core_filter_chain::set_frame_count(uint64_t count)
void gl3_filter_chain::set_frame_count(uint64_t count)
{
unsigned i;
for (i = 0; i < passes.size(); i++)
passes[i]->set_frame_count(count);
}
void gl_core_filter_chain::set_frame_count_period(unsigned pass, unsigned period)
void gl3_filter_chain::set_frame_count_period(unsigned pass, unsigned period)
{
passes[pass]->set_frame_count_period(period);
}
void gl_core_filter_chain::set_frame_direction(int32_t direction)
void gl3_filter_chain::set_frame_direction(int32_t direction)
{
unsigned i;
for (i = 0; i < passes.size(); i++)
passes[i]->set_frame_direction(direction);
}
void gl_core_filter_chain::set_pass_name(unsigned pass, const char *name)
void gl3_filter_chain::set_pass_name(unsigned pass, const char *name)
{
passes[pass]->set_name(name);
}
static std::unique_ptr<gl_core_shader::StaticTexture> gl_core_filter_chain_load_lut(
gl_core_filter_chain *chain,
static std::unique_ptr<gl3_shader::StaticTexture> gl3_filter_chain_load_lut(
gl3_filter_chain *chain,
const video_shader_lut *shader)
{
texture_image image;
@ -2134,21 +2134,21 @@ static std::unique_ptr<gl_core_shader::StaticTexture> gl_core_filter_chain_load_
if (image.pixels)
image_texture_free(&image);
return std::unique_ptr<gl_core_shader::StaticTexture>(new gl_core_shader::StaticTexture(shader->id,
return std::unique_ptr<gl3_shader::StaticTexture>(new gl3_shader::StaticTexture(shader->id,
tex, image.width, image.height,
shader->filter != RARCH_FILTER_NEAREST,
levels > 1,
rarch_wrap_to_address(shader->wrap)));
}
static bool gl_core_filter_chain_load_luts(
gl_core_filter_chain *chain,
static bool gl3_filter_chain_load_luts(
gl3_filter_chain *chain,
video_shader *shader)
{
unsigned i;
for (i = 0; i < shader->luts; i++)
{
std::unique_ptr<gl_core_shader::StaticTexture> image = gl_core_filter_chain_load_lut(chain, &shader->lut[i]);
std::unique_ptr<gl3_shader::StaticTexture> image = gl3_filter_chain_load_lut(chain, &shader->lut[i]);
if (!image)
{
RARCH_ERR("[GLCore]: Failed to load LUT \"%s\".\n", shader->lut[i].path);
@ -2161,12 +2161,12 @@ static bool gl_core_filter_chain_load_luts(
return true;
}
gl_core_filter_chain_t *gl_core_filter_chain_create_default(
gl3_filter_chain_t *gl3_filter_chain_create_default(
glslang_filter_chain_filter filter)
{
struct gl_core_filter_chain_pass_info pass_info;
struct gl3_filter_chain_pass_info pass_info;
std::unique_ptr<gl_core_filter_chain> chain{ new gl_core_filter_chain(1) };
std::unique_ptr<gl3_filter_chain> chain{ new gl3_filter_chain(1) };
if (!chain)
return nullptr;
@ -2183,11 +2183,11 @@ gl_core_filter_chain_t *gl_core_filter_chain_create_default(
chain->set_pass_info(0, pass_info);
chain->set_shader(0, GL_VERTEX_SHADER,
gl_core_shader::opaque_vert,
sizeof(gl_core_shader::opaque_vert) / sizeof(uint32_t));
gl3_shader::opaque_vert,
sizeof(gl3_shader::opaque_vert) / sizeof(uint32_t));
chain->set_shader(0, GL_FRAGMENT_SHADER,
gl_core_shader::opaque_frag,
sizeof(gl_core_shader::opaque_frag) / sizeof(uint32_t));
gl3_shader::opaque_frag,
sizeof(gl3_shader::opaque_frag) / sizeof(uint32_t));
if (!chain->init())
return nullptr;
@ -2195,7 +2195,7 @@ gl_core_filter_chain_t *gl_core_filter_chain_create_default(
return chain.release();
}
gl_core_filter_chain_t *gl_core_filter_chain_create_from_preset(
gl3_filter_chain_t *gl3_filter_chain_create_from_preset(
const char *path, glslang_filter_chain_filter filter)
{
unsigned i;
@ -2208,12 +2208,12 @@ gl_core_filter_chain_t *gl_core_filter_chain_create_from_preset(
bool last_pass_is_fbo = shader->pass[shader->passes - 1].fbo.valid;
std::unique_ptr<gl_core_filter_chain> chain{ new gl_core_filter_chain(shader->passes + (last_pass_is_fbo ? 1 : 0)) };
std::unique_ptr<gl3_filter_chain> chain{ new gl3_filter_chain(shader->passes + (last_pass_is_fbo ? 1 : 0)) };
if (!chain)
return nullptr;
if ( shader->luts
&& !gl_core_filter_chain_load_luts(chain.get(), shader.get()))
&& !gl3_filter_chain_load_luts(chain.get(), shader.get()))
return nullptr;
shader->num_parameters = 0;
@ -2221,7 +2221,7 @@ gl_core_filter_chain_t *gl_core_filter_chain_create_from_preset(
for (i = 0; i < shader->passes; i++)
{
glslang_output output;
struct gl_core_filter_chain_pass_info pass_info;
struct gl3_filter_chain_pass_info pass_info;
const video_shader_pass *pass = &shader->pass[i];
const video_shader_pass *next_pass =
i + 1 < shader->passes ? &shader->pass[i + 1] : nullptr;
@ -2361,7 +2361,7 @@ gl_core_filter_chain_t *gl_core_filter_chain_create_from_preset(
}
else
{
pass_info.rt_format = gl_core_shader::convert_glslang_format(output.meta.rt_format);
pass_info.rt_format = gl3_shader::convert_glslang_format(output.meta.rt_format);
RARCH_LOG("[slang]: Using render target format %s for pass output #%u.\n",
glslang_format_to_string(output.meta.rt_format), i);
}
@ -2375,7 +2375,7 @@ gl_core_filter_chain_t *gl_core_filter_chain_create_from_preset(
else if (pass->fbo.fp_fbo)
output.meta.rt_format = SLANG_FORMAT_R16G16B16A16_SFLOAT;
pass_info.rt_format = gl_core_shader::convert_glslang_format(output.meta.rt_format);
pass_info.rt_format = gl3_shader::convert_glslang_format(output.meta.rt_format);
RARCH_LOG("[slang]: Using render target format %s for pass output #%u.\n",
glslang_format_to_string(output.meta.rt_format), i);
@ -2421,7 +2421,7 @@ gl_core_filter_chain_t *gl_core_filter_chain_create_from_preset(
if (last_pass_is_fbo)
{
struct gl_core_filter_chain_pass_info pass_info;
struct gl3_filter_chain_pass_info pass_info;
pass_info.scale_type_x = GLSLANG_FILTER_CHAIN_SCALE_VIEWPORT;
pass_info.scale_type_y = GLSLANG_FILTER_CHAIN_SCALE_VIEWPORT;
@ -2440,13 +2440,13 @@ gl_core_filter_chain_t *gl_core_filter_chain_create_from_preset(
chain->set_shader(shader->passes,
GL_VERTEX_SHADER,
gl_core_shader::opaque_vert,
sizeof(gl_core_shader::opaque_vert) / sizeof(uint32_t));
gl3_shader::opaque_vert,
sizeof(gl3_shader::opaque_vert) / sizeof(uint32_t));
chain->set_shader(shader->passes,
GL_FRAGMENT_SHADER,
gl_core_shader::opaque_frag,
sizeof(gl_core_shader::opaque_frag) / sizeof(uint32_t));
gl3_shader::opaque_frag,
sizeof(gl3_shader::opaque_frag) / sizeof(uint32_t));
}
chain->set_shader_preset(std::move(shader));
@ -2457,12 +2457,12 @@ gl_core_filter_chain_t *gl_core_filter_chain_create_from_preset(
return chain.release();
}
struct video_shader *gl_core_filter_chain_get_preset(
gl_core_filter_chain_t *chain) { return chain->get_shader_preset(); }
void gl_core_filter_chain_free(gl_core_filter_chain_t *chain) { delete chain; }
struct video_shader *gl3_filter_chain_get_preset(
gl3_filter_chain_t *chain) { return chain->get_shader_preset(); }
void gl3_filter_chain_free(gl3_filter_chain_t *chain) { delete chain; }
void gl_core_filter_chain_set_shader(
gl_core_filter_chain_t *chain,
void gl3_filter_chain_set_shader(
gl3_filter_chain_t *chain,
unsigned pass,
GLenum shader_stage,
const uint32_t *spirv,
@ -2471,71 +2471,71 @@ void gl_core_filter_chain_set_shader(
chain->set_shader(pass, shader_stage, spirv, spirv_words);
}
void gl_core_filter_chain_set_pass_info(
gl_core_filter_chain_t *chain,
void gl3_filter_chain_set_pass_info(
gl3_filter_chain_t *chain,
unsigned pass,
const struct gl_core_filter_chain_pass_info *info)
const struct gl3_filter_chain_pass_info *info)
{
chain->set_pass_info(pass, *info);
}
bool gl_core_filter_chain_init(gl_core_filter_chain_t *chain)
bool gl3_filter_chain_init(gl3_filter_chain_t *chain)
{
return chain->init();
}
void gl_core_filter_chain_set_input_texture(
gl_core_filter_chain_t *chain,
const struct gl_core_filter_chain_texture *texture)
void gl3_filter_chain_set_input_texture(
gl3_filter_chain_t *chain,
const struct gl3_filter_chain_texture *texture)
{
chain->set_input_texture(*texture);
}
void gl_core_filter_chain_set_frame_count(
gl_core_filter_chain_t *chain,
void gl3_filter_chain_set_frame_count(
gl3_filter_chain_t *chain,
uint64_t count)
{
chain->set_frame_count(count);
}
void gl_core_filter_chain_set_frame_direction(
gl_core_filter_chain_t *chain,
void gl3_filter_chain_set_frame_direction(
gl3_filter_chain_t *chain,
int32_t direction)
{
chain->set_frame_direction(direction);
}
void gl_core_filter_chain_set_frame_count_period(
gl_core_filter_chain_t *chain,
void gl3_filter_chain_set_frame_count_period(
gl3_filter_chain_t *chain,
unsigned pass,
unsigned period)
{
chain->set_frame_count_period(pass, period);
}
void gl_core_filter_chain_set_pass_name(
gl_core_filter_chain_t *chain,
void gl3_filter_chain_set_pass_name(
gl3_filter_chain_t *chain,
unsigned pass,
const char *name)
{
chain->set_pass_name(pass, name);
}
void gl_core_filter_chain_build_offscreen_passes(
gl_core_filter_chain_t *chain,
const gl_core_viewport *vp)
void gl3_filter_chain_build_offscreen_passes(
gl3_filter_chain_t *chain,
const gl3_viewport *vp)
{
chain->build_offscreen_passes(*vp);
}
void gl_core_filter_chain_build_viewport_pass(
gl_core_filter_chain_t *chain,
const gl_core_viewport *vp, const float *mvp)
void gl3_filter_chain_build_viewport_pass(
gl3_filter_chain_t *chain,
const gl3_viewport *vp, const float *mvp)
{
chain->build_viewport_pass(*vp, mvp);
}
void gl_core_filter_chain_end_frame(gl_core_filter_chain_t *chain)
void gl3_filter_chain_end_frame(gl3_filter_chain_t *chain)
{
chain->end_frame();
}

76
gfx/drivers_shader/shader_gl3.h
View File

@ -27,9 +27,9 @@
RETRO_BEGIN_DECLS
typedef struct gl_core_filter_chain gl_core_filter_chain_t;
typedef struct gl3_filter_chain gl3_filter_chain_t;
struct gl_core_filter_chain_texture
struct gl3_filter_chain_texture
{
GLuint image;
unsigned width;
@ -39,7 +39,7 @@ struct gl_core_filter_chain_texture
GLenum format;
};
struct gl_core_viewport
struct gl3_viewport
{
GLint x;
GLint y;
@ -47,7 +47,7 @@ struct gl_core_viewport
GLsizei height;
};
struct gl_core_filter_chain_pass_info
struct gl3_filter_chain_pass_info
{
/* Maximum number of mip-levels to use. */
unsigned max_levels;
@ -67,7 +67,7 @@ struct gl_core_filter_chain_pass_info
enum glslang_filter_chain_address address;
};
struct gl_core_buffer_locations
struct gl3_buffer_locations
{
GLint flat_ubo_vertex;
GLint flat_ubo_fragment;
@ -77,74 +77,74 @@ struct gl_core_buffer_locations
GLuint buffer_index_ubo_fragment;
};
gl_core_filter_chain_t *gl_core_filter_chain_new(void);
gl3_filter_chain_t *gl3_filter_chain_new(void);
void gl_core_filter_chain_free(
gl_core_filter_chain_t *chain);
void gl3_filter_chain_free(
gl3_filter_chain_t *chain);
void gl_core_filter_chain_set_shader(
gl_core_filter_chain_t *chain,
void gl3_filter_chain_set_shader(
gl3_filter_chain_t *chain,
unsigned pass,
GLenum shader_type,
const uint32_t *spirv,
size_t spirv_words);
void gl_core_filter_chain_set_pass_info(
gl_core_filter_chain_t *chain,
void gl3_filter_chain_set_pass_info(
gl3_filter_chain_t *chain,
unsigned pass,
const struct gl_core_filter_chain_pass_info *info);
const struct gl3_filter_chain_pass_info *info);
bool gl_core_filter_chain_init(gl_core_filter_chain_t *chain);
bool gl3_filter_chain_init(gl3_filter_chain_t *chain);
void gl_core_filter_chain_set_input_texture(
gl_core_filter_chain_t *chain,
const struct gl_core_filter_chain_texture *texture);
void gl3_filter_chain_set_input_texture(
gl3_filter_chain_t *chain,
const struct gl3_filter_chain_texture *texture);
void gl_core_filter_chain_set_frame_count(
gl_core_filter_chain_t *chain,
void gl3_filter_chain_set_frame_count(
gl3_filter_chain_t *chain,
uint64_t count);
void gl_core_filter_chain_set_frame_count_period(
gl_core_filter_chain_t *chain,
void gl3_filter_chain_set_frame_count_period(
gl3_filter_chain_t *chain,
unsigned pass,
unsigned period);
void gl_core_filter_chain_set_frame_direction(
gl_core_filter_chain_t *chain,
void gl3_filter_chain_set_frame_direction(
gl3_filter_chain_t *chain,
int32_t direction);
void gl_core_filter_chain_set_pass_name(
gl_core_filter_chain_t *chain,
void gl3_filter_chain_set_pass_name(
gl3_filter_chain_t *chain,
unsigned pass,
const char *name);
void gl_core_filter_chain_build_offscreen_passes(
gl_core_filter_chain_t *chain,
const struct gl_core_viewport *vp);
void gl3_filter_chain_build_offscreen_passes(
gl3_filter_chain_t *chain,
const struct gl3_viewport *vp);
void gl_core_filter_chain_build_viewport_pass(
gl_core_filter_chain_t *chain,
const struct gl_core_viewport *vp,
void gl3_filter_chain_build_viewport_pass(
gl3_filter_chain_t *chain,
const struct gl3_viewport *vp,
const float *mvp);
gl_core_filter_chain_t *gl_core_filter_chain_create_default(
gl3_filter_chain_t *gl3_filter_chain_create_default(
enum glslang_filter_chain_filter filter);
gl_core_filter_chain_t *gl_core_filter_chain_create_from_preset(
gl3_filter_chain_t *gl3_filter_chain_create_from_preset(
const char *path,
enum glslang_filter_chain_filter filter);
struct video_shader *gl_core_filter_chain_get_preset(
gl_core_filter_chain_t *chain);
struct video_shader *gl3_filter_chain_get_preset(
gl3_filter_chain_t *chain);
void gl_core_filter_chain_end_frame(gl_core_filter_chain_t *chain);
void gl3_filter_chain_end_frame(gl3_filter_chain_t *chain);
GLuint gl_core_cross_compile_program(
GLuint gl3_cross_compile_program(
const uint32_t *vertex,
size_t vertex_size,
const uint32_t *fragment,
size_t fragment_size,
struct gl_core_buffer_locations *loc,
struct gl3_buffer_locations *loc,
bool flatten);
RETRO_END_DECLS

14
gfx/font_driver.c
View File

@ -214,28 +214,28 @@ static bool gl_font_init_first(
#endif
#ifdef HAVE_OPENGL_CORE
static const font_renderer_t *gl_core_font_backends[] = {
&gl_core_raster_font,
static const font_renderer_t *gl3_font_backends[] = {
&gl3_raster_font,
NULL,
};
static bool gl_core_font_init_first(
static bool gl3_font_init_first(
const void **font_driver, void **font_handle,
void *video_data, const char *font_path,
float font_size, bool is_threaded)
{
unsigned i;
for (i = 0; gl_core_font_backends[i]; i++)
for (i = 0; gl3_font_backends[i]; i++)
{
void *data = gl_core_font_backends[i]->init(
void *data = gl3_font_backends[i]->init(
video_data, font_path, font_size,
is_threaded);
if (!data)
continue;
*font_driver = gl_core_font_backends[i];
*font_driver = gl3_font_backends[i];
*font_handle = data;
return true;
}
@ -699,7 +699,7 @@ static bool font_init_first(
#endif
#ifdef HAVE_OPENGL_CORE
case FONT_DRIVER_RENDER_OPENGL_CORE_API:
return gl_core_font_init_first(font_driver, font_handle,
return gl3_font_init_first(font_driver, font_handle,
video_data, font_path, font_size, is_threaded);
#endif
#ifdef HAVE_VULKAN

2
gfx/font_driver.h
View File

@ -175,7 +175,7 @@ int font_driver_get_line_descender(void *font_data, float scale);
int font_driver_get_line_centre_offset(void *font_data, float scale);
extern font_renderer_t gl_raster_font;
extern font_renderer_t gl_core_raster_font;
extern font_renderer_t gl3_raster_font;
extern font_renderer_t gl1_raster_font;
extern font_renderer_t d3d_xdk1_font;
extern font_renderer_t d3d_win32_font;

2
gfx/gfx_display.c
View File

@ -99,7 +99,7 @@ static gfx_display_ctx_driver_t *gfx_display_ctx_drivers[] = {
&gfx_display_ctx_gl1,
#endif
#ifdef HAVE_OPENGL_CORE
&gfx_display_ctx_gl_core,
&gfx_display_ctx_gl3,
#endif
#ifdef HAVE_VULKAN
&gfx_display_ctx_vulkan,

2
gfx/gfx_display.h
View File

@ -344,7 +344,7 @@ bool gfx_display_init_first_driver(gfx_display_t *p_disp,
bool video_is_threaded);
extern gfx_display_ctx_driver_t gfx_display_ctx_gl;
extern gfx_display_ctx_driver_t gfx_display_ctx_gl_core;
extern gfx_display_ctx_driver_t gfx_display_ctx_gl3;
extern gfx_display_ctx_driver_t gfx_display_ctx_gl1;
extern gfx_display_ctx_driver_t gfx_display_ctx_vulkan;
extern gfx_display_ctx_driver_t gfx_display_ctx_metal;

18
gfx/video_driver.c
View File

@ -276,9 +276,9 @@ const video_driver_t *video_drivers[] = {
#ifdef HAVE_OPENGL
&video_gl2,
#endif
#if defined(HAVE_OPENGL_CORE)
&video_gl_core,
#endif
#if defined(HAVE_OPENGL_CORE)
&video_gl3,
#endif
#ifdef HAVE_OPENGL1
&video_gl1,
#endif
@ -434,11 +434,11 @@ video_driver_t *hw_render_context_driver(
switch (type)
{
case RETRO_HW_CONTEXT_OPENGL_CORE:
#ifdef HAVE_OPENGL_CORE
return &video_gl_core;
#else
break;
#endif
#ifdef HAVE_OPENGL_CORE
return &video_gl3;
#else
break;
#endif
case RETRO_HW_CONTEXT_OPENGL:
#ifdef HAVE_OPENGL
return &video_gl2;
@ -2278,7 +2278,7 @@ bool video_driver_find_driver(
"glcore");
RARCH_LOG("[Video]: \"%s\" saved as cached driver.\n",
settings->arrays.video_driver);
video_st->current_video = &video_gl_core;
video_st->current_video = &video_gl3;
return true;
}
#else

2
gfx/video_driver.h
View File

@ -1413,7 +1413,7 @@ void video_driver_frame(const void *data, unsigned width,
extern const video_driver_t *video_drivers[];
extern video_driver_t video_gl_core;
extern video_driver_t video_gl3;
extern video_driver_t video_gl2;
extern video_driver_t video_gl1;
extern video_driver_t video_vulkan;