Expand functionality of set_shader callback function

360/frontend-xdk/menu.cpp

@@ -859,6 +859,15 @@ HRESULT CRetroArchShaderBrowser::OnInit(XUIMessageInit * pInitData, BOOL& bHandl
    return 0;
 }
 
+unsigned get_shader_type(void)
+{
+#if defined(HAVE_HLSL)
+   return RARCH_SHADER_HLSL;
+#else
+   return RARCH_SHADER_NONE;
+#endif
+}
+
 HRESULT CRetroArchShaderBrowser::OnNotifyPress( HXUIOBJ hObjPressed, BOOL& bHandled )
 {
    char path[PATH_MAX];
@@ -869,16 +878,31 @@ HRESULT CRetroArchShaderBrowser::OnNotifyPress( HXUIOBJ hObjPressed, BOOL& bHand
       if(path_file_exists(tmp_browser.current_dir.list->elems[index].data))
       {
          convert_wchar_to_char(str_buffer, (const wchar_t *)m_shaderlist.GetText(index), sizeof(str_buffer));
+         unsigned shader_type = get_shader_type();
 
          switch(set_shader)
          {
             case 1:
                snprintf(g_settings.video.cg_shader_path, sizeof(g_settings.video.cg_shader_path), "%s\\%s", filebrowser_get_current_dir(&tmp_browser), str_buffer);
-               rarch_load_shader(set_shader, g_settings.video.cg_shader_path);
+               if (shader_type != RARCH_SHADER_NONE)
+               {
+                  device_ptr->set_shader(driver.video_data, (enum rarch_shader_type)shader_type, g_settings.video.cg_shader_path, (1ULL << RARCH_SHADER_PASS0));
+                  if (g_extern.console.rmenu.state.msg_info.enable)
+                     rarch_settings_msg(S_MSG_SHADER_LOADING_SUCCEEDED, S_DELAY_180);
+               }
+               else
+                  RARCH_ERR("Shaders are unsupported on this platform.\n");
                break;
             case 2:
                snprintf (g_settings.video.second_pass_shader, sizeof(g_settings.video.second_pass_shader), "%s\\%s", filebrowser_get_current_dir(&tmp_browser), str_buffer);
-               rarch_load_shader(set_shader, g_settings.video.second_pass_shader);
+               if (shader_type != RARCH_SHADER_NONE)
+               {
+                  device_ptr->set_shader(driver.video_data, (enum rarch_shader_type)shader_type, g_settings.video.second_pass_shader, (1ULL << RARCH_SHADER_PASS1));
+                  if (g_extern.console.rmenu.state.msg_info.enable)
+                     rarch_settings_msg(S_MSG_SHADER_LOADING_SUCCEEDED, S_DELAY_180);
+               }
+               else
+                  RARCH_ERR("Shaders are unsupported on this platform.\n");
                break;
             default:
                break;

command.c

@@ -229,7 +229,7 @@ static bool cmd_set_shader(const char *arg)
    msg_queue_push(g_extern.msg_queue, msg, 1, 120);
    RARCH_LOG("Applying shader \"%s\".\n", arg);
 
-   return video_set_shader_func(type, arg);
+   return video_set_shader_func(type, arg, (1ULL << RARCH_SHADER_MULTIPASS));
 }
 
 static const struct cmd_action_map action_map[] = {

console/rarch_console_video.c

@@ -91,19 +91,3 @@ void rarch_set_core_viewport(void)
    else
       aspectratio_lut[ASPECT_RATIO_CORE].value = g_extern.system.av_info.geometry.aspect_ratio;
 }
-
-#if defined(HAVE_HLSL) || defined(HAVE_CG) || defined(HAVE_GLSL)
-void rarch_load_shader(unsigned slot, const char *path)
-{
-#if defined(HAVE_HLSL)
-   hlsl_load_shader(slot, path);
-#elif defined(HAVE_CG) && defined(HAVE_OPENGL)
-   gl_cg_load_shader(slot, path);
-#else
-RARCH_WARN("Shader support is not implemented for this build.\n");
-#endif
-
-   if (g_extern.console.rmenu.state.msg_info.enable)
-      rarch_settings_msg(S_MSG_SHADER_LOADING_SUCCEEDED, S_DELAY_180);
-}
-#endif

console/rarch_console_video.h

@@ -103,6 +103,5 @@ extern struct aspect_ratio_elem aspectratio_lut[ASPECT_RATIO_END];
 
 extern void rarch_set_auto_viewport(unsigned width, unsigned height);
 extern void rarch_set_core_viewport(void);
-extern void rarch_load_shader(unsigned slot, const char *path);
 
 #endif

console/rmenu/rmenu.c

@@ -615,6 +615,19 @@ void browser_render(void *data)
    }
 }
 
+unsigned get_shader_type(void)
+{
+#if defined(HAVE_GLSL)
+   return RARCH_SHADER_BSNES;
+#elif defined(HAVE_CG)
+   return RARCH_SHADER_CG;
+#elif defined(HAVE_HLSL)
+   return RARCH_SHADER_HLSL;
+#else
+   return RARCH_SHADER_NONE;
+#endif
+}
+
 int select_file(void *data, void *state)
 {
    menu *current_menu = (menu*)data;
@@ -663,20 +676,42 @@ int select_file(void *data, void *state)
          ret = filebrowser_iterate(filebrowser, FILEBROWSER_ACTION_OK);
       else
       {
+         unsigned shader_type = 0;
+         (void)shader_type;
+
          snprintf(path, sizeof(path), filebrowser_get_current_path(filebrowser));
 
          switch(current_menu->enum_id)
          {
 #if defined(HAVE_CG) || defined(HAVE_HLSL) || defined(HAVE_GLSL)
             case SHADER_CHOICE:
-               rarch_load_shader(set_shader+1, path);
                switch(set_shader+1)
                {
                   case 1:
                      strlcpy(g_settings.video.cg_shader_path, path, sizeof(g_settings.video.cg_shader_path));
+
+                     shader_type = get_shader_type();
+                     if (shader_type != RARCH_SHADER_NONE)
+                     {
+                        driver.video->set_shader(driver.video_data, (enum rarch_shader_type)shader_type, path, 1ULL << RARCH_SHADER_PASS0);
+                        if (g_extern.console.rmenu.state.msg_info.enable)
+                           rarch_settings_msg(S_MSG_SHADER_LOADING_SUCCEEDED, S_DELAY_180);
+                     }
+                     else
+                        RARCH_ERR("Shaders are unsupported on this platform.\n");
                      break;
                   case 2:
                      strlcpy(g_settings.video.second_pass_shader, path, sizeof(g_settings.video.second_pass_shader));
+
+                     shader_type = get_shader_type();
+                     if (shader_type != RARCH_SHADER_NONE)
+                     {
+                        driver.video->set_shader(driver.video_data, (enum rarch_shader_type)shader_type, path, 1ULL << RARCH_SHADER_PASS1);
+                        if (g_extern.console.rmenu.state.msg_info.enable)
+                           rarch_settings_msg(S_MSG_SHADER_LOADING_SUCCEEDED, S_DELAY_180);
+                     }
+                     else
+                        RARCH_ERR("Shaders are unsupported on this platform.\n");
                      break;
                }
                break;
@@ -1066,8 +1101,16 @@ static void set_setting_action(void *data, unsigned switchvalue, uint64_t input)
          }
          if(input & (1ULL << RMENU_DEVICE_NAV_START))
          {
-            rarch_load_shader(1, NULL);
             strlcpy(g_settings.video.cg_shader_path, default_paths.shader_file, sizeof(g_settings.video.cg_shader_path));
+            unsigned shader_type = get_shader_type();
+            if (shader_type != RARCH_SHADER_NONE)
+            {
+               driver.video->set_shader(driver.video_data, (enum rarch_shader_type)shader_type, NULL, (1ULL << RARCH_SHADER_PASS0) | (1ULL << RARCH_SHADER_PASS0_STOCK));
+               if (g_extern.console.rmenu.state.msg_info.enable)
+                  rarch_settings_msg(S_MSG_SHADER_LOADING_SUCCEEDED, S_DELAY_180);
+            }
+            else
+               RARCH_ERR("Shaders are unsupported on this platform.\n");
          }
          break;
       case SETTING_SHADER_2:
@@ -1079,8 +1122,16 @@ static void set_setting_action(void *data, unsigned switchvalue, uint64_t input)
          }
          if(input & (1ULL << RMENU_DEVICE_NAV_START))
          {
-            rarch_load_shader(2, NULL);
             strlcpy(g_settings.video.second_pass_shader, default_paths.shader_file, sizeof(g_settings.video.second_pass_shader));
+            unsigned shader_type = get_shader_type();
+            if (shader_type != RARCH_SHADER_NONE)
+            {
+               driver.video->set_shader(driver.video_data, (enum rarch_shader_type)shader_type, NULL, (1ULL << RARCH_SHADER_PASS1) | (1ULL << RARCH_SHADER_PASS1_STOCK));
+               if (g_extern.console.rmenu.state.msg_info.enable)
+                  rarch_settings_msg(S_MSG_SHADER_LOADING_SUCCEEDED, S_DELAY_180);
+            }
+            else
+               RARCH_ERR("Shaders are unsupported on this platform.\n");
          }
          break;
 #endif

driver.h

@@ -130,11 +130,21 @@ struct retro_keybind
 enum rarch_shader_type
 {
    RARCH_SHADER_CG,
+   RARCH_SHADER_HLSL,
    RARCH_SHADER_BSNES,
    RARCH_SHADER_AUTO,
    RARCH_SHADER_NONE
 };
 
+enum rarch_shader_mask
+{
+   RARCH_SHADER_MULTIPASS   = 1,
+   RARCH_SHADER_PASS0,
+   RARCH_SHADER_PASS0_STOCK,
+   RARCH_SHADER_PASS1,
+   RARCH_SHADER_PASS1_STOCK
+};
+
 typedef struct video_info
 {
    unsigned width;
@@ -223,7 +233,7 @@ typedef struct video_driver
    // Is the window still active?
    bool (*alive)(void *data);
    bool (*focus)(void *data); // Does the window have focus?
-   bool (*set_shader)(void *data, enum rarch_shader_type type, const char *path); // Sets shader. Might not be implemented.
+   bool (*set_shader)(void *data, enum rarch_shader_type type, const char *path, unsigned mask); // Sets shader. Might not be implemented.
    void (*free)(void *data);
    const char *ident;
 

driver_funcs.h

@@ -37,7 +37,7 @@
 #define video_set_nonblock_state_func(state) driver.video->set_nonblock_state(driver.video_data, state)
 #define video_alive_func() driver.video->alive(driver.video_data)
 #define video_focus_func() driver.video->focus(driver.video_data)
-#define video_set_shader_func(type, path) driver.video->set_shader(driver.video_data, type, path)
+#define video_set_shader_func(type, path, mask) driver.video->set_shader(driver.video_data, type, path, mask)
 #define video_set_rotation_func(rotate) driver.video->set_rotation(driver.video_data, rotate)
 #define video_set_aspect_ratio_func(aspect_idx) driver.video->set_aspect_ratio(driver.video_data, aspect_idx)
 #define video_viewport_info_func(info) driver.video->viewport_info(driver.video_data, info)
@@ -147,7 +147,7 @@ static inline bool input_key_pressed_func(int key)
 #define video_set_rotation_func(rotation)	MAKENAME_VIDEO(_set_rotation)(driver.video_data, rotation)
 #define video_stop_func() MAKENAME_VIDEO(_stop)()
 #define video_start_func() MAKENAME_VIDEO(_start)()
-#define video_set_shader_func(type, path) MAKENAME_VIDEO(_set_shader)(driver.video_data, type, path)
+#define video_set_shader_func(type, path, mask) MAKENAME_VIDEO(_set_shader)(driver.video_data, type, path, mask)
 #define video_xml_shader_func(path) driver.video->xml_shader(driver.video_data, path)
 
 /*============================================================

gfx/gl.c

@@ -1709,30 +1709,59 @@ static bool gl_focus(void *data)
 }
 
 #if defined(HAVE_GLSL) || defined(HAVE_CG)
-static bool gl_set_shader(void *data, enum rarch_shader_type type, const char *path)
+static bool gl_set_shader(void *data, enum rarch_shader_type type, const char *path, unsigned mask)
 {
    gl_t *gl = (gl_t*)data;
 
+   if (mask & (1ULL << RARCH_SHADER_MULTIPASS))
+   {
 #ifdef HAVE_FBO
-   gl_deinit_fbo(gl);
+      gl_deinit_fbo(gl);
-   glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
+      glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
 #endif
 
-   gl_shader_deinit(gl);
+      gl_shader_deinit(gl);
+   }
 
    switch (type)
    {
 #ifdef HAVE_GLSL
       case RARCH_SHADER_BSNES:
-         if (!gl_glsl_init(path))
+         if (mask & (1ULL << RARCH_SHADER_MULTIPASS))
-            return false;
+         {
+            if (!gl_glsl_init(path))
+               return false;
+         }
+         else if (mask & (1ULL << RARCH_SHADER_PASS0))
+         {
+            if (!gl_glsl_load_shader(1, (mask & (1ULL << RARCH_SHADER_PASS0_STOCK)) ? NULL : path))
+               return false;
+         }
+         else if (mask & (1ULL << RARCH_SHADER_PASS1))
+         {
+            if (!gl_glsl_load_shader(2, (mask & (1ULL << RARCH_SHADER_PASS1_STOCK)) ? NULL : path))
+               return false;
+         }
          break;
 #endif
 
 #ifdef HAVE_CG
       case RARCH_SHADER_CG:
-         if (!gl_cg_init(path))
+         if (mask & (1ULL << RARCH_SHADER_MULTIPASS))
-            return false;
+         {
+            if (!gl_cg_init(path))
+               return false;
+         }
+         else if (mask & (1ULL << RARCH_SHADER_PASS0))
+         {
+            if (!gl_cg_load_shader(1, (mask & (1ULL << RARCH_SHADER_PASS0_STOCK)) ? NULL : path))
+               return false;
+         }
+         else if (mask & (1ULL << RARCH_SHADER_PASS1))
+         {
+            if (!gl_cg_load_shader(2, (mask & (1ULL << RARCH_SHADER_PASS1_STOCK)) ? NULL : path))
+               return false;
+         }
          break;
 #endif
 
@@ -1741,14 +1770,17 @@ static bool gl_set_shader(void *data, enum rarch_shader_type type, const char *p
          return false;
    }
 
+   if (mask & (1ULL << RARCH_SHADER_MULTIPASS))
+   {
 #ifdef HAVE_FBO
-   // Set up render to texture again.
+      // Set up render to texture again.
-   gl_init_fbo(gl, gl->tex_w, gl->tex_h);
+      gl_init_fbo(gl, gl->tex_w, gl->tex_h);
 #endif
 
-   // Apparently need to set viewport for passes when we aren't using FBOs.
+      // Apparently need to set viewport for passes when we aren't using FBOs.
-   gl_set_shader_viewport(gl, 0);
+      gl_set_shader_viewport(gl, 0);
-   gl_set_shader_viewport(gl, 1);
+      gl_set_shader_viewport(gl, 1);
+   }
 
    return true;
 }

gx/gx_video.c

@@ -999,11 +999,14 @@ static void gx_apply_state_changes(void)
    gx->should_resize = true;
 }
 
-static bool gx_set_shader(void *data, enum rarch_shader_type type, const char *path)
+static bool gx_set_shader(void *data, enum rarch_shader_type type, const char *path, unsigned mask)
 {
    (void)data;
    (void)type;
    (void)path;
+   (void)mask;
+
+   RARCH_WARN("Shader support is not implemented for GX.\n");
 
    return false;
 }

retroarch.c

@@ -2342,7 +2342,7 @@ static void check_shader_dir(void)
       msg_queue_push(g_extern.msg_queue, msg, 1, 120);
       RARCH_LOG("Applying shader \"%s\".\n", shader);
 
-      if (!video_set_shader_func(type, shader))
+      if (!video_set_shader_func(type, shader, (1ULL << RARCH_SHADER_MULTIPASS)))
          RARCH_WARN("Failed to apply shader.\n");
    }
 

xdk/xdk_d3d.cpp

@@ -327,13 +327,41 @@ void xdk_d3d_init_fbo(void *data)
 }
 #endif
 
-static bool xdk_d3d_set_shader(void *data, enum rarch_shader_type type, const char *path)
+static bool xdk_d3d_set_shader(void *data, enum rarch_shader_type type, const char *path, unsigned mask)
 {
+   xdk_d3d_video_t *d3d = (xdk_d3d_video_t*)data;
+
    (void)data;
    (void)type;
    (void)path;
 
-   return false;
+   switch (type)
+   {
+#if defined(HAVE_HLSL)
+      case RARCH_SHADER_HLSL:
+         if (mask & (1ULL << RARCH_SHADER_MULTIPASS))
+         {
+            if (!gl_hlsl_init(path))
+               return false;
+         }
+         else if (mask & (1ULL << RARCH_SHADER_PASS0))
+         {
+            if (!gl_hlsl_load_shader(1, (mask & RARCH_SHADER_PASS0_STOCK) ? NULL : path))
+               return false;
+         }
+         else if (mask & (1ULL << RARCH_SHADER_PASS1))
+         {
+            if (!gl_hlsl_load_shader(2, (mask & RARCH_SHADER_PASS1_STOCK) ? NULL : path))
+               return false;
+         }
+         break;
+#endif
+      default:
+         RARCH_ERR("Invalid shader type in gl_set_shader().\n");
+         return false;
+   }
+
+   return true;
 }
 
 void xdk_d3d_generate_pp(D3DPRESENT_PARAMETERS *d3dpp, const video_info_t *video)