(D3D9 HLSL) Implement all XMB shader pipeline effects

Add support for all 6 XMB animated background effects to the D3D9
HLSL driver: Ribbon (MENU), Ribbon Simple (MENU_2), Snow Simple
(MENU_3), Snow (MENU_4), Bokeh (MENU_5), and Snowflake (MENU_6).

Previously only Ribbon and Ribbon Simple were partially wired up
using the stock shader, and Snow Simple was stubbed.

New SM3 shader files (ps_3_0/vs_3_0):
  ribbon_sm3.hlsl.h        — ddx/ddy normals, /13.0 divisor
  ribbon_simple_sm3.hlsl.h — flat color ribbon
  simple_snow_sm3.hlsl.h   — snow simple with frac() scroll fix
  snow_sm3.hlsl.h          — snow with frac() scroll fix
  bokeh_sm3.hlsl.h         — bokeh particle effect
  snowflake_sm3.hlsl.h     — snowflake with atan2

SM3 porting notes vs SM4:
- SV_POSITION/SV_TARGET replaced with POSITION/COLOR semantics
- Screen position passed via TEXCOORD0 since SM3 pixel shaders
  cannot read VPOS reliably; vertex shader computes screen coords
  from clip position
- Vertex input changed to float3 to match existing D3D9 vertex
  declaration (FLOAT3 POSITION)
- Global float constants (baseScale, density, speed) inlined as
  literals to avoid D3DCompile creating CTAB uniform entries that
  lose their initial values
- Snowflake atime moved from static const global to local variable

d3d9hlsl.c changes:
- Added pipeline_shaders[6] and pipeline_data[6] to renderchain
  struct for compiled shader programs and CTAB bytecode
- All 6 shaders compiled at renderchain init via
  d3d9_hlsl_load_program_ex with bytecode stored for CTAB uniform
  lookup
- draw_pipeline: creates fullscreen quad VBO for MENU_3-6 using
  separate blank_coords to avoid mutating the shared ca->coords
  vertex count; sets time/OutputSize/alpha uniforms via CTAB
  register lookup; ribbon uses DESTCOLOR+ONE blend matching D3D11
- draw: selects pipeline shader per effect, sets vertex
  declaration, sets MVP ortho matrix for snow/bokeh/snowflake,
  restores stock shader after draw to prevent constant register
  corruption for subsequent non-pipeline draws
- Pipeline index computed as VIDEO_SHADER_MENU - pipeline_id
  (enum values decrease: MENU=62, MENU_6=57)
- Range checks use <= MENU / >= MENU_6 for the same reason
- Cleanup: releases fullscreen VBO on destroy

Author: LibretroAdmin

gfx/drivers/d3d9hlsl.c

@@ -84,6 +84,12 @@
 #include "../../retroarch.h"
 
 #include "d3d_shaders/shaders_common.h"
+#include "d3d_shaders/ribbon_sm3.hlsl.h"
+#include "d3d_shaders/ribbon_simple_sm3.hlsl.h"
+#include "d3d_shaders/simple_snow_sm3.hlsl.h"
+#include "d3d_shaders/snow_sm3.hlsl.h"
+#include "d3d_shaders/bokeh_sm3.hlsl.h"
+#include "d3d_shaders/snowflake_sm3.hlsl.h"
 
 static const char *stock_hlsl_program = CG(
       void main_vertex
@@ -645,12 +651,18 @@ typedef struct hlsl_renderchain
    hlsl_pass_data_t pass_data[GFX_MAX_SHADERS + 1];
    unsigned pass_data_count;
    hlsl_pass_data_t stock_data;
+   /* XMB pipeline shaders */
+   struct shader_pass pipeline_shaders[6]; /* MENU..MENU_6 */
+   hlsl_pass_data_t  pipeline_data[6];
+   bool              pipeline_inited;
 } hlsl_renderchain_t;
 
 /* Pipeline vertex buffer for menu shader effects (VIDEO_SHADER_MENU, etc.).
  * Stored as a file-static since the d3d9 menu_display struct
  * does not have a pipeline_vbo member like d3d10_video_t does. */
 static LPDIRECT3DVERTEXBUFFER9 d3d9_hlsl_menu_pipeline_vbo = NULL;
+static LPDIRECT3DVERTEXBUFFER9 d3d9_hlsl_menu_fullscreen_vbo = NULL;
+static LPDIRECT3DVERTEXDECLARATION9 d3d9_hlsl_pipeline_decl = NULL;
 static LPDIRECT3DVERTEXDECLARATION9 d3d9_hlsl_overlay_decl = NULL;
 
 static void d3d9_vertex_buffer_free(void *vertex_data, void *vertex_declaration)
@@ -788,21 +800,60 @@ static void gfx_display_d3d9_hlsl_draw(gfx_display_ctx_draw_t *draw,
       case VIDEO_SHADER_MENU:
       case VIDEO_SHADER_MENU_2:
       case VIDEO_SHADER_MENU_3:
+      case VIDEO_SHADER_MENU_4:
+      case VIDEO_SHADER_MENU_5:
+      case VIDEO_SHADER_MENU_6:
       {
-         /* Draw the pipeline vertices using the stock shader,
-          * then restore blend state and menu display vertex state.
-          * Adapted from d3d10 gfx_display_d3d10_draw pipeline path. */
          hlsl_renderchain_t *_chain = (hlsl_renderchain_t*)d3d->renderchain_data;
 
-         if (_chain)
+         if (_chain && _chain->pipeline_inited)
          {
-            IDirect3DDevice9_SetVertexShader(dev, (LPDIRECT3DVERTEXSHADER9)(&_chain->stock_shader)->vprg);
-
-            IDirect3DDevice9_SetPixelShader(dev, (LPDIRECT3DPIXELSHADER9)(&_chain->stock_shader)->fprg);
+            unsigned idx = VIDEO_SHADER_MENU - draw->pipeline_id;
+            struct shader_pass *shader = &_chain->pipeline_shaders[idx];
+
+            IDirect3DDevice9_SetVertexShader(dev,
+                  (LPDIRECT3DVERTEXSHADER9)shader->vprg);
+            IDirect3DDevice9_SetPixelShader(dev,
+                  (LPDIRECT3DPIXELSHADER9)shader->fprg);
+            IDirect3DDevice9_SetVertexDeclaration(dev,
+                  (LPDIRECT3DVERTEXDECLARATION9)d3d->menu_display.decl);
+
+            /* Snow/bokeh/snowflake need MVP matrix set */
+            if (draw->pipeline_id <= VIDEO_SHADER_MENU_3)
+            {
+               hlsl_pass_data_t *pd = &_chain->pipeline_data[idx];
+               /* Row-major ortho for mul(matrix, vector) in shader.
+                * D3D9 SetVertexShaderConstantF stores rows sequentially.
+                * mul(M, v) computes dot(row[i], v) — correct with row-major.
+                * Maps X [0,1]→[-1,1], Y [0,1]→[-1,1], Z pass-through. */
+               static const float ortho_mvp[16] = {
+                   2.0f,  0.0f, 0.0f, 0.0f,
+                   0.0f,  2.0f, 0.0f, 0.0f,
+                   0.0f,  0.0f, 1.0f, 0.0f,
+                  -1.0f, -1.0f, 0.0f, 1.0f
+               };
+               {
+                  int reg = d3d9_hlsl_ctab_find_register(
+                        pd->vs_bytecode, pd->vs_bytecode_dwords,
+                        "modelViewProj", NULL, NULL);
+                  if (reg >= 0)
+                     d3d9_hlsl_set_vs_const(dev, reg, ortho_mvp, 4);
+               }
+            }
 
             IDirect3DDevice9_DrawPrimitive(dev, D3DPT_TRIANGLESTRIP,
                   0, draw->coords->vertices - 2);
          }
+         else if (_chain)
+         {
+            /* Fallback to stock shader */
+            IDirect3DDevice9_SetVertexShader(dev,
+                  (LPDIRECT3DVERTEXSHADER9)(&_chain->stock_shader)->vprg);
+            IDirect3DDevice9_SetPixelShader(dev,
+                  (LPDIRECT3DPIXELSHADER9)(&_chain->stock_shader)->fprg);
+            IDirect3DDevice9_DrawPrimitive(dev, D3DPT_TRIANGLESTRIP,
+                  0, draw->coords->vertices - 2);
+         }
 
          /* Re-enable alpha blending after pipeline draw */
          IDirect3DDevice9_SetRenderState(dev,
@@ -818,6 +869,16 @@ static void gfx_display_d3d9_hlsl_draw(gfx_display_ctx_draw_t *draw,
                0, sizeof(Vertex));
          IDirect3DDevice9_SetVertexDeclaration(dev,
                (LPDIRECT3DVERTEXDECLARATION9)d3d->menu_display.decl);
+
+         /* Restore stock shader and its constants so subsequent
+          * non-pipeline draws (text, icons) work correctly. */
+         if (_chain)
+         {
+            IDirect3DDevice9_SetVertexShader(dev,
+                  (LPDIRECT3DVERTEXSHADER9)(&_chain->stock_shader)->vprg);
+            IDirect3DDevice9_SetPixelShader(dev,
+                  (LPDIRECT3DPIXELSHADER9)(&_chain->stock_shader)->fprg);
+         }
          return;
       }
       default:
@@ -1080,19 +1141,79 @@ static void gfx_display_d3d9_hlsl_draw_pipeline(
 
          draw->coords->vertices = ca->coords.vertices;
 
-         /* Set pipeline blend state */
+         /* Set pipeline blend state — ribbon uses multiplicative blend
+          * (DESTCOLOR + ONE) matching D3D11's blend_pipeline. */
          IDirect3DDevice9_SetRenderState(d3d->dev,
-               D3DRS_SRCBLEND,  D3DBLEND_SRCALPHA);
+               D3DRS_SRCBLEND,  D3DBLEND_DESTCOLOR);
          IDirect3DDevice9_SetRenderState(d3d->dev,
-               D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
+               D3DRS_DESTBLEND, D3DBLEND_ONE);
          IDirect3DDevice9_SetRenderState(d3d->dev,
                D3DRS_ALPHABLENDENABLE, true);
          break;
       }
 
       case VIDEO_SHADER_MENU_3:
+      case VIDEO_SHADER_MENU_4:
+      case VIDEO_SHADER_MENU_5:
+      case VIDEO_SHADER_MENU_6:
       {
-         draw->coords->vertices = 4;
+         static struct video_coords blank_coords = {0};
+
+         /* Fullscreen quad for snow/bokeh/snowflake effects */
+         if (!d3d9_hlsl_menu_fullscreen_vbo)
+         {
+            Vertex verts[4];
+            verts[0].x = 0.0f; verts[0].y = 0.0f; verts[0].z = 0.0f;
+            verts[0].u = 0.0f; verts[0].v = 1.0f;
+            verts[0].color = D3DCOLOR_ARGB(0xFF, 0xFF, 0xFF, 0xFF);
+            verts[1].x = 1.0f; verts[1].y = 0.0f; verts[1].z = 0.0f;
+            verts[1].u = 1.0f; verts[1].v = 1.0f;
+            verts[1].color = D3DCOLOR_ARGB(0xFF, 0xFF, 0xFF, 0xFF);
+            verts[2].x = 0.0f; verts[2].y = 1.0f; verts[2].z = 0.0f;
+            verts[2].u = 0.0f; verts[2].v = 0.0f;
+            verts[2].color = D3DCOLOR_ARGB(0xFF, 0xFF, 0xFF, 0xFF);
+            verts[3].x = 1.0f; verts[3].y = 1.0f; verts[3].z = 0.0f;
+            verts[3].u = 1.0f; verts[3].v = 0.0f;
+            verts[3].color = D3DCOLOR_ARGB(0xFF, 0xFF, 0xFF, 0xFF);
+
+            if (SUCCEEDED(IDirect3DDevice9_CreateVertexBuffer(
+                        d3d->dev, 4 * sizeof(Vertex),
+                        D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT,
+                        (LPDIRECT3DVERTEXBUFFER9*)&d3d9_hlsl_menu_fullscreen_vbo, NULL)))
+            {
+               void *lock = NULL;
+               IDirect3DVertexBuffer9_Lock(
+                     (LPDIRECT3DVERTEXBUFFER9)d3d9_hlsl_menu_fullscreen_vbo,
+                     0, 0, &lock, 0);
+               if (lock)
+               {
+                  memcpy(lock, verts, sizeof(verts));
+                  IDirect3DVertexBuffer9_Unlock(
+                        (LPDIRECT3DVERTEXBUFFER9)d3d9_hlsl_menu_fullscreen_vbo);
+               }
+            }
+         }
+
+         if (d3d9_hlsl_menu_fullscreen_vbo)
+         {
+            IDirect3DDevice9_SetStreamSource(d3d->dev, 0,
+                  (LPDIRECT3DVERTEXBUFFER9)d3d9_hlsl_menu_fullscreen_vbo,
+                  0, sizeof(Vertex));
+         }
+
+         /* Use separate coords to avoid mutating the shared
+          * ca->coords.vertices (which ribbon needs at 8064). */
+         blank_coords.vertices = 4;
+         draw->coords          = &blank_coords;
+         draw->prim_type = GFX_DISPLAY_PRIM_TRIANGLESTRIP;
+
+         /* Set blend state for particle effects */
+         IDirect3DDevice9_SetRenderState(d3d->dev,
+               D3DRS_SRCBLEND,  D3DBLEND_SRCALPHA);
+         IDirect3DDevice9_SetRenderState(d3d->dev,
+               D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
+         IDirect3DDevice9_SetRenderState(d3d->dev,
+               D3DRS_ALPHABLENDENABLE, true);
          break;
       }
 
@@ -1105,7 +1226,56 @@ static void gfx_display_d3d9_hlsl_draw_pipeline(
 
    {
       hlsl_renderchain_t *_chain = (hlsl_renderchain_t*)d3d->renderchain_data;
-      if (_chain)
+      if (_chain && _chain->pipeline_inited
+            && draw->pipeline_id <= VIDEO_SHADER_MENU
+            && draw->pipeline_id >= VIDEO_SHADER_MENU_6)
+      {
+         unsigned idx = VIDEO_SHADER_MENU - draw->pipeline_id;
+         hlsl_pass_data_t *pd = &_chain->pipeline_data[idx];
+
+         /* Set time uniform for all pipeline shaders */
+         d3d9_hlsl_set_param_1f(pd->vs_bytecode, pd->vs_bytecode_dwords,
+               true, d3d->dev, "time", &t);
+         d3d9_hlsl_set_param_1f(pd->ps_bytecode, pd->ps_bytecode_dwords,
+               false, d3d->dev, "time", &t);
+
+         /* Set OutputSize for snow/bokeh/snowflake shaders */
+         if (draw->pipeline_id <= VIDEO_SHADER_MENU_3)
+         {
+            D3DVIEWPORT9 vp;
+            IDirect3DDevice9_GetViewport(d3d->dev, &vp);
+            {
+               float output_size[4];
+               int reg;
+               output_size[0] = (float)vp.Width;
+               output_size[1] = (float)vp.Height;
+               output_size[2] = 0.0f;
+               output_size[3] = 0.0f;
+               /* Set OutputSize as a full register (float2 occupies one register) */
+               reg = d3d9_hlsl_ctab_find_register(
+                     pd->vs_bytecode, pd->vs_bytecode_dwords,
+                     "OutputSize", NULL, NULL);
+               if (reg >= 0)
+                  d3d9_hlsl_set_vs_const(d3d->dev, reg, output_size, 1);
+               reg = d3d9_hlsl_ctab_find_register(
+                     pd->ps_bytecode, pd->ps_bytecode_dwords,
+                     "OutputSize", NULL, NULL);
+               if (reg >= 0)
+                  d3d9_hlsl_set_ps_const(d3d->dev, reg, output_size, 1);
+            }
+         }
+
+         /* Set alpha for ribbon shaders */
+         if (draw->pipeline_id >= VIDEO_SHADER_MENU_2)
+         {
+            float alpha_val = draw->color ? draw->color[3] : 1.0f;
+            d3d9_hlsl_set_param_1f(pd->vs_bytecode, pd->vs_bytecode_dwords,
+                  true, d3d->dev, "alpha", &alpha_val);
+            d3d9_hlsl_set_param_1f(pd->ps_bytecode, pd->ps_bytecode_dwords,
+                  false, d3d->dev, "alpha", &alpha_val);
+         }
+      }
+      else if (_chain)
       {
          d3d9_hlsl_set_param_1f(
                _chain->stock_data.vs_bytecode,
@@ -2546,6 +2716,35 @@ static bool hlsl_d3d9_renderchain_init(
    IDirect3DDevice9_SetVertexShader(dev, (LPDIRECT3DVERTEXSHADER9)(&chain->stock_shader)->vprg);
    IDirect3DDevice9_SetPixelShader(dev, (LPDIRECT3DPIXELSHADER9)(&chain->stock_shader)->fprg);
 
+   /* Compile XMB pipeline shaders */
+   {
+      const char *pipeline_sources[6];
+      unsigned i;
+      pipeline_sources[0] = hlsl_ribbon_program;
+      pipeline_sources[1] = hlsl_ribbon_simple_program;
+      pipeline_sources[2] = hlsl_simple_snow_program;
+      pipeline_sources[3] = hlsl_snow_program;
+      pipeline_sources[4] = hlsl_bokeh_program;
+      pipeline_sources[5] = hlsl_snowflake_program;
+      chain->pipeline_inited = true;
+      for (i = 0; i < 6; i++)
+      {
+         hlsl_uniform_map_init(&chain->pipeline_data[i].vs_map);
+         hlsl_uniform_map_init(&chain->pipeline_data[i].ps_map);
+         chain->pipeline_data[i].vs_bytecode = NULL;
+         chain->pipeline_data[i].ps_bytecode = NULL;
+         if (!d3d9_hlsl_load_program_ex(dev,
+                  &chain->pipeline_shaders[i],
+                  pipeline_sources[i],
+                  &chain->pipeline_data[i]))
+         {
+            RARCH_WARN("[D3D9 HLSL] Could not compile XMB pipeline shader %u, effects disabled.\n", i);
+            chain->pipeline_inited = false;
+            break;
+         }
+      }
+   }
+
    return true;
 }
 
@@ -6222,6 +6421,16 @@ static void d3d9_hlsl_deinitialize(d3d9_video_t *d3d)
    d3d9_vertex_buffer_free(d3d->menu_display.buffer,
          d3d->menu_display.decl);
 
+   if (d3d9_hlsl_menu_fullscreen_vbo)
+   {
+      IDirect3DVertexBuffer9_Release(d3d9_hlsl_menu_fullscreen_vbo);
+      d3d9_hlsl_menu_fullscreen_vbo = NULL;
+   }
+   if (d3d9_hlsl_pipeline_decl)
+   {
+      IDirect3DVertexDeclaration9_Release(d3d9_hlsl_pipeline_decl);
+      d3d9_hlsl_pipeline_decl = NULL;
+   }
    if (d3d9_hlsl_menu_pipeline_vbo)
    {
       IDirect3DVertexBuffer9_Release(d3d9_hlsl_menu_pipeline_vbo);

gfx/drivers/d3d_shaders/bokeh_sm3.hlsl.h

@@ -0,0 +1,56 @@
+
+static const char *hlsl_bokeh_program = CG(
+
+   uniform float4x4 modelViewProj;
+   uniform float2 OutputSize;
+   uniform float time;
+
+   void main_vertex(
+      float4 position : POSITION,
+      float2 texcoord : TEXCOORD0,
+      out float4 oPosition : POSITION,
+      out float2 vpos : TEXCOORD0
+   )
+   {
+      oPosition = mul(modelViewProj, position);
+      vpos = float2(
+         (oPosition.x / oPosition.w * 0.5 + 0.5) * OutputSize.x,
+         (0.5 - oPosition.y / oPosition.w * 0.5) * OutputSize.y);
+   }
+
+   struct output
+   {
+      float4 color : COLOR;
+   };
+
+   output main_fragment(float2 vpos : TEXCOORD0)
+   {
+      output OUT;
+      float speed = time * 4.0;
+      float2 uv = -1.0 + 2.0 * vpos.xy / OutputSize;
+      uv.x *= OutputSize.x / OutputSize.y;
+      float3 color = float3(0.0, 0.0, 0.0);
+
+      for (int i = 0; i < 8; i++)
+      {
+         float pha = sin(float(i) * 546.13 + 1.0) * 0.5 + 0.5;
+         float siz = pow(sin(float(i) * 651.74 + 5.0) * 0.5 + 0.5, 4.0);
+         float pox = sin(float(i) * 321.55 + 4.1) * OutputSize.x / OutputSize.y;
+         float rad = 0.1 + 0.5 * siz + sin(pha + siz) / 4.0;
+         float2 pos = float2(pox + sin(speed / 15. + pha + siz),
+            -1.0 - rad + (2.0 + 2.0 * rad) * frac(pha + 0.3 * (speed / 7.) * (0.2 + 0.8 * siz)));
+         float dis = length(uv - pos);
+         if (dis < rad)
+         {
+            float3 col = lerp(
+               float3(0.194 * sin(speed / 6.0) + 0.3, 0.2, 0.3 * pha),
+               float3(1.1 * sin(speed / 9.0) + 0.3, 0.2 * pha, 0.4),
+               0.5 + 0.5 * sin(float(i)));
+            color += col.zyx * (1.0 - smoothstep(rad * 0.15, rad, dis));
+         }
+      }
+      color *= sqrt(1.5 - 0.5 * length(uv));
+      OUT.color = float4(color.r, color.g, color.b, 0.5);
+      return OUT;
+   }
+);