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

(Android) Some patches for RMenu compatibility

Browse Source
This commit is contained in:
twinaphex 2012-12-14 01:29:01 +01:00
parent 5421fb8269
commit 707bcd483f
10 changed files with 277 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
console/rmenu/rmenu.h
View File

@ -17,16 +17,21 @@
#ifndef _RMENU_H_
#define _RMENU_H_
#if defined(__CELLOS_LV2__)
#if defined(HAVE_OPENGL)
#define DEVICE_CAST gl_t*
#define input_ptr input_ps3
#define video_ptr video_gl
#endif
#if defined(__CELLOS_LV2__)
#define input_ptr input_ps3
#elif defined(ANDROID)
#define input_ptr input_android
#elif defined(_XBOX1)
#define DEVICE_CAST xdk_d3d_video_t*
#define input_ptr input_xinput
#define video_ptr video_xdk_d3d
#endif
typedef struct

2
driver.h
View File

@ -209,7 +209,7 @@ typedef struct video_driver
const char *ident;
// Callbacks essentially useless on PC, but useful on consoles where the drivers are used for more stuff.
#ifdef RARCH_CONSOLE
#if defined(HAVE_RMENU)
void (*start)(void);
void (*stop)(void);
void (*restart)(void);

241
gfx/context/androidegl_ctx.c
View File

@ -22,9 +22,16 @@
#include <GLES/gl.h>
#include "../../android/native/jni/android_general.h"
#include "../image.h"
#include "../gl_font.h"
#include <stdint.h>
#if defined(HAVE_RMENU)
GLuint menu_texture_id;
static struct texture_image menu_texture;
#endif
#ifdef HAVE_GLSL
#include "../shader_glsl.h"
#endif
@ -286,6 +293,220 @@ static void gfx_ctx_input_driver(const input_driver_t **input, void **input_data
*input_data = NULL;
}
static void gfx_ctx_set_filtering(unsigned index, bool set_smooth)
{
gl_t *gl = driver.video_data;
if (!gl)
return;
if (index == 1)
{
// Apply to all PREV textures.
for (unsigned i = 0; i < TEXTURES; i++)
{
glBindTexture(GL_TEXTURE_2D, gl->texture[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, set_smooth ? GL_LINEAR : GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, set_smooth ? GL_LINEAR : GL_NEAREST);
}
}
#ifdef HAVE_FBO
else if (index >= 2 && gl->fbo_inited)
{
glBindTexture(GL_TEXTURE_2D, gl->fbo_texture[index - 2]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, set_smooth ? GL_LINEAR : GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, set_smooth ? GL_LINEAR : GL_NEAREST);
}
#endif
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
}
static void gfx_ctx_set_fbo(unsigned mode)
{
gl_t *gl = driver.video_data;
#ifdef HAVE_FBO
switch(mode)
{
case FBO_DEINIT:
gl_deinit_fbo(gl);
break;
case FBO_REINIT:
gl_deinit_fbo(gl);
/* fall-through */
case FBO_INIT:
gl_init_fbo(gl, gl->tex_w, gl->tex_h);
break;
}
#endif
}
static void gfx_ctx_get_available_resolutions (void)
{
/* TODO */
}
#ifdef HAVE_RMENU
#define DRIVE_MAPPING_SIZE 3
bool rmenu_inited = false;
const char drive_mappings[DRIVE_MAPPING_SIZE][32] = {
"/",
"/mnt/sdcard",
"/mnt/extsd"
};
unsigned char drive_mapping_idx = 1;
static bool gfx_ctx_rmenu_init(void)
{
gl_t *gl = driver.video_data;
if (!gl)
return false;
#ifdef HAVE_RMENU
glGenTextures(1, &menu_texture_id);
RARCH_LOG("Loading texture image for menu...\n");
if (!texture_image_load(default_paths.menu_border_file, &menu_texture))
{
RARCH_ERR("Failed to load texture image for menu.\n");
return false;
}
glBindTexture(GL_TEXTURE_2D, menu_texture_id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, gl->border_type);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, gl->border_type);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, RARCH_GL_INTERNAL_FORMAT32,
menu_texture.width, menu_texture.height, 0,
RARCH_GL_TEXTURE_TYPE32, RARCH_GL_FORMAT32, menu_texture.pixels);
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
free(menu_texture.pixels);
#endif
rmenu_inited = true;
return true;
}
static void gfx_ctx_rmenu_free(void)
{
gl_t *gl = driver.video_data;
#ifdef HAVE_RMENU
gl->draw_rmenu = false;
#endif
}
static void gfx_ctx_rmenu_frame(void *data)
{
gl_t *gl = (gl_t*)data;
gl_shader_use(gl, RARCH_GLSL_MENU_SHADER_INDEX);
gl_set_viewport(gl, gl->win_width, gl->win_height, true, false);
if (gl->shader)
{
gl->shader->set_params(gl->win_width, gl->win_height,
gl->win_width, gl->win_height,
gl->win_width, gl->win_height,
gl->frame_count, NULL, NULL, NULL, 0);
}
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, menu_texture_id);
gl->coords.vertex = vertexes_flipped;
gl_shader_set_coords(gl, &gl->coords, &gl->mvp);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
gl_set_viewport(gl, gl->win_width, gl->win_height, false, true);
}
static void gfx_ctx_menu_draw_panel(rarch_position_t *position)
{
(void)position;
}
static void gfx_ctx_menu_draw_bg(rarch_position_t *position)
{
(void)position;
}
static const char * rmenu_ctx_drive_mapping_previous(void)
{
if(drive_mapping_idx > 0)
drive_mapping_idx--;
return drive_mappings[drive_mapping_idx];
}
static const char * rmenu_ctx_drive_mapping_next(void)
{
if((drive_mapping_idx + 1) < DRIVE_MAPPING_SIZE)
drive_mapping_idx++;
return drive_mappings[drive_mapping_idx];
}
static void gfx_ctx_menu_enable(bool enable)
{
gl_t *gl = driver.video_data;
if (enable)
{
if(!rmenu_inited)
gfx_ctx_rmenu_init();
gl->draw_rmenu = true;
}
else
{
gfx_ctx_rmenu_free();
}
}
#endif
static void rmenu_ctx_screenshot_enable(bool enable)
{
/* TODO */
(void)enable;
}
static void gfx_ctx_set_overscan(void)
{
gl_t *gl = driver.video_data;
if (!gl)
return;
gl->should_resize = true;
}
static int gfx_ctx_check_resolution(unsigned resolution_id)
{
/* TODO */
return 0;
}
static unsigned gfx_ctx_get_resolution_width(unsigned resolution_id)
{
int gl_width;
eglQuerySurface(g_egl_dpy, g_egl_surf, EGL_WIDTH, &gl_width);
return gl_width;
}
static void rmenu_ctx_render_msg(float xpos, float ypos, float scale, unsigned color, const char *msg, ...)
{
gl_t *gl = driver.video_data;
gl_render_msg_place(gl, xpos, ypos, scale, color, msg);
}
static gfx_ctx_proc_t gfx_ctx_get_proc_address(const char *symbol)
{
rarch_assert(sizeof(void*) == sizeof(void (*)(void)));
@ -336,4 +557,24 @@ const gfx_ctx_driver_t gfx_ctx_android = {
gfx_ctx_init_egl_image_buffer,
gfx_ctx_write_egl_image,
"android",
#ifdef HAVE_RMENU
gfx_ctx_clear,
gfx_ctx_set_blend,
gfx_ctx_set_filtering,
gfx_ctx_get_available_resolutions,
gfx_ctx_check_resolution,
gfx_ctx_set_fbo,
gfx_ctx_rmenu_init,
gfx_ctx_rmenu_frame,
gfx_ctx_rmenu_free,
gfx_ctx_menu_enable,
gfx_ctx_menu_draw_bg,
gfx_ctx_menu_draw_panel,
gfx_ctx_ps3_set_default_pos,
rmenu_ctx_render_msg,
rmenu_ctx_screenshot_enable,
rmenu_ctx_screenshot_dump,
rmenu_ctx_drive_mapping_previous,
rmenu_ctx_drive_mapping_next,
#endif
};

10
gfx/context/ps3_ctx.c
View File

@ -320,8 +320,8 @@ static bool gfx_ctx_rmenu_init(void)
}
glBindTexture(GL_TEXTURE_2D, menu_texture_id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, gl->border_type);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, gl->border_type);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
@ -389,7 +389,6 @@ static void gfx_ctx_rmenu_frame(void *data)
gl_set_viewport(gl, gl->win_width, gl->win_height, false, true);
}
static void gfx_ctx_menu_draw_panel(rarch_position_t *position)
{
(void)position;
@ -564,16 +563,13 @@ const gfx_ctx_driver_t gfx_ctx_ps3 = {
gfx_ctx_init_egl_image_buffer,
gfx_ctx_write_egl_image,
"ps3",
// RARCH_CONSOLE stuff.
#ifdef HAVE_RMENU
gfx_ctx_clear,
gfx_ctx_set_blend,
gfx_ctx_set_filtering,
gfx_ctx_get_available_resolutions,
gfx_ctx_check_resolution,
gfx_ctx_set_fbo,
#ifdef HAVE_RMENU
gfx_ctx_rmenu_init,
gfx_ctx_rmenu_frame,
gfx_ctx_rmenu_free,

5
gfx/gfx_context.h
View File

@ -104,16 +104,13 @@ typedef struct gfx_ctx_driver
// Human readable string.
const char *ident;
#ifdef RARCH_CONSOLE
#if defined(HAVE_RMENU) || defined(_XBOX360)
void (*clear)(void);
void (*set_blend)(bool enable);
void (*set_filtering)(unsigned index, bool set_smooth);
void (*get_available_resolutions)(void);
int (*check_resolution)(unsigned resolution_id);
void (*set_fbo)(unsigned);
#endif
#if defined(HAVE_RMENU) || defined(_XBOX360)
bool (*rmenu_init)(void);
void (*rmenu_frame)(void *data);
void (*rmenu_free)(void);

17
gfx/gl.c
View File

@ -1188,7 +1188,7 @@ static bool gl_frame(void *data, const void *frame, unsigned width, unsigned hei
RARCH_PERFORMANCE_STOP(frame_run);
#ifdef RARCH_CONSOLE
#if defined(HAVE_RMENU)
if (!gl->block_swap)
#endif
context_swap_buffers_func();
@ -1690,7 +1690,7 @@ static bool gl_read_viewport(void *data, uint8_t *buffer)
}
#endif
#ifdef RARCH_CONSOLE
#ifdef HAVE_RMENU
static void gl_start(void)
{
video_info_t video_info = {0};
@ -1735,10 +1735,8 @@ static void gl_restart(void)
if (!gl)
return;
#ifdef RARCH_CONSOLE
bool should_block_swap = gl->block_swap;
#endif
#ifdef HAVE_RMENU
bool should_block_swap = gl->block_swap;
bool should_draw_rmenu = gl->draw_rmenu;
#endif
@ -1750,14 +1748,11 @@ static void gl_restart(void)
#ifdef HAVE_RMENU
gl->draw_rmenu = should_draw_rmenu;
#endif
gl->frame_count = 0;
#ifdef RARCH_CONSOLE
gl->block_swap = should_block_swap;
SET_TIMER_EXPIRATION(gl, 0, 30);
#endif
gl->frame_count = 0;
}
static void gl_apply_state_changes(void)
@ -1800,7 +1795,7 @@ const video_driver_t video_gl = {
gl_free,
"gl",
#ifdef RARCH_CONSOLE
#ifdef HAVE_RMENU
gl_start,
gl_stop,
gl_restart,

4
gfx/gl_common.h
View File

@ -275,10 +275,8 @@ typedef struct gl
GLfloat font_color_dark[16];
#endif
#ifdef RARCH_CONSOLE
bool block_swap;
#endif
#ifdef HAVE_RMENU
bool block_swap;
bool draw_rmenu;
#endif

3
gfx/gl_font.h
View File

@ -21,10 +21,7 @@
void gl_init_font(void *data, const char *font_path, unsigned font_size);
void gl_deinit_font(void *data);
void gl_render_msg(void *data, const char *msg);
#ifdef RARCH_CONSOLE
void gl_render_msg_place(void *data, float x, float y, float scale, uint32_t color, const char *msg);
#endif
#endif

20
gfx/shader_glsl.c
View File

@ -123,11 +123,9 @@ static PFNGLVERTEXATTRIBPOINTERPROC pglVertexAttribPointer;
#define MAX_VARIABLES 256
#ifdef RARCH_GPU_PERFORMANCE_MODE
#define MAX_PROGRAMS 8
#define MAX_TEXTURES 4
#define PREV_TEXTURES 3
#else
#define MAX_PROGRAMS 16
#define MAX_TEXTURES 8
#define PREV_TEXTURES 7
#endif
@ -141,9 +139,9 @@ enum filter_type
static bool glsl_enable;
static bool glsl_modern;
static GLuint gl_program[MAX_PROGRAMS];
static enum filter_type gl_filter_type[MAX_PROGRAMS];
static struct gl_fbo_scale gl_scale[MAX_PROGRAMS];
static GLuint gl_program[RARCH_GLSL_MAX_SHADERS];
static enum filter_type gl_filter_type[RARCH_GLSL_MAX_SHADERS];
static struct gl_fbo_scale gl_scale[RARCH_GLSL_MAX_SHADERS];
static unsigned gl_num_programs;
static unsigned active_index;
@ -158,7 +156,7 @@ static char gl_tracker_script_class[64];
static char *gl_script_program;
static GLint gl_attribs[PREV_TEXTURES + 1 + 4 + MAX_PROGRAMS];
static GLint gl_attribs[PREV_TEXTURES + 1 + 4 + RARCH_GLSL_MAX_SHADERS];
static unsigned gl_attrib_index;
static gfx_ctx_proc_t (*glsl_get_proc_address)(const char*);
@ -205,11 +203,11 @@ struct shader_uniforms
int lut_texture[MAX_TEXTURES];
struct shader_uniforms_frame orig;
struct shader_uniforms_frame pass[MAX_PROGRAMS];
struct shader_uniforms_frame pass[RARCH_GLSL_MAX_SHADERS];
struct shader_uniforms_frame prev[PREV_TEXTURES];
};
static struct shader_uniforms gl_uniforms[MAX_PROGRAMS];
static struct shader_uniforms gl_uniforms[RARCH_GLSL_MAX_SHADERS];
static const char *stock_vertex_legacy =
"varying vec4 color;\n"
@ -1001,7 +999,7 @@ static void find_uniforms(GLuint prog, struct shader_uniforms *uni)
find_uniforms_frame(prog, &uni->orig, "rubyOrig");
char frame_base[64];
for (unsigned i = 0; i < MAX_PROGRAMS; i++)
for (unsigned i = 0; i < RARCH_GLSL_MAX_SHADERS; i++)
{
snprintf(frame_base, sizeof(frame_base), "rubyPass%u", i + 1);
find_uniforms_frame(prog, &uni->pass[i], frame_base);
@ -1073,11 +1071,11 @@ bool gl_glsl_init(const char *path)
#endif
unsigned num_progs = 0;
struct shader_program progs[MAX_PROGRAMS] = {{0}};
struct shader_program progs[RARCH_GLSL_MAX_SHADERS] = {{0}};
#ifdef HAVE_XML
if (path)
{
num_progs = get_xml_shaders(path, progs, MAX_PROGRAMS - 1);
num_progs = get_xml_shaders(path, progs, RARCH_GLSL_MAX_SHADERS - 1);
if (num_progs == 0)
{

8
gfx/shader_glsl.h
View File

@ -20,6 +20,14 @@
#include "../boolean.h"
#include "shader_common.h"
#ifdef RARCH_GPU_PERFORMANCE_MODE
#define RARCH_GLSL_MAX_SHADERS 8
#else
#define RARCH_GLSL_MAX_SHADERS 16
#endif
#define RARCH_GLSL_MENU_SHADER_INDEX (RARCH_GLSL_MAX_SHADERS - 1)
bool gl_glsl_init(const char *path);
void gl_glsl_deinit(void);