(Android) Some patches for RMenu compatibility

console/rmenu/rmenu.h

@@ -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

driver.h

@@ -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);

gfx/context/androidegl_ctx.c

@@ -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
 };

gfx/context/ps3_ctx.c

@@ -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_S, gl->border_type);
-   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+   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",
-
+#ifdef HAVE_RMENU
-   // RARCH_CONSOLE stuff.
    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,

gfx/gfx_context.h

@@ -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);

gfx/gl.c

@@ -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,

gfx/gl_common.h

@@ -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
 

gfx/gl_font.h

@@ -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
 

gfx/shader_glsl.c

@@ -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 GLuint gl_program[RARCH_GLSL_MAX_SHADERS];
-static enum filter_type gl_filter_type[MAX_PROGRAMS];
+static enum filter_type gl_filter_type[RARCH_GLSL_MAX_SHADERS];
-static struct gl_fbo_scale gl_scale[MAX_PROGRAMS];
+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)
       {

gfx/shader_glsl.h

@@ -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);