libretro/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2025-02-24 11:52:52 +00:00
Code Issues Actions 25 Packages Projects Releases Wiki Activity

Combine video_driver.c and video_shader_driver.c

Browse Source
This commit is contained in:
twinaphex 2017-05-18 14:47:24 +02:00
parent 4e7b376e18
commit 59b3344e72
28 changed files with 619 additions and 692 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile.common
View File

@ -223,7 +223,6 @@ OBJ += frontend/frontend.o \
tasks/task_powerstate.o \
$(LIBRETRO_COMM_DIR)/gfx/scaler/scaler.o \
gfx/drivers_shader/shader_null.o \
gfx/video_shader_driver.o \
gfx/video_shader_parse.o \
$(LIBRETRO_COMM_DIR)/gfx/scaler/pixconv.o \
$(LIBRETRO_COMM_DIR)/gfx/scaler/scaler_int.o \

4
gfx/drivers/d3d.h
View File

@ -46,10 +46,6 @@
#include "../../driver.h"
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_HLSL)
#include "../video_shader_driver.h"
#endif
#include "../font_driver.h"
#include "../video_driver.h"
#include "../common/d3d_common.h"

2
gfx/drivers/gl.c
View File

@ -75,8 +75,6 @@
#include "../common/win32_common.h"
#endif
#include "../video_shader_driver.h"
#ifndef GL_SYNC_GPU_COMMANDS_COMPLETE
#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
#endif

1
gfx/drivers_font/gl_raster_font.c
View File

@ -22,7 +22,6 @@
#include "../common/gl_common.h"
#include "../font_driver.h"
#include "../video_shader_driver.h"
#include "../video_driver.h"
/* TODO: Move viewport side effects to the caller: it's a source of bugs. */

2
gfx/drivers_renderchain/gl_legacy_renderchain.c
View File

@ -50,7 +50,7 @@
#include "../common/win32_common.h"
#endif
#include "../video_shader_driver.h"
#include "../video_driver.h"
#define set_texture_coords(coords, xamt, yamt) \
coords[2] = xamt; \

2
gfx/drivers_renderchain/xdk_renderchain.cpp
View File

@ -21,7 +21,7 @@
#include "../drivers/d3d.h"
#include "../common/d3d_common.h"
#include "../video_shader_driver.h"
#include "../video_driver.h"
#include "../../configuration.h"
#include "../../verbosity.h"

2
gfx/drivers_shader/shader_gl_cg.c
View File

@ -46,7 +46,7 @@
#include "../include/Cg/cg.h"
#include "../video_shader_driver.h"
#include "../video_driver.h"
#include "../video_shader_parse.h"
#include "../../core.h"
#include "../../managers/state_manager.h"

2
gfx/drivers_shader/shader_glsl.h
View File

@ -19,7 +19,7 @@
#define __RARCH_GLSL_H
#include <boolean.h>
#include "../video_shader_driver.h"
#include "../video_driver.h"
void gl_glsl_set_get_proc_address(gfx_ctx_proc_t (*proc)(const char*));

3
gfx/drivers_shader/shader_hlsl.h
View File

@ -17,9 +17,10 @@
#ifndef __RARCH_HLSL_H
#define __RARCH_HLSL_H
#include "../video_shader_driver.h"
#include <stdint.h>
#include "../video_driver.h"
void hlsl_set_proj_matrix(void *data, XMMATRIX rotation_value);
#define RARCH_HLSL_MAX_SHADERS 16

2
gfx/drivers_shader/shader_null.c
View File

@ -27,7 +27,7 @@
#include "../../config.h"
#endif
#include "../video_shader_driver.h"
#include "../video_driver.h"
typedef struct null_shader_data
{

2
gfx/drivers_shader/shader_vulkan.cpp
View File

@ -30,7 +30,7 @@
#include "slang_reflection.hpp"
#include "../video_shader_driver.h"
#include "../video_driver.h"
#include "../../verbosity.h"
#include "../../msg_hash.h"

2
gfx/drivers_shader/slang_preprocess.h
View File

@ -18,7 +18,7 @@
#include <boolean.h>
#include <retro_common_api.h>
#include "../video_shader_driver.h"
#include "../video_driver.h"
RETRO_BEGIN_DECLS

306
gfx/video_driver.c
View File

@ -43,6 +43,10 @@
#include "../menu/menu_setting.h"
#endif
#ifdef HAVE_OPENGL
#include "common/gl_common.h"
#endif
#include "video_thread_wrapper.h"
#include "video_driver.h"
@ -201,6 +205,9 @@ gfx_ctx_driver_t current_video_context;
void *video_context_data = NULL;
shader_backend_t *current_shader = NULL;
void *shader_data = NULL;
struct aspect_ratio_elem aspectratio_lut[ASPECT_RATIO_END] = {
{ "4:3", 1.3333f },
{ "16:9", 1.7778f },
@ -365,6 +372,20 @@ static const gfx_ctx_driver_t *gfx_ctx_drivers[] = {
NULL
};
static const shader_backend_t *shader_ctx_drivers[] = {
#ifdef HAVE_GLSL
&gl_glsl_backend,
#endif
#ifdef HAVE_CG
&gl_cg_backend,
#endif
#ifdef HAVE_HLSL
&hlsl_backend,
#endif
&shader_null_backend,
NULL
};
/* Stub functions */
static void update_window_title_null(void *data, video_frame_info_t *video_info)
@ -2984,3 +3005,288 @@ bool video_driver_cached_frame_has_valid_framebuffer(void)
return (frame_cache_data == RETRO_HW_FRAME_BUFFER_VALID);
return false;
}
static const shader_backend_t *video_shader_set_backend(enum rarch_shader_type type)
{
switch (type)
{
case RARCH_SHADER_CG:
{
#ifdef HAVE_CG
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT))
{
RARCH_ERR("[Shader driver]: Cg cannot be used with core GL context. Trying to fall back to GLSL...\n");
return video_shader_set_backend(RARCH_SHADER_GLSL);
}
RARCH_LOG("[Shader driver]: Using Cg shader backend.\n");
return &gl_cg_backend;
#else
break;
#endif
}
case RARCH_SHADER_GLSL:
#ifdef HAVE_GLSL
RARCH_LOG("[Shader driver]: Using GLSL shader backend.\n");
return &gl_glsl_backend;
#else
break;
#endif
case RARCH_SHADER_NONE:
default:
break;
}
return NULL;
}
bool video_shader_driver_get_prev_textures(video_shader_ctx_texture_t *texture)
{
if (!texture)
{
if (texture)
texture->id = 0;
return false;
}
texture->id = current_shader->get_prev_textures(shader_data);
return true;
}
bool video_shader_driver_get_ident(video_shader_ctx_ident_t *ident)
{
if (!ident)
return false;
ident->ident = current_shader->ident;
return true;
}
bool video_shader_driver_get_current_shader(video_shader_ctx_t *shader)
{
void *video_driver = video_driver_get_ptr(true);
const video_poke_interface_t *video_poke = video_driver_get_poke();
shader->data = NULL;
if (!video_poke || !video_driver || !video_poke->get_current_shader)
return false;
shader->data = video_poke->get_current_shader(video_driver);
return true;
}
bool video_shader_driver_direct_get_current_shader(video_shader_ctx_t *shader)
{
shader->data = current_shader->get_current_shader(shader_data);
return true;
}
bool video_shader_driver_deinit(void)
{
if (!current_shader)
return false;
if (current_shader->deinit)
current_shader->deinit(shader_data);
shader_data = NULL;
current_shader = NULL;
return true;
}
static enum gfx_wrap_type video_shader_driver_wrap_type_null(
void *data, unsigned index)
{
return RARCH_WRAP_BORDER;
}
static bool video_shader_driver_set_mvp_null(void *data,
void *shader_data, const math_matrix_4x4 *mat)
{
#ifdef HAVE_OPENGL
#ifndef NO_GL_FF_MATRIX
if (string_is_equal_fast(video_driver_get_ident(), "gl", 2))
gl_ff_matrix(mat);
#endif
#endif
return false;
}
static bool video_shader_driver_set_coords_null(void *handle_data,
void *shader_data, const struct video_coords *coords)
{
#ifdef HAVE_OPENGL
#ifndef NO_GL_FF_VERTEX
if (string_is_equal_fast(video_driver_get_ident(), "gl", 2))
gl_ff_vertex(coords);
#endif
#endif
return false;
}
static void video_shader_driver_use_null(void *data,
void *shader_data, unsigned idx, bool set_active)
{
(void)data;
(void)idx;
(void)set_active;
}
static struct video_shader *video_shader_driver_get_current_shader_null(void *data)
{
return NULL;
}
static void video_shader_driver_set_params_null(void *data, void *shader_data,
unsigned width, unsigned height,
unsigned tex_width, unsigned tex_height,
unsigned out_width, unsigned out_height,
unsigned frame_count,
const void *info,
const void *prev_info,
const void *feedback_info,
const void *fbo_info, unsigned fbo_info_cnt)
{
}
static void video_shader_driver_scale_null(void *data,
unsigned idx, struct gfx_fbo_scale *scale)
{
(void)idx;
(void)scale;
}
static bool video_shader_driver_mipmap_input_null(void *data, unsigned idx)
{
(void)idx;
return false;
}
static bool video_shader_driver_filter_type_null(void *data, unsigned idx, bool *smooth)
{
(void)idx;
(void)smooth;
return false;
}
static unsigned video_shader_driver_num_null(void *data)
{
return 0;
}
static bool video_shader_driver_get_feedback_pass_null(void *data, unsigned *idx)
{
(void)idx;
return false;
}
static void video_shader_driver_reset_to_defaults(void)
{
if (!current_shader->wrap_type)
current_shader->wrap_type = video_shader_driver_wrap_type_null;
if (!current_shader->set_mvp)
current_shader->set_mvp = video_shader_driver_set_mvp_null;
if (!current_shader->set_coords)
current_shader->set_coords = video_shader_driver_set_coords_null;
if (!current_shader->use)
current_shader->use = video_shader_driver_use_null;
if (!current_shader->set_params)
current_shader->set_params = video_shader_driver_set_params_null;
if (!current_shader->shader_scale)
current_shader->shader_scale = video_shader_driver_scale_null;
if (!current_shader->mipmap_input)
current_shader->mipmap_input = video_shader_driver_mipmap_input_null;
if (!current_shader->filter_type)
current_shader->filter_type = video_shader_driver_filter_type_null;
if (!current_shader->num_shaders)
current_shader->num_shaders = video_shader_driver_num_null;
if (!current_shader->get_current_shader)
current_shader->get_current_shader= video_shader_driver_get_current_shader_null;
if (!current_shader->get_feedback_pass)
current_shader->get_feedback_pass = video_shader_driver_get_feedback_pass_null;
}
/* Finds first suitable shader context driver. */
bool video_shader_driver_init_first(void)
{
current_shader = (shader_backend_t*)shader_ctx_drivers[0];
video_shader_driver_reset_to_defaults();
return true;
}
bool video_shader_driver_init(video_shader_ctx_init_t *init)
{
void *tmp = NULL;
if (!init->shader || !init->shader->init)
{
init->shader = video_shader_set_backend(init->shader_type);
if (!init->shader)
return false;
}
tmp = init->shader->init(init->data, init->path);
if (!tmp)
return false;
shader_data = tmp;
current_shader = (shader_backend_t*)init->shader;
video_shader_driver_reset_to_defaults();
return true;
}
bool video_shader_driver_get_feedback_pass(unsigned *data)
{
return current_shader->get_feedback_pass(shader_data, data);
}
bool video_shader_driver_mipmap_input(unsigned *index)
{
return current_shader->mipmap_input(shader_data, *index);
}
bool video_shader_driver_scale(video_shader_ctx_scale_t *scaler)
{
if (!scaler || !scaler->scale)
return false;
scaler->scale->valid = false;
current_shader->shader_scale(shader_data, scaler->idx, scaler->scale);
return true;
}
bool video_shader_driver_info(video_shader_ctx_info_t *shader_info)
{
if (!shader_info)
return false;
shader_info->num = current_shader->num_shaders(shader_data);
return true;
}
bool video_shader_driver_filter_type(video_shader_ctx_filter_t *filter)
{
return (filter) ? current_shader->filter_type(shader_data,
filter->index, filter->smooth) : false;
}
bool video_shader_driver_compile_program(struct shader_program_info *program_info)
{
return (program_info) ? current_shader->compile_program(program_info->data,
program_info->idx, NULL, program_info) : false;
}
bool video_shader_driver_wrap_type(video_shader_ctx_wrap_t *wrap)
{
wrap->type = current_shader->wrap_type(shader_data, wrap->idx);
return true;
}

299
gfx/video_driver.h
View File

@ -23,6 +23,7 @@
#include <boolean.h>
#include <retro_common_api.h>
#include <gfx/math/matrix_4x4.h>
#ifdef HAVE_CONFIG_H
#include "../config.h"
@ -33,11 +34,38 @@
#endif
#include "video_defines.h"
#include "video_coord_array.h"
#include "video_filter.h"
#include "video_shader_parse.h"
#include "../input/input_driver.h"
#if defined(HAVE_CG) || defined(HAVE_HLSL) || defined(HAVE_GLSL) || defined(HAVE_SLANG)
#ifndef HAVE_SHADER_MANAGER
#define HAVE_SHADER_MANAGER
#endif
#include "video_shader_parse.h"
#define VIDEO_SHADER_STOCK_BLEND (GFX_MAX_SHADERS - 1)
#define VIDEO_SHADER_MENU (GFX_MAX_SHADERS - 2)
#define VIDEO_SHADER_MENU_2 (GFX_MAX_SHADERS - 3)
#define VIDEO_SHADER_MENU_3 (GFX_MAX_SHADERS - 4)
#define VIDEO_SHADER_MENU_4 (GFX_MAX_SHADERS - 5)
#define VIDEO_SHADER_MENU_5 (GFX_MAX_SHADERS - 6)
#endif
#if defined(_XBOX360)
#define DEFAULT_SHADER_TYPE RARCH_SHADER_HLSL
#elif defined(__PSL1GHT__) || defined(HAVE_OPENGLES2) || defined(HAVE_GLSL)
#define DEFAULT_SHADER_TYPE RARCH_SHADER_GLSL
#elif defined(__CELLOS_LV2__) || defined(HAVE_CG)
#define DEFAULT_SHADER_TYPE RARCH_SHADER_CG
#else
#define DEFAULT_SHADER_TYPE RARCH_SHADER_NONE
#endif
RETRO_BEGIN_DECLS
#ifndef MAX_EGLIMAGE_TEXTURES
@ -72,6 +100,223 @@ enum display_flags
GFX_CTX_FLAGS_CUSTOMIZABLE_SWAPCHAIN_IMAGES
};
enum shader_uniform_type
{
UNIFORM_1F = 0,
UNIFORM_2F,
UNIFORM_3F,
UNIFORM_4F,
UNIFORM_1FV,
UNIFORM_2FV,
UNIFORM_3FV,
UNIFORM_4FV,
UNIFORM_1I
};
enum shader_program_type
{
SHADER_PROGRAM_VERTEX = 0,
SHADER_PROGRAM_FRAGMENT,
SHADER_PROGRAM_COMBINED
};
struct shader_program_info
{
void *data;
const char *vertex;
const char *fragment;
const char *combined;
unsigned idx;
bool is_file;
};
struct uniform_info
{
unsigned type; /* shader uniform type */
bool enabled;
int32_t location;
int32_t count;
struct
{
enum shader_program_type type;
const char *ident;
uint32_t idx;
bool add_prefix;
bool enable;
} lookup;
struct
{
struct
{
intptr_t v0;
intptr_t v1;
intptr_t v2;
intptr_t v3;
} integer;
intptr_t *integerv;
struct
{
uintptr_t v0;
uintptr_t v1;
uintptr_t v2;
uintptr_t v3;
} unsigned_integer;
uintptr_t *unsigned_integerv;
struct
{
float v0;
float v1;
float v2;
float v3;
} f;
float *floatv;
} result;
};
typedef struct shader_backend
{
void *(*init)(void *data, const char *path);
void (*deinit)(void *data);
/* Set shader parameters. */
void (*set_params)(void *data, void *shader_data,
unsigned width, unsigned height,
unsigned tex_width, unsigned tex_height,
unsigned out_width, unsigned out_height,
unsigned frame_counter,
const void *info,
const void *prev_info,
const void *feedback_info,
const void *fbo_info, unsigned fbo_info_cnt);
void (*set_uniform_parameter)(void *data, struct uniform_info *param,
void *uniform_data);
/* Compile a shader program. */
bool (*compile_program)(void *data, unsigned idx,
void *program_data, struct shader_program_info *program_info);
/* Use a shader program specified by variable 'index'. */
void (*use)(void *data, void *shader_data, unsigned index, bool set_active);
/* Returns the number of currently loaded shaders. */
unsigned (*num_shaders)(void *data);
bool (*filter_type)(void *data, unsigned index, bool *smooth);
enum gfx_wrap_type (*wrap_type)(void *data, unsigned index);
void (*shader_scale)(void *data,
unsigned index, struct gfx_fbo_scale *scale);
bool (*set_coords)(void *handle_data,
void *shader_data, const struct video_coords *coords);
bool (*set_coords_fallback)(void *handle_data,
void *shader_data, const struct video_coords *coords);
bool (*set_mvp)(void *data, void *shader_data,
const math_matrix_4x4 *mat);
unsigned (*get_prev_textures)(void *data);
bool (*get_feedback_pass)(void *data, unsigned *pass);
bool (*mipmap_input)(void *data, unsigned index);
struct video_shader *(*get_current_shader)(void *data);
enum rarch_shader_type type;
/* Human readable string. */
const char *ident;
} shader_backend_t;
typedef struct video_shader_ctx_init
{
enum rarch_shader_type shader_type;
const shader_backend_t *shader;
struct
{
bool core_context_enabled;
} gl;
void *data;
const char *path;
} video_shader_ctx_init_t;
typedef struct video_shader_ctx_params
{
void *data;
unsigned width;
unsigned height;
unsigned tex_width;
unsigned tex_height;
unsigned out_width;
unsigned out_height;
unsigned frame_counter;
const void *info;
const void *prev_info;
const void *feedback_info;
const void *fbo_info;
unsigned fbo_info_cnt;
} video_shader_ctx_params_t;
typedef struct video_shader_ctx_coords
{
void *handle_data;
const void *data;
} video_shader_ctx_coords_t;
typedef struct video_shader_ctx_scale
{
unsigned idx;
struct gfx_fbo_scale *scale;
} video_shader_ctx_scale_t;
typedef struct video_shader_ctx_info
{
bool set_active;
unsigned num;
unsigned idx;
void *data;
} video_shader_ctx_info_t;
typedef struct video_shader_ctx_mvp
{
void *data;
const math_matrix_4x4 *matrix;
} video_shader_ctx_mvp_t;
typedef struct video_shader_ctx_filter
{
unsigned index;
bool *smooth;
} video_shader_ctx_filter_t;
typedef struct video_shader_ctx_wrap
{
unsigned idx;
enum gfx_wrap_type type;
} video_shader_ctx_wrap_t;
typedef struct video_shader_ctx
{
struct video_shader *data;
} video_shader_ctx_t;
typedef struct video_shader_ctx_ident
{
const char *ident;
} video_shader_ctx_ident_t;
typedef struct video_shader_ctx_texture
{
unsigned id;
} video_shader_ctx_texture_t;
typedef void (*gfx_ctx_proc_t)(void);
typedef struct video_frame_info video_frame_info_t;
@ -948,6 +1193,60 @@ extern gfx_ctx_driver_t current_video_context;
extern void *video_context_data;
bool video_shader_driver_get_prev_textures(video_shader_ctx_texture_t *texture);
bool video_shader_driver_get_ident(video_shader_ctx_ident_t *ident);
bool video_shader_driver_get_current_shader(video_shader_ctx_t *shader);
bool video_shader_driver_direct_get_current_shader(video_shader_ctx_t *shader);
bool video_shader_driver_deinit(void);
#define video_shader_driver_set_parameter(param) \
if (current_shader && current_shader->set_uniform_parameter) \
current_shader->set_uniform_parameter(shader_data, &param, NULL)
#define video_shader_driver_set_parameters(params) \
current_shader->set_params(params.data, shader_data, params.width, params.height, params.tex_width, params.tex_height, params.out_width, params.out_height, params.frame_counter, params.info, params.prev_info, params.feedback_info, params.fbo_info, params.fbo_info_cnt)
bool video_shader_driver_init_first(void);
bool video_shader_driver_init(video_shader_ctx_init_t *init);
bool video_shader_driver_get_feedback_pass(unsigned *data);
bool video_shader_driver_mipmap_input(unsigned *index);
#define video_shader_driver_set_coords(coords) \
if (!current_shader->set_coords(coords.handle_data, shader_data, (const struct video_coords*)coords.data) && current_shader->set_coords_fallback) \
current_shader->set_coords_fallback(coords.handle_data, shader_data, (const struct video_coords*)coords.data)
bool video_shader_driver_scale(video_shader_ctx_scale_t *scaler);
bool video_shader_driver_info(video_shader_ctx_info_t *shader_info);
#define video_shader_driver_set_mvp(mvp) \
if (mvp.matrix) \
current_shader->set_mvp(mvp.data, shader_data, mvp.matrix) \
bool video_shader_driver_filter_type(video_shader_ctx_filter_t *filter);
bool video_shader_driver_compile_program(struct shader_program_info *program_info);
#define video_shader_driver_use(shader_info) \
current_shader->use(shader_info.data, shader_data, shader_info.idx, shader_info.set_active)
bool video_shader_driver_wrap_type(video_shader_ctx_wrap_t *wrap);
extern shader_backend_t *current_shader;
extern void *shader_data;
extern const shader_backend_t gl_glsl_backend;
extern const shader_backend_t hlsl_backend;
extern const shader_backend_t gl_cg_backend;
extern const shader_backend_t shader_null_backend;
RETRO_END_DECLS
#endif

331
gfx/video_shader_driver.c
View File

@ -1,331 +0,0 @@
/* RetroArch - A frontend for libretro.
* Copyright (C) 2011-2017 - Daniel De Matteis
*
* RetroArch 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.
*
* RetroArch 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 RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#include <string.h>
#include <string/stdstring.h>
#include <gfx/math/matrix_4x4.h>
#ifdef HAVE_CONFIG_H
#include "../config.h"
#endif
#ifdef HAVE_OPENGL
#include "common/gl_common.h"
#endif
#include "video_shader_driver.h"
#include "../verbosity.h"
static const shader_backend_t *shader_ctx_drivers[] = {
#ifdef HAVE_GLSL
&gl_glsl_backend,
#endif
#ifdef HAVE_CG
&gl_cg_backend,
#endif
#ifdef HAVE_HLSL
&hlsl_backend,
#endif
&shader_null_backend,
NULL
};
shader_backend_t *current_shader = NULL;
void *shader_data = NULL;
static const shader_backend_t *video_shader_set_backend(enum rarch_shader_type type)
{
switch (type)
{
case RARCH_SHADER_CG:
{
#ifdef HAVE_CG
gfx_ctx_flags_t flags;
video_context_driver_get_flags(&flags);
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT))
{
RARCH_ERR("[Shader driver]: Cg cannot be used with core GL context. Trying to fall back to GLSL...\n");
return video_shader_set_backend(RARCH_SHADER_GLSL);
}
RARCH_LOG("[Shader driver]: Using Cg shader backend.\n");
return &gl_cg_backend;
#else
break;
#endif
}
case RARCH_SHADER_GLSL:
#ifdef HAVE_GLSL
RARCH_LOG("[Shader driver]: Using GLSL shader backend.\n");
return &gl_glsl_backend;
#else
break;
#endif
case RARCH_SHADER_NONE:
default:
break;
}
return NULL;
}
bool video_shader_driver_get_prev_textures(video_shader_ctx_texture_t *texture)
{
if (!texture)
{
if (texture)
texture->id = 0;
return false;
}
texture->id = current_shader->get_prev_textures(shader_data);
return true;
}
bool video_shader_driver_get_ident(video_shader_ctx_ident_t *ident)
{
if (!ident)
return false;
ident->ident = current_shader->ident;
return true;
}
bool video_shader_driver_get_current_shader(video_shader_ctx_t *shader)
{
void *video_driver = video_driver_get_ptr(true);
const video_poke_interface_t *video_poke = video_driver_get_poke();
shader->data = NULL;
if (!video_poke || !video_driver || !video_poke->get_current_shader)
return false;
shader->data = video_poke->get_current_shader(video_driver);
return true;
}
bool video_shader_driver_direct_get_current_shader(video_shader_ctx_t *shader)
{
shader->data = current_shader->get_current_shader(shader_data);
return true;
}
bool video_shader_driver_deinit(void)
{
if (!current_shader)
return false;
if (current_shader->deinit)
current_shader->deinit(shader_data);
shader_data = NULL;
current_shader = NULL;
return true;
}
static enum gfx_wrap_type video_shader_driver_wrap_type_null(
void *data, unsigned index)
{
return RARCH_WRAP_BORDER;
}
static bool video_shader_driver_set_mvp_null(void *data,
void *shader_data, const math_matrix_4x4 *mat)
{
#ifdef HAVE_OPENGL
#ifndef NO_GL_FF_MATRIX
if (string_is_equal_fast(video_driver_get_ident(), "gl", 2))
gl_ff_matrix(mat);
#endif
#endif
return false;
}
static bool video_shader_driver_set_coords_null(void *handle_data,
void *shader_data, const struct video_coords *coords)
{
#ifdef HAVE_OPENGL
#ifndef NO_GL_FF_VERTEX
if (string_is_equal_fast(video_driver_get_ident(), "gl", 2))
gl_ff_vertex(coords);
#endif
#endif
return false;
}
static void video_shader_driver_use_null(void *data,
void *shader_data, unsigned idx, bool set_active)
{
(void)data;
(void)idx;
(void)set_active;
}
static struct video_shader *video_shader_driver_get_current_shader_null(void *data)
{
return NULL;
}
static void video_shader_driver_set_params_null(void *data, void *shader_data,
unsigned width, unsigned height,
unsigned tex_width, unsigned tex_height,
unsigned out_width, unsigned out_height,
unsigned frame_count,
const void *info,
const void *prev_info,
const void *feedback_info,
const void *fbo_info, unsigned fbo_info_cnt)
{
}
static void video_shader_driver_scale_null(void *data,
unsigned idx, struct gfx_fbo_scale *scale)
{
(void)idx;
(void)scale;
}
static bool video_shader_driver_mipmap_input_null(void *data, unsigned idx)
{
(void)idx;
return false;
}
static bool video_shader_driver_filter_type_null(void *data, unsigned idx, bool *smooth)
{
(void)idx;
(void)smooth;
return false;
}
static unsigned video_shader_driver_num_null(void *data)
{
return 0;
}
static bool video_shader_driver_get_feedback_pass_null(void *data, unsigned *idx)
{
(void)idx;
return false;
}
static void video_shader_driver_reset_to_defaults(void)
{
if (!current_shader->wrap_type)
current_shader->wrap_type = video_shader_driver_wrap_type_null;
if (!current_shader->set_mvp)
current_shader->set_mvp = video_shader_driver_set_mvp_null;
if (!current_shader->set_coords)
current_shader->set_coords = video_shader_driver_set_coords_null;
if (!current_shader->use)
current_shader->use = video_shader_driver_use_null;
if (!current_shader->set_params)
current_shader->set_params = video_shader_driver_set_params_null;
if (!current_shader->shader_scale)
current_shader->shader_scale = video_shader_driver_scale_null;
if (!current_shader->mipmap_input)
current_shader->mipmap_input = video_shader_driver_mipmap_input_null;
if (!current_shader->filter_type)
current_shader->filter_type = video_shader_driver_filter_type_null;
if (!current_shader->num_shaders)
current_shader->num_shaders = video_shader_driver_num_null;
if (!current_shader->get_current_shader)
current_shader->get_current_shader= video_shader_driver_get_current_shader_null;
if (!current_shader->get_feedback_pass)
current_shader->get_feedback_pass = video_shader_driver_get_feedback_pass_null;
}
/* Finds first suitable shader context driver. */
bool video_shader_driver_init_first(void)
{
current_shader = (shader_backend_t*)shader_ctx_drivers[0];
video_shader_driver_reset_to_defaults();
return true;
}
bool video_shader_driver_init(video_shader_ctx_init_t *init)
{
void *tmp = NULL;
if (!init->shader || !init->shader->init)
{
init->shader = video_shader_set_backend(init->shader_type);
if (!init->shader)
return false;
}
tmp = init->shader->init(init->data, init->path);
if (!tmp)
return false;
shader_data = tmp;
current_shader = (shader_backend_t*)init->shader;
video_shader_driver_reset_to_defaults();
return true;
}
bool video_shader_driver_get_feedback_pass(unsigned *data)
{
return current_shader->get_feedback_pass(shader_data, data);
}
bool video_shader_driver_mipmap_input(unsigned *index)
{
return current_shader->mipmap_input(shader_data, *index);
}
bool video_shader_driver_scale(video_shader_ctx_scale_t *scaler)
{
if (!scaler || !scaler->scale)
return false;
scaler->scale->valid = false;
current_shader->shader_scale(shader_data, scaler->idx, scaler->scale);
return true;
}
bool video_shader_driver_info(video_shader_ctx_info_t *shader_info)
{
if (!shader_info)
return false;
shader_info->num = current_shader->num_shaders(shader_data);
return true;
}
bool video_shader_driver_filter_type(video_shader_ctx_filter_t *filter)
{
return (filter) ? current_shader->filter_type(shader_data,
filter->index, filter->smooth) : false;
}
bool video_shader_driver_compile_program(struct shader_program_info *program_info)
{
return (program_info) ? current_shader->compile_program(program_info->data,
program_info->idx, NULL, program_info) : false;
}
bool video_shader_driver_wrap_type(video_shader_ctx_wrap_t *wrap)
{
wrap->type = current_shader->wrap_type(shader_data, wrap->idx);
return true;
}

330
gfx/video_shader_driver.h
View File

@ -1,330 +0,0 @@
/* RetroArch - A frontend for libretro.
* Copyright (C) 2011-2017 - Daniel De Matteis
*
* RetroArch 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.
*
* RetroArch 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 RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef VIDEO_SHADER_DRIVER_H__
#define VIDEO_SHADER_DRIVER_H__
#include <boolean.h>
#include <retro_common_api.h>
#include <gfx/math/matrix_4x4.h>
#include "video_coord_array.h"
#ifdef HAVE_CONFIG_H
#include "../config.h"
#endif
#if defined(HAVE_CG) || defined(HAVE_HLSL) || defined(HAVE_GLSL) || defined(HAVE_SLANG)
#ifndef HAVE_SHADER_MANAGER
#define HAVE_SHADER_MANAGER
#endif
#include "video_shader_parse.h"
#define VIDEO_SHADER_STOCK_BLEND (GFX_MAX_SHADERS - 1)
#define VIDEO_SHADER_MENU (GFX_MAX_SHADERS - 2)
#define VIDEO_SHADER_MENU_2 (GFX_MAX_SHADERS - 3)
#define VIDEO_SHADER_MENU_3 (GFX_MAX_SHADERS - 4)
#define VIDEO_SHADER_MENU_4 (GFX_MAX_SHADERS - 5)
#define VIDEO_SHADER_MENU_5 (GFX_MAX_SHADERS - 6)
#endif
#if defined(_XBOX360)
#define DEFAULT_SHADER_TYPE RARCH_SHADER_HLSL
#elif defined(__PSL1GHT__) || defined(HAVE_OPENGLES2) || defined(HAVE_GLSL)
#define DEFAULT_SHADER_TYPE RARCH_SHADER_GLSL
#elif defined(__CELLOS_LV2__) || defined(HAVE_CG)
#define DEFAULT_SHADER_TYPE RARCH_SHADER_CG
#else
#define DEFAULT_SHADER_TYPE RARCH_SHADER_NONE
#endif
#include "video_driver.h"
RETRO_BEGIN_DECLS
enum shader_uniform_type
{
UNIFORM_1F = 0,
UNIFORM_2F,
UNIFORM_3F,
UNIFORM_4F,
UNIFORM_1FV,
UNIFORM_2FV,
UNIFORM_3FV,
UNIFORM_4FV,
UNIFORM_1I
};
enum shader_program_type
{
SHADER_PROGRAM_VERTEX = 0,
SHADER_PROGRAM_FRAGMENT,
SHADER_PROGRAM_COMBINED
};
struct shader_program_info
{
void *data;
const char *vertex;
const char *fragment;
const char *combined;
unsigned idx;
bool is_file;
};
struct uniform_info
{
unsigned type; /* shader uniform type */
bool enabled;
int32_t location;
int32_t count;
struct
{
enum shader_program_type type;
const char *ident;
uint32_t idx;
bool add_prefix;
bool enable;
} lookup;
struct
{
struct
{
intptr_t v0;
intptr_t v1;
intptr_t v2;
intptr_t v3;
} integer;
intptr_t *integerv;
struct
{
uintptr_t v0;
uintptr_t v1;
uintptr_t v2;
uintptr_t v3;
} unsigned_integer;
uintptr_t *unsigned_integerv;
struct
{
float v0;
float v1;
float v2;
float v3;
} f;
float *floatv;
} result;
};
typedef struct shader_backend
{
void *(*init)(void *data, const char *path);
void (*deinit)(void *data);
/* Set shader parameters. */
void (*set_params)(void *data, void *shader_data,
unsigned width, unsigned height,
unsigned tex_width, unsigned tex_height,
unsigned out_width, unsigned out_height,
unsigned frame_counter,
const void *info,
const void *prev_info,
const void *feedback_info,
const void *fbo_info, unsigned fbo_info_cnt);
void (*set_uniform_parameter)(void *data, struct uniform_info *param,
void *uniform_data);
/* Compile a shader program. */
bool (*compile_program)(void *data, unsigned idx,
void *program_data, struct shader_program_info *program_info);
/* Use a shader program specified by variable 'index'. */
void (*use)(void *data, void *shader_data, unsigned index, bool set_active);
/* Returns the number of currently loaded shaders. */
unsigned (*num_shaders)(void *data);
bool (*filter_type)(void *data, unsigned index, bool *smooth);
enum gfx_wrap_type (*wrap_type)(void *data, unsigned index);
void (*shader_scale)(void *data,
unsigned index, struct gfx_fbo_scale *scale);
bool (*set_coords)(void *handle_data,
void *shader_data, const struct video_coords *coords);
bool (*set_coords_fallback)(void *handle_data,
void *shader_data, const struct video_coords *coords);
bool (*set_mvp)(void *data, void *shader_data,
const math_matrix_4x4 *mat);
unsigned (*get_prev_textures)(void *data);
bool (*get_feedback_pass)(void *data, unsigned *pass);
bool (*mipmap_input)(void *data, unsigned index);
struct video_shader *(*get_current_shader)(void *data);
enum rarch_shader_type type;
/* Human readable string. */
const char *ident;
} shader_backend_t;
typedef struct video_shader_ctx_init
{
enum rarch_shader_type shader_type;
const shader_backend_t *shader;
struct
{
bool core_context_enabled;
} gl;
void *data;
const char *path;
} video_shader_ctx_init_t;
typedef struct video_shader_ctx_params
{
void *data;
unsigned width;
unsigned height;
unsigned tex_width;
unsigned tex_height;
unsigned out_width;
unsigned out_height;
unsigned frame_counter;
const void *info;
const void *prev_info;
const void *feedback_info;
const void *fbo_info;
unsigned fbo_info_cnt;
} video_shader_ctx_params_t;
typedef struct video_shader_ctx_coords
{
void *handle_data;
const void *data;
} video_shader_ctx_coords_t;
typedef struct video_shader_ctx_scale
{
unsigned idx;
struct gfx_fbo_scale *scale;
} video_shader_ctx_scale_t;
typedef struct video_shader_ctx_info
{
bool set_active;
unsigned num;
unsigned idx;
void *data;
} video_shader_ctx_info_t;
typedef struct video_shader_ctx_mvp
{
void *data;
const math_matrix_4x4 *matrix;
} video_shader_ctx_mvp_t;
typedef struct video_shader_ctx_filter
{
unsigned index;
bool *smooth;
} video_shader_ctx_filter_t;
typedef struct video_shader_ctx_wrap
{
unsigned idx;
enum gfx_wrap_type type;
} video_shader_ctx_wrap_t;
typedef struct video_shader_ctx
{
struct video_shader *data;
} video_shader_ctx_t;
typedef struct video_shader_ctx_ident
{
const char *ident;
} video_shader_ctx_ident_t;
typedef struct video_shader_ctx_texture
{
unsigned id;
} video_shader_ctx_texture_t;
bool video_shader_driver_get_prev_textures(video_shader_ctx_texture_t *texture);
bool video_shader_driver_get_ident(video_shader_ctx_ident_t *ident);
bool video_shader_driver_get_current_shader(video_shader_ctx_t *shader);
bool video_shader_driver_direct_get_current_shader(video_shader_ctx_t *shader);
bool video_shader_driver_deinit(void);
#define video_shader_driver_set_parameter(param) \
if (current_shader && current_shader->set_uniform_parameter) \
current_shader->set_uniform_parameter(shader_data, &param, NULL)
#define video_shader_driver_set_parameters(params) \
current_shader->set_params(params.data, shader_data, params.width, params.height, params.tex_width, params.tex_height, params.out_width, params.out_height, params.frame_counter, params.info, params.prev_info, params.feedback_info, params.fbo_info, params.fbo_info_cnt)
bool video_shader_driver_init_first(void);
bool video_shader_driver_init(video_shader_ctx_init_t *init);
bool video_shader_driver_get_feedback_pass(unsigned *data);
bool video_shader_driver_mipmap_input(unsigned *index);
#define video_shader_driver_set_coords(coords) \
if (!current_shader->set_coords(coords.handle_data, shader_data, (const struct video_coords*)coords.data) && current_shader->set_coords_fallback) \
current_shader->set_coords_fallback(coords.handle_data, shader_data, (const struct video_coords*)coords.data)
bool video_shader_driver_scale(video_shader_ctx_scale_t *scaler);
bool video_shader_driver_info(video_shader_ctx_info_t *shader_info);
#define video_shader_driver_set_mvp(mvp) \
if (mvp.matrix) \
current_shader->set_mvp(mvp.data, shader_data, mvp.matrix) \
bool video_shader_driver_filter_type(video_shader_ctx_filter_t *filter);
bool video_shader_driver_compile_program(struct shader_program_info *program_info);
#define video_shader_driver_use(shader_info) \
current_shader->use(shader_info.data, shader_data, shader_info.idx, shader_info.set_active)
bool video_shader_driver_wrap_type(video_shader_ctx_wrap_t *wrap);
extern shader_backend_t *current_shader;
extern void *shader_data;
extern const shader_backend_t gl_glsl_backend;
extern const shader_backend_t hlsl_backend;
extern const shader_backend_t gl_cg_backend;
extern const shader_backend_t shader_null_backend;
RETRO_END_DECLS
#endif

1
gfx/video_thread_wrapper.c
View File

@ -25,7 +25,6 @@
#include "video_thread_wrapper.h"
#include "font_driver.h"
#include "video_shader_driver.h"
#include "../retroarch.h"
#include "../verbosity.h"

4
griffin/griffin.c
View File

@ -224,10 +224,8 @@ VIDEO CONTEXT
VIDEO SHADERS
============================================================ */
#ifdef HAVE_SHADERS
#include "../gfx/video_shader_driver.c"
#include "../gfx/video_shader_parse.c"
#include "../gfx/drivers_shader/shader_null.c"
#ifdef HAVE_CG
@ -244,8 +242,6 @@ VIDEO SHADERS
#include "../gfx/drivers_shader/shader_glsl.c"
#endif
#endif
/*============================================================
VIDEO IMAGE
============================================================ */

2
menu/cbs/menu_cbs_start.c
View File

@ -36,7 +36,7 @@
#include "../../retroarch.h"
#include "../../performance_counters.h"
#include "../../gfx/video_shader_driver.h"
#include "../../gfx/video_driver.h"
#include "../../input/input_config.h"
#include "../../input/input_remapping.h"

2
menu/drivers/nuklear/nk_common.c
View File

@ -30,7 +30,7 @@
#include "nk_common.h"
#include "../../menu_display.h"
#include "../../../gfx/video_shader_driver.h"
#include "../../../gfx/video_driver.h"
#ifdef HAVE_GLSL
#include "../../../gfx/drivers/gl_shaders/pipeline_nuklear.glsl.vert.h"

1
menu/drivers_display/menu_display_ctr.c
View File

@ -24,7 +24,6 @@
#include "../../retroarch.h"
#include "../../gfx/font_driver.h"
#include "../../gfx/video_driver.h"
#include "../../gfx/video_shader_driver.h"
#include "../../gfx/common/ctr_common.h"
#include "../../gfx/drivers/ctr_gu.h"
#include "../../ctr/gpu_old.h"

1
menu/drivers_display/menu_display_gl.c
View File

@ -22,7 +22,6 @@
#include "../../retroarch.h"
#include "../../gfx/font_driver.h"
#include "../../gfx/video_driver.h"
#include "../../gfx/video_shader_driver.h"
#include "../../gfx/common/gl_common.h"
#include "../menu_display.h"

1
menu/drivers_display/menu_display_vita2d.c
View File

@ -26,7 +26,6 @@
#include "../../retroarch.h"
#include "../../gfx/font_driver.h"
#include "../../gfx/video_driver.h"
#include "../../gfx/video_shader_driver.h"
#include "../../gfx/common/vita2d_common.h"
#include "../../defines/psp_defines.h"

1
menu/drivers_display/menu_display_vulkan.c
View File

@ -25,7 +25,6 @@
#include "../../gfx/font_driver.h"
#include "../../gfx/video_driver.h"
#include "../../gfx/common/vulkan_common.h"
#include "../../gfx/video_shader_driver.h"
/* Will do Y-flip later, but try to make it similar to GL. */
static const float vk_vertexes[] = {

2
menu/menu_displaylist.c
View File

@ -68,7 +68,7 @@
#include "../core.h"
#include "../frontend/frontend_driver.h"
#include "../ui/ui_companion_driver.h"
#include "../gfx/video_shader_driver.h"
#include "../gfx/video_driver.h"
#include "../config.features.h"
#include "../version_git.h"
#include "../input/input_config.h"

2
menu/menu_driver.h
View File

@ -31,7 +31,7 @@
#include "menu_input.h"
#include "menu_entries.h"
#include "../gfx/video_shader_driver.h"
#include "../gfx/video_driver.h"
RETRO_BEGIN_DECLS

2
menu/menu_shader.h
View File

@ -19,7 +19,7 @@
#include <retro_common_api.h>
#include "../gfx/video_shader_driver.h"
#include "../gfx/video_driver.h"
RETRO_BEGIN_DECLS

1
ui/drivers/ui_win32.c
View File

@ -51,7 +51,6 @@
#include "../../paths.h"
#include "../../retroarch.h"
#include "../../gfx/video_driver.h"
#include "../../gfx/video_shader_driver.h"
#include "../../tasks/tasks_internal.h"
#include "../../gfx/common/gl_common.h"