Add Preset System

API/FrameHookContext.cs

@@ -0,0 +1,302 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace ADOFAIRenderer.API;
+
+/// <summary>
+/// Execution context provided to frame modification hooks, managing GPU ping-pong double buffering.
+/// </summary>
+/// <remarks>
+/// <para>
+/// <b>Zero-Allocation Notice:</b> For maximum performance on the render hot path, the pipeline reuses context instances
+/// across frames. Do not cache the context instance itself across frames.
+/// </para>
+/// <para>
+/// <b>Execution Frequency Notice:</b> This hook is executed only when a frame is captured for video encoding.
+/// When <c>RenderFPS</c> exceeds <c>VideoFPS</c>, intermediate game rendering frames are skipped and the hook
+/// will <b>not</b> be invoked on every rendered game frame.
+/// </para>
+/// </remarks>
+[SuppressMessage("ReSharper", "UnusedType.Global")]
+[SuppressMessage("ReSharper", "UnusedMember.Global")]
+[SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
+[SuppressMessage("ReSharper", "UnusedAutoPropertyAccessor.Global")]
+public class FrameHookContext
+{
+    private RenderTexture _originalSource = null!;
+    private RenderTexture _pingRT = null!;
+    private RenderTexture _pongRT = null!;
+
+    private RenderTexture _currentSource = null!;
+    private RenderTexture _currentDestination = null!;
+    private bool _hasModified;
+
+    /// <summary>
+    /// The input <see cref="RenderTexture"/> containing the rendered frame before the current pass.
+    /// </summary>
+    public RenderTexture Source => _currentSource;
+
+    /// <summary>
+    /// The writable destination <see cref="RenderTexture"/> for the current pass.
+    /// </summary>
+    public RenderTexture Destination => _currentDestination;
+
+    /// <summary>
+    /// The active <see cref="RenderTexture"/> representing the current state of the modified frame.
+    /// </summary>
+    public RenderTexture Current => _currentSource;
+
+    /// <summary>
+    /// The original unmodified render texture captured from the game for the current frame before any hooks were applied.
+    /// </summary>
+    public RenderTexture OriginalSource => _originalSource;
+
+    /// <summary>
+    /// Indicates whether any modifications or swaps have been applied to this frame.
+    /// </summary>
+    public bool HasModified => _hasModified;
+
+    /// <summary>
+    /// The sequential 0-based index of the video frame currently being encoded.
+    /// </summary>
+    public long FrameIndex { get; private set; }
+
+    /// <summary>
+    /// Alias for <see cref="FrameIndex"/>. The sequential 0-based index of the video frame.
+    /// </summary>
+    public long VideoFrameIndex => FrameIndex;
+
+    /// <summary>
+    /// The sequential 0-based index of the game render frame.
+    /// </summary>
+    public long RenderFrameIndex { get; private set; }
+
+    /// <summary>
+    /// The timestamp of the current frame in seconds relative to video start.
+    /// </summary>
+    public double VideoTime { get; private set; }
+
+    /// <summary>
+    /// The delta time duration in seconds of a single video frame (equivalent to 1.0 / VideoFPS).
+    /// </summary>
+    public double DeltaTime => VideoFPS > 0 ? 1.0 / VideoFPS : 0.0;
+
+    /// <summary>
+    /// The width of the frame in pixels.
+    /// </summary>
+    public int Width => _currentSource.width;
+
+    /// <summary>
+    /// The height of the frame in pixels.
+    /// </summary>
+    public int Height => _currentSource.height;
+
+    /// <summary>
+    /// The configured render frames per second.
+    /// </summary>
+    public double RenderFPS { get; private set; }
+
+    /// <summary>
+    /// The output video frames per second.
+    /// </summary>
+    public double VideoFPS { get; private set; }
+
+    /// <summary>
+    /// The number of successful modification passes completed for the current frame.
+    /// </summary>
+    public int PassCount { get; private set; }
+
+    internal FrameHookContext(
+        RenderTexture originalSource,
+        RenderTexture pingRT,
+        RenderTexture pongRT,
+        RenderTexture firstDestination,
+        long frameIndex,
+        long renderFrameIndex,
+        double videoTime,
+        double renderFps,
+        double videoFps)
+    {
+        Reset(originalSource, pingRT, pongRT, firstDestination, frameIndex, renderFrameIndex, videoTime, renderFps, videoFps);
+    }
+
+    internal void Reset(
+        RenderTexture originalSource,
+        RenderTexture pingRT,
+        RenderTexture pongRT,
+        RenderTexture firstDestination,
+        long frameIndex,
+        long renderFrameIndex,
+        double videoTime,
+        double renderFps,
+        double videoFps)
+    {
+        _originalSource = originalSource;
+        _pingRT = pingRT;
+        _pongRT = pongRT;
+
+        _currentSource = originalSource;
+        _currentDestination = firstDestination;
+        _hasModified = false;
+        PassCount = 0;
+
+        FrameIndex = frameIndex;
+        RenderFrameIndex = renderFrameIndex;
+        VideoTime = videoTime;
+        RenderFPS = renderFps;
+        VideoFPS = videoFps;
+    }
+
+    /// <summary>
+    /// Blits from <see cref="Source"/> to <see cref="Destination"/> using the specified <see cref="Material"/> and automatically swaps ping-pong buffers.
+    /// </summary>
+    /// <param name="material">The material containing the shader to apply, or <c>null</c> for a standard copy.</param>
+    /// <param name="pass">The shader pass index to use, or -1 to execute all passes.</param>
+    public void Blit(Material? material = null, int pass = -1)
+    {
+        if (material != null)
+        {
+            if (pass >= 0)
+                Graphics.Blit(_currentSource, _currentDestination, material, pass);
+            else
+                Graphics.Blit(_currentSource, _currentDestination, material);
+        }
+        else
+        {
+            Graphics.Blit(_currentSource, _currentDestination);
+        }
+
+        Swap();
+    }
+
+    /// <summary>
+    /// Blits from a custom source <see cref="Texture"/> to <see cref="Destination"/> using the specified <see cref="Material"/> and automatically swaps ping-pong buffers.
+    /// </summary>
+    /// <param name="customSource">The custom source texture to blit from.</param>
+    /// <param name="material">The material containing the shader to apply, or <c>null</c> for a standard copy.</param>
+    /// <param name="pass">The shader pass index to use, or -1 to execute all passes.</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="customSource"/> is null.</exception>
+    public void Blit(Texture customSource, Material? material = null, int pass = -1)
+    {
+        if (customSource == null) throw new ArgumentNullException(nameof(customSource));
+
+        if (material != null)
+        {
+            if (pass >= 0)
+                Graphics.Blit(customSource, _currentDestination, material, pass);
+            else
+                Graphics.Blit(customSource, _currentDestination, material);
+        }
+        else
+        {
+            Graphics.Blit(customSource, _currentDestination);
+        }
+
+        Swap();
+    }
+
+    /// <summary>
+    /// Copies the contents of <see cref="Source"/> into <see cref="Destination"/> without swapping buffers.
+    /// Call this before drawing custom overlays into <see cref="Destination"/> if you wish to preserve the background.
+    /// </summary>
+    public void Copy()
+    {
+        Graphics.Blit(_currentSource, _currentDestination);
+    }
+
+    /// <summary>
+    /// Clears <see cref="Destination"/> with the specified color.
+    /// </summary>
+    /// <param name="clearColor">The color to clear with, or <c>null</c> for <see cref="Color.clear"/>.</param>
+    public void ClearDestination(Color? clearColor = null)
+    {
+        var prev = RenderTexture.active;
+        try
+        {
+            RenderTexture.active = _currentDestination;
+            GL.Clear(false, true, clearColor ?? Color.clear);
+        }
+        finally
+        {
+            RenderTexture.active = prev;
+        }
+    }
+
+    /// <summary>
+    /// Temporarily activates <see cref="Destination"/> as <see cref="RenderTexture.active"/> to perform custom draw calls,
+    /// safely restoring the previous active RenderTexture afterwards.
+    /// </summary>
+    /// <param name="drawAction">The action that performs custom draw operations.</param>
+    /// <param name="autoSwap">If <c>true</c> (default), automatically calls <see cref="Swap"/> after drawing.</param>
+    /// <param name="preserveBackground">If <c>true</c>, copies <see cref="Source"/> into <see cref="Destination"/> before executing <paramref name="drawAction"/>.</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="drawAction"/> is null.</exception>
+    public void DrawToDestination(Action drawAction, bool autoSwap = true, bool preserveBackground = false)
+    {
+        if (drawAction == null) throw new ArgumentNullException(nameof(drawAction));
+
+        if (preserveBackground)
+        {
+            Copy();
+        }
+
+        var prev = RenderTexture.active;
+        try
+        {
+            RenderTexture.active = _currentDestination;
+            drawAction();
+        }
+        finally
+        {
+            RenderTexture.active = prev;
+        }
+
+        if (autoSwap)
+        {
+            Swap();
+        }
+    }
+
+    /// <summary>
+    /// Executes a <see cref="CommandBuffer"/> against the GPU and optionally swaps buffers.
+    /// </summary>
+    /// <param name="commandBuffer">The command buffer to execute.</param>
+    /// <param name="autoSwap">If <c>true</c> (default), automatically calls <see cref="Swap"/> after execution.</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="commandBuffer"/> is null.</exception>
+    public void ExecuteCommandBuffer(CommandBuffer commandBuffer, bool autoSwap = true)
+    {
+        if (commandBuffer == null) throw new ArgumentNullException(nameof(commandBuffer));
+        Graphics.ExecuteCommandBuffer(commandBuffer);
+        if (autoSwap)
+        {
+            Swap();
+        }
+    }
+
+    /// <summary>
+    /// Swaps the active <see cref="Source"/> and <see cref="Destination"/> ping-pong buffers.
+    /// Call this after manually writing or rendering into <see cref="Destination"/> so that subsequent hooks or the video encoder read the updated frame.
+    /// </summary>
+    public void Swap()
+    {
+        _hasModified = true;
+        PassCount++;
+
+        var previousDestination = _currentDestination;
+        _currentSource = previousDestination;
+        _currentDestination = (previousDestination == _pingRT) ? _pongRT : _pingRT;
+    }
+
+    /// <summary>
+    /// Replaces the current modified frame texture with a custom <see cref="RenderTexture"/>.
+    /// </summary>
+    /// <param name="customTexture">The custom texture to set as the active frame.</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="customTexture"/> is null.</exception>
+    public void ReplaceCurrent(RenderTexture customTexture)
+    {
+        _currentSource = customTexture ?? throw new ArgumentNullException(nameof(customTexture));
+        _hasModified = true;
+        PassCount++;
+    }
+}

API/IFrameHook.cs

@@ -0,0 +1,24 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace ADOFAIRenderer.API;
+
+/// <summary>
+/// Represents a custom frame modification hook that can modify rendered frames using GPU ping-pong double buffering.
+/// </summary>
+/// <remarks>
+/// <b>Execution Frequency Note:</b> Frame hooks are only invoked for frames that are actually encoded into the final video (<c>VideoFPS</c>).
+/// When <c>RenderFPS</c> is higher than <c>VideoFPS</c>, intermediate game render frames are skipped and this hook
+/// will <b>not</b> be called on every game frame.
+/// </remarks>
+[SuppressMessage("ReSharper", "UnusedType.Global")]
+public interface IFrameHook
+{
+    /// <summary>
+    /// Invoked for each captured video frame before it is encoded.
+    /// </summary>
+    /// <remarks>
+    /// This method is not called on every rendered game frame if <c>RenderFPS</c> exceeds <c>VideoFPS</c>.
+    /// </remarks>
+    /// <param name="context">The frame hook context providing access to ping-pong textures and frame metadata.</param>
+    void OnRenderFrame(FrameHookContext context);
+}

API/RenderSession.cs

@@ -1,9 +1,11 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using ADOFAIRenderer.Core;
 using ADOFAIRenderer.Data;
 using ADOFAIRenderer.Util;
+using UnityEngine;
 
 namespace ADOFAIRenderer.API;
 
@@ -11,8 +13,47 @@ namespace ADOFAIRenderer.API;
 /// Fluent builder for configuring and starting a render session.
 /// </summary>
 [SuppressMessage("ReSharper", "UnusedType.Global")]
+[SuppressMessage("ReSharper", "UnusedMember.Global")]
+[SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
 public class RenderSession
 {
+    private sealed class GlobalHookRegistration : IDisposable
+    {
+        public object Key { get; }
+        public Action<FrameHookContext> Action { get; }
+        private bool _isDisposed;
+
+        public GlobalHookRegistration(object key, Action<FrameHookContext> action)
+        {
+            Key = key;
+            Action = action;
+        }
+
+        public void Dispose()
+        {
+            if (_isDisposed) return;
+            _isDisposed = true;
+            RemoveGlobalRegistration(this);
+        }
+    }
+
+    private sealed class SessionHookEntry
+    {
+        public object Key { get; }
+        public Action<FrameHookContext> Action { get; }
+
+        public SessionHookEntry(object key, Action<FrameHookContext> action)
+        {
+            Key = key;
+            Action = action;
+        }
+    }
+
+    private static readonly List<GlobalHookRegistration> GlobalFrameHooks = new();
+    private static readonly object GlobalHooksLock = new();
+    private static int _globalHooksVersion;
+
+    private readonly List<SessionHookEntry> _frameHooks = new();
     private bool _auto = true;
 
     /// <summary>
@@ -126,6 +167,331 @@ public class RenderSession
         return this;
     }
 
+    /// <summary>
+    /// Adds a custom frame modification hook to be executed for each encoded video frame.
+    /// The hook can modify the rendered frame using GPU ping-pong double buffering.
+    /// </summary>
+    /// <remarks>
+    /// <b>Execution Frequency Note:</b> This hook is invoked only for frames that are captured for the output video.
+    /// When <c>RenderFPS</c> is higher than <c>VideoFPS</c>, intermediate game render frames are skipped,
+    /// so this hook will <b>not</b> be called on every game frame.
+    /// </remarks>
+    /// <param name="hook">The callback action that receives a <see cref="FrameHookContext"/>.</param>
+    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="hook"/> is null.</exception>
+    public RenderSession AddFrameHook(Action<FrameHookContext> hook)
+    {
+        if (hook == null) throw new ArgumentNullException(nameof(hook));
+        _frameHooks.Add(new SessionHookEntry(hook, hook));
+        return this;
+    }
+
+    /// <summary>
+    /// Adds a material-based post-processing pass to be executed for each encoded video frame.
+    /// Automatically performs a GPU blit from source to destination and swaps buffers.
+    /// </summary>
+    /// <param name="material">The material containing the shader to apply.</param>
+    /// <param name="pass">The shader pass index to use, or -1 to execute all passes.</param>
+    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="material"/> is null.</exception>
+    public RenderSession AddFrameHook(Material material, int pass = -1)
+    {
+        if (material is null) throw new ArgumentNullException(nameof(material));
+        _frameHooks.Add(new SessionHookEntry(material, context => context.Blit(material, pass)));
+        return this;
+    }
+
+    /// <summary>
+    /// Adds a custom frame modification hook implementing <see cref="IFrameHook"/>.
+    /// </summary>
+    /// <param name="hook">The hook instance to execute.</param>
+    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="hook"/> is null.</exception>
+    public RenderSession AddFrameHook(IFrameHook hook)
+    {
+        if (hook == null) throw new ArgumentNullException(nameof(hook));
+        _frameHooks.Add(new SessionHookEntry(hook, hook.OnRenderFrame));
+        return this;
+    }
+
+    /// <summary>
+    /// Alias for <see cref="AddFrameHook(Action{FrameHookContext})"/>.
+    /// </summary>
+    /// <param name="hook">The callback action that receives a <see cref="FrameHookContext"/>.</param>
+    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
+    public RenderSession WithFrameHook(Action<FrameHookContext> hook) => AddFrameHook(hook);
+
+    /// <summary>
+    /// Alias for <see cref="AddFrameHook(Material, int)"/>.
+    /// </summary>
+    /// <param name="material">The material containing the shader to apply.</param>
+    /// <param name="pass">The shader pass index to use, or -1 to execute all passes.</param>
+    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
+    public RenderSession WithFrameHook(Material material, int pass = -1) => AddFrameHook(material, pass);
+
+    /// <summary>
+    /// Alias for <see cref="AddFrameHook(IFrameHook)"/>.
+    /// </summary>
+    /// <param name="hook">The hook instance to execute.</param>
+    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
+    public RenderSession WithFrameHook(IFrameHook hook) => AddFrameHook(hook);
+
+    /// <summary>
+    /// Removes a previously added frame modification hook callback from this session.
+    /// </summary>
+    /// <param name="hook">The hook action to remove.</param>
+    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
+    public RenderSession RemoveFrameHook(Action<FrameHookContext> hook)
+    {
+        var idx = _frameHooks.FindIndex(e => ReferenceEquals(e.Key, hook) || Equals(e.Action, hook));
+        if (idx >= 0) _frameHooks.RemoveAt(idx);
+        return this;
+    }
+
+    /// <summary>
+    /// Removes a previously added material-based post-processing pass from this session.
+    /// </summary>
+    /// <param name="material">The material to remove.</param>
+    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
+    public RenderSession RemoveFrameHook(Material material)
+    {
+        if (material)
+        {
+            for (var i = _frameHooks.Count - 1; i >= 0; i--)
+            {
+                if (ReferenceEquals(_frameHooks[i].Key, material))
+                {
+                    _frameHooks.RemoveAt(i);
+                }
+            }
+        }
+        return this;
+    }
+
+    /// <summary>
+    /// Removes a previously added <see cref="IFrameHook"/> from this session.
+    /// </summary>
+    /// <param name="hook">The hook instance to remove.</param>
+    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
+    public RenderSession RemoveFrameHook(IFrameHook hook)
+    {
+        var idx = _frameHooks.FindIndex(e => ReferenceEquals(e.Key, hook));
+        if (idx >= 0) _frameHooks.RemoveAt(idx);
+        return this;
+    }
+
+    /// <summary>
+    /// Clears all frame modification hooks configured for this render session.
+    /// </summary>
+    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
+    public RenderSession ClearFrameHooks()
+    {
+        _frameHooks.Clear();
+        return this;
+    }
+
+    /// <summary>
+    /// Registers a global frame modification hook that will execute on every render session.
+    /// </summary>
+    /// <remarks>
+    /// <b>Execution Frequency Note:</b> Global frame hooks are executed only for frames that are captured for the output video.
+    /// When <c>RenderFPS</c> is higher than <c>VideoFPS</c>, intermediate game render frames are skipped,
+    /// so this hook will <b>not</b> be called on every game frame.
+    /// </remarks>
+    /// <param name="hook">The callback action that receives a <see cref="FrameHookContext"/>.</param>
+    /// <returns>An <see cref="IDisposable"/> registration handle that unregisters the hook when disposed.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="hook"/> is null.</exception>
+    public static IDisposable AddGlobalFrameHook(Action<FrameHookContext> hook)
+    {
+        if (hook == null) throw new ArgumentNullException(nameof(hook));
+        var reg = new GlobalHookRegistration(hook, hook);
+        lock (GlobalHooksLock)
+        {
+            GlobalFrameHooks.Add(reg);
+            _globalHooksVersion++;
+        }
+        return reg;
+    }
+
+    /// <summary>
+    /// Registers a global material-based post-processing pass that will execute on every render session.
+    /// </summary>
+    /// <param name="material">The material containing the shader to apply.</param>
+    /// <param name="pass">The shader pass index to use, or -1 to execute all passes.</param>
+    /// <returns>An <see cref="IDisposable"/> registration handle that unregisters the hook when disposed.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="material"/> is null.</exception>
+    public static IDisposable AddGlobalFrameHook(Material material, int pass = -1)
+    {
+        if (material is null) throw new ArgumentNullException(nameof(material));
+        var reg = new GlobalHookRegistration(material, context => context.Blit(material, pass));
+        lock (GlobalHooksLock)
+        {
+            GlobalFrameHooks.Add(reg);
+            _globalHooksVersion++;
+        }
+        return reg;
+    }
+
+    /// <summary>
+    /// Registers a global frame modification hook implementing <see cref="IFrameHook"/>.
+    /// </summary>
+    /// <param name="hook">The hook instance to execute.</param>
+    /// <returns>An <see cref="IDisposable"/> registration handle that unregisters the hook when disposed.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="hook"/> is null.</exception>
+    public static IDisposable AddGlobalFrameHook(IFrameHook hook)
+    {
+        if (hook == null) throw new ArgumentNullException(nameof(hook));
+        var reg = new GlobalHookRegistration(hook, hook.OnRenderFrame);
+        lock (GlobalHooksLock)
+        {
+            GlobalFrameHooks.Add(reg);
+            _globalHooksVersion++;
+        }
+        return reg;
+    }
+
+    /// <summary>
+    /// Unregisters a previously registered global frame modification hook.
+    /// </summary>
+    /// <param name="hook">The hook action to remove.</param>
+    /// <returns><c>true</c> if the hook was successfully removed; otherwise, <c>false</c>.</returns>
+    public static bool RemoveGlobalFrameHook(Action<FrameHookContext> hook)
+    {
+        lock (GlobalHooksLock)
+        {
+            var idx = GlobalFrameHooks.FindIndex(r => ReferenceEquals(r.Key, hook) || Equals(r.Action, hook));
+            if (idx >= 0)
+            {
+                GlobalFrameHooks.RemoveAt(idx);
+                _globalHooksVersion++;
+                return true;
+            }
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Unregisters a previously registered global material-based post-processing pass.
+    /// </summary>
+    /// <param name="material">The material to remove.</param>
+    /// <returns><c>true</c> if any hooks matching <paramref name="material"/> were removed; otherwise, <c>false</c>.</returns>
+    public static bool RemoveGlobalFrameHook(Material material)
+    {
+        lock (GlobalHooksLock)
+        {
+            var removed = false;
+            for (var i = GlobalFrameHooks.Count - 1; i >= 0; i--)
+            {
+                if (ReferenceEquals(GlobalFrameHooks[i].Key, material))
+                {
+                    GlobalFrameHooks.RemoveAt(i);
+                    removed = true;
+                }
+            }
+            if (removed)
+            {
+                _globalHooksVersion++;
+            }
+            return removed;
+        }
+    }
+
+    /// <summary>
+    /// Unregisters a previously registered global frame modification hook implementing <see cref="IFrameHook"/>.
+    /// </summary>
+    /// <param name="hook">The hook instance to remove.</param>
+    /// <returns><c>true</c> if the hook was successfully removed; otherwise, <c>false</c>.</returns>
+    public static bool RemoveGlobalFrameHook(IFrameHook hook)
+    {
+        lock (GlobalHooksLock)
+        {
+            var idx = GlobalFrameHooks.FindIndex(r => ReferenceEquals(r.Key, hook));
+            if (idx >= 0)
+            {
+                GlobalFrameHooks.RemoveAt(idx);
+                _globalHooksVersion++;
+                return true;
+            }
+            return false;
+        }
+    }
+
+    private static void RemoveGlobalRegistration(GlobalHookRegistration registration)
+    {
+        lock (GlobalHooksLock)
+        {
+            if (GlobalFrameHooks.Remove(registration))
+            {
+                _globalHooksVersion++;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Clears all registered global frame modification hooks.
+    /// </summary>
+    public static void ClearGlobalFrameHooks()
+    {
+        lock (GlobalHooksLock)
+        {
+            if (GlobalFrameHooks.Count > 0)
+            {
+                GlobalFrameHooks.Clear();
+                _globalHooksVersion++;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Indicates whether any global frame modification hooks are currently registered.
+    /// </summary>
+    public static bool HasGlobalFrameHooks
+    {
+        get
+        {
+            lock (GlobalHooksLock)
+            {
+                return GlobalFrameHooks.Count > 0;
+            }
+        }
+    }
+
+    /// <summary>
+    /// The number of currently registered global frame modification hooks.
+    /// </summary>
+    public static int GlobalFrameHookCount
+    {
+        get
+        {
+            lock (GlobalHooksLock)
+            {
+                return GlobalFrameHooks.Count;
+            }
+        }
+    }
+
+    internal static int GlobalHooksVersion
+    {
+        get
+        {
+            lock (GlobalHooksLock)
+            {
+                return _globalHooksVersion;
+            }
+        }
+    }
+
+    internal static void CopyGlobalFrameHooksTo(List<Action<FrameHookContext>> destination)
+    {
+        lock (GlobalHooksLock)
+        {
+            for (var i = 0; i < GlobalFrameHooks.Count; i++)
+            {
+                destination.Add(GlobalFrameHooks[i].Action);
+            }
+        }
+    }
+
     /// <summary>
     /// Applies the configured flags and initiates the render session.
     /// </summary>
@@ -144,6 +510,15 @@ public class RenderSession
         if (_onComplete is not null) RenderContext.OnComplete = _onComplete;
         if (_onLastUpdate is not null) RenderContext.OnLastUpdate = _onLastUpdate;
 
+        RenderContext.SessionFrameHooks.Clear();
+        if (_frameHooks.Count > 0)
+        {
+            foreach (var t in _frameHooks)
+            {
+                RenderContext.SessionFrameHooks.Add(t.Action);
+            }
+        }
+        
         RenderManager.Instance.levelPath = levelPath;
         RenderManager.Instance.Configuration = renderConfig;
 

Core/Data/GlobalSettings.cs

@@ -6,20 +6,28 @@ using Newtonsoft.Json;
 
 namespace ADOFAIRenderer.Core.Data;
 
-public class GlobalConfig
+internal class GlobalConfig
 {
     public string? OutputDirectory { get; set; }
+    public string? LastPresetName { get; set; }
+    public bool DefaultPresetsInitialized { get; set; }
 }
 
-public static class GlobalSettings
+internal static class GlobalSettings
 {
-    private static string SettingsFilePath =>
-        Path.Combine(MelonEnvironment.GameRootDirectory, "UserData", "ADOFAIRenderer", "global_settings.json");
+    private static string GetGameRootDir()
+    {
+        var root = MelonEnvironment.GameRootDirectory;
+        return string.IsNullOrEmpty(root) ? AppDomain.CurrentDomain.BaseDirectory : root;
+    }
 
-    public static GlobalConfig Current { get; set; } = new();
+    private static string SettingsFilePath =>
+        Path.Combine(GetGameRootDir(), "UserData", "ADOFAIRenderer", "global_settings.json");
+
+    public static GlobalConfig Current { get; private set; } = new();
 
     public static string DefaultOutputDirectory =>
-        Path.Combine(MelonEnvironment.GameRootDirectory, "Render");
+        Path.Combine(GetGameRootDir(), "Render");
 
     public static string EffectiveOutputDirectory
     {

Core/FrameHookPipeline.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Collections.Generic;
+using ADOFAIRenderer.API;
+using MelonLoader;
+using UnityEngine;
+
+namespace ADOFAIRenderer.Core;
+
+internal class FrameHookPipeline : IDisposable
+{
+    private RenderTexture? _pingRT;
+    private RenderTexture? _pongRT;
+    private RenderTexture? _lastOutputRT;
+    private FrameHookContext? _reusableContext;
+    private int _width;
+    private int _height;
+    private RenderTextureFormat _format;
+
+    public RenderTexture? Process(
+        RenderTexture sourceTexture,
+        long frameIndex,
+        long renderFrameIndex,
+        double videoTime,
+        double renderFps,
+        double videoFps,
+        IReadOnlyList<Action<FrameHookContext>> hooks)
+    {
+        if (hooks.Count == 0 || !sourceTexture || !sourceTexture.IsCreated())
+            return sourceTexture;
+
+        EnsureBuffers(sourceTexture);
+
+        if (!_pingRT || !_pongRT || !_pingRT.IsCreated() || !_pongRT.IsCreated())
+            return sourceTexture;
+
+        var prevActive = RenderTexture.active;
+        try
+        {
+            // Inter-frame ping-pong safety: start with the buffer that was NOT used as the output
+            // of the previous frame, ensuring the buffer currently being read back is not immediately overwritten.
+            var firstDestination = _lastOutputRT == _pingRT ? _pongRT : _pingRT;
+
+            if (_reusableContext == null)
+            {
+                _reusableContext = new FrameHookContext(
+                    sourceTexture,
+                    _pingRT,
+                    _pongRT,
+                    firstDestination,
+                    frameIndex,
+                    renderFrameIndex,
+                    videoTime,
+                    renderFps,
+                    videoFps
+                );
+            }
+            else
+            {
+                _reusableContext.Reset(
+                    sourceTexture,
+                    _pingRT,
+                    _pongRT,
+                    firstDestination,
+                    frameIndex,
+                    renderFrameIndex,
+                    videoTime,
+                    renderFps,
+                    videoFps
+                );
+            }
+
+            for (var i = 0; i < hooks.Count; i++)
+            {
+                try
+                {
+                    hooks[i](_reusableContext);
+                }
+                catch (Exception ex)
+                {
+                    Melon<RenderMod>.Logger.Error($"[FrameHook] Error executing frame hook #{i} on frame {frameIndex}: {ex}");
+                }
+            }
+
+            var result = _reusableContext.Current;
+            _lastOutputRT = _reusableContext.HasModified ? result : null;
+            return result;
+        }
+        finally
+        {
+            RenderTexture.active = prevActive;
+        }
+    }
+
+    private void EnsureBuffers(RenderTexture sourceTexture)
+    {
+        var width = sourceTexture.width;
+        var height = sourceTexture.height;
+        var format = sourceTexture.format;
+
+        if (_pingRT && _pongRT &&
+            _width == width && _height == height && _format == format &&
+            _pingRT.IsCreated() && _pongRT.IsCreated())
+        {
+            return;
+        }
+
+        ReleaseBuffers();
+
+        _width = width;
+        _height = height;
+        _format = format;
+
+        try
+        {
+            var desc = sourceTexture.descriptor;
+            desc.depthBufferBits = 0;
+            desc.msaaSamples = 1;
+            desc.useMipMap = false;
+            desc.autoGenerateMips = false;
+
+            var supportsUav = SystemInfo.supportsComputeShaders &&
+                              SystemInfo.SupportsRandomWriteOnRenderTextureFormat(desc.colorFormat);
+            desc.enableRandomWrite = supportsUav;
+
+            _pingRT = new RenderTexture(desc)
+            {
+                name = "ADOFAIRenderer_PingBuffer",
+                filterMode = sourceTexture.filterMode,
+                wrapMode = sourceTexture.wrapMode
+            };
+            _pingRT.Create();
+
+            _pongRT = new RenderTexture(desc)
+            {
+                name = "ADOFAIRenderer_PongBuffer",
+                filterMode = sourceTexture.filterMode,
+                wrapMode = sourceTexture.wrapMode
+            };
+            _pongRT.Create();
+        }
+        catch (Exception ex)
+        {
+            ReleaseBuffers();
+            Melon<RenderMod>.Logger.Warning($"[FrameHook] Failed to create descriptor-based PingPong RTs: {ex.Message}. Falling back to standard ARGB32.");
+            _pingRT = new RenderTexture(width, height, 0, RenderTextureFormat.ARGB32)
+            {
+                name = "ADOFAIRenderer_PingBuffer",
+                filterMode = sourceTexture.filterMode,
+                wrapMode = sourceTexture.wrapMode
+            };
+            _pingRT.Create();
+
+            _pongRT = new RenderTexture(width, height, 0, RenderTextureFormat.ARGB32)
+            {
+                name = "ADOFAIRenderer_PongBuffer",
+                filterMode = sourceTexture.filterMode,
+                wrapMode = sourceTexture.wrapMode
+            };
+            _pongRT.Create();
+        }
+    }
+
+    public void ReleaseBuffers()
+    {
+        if (_pingRT)
+        {
+            if (_pingRT.IsCreated()) _pingRT.Release();
+            UnityEngine.Object.Destroy(_pingRT);
+            _pingRT = null;
+        }
+
+        if (_pongRT)
+        {
+            if (_pongRT.IsCreated()) _pongRT.Release();
+            UnityEngine.Object.Destroy(_pongRT);
+            _pongRT = null;
+        }
+
+        _width = 0;
+        _height = 0;
+        _lastOutputRT = null;
+        _reusableContext = null;
+    }
+
+    public void Dispose()
+    {
+        ReleaseBuffers();
+    }
+}

Core/PresetManager.cs

@@ -2,24 +2,118 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using ADOFAIRenderer.Core.Data;
+using ADOFAIRenderer.Data;
 using MelonLoader;
 using MelonLoader.Utils;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
-namespace ADOFAIRenderer.Data;
+namespace ADOFAIRenderer.Core;
 
-internal class RenderPreset
+public class RenderPreset
 {
     public string Name { get; set; } = string.Empty;
     public RenderConfig Config { get; set; } = null!;
+
+    public RenderPreset Clone()
+    {
+        return new RenderPreset
+        {
+            Name = Name,
+            Config = Config.Clone()
+        };
+    }
 }
 
-internal static class PresetManager
+public static class PresetManager
 {
+    private static readonly List<RenderPreset> DefaultPresets = new()
+    {
+        new RenderPreset
+        {
+            Name = "FHD 60fps (1x)",
+            Config = new RenderConfig
+            {
+                RenderWidth = 1920,
+                RenderHeight = 1080,
+                RenderFPS = 60,
+                VideoFPS = 60,
+                DelayAfterEnd = 15,
+                ShowJudgementText = false,
+                VideoConfig = new VideoEncodingConfig { Codec = Codec.H264, RateControlMode = RateControlMode.CBR, Bitrate = 20000, MaxBitrate = 35000, QP = 18, KeyframeInterval = 2.0 },
+                AudioConfig = new AudioEncodingConfig { RenderAudio = true, AudioSampleRate = 48000, AudioChannels = 2, AudioBitrate = 256000 },
+                AdvancedConfig = new AdvancedConfig { ProcessAudio = true, NonTile = false, FileExtension = "mkv" }
+            }
+        },
+        new RenderPreset
+        {
+            Name = "FHD 60fps (4x)",
+            Config = new RenderConfig
+            {
+                RenderWidth = 1920,
+                RenderHeight = 1080,
+                RenderFPS = 240,
+                VideoFPS = 60,
+                DelayAfterEnd = 15,
+                ShowJudgementText = false,
+                VideoConfig = new VideoEncodingConfig { Codec = Codec.H264, RateControlMode = RateControlMode.CBR, Bitrate = 30000, MaxBitrate = 50000, QP = 18, KeyframeInterval = 2.0 },
+                AudioConfig = new AudioEncodingConfig { RenderAudio = true, AudioSampleRate = 48000, AudioChannels = 2, AudioBitrate = 256000 },
+                AdvancedConfig = new AdvancedConfig { ProcessAudio = true, NonTile = false, FileExtension = "mkv" }
+            }
+        },
+        new RenderPreset
+        {
+            Name = "QHD 60fps (4x)",
+            Config = new RenderConfig
+            {
+                RenderWidth = 2560,
+                RenderHeight = 1440,
+                RenderFPS = 240,
+                VideoFPS = 60,
+                DelayAfterEnd = 15,
+                ShowJudgementText = false,
+                VideoConfig = new VideoEncodingConfig { Codec = Codec.H264, RateControlMode = RateControlMode.CBR, Bitrate = 35000, MaxBitrate = 60000, QP = 18, KeyframeInterval = 2.0 },
+                AudioConfig = new AudioEncodingConfig { RenderAudio = true, AudioSampleRate = 48000, AudioChannels = 2, AudioBitrate = 256000 },
+                AdvancedConfig = new AdvancedConfig { ProcessAudio = true, NonTile = false, FileExtension = "mkv" }
+            }
+        },
+        new RenderPreset
+        {
+            Name = "4K 60fps (4x)",
+            Config = new RenderConfig
+            {
+                RenderWidth = 3840,
+                RenderHeight = 2160,
+                RenderFPS = 240,
+                VideoFPS = 60,
+                DelayAfterEnd = 15,
+                ShowJudgementText = false,
+                VideoConfig = new VideoEncodingConfig { Codec = Codec.H264, RateControlMode = RateControlMode.CBR, Bitrate = 60000, MaxBitrate = 100000, QP = 18, KeyframeInterval = 2.0 },
+                AudioConfig = new AudioEncodingConfig { RenderAudio = true, AudioSampleRate = 48000, AudioChannels = 2, AudioBitrate = 256000 },
+                AdvancedConfig = new AdvancedConfig { ProcessAudio = true, NonTile = false, FileExtension = "mkv" }
+            }
+        }
+    };
+
     private static string GetPresetsDirectory()
     {
-        return Path.Combine(MelonEnvironment.GameRootDirectory, "UserData", "ADOFAIRenderer", "Presets");
+        string? root = null;
+        try
+        {
+            root = MelonEnvironment.GameRootDirectory;
+        }
+        catch
+        {
+            // Outside MelonLoader host environment (e.g. tests)
+        }
+
+        if (string.IsNullOrEmpty(root))
+        {
+            root = AppDomain.CurrentDomain.BaseDirectory;
+        }
+
+        return Path.Combine(root, "UserData", "ADOFAIRenderer", "Presets");
     }
 
     private static string GetSafeFileName(string name)
@@ -27,6 +121,45 @@ internal static class PresetManager
         return Path.GetInvalidFileNameChars().Aggregate(name, (current, c) => current.Replace(c, '_'));
     }
 
+    public static void EnsureDefaultPresetsCreated()
+    {
+        try
+        {
+            var dir = GetPresetsDirectory();
+            if (!Directory.Exists(dir))
+            {
+                Directory.CreateDirectory(dir);
+            }
+
+            if (!GlobalSettings.Current.DefaultPresetsInitialized)
+            {
+                var settings = new JsonSerializerSettings
+                {
+                    Formatting = Formatting.Indented
+                };
+                settings.Converters.Add(new ColorJsonConverter());
+
+                foreach (var def in DefaultPresets)
+                {
+                    var safeName = GetSafeFileName(def.Name);
+                    var filePath = Path.Combine(dir, safeName + ".json");
+                    if (!File.Exists(filePath))
+                    {
+                        var json = JsonConvert.SerializeObject(def, settings);
+                        File.WriteAllText(filePath, json);
+                    }
+                }
+
+                GlobalSettings.Current.DefaultPresetsInitialized = true;
+                GlobalSettings.Save();
+            }
+        }
+        catch (Exception ex)
+        {
+            MelonLogger.Warning($"Error initializing default presets: {ex.Message}");
+        }
+    }
+
     public static void SavePreset(string name, RenderConfig config)
     {
         if (string.IsNullOrWhiteSpace(name))
@@ -43,10 +176,16 @@ internal static class PresetManager
         var preset = new RenderPreset
         {
             Name = name,
-            Config = config
+            Config = config.Clone()
         };
 
-        string json = JsonConvert.SerializeObject(preset, Formatting.Indented);
+        var settings = new JsonSerializerSettings
+        {
+            Formatting = Formatting.Indented
+        };
+        settings.Converters.Add(new ColorJsonConverter());
+
+        string json = JsonConvert.SerializeObject(preset, settings);
         string safeName = GetSafeFileName(name);
         string filePath = Path.Combine(dir, safeName + ".json");
         File.WriteAllText(filePath, json);
@@ -54,14 +193,26 @@ internal static class PresetManager
 
     public static List<RenderPreset> GetPresets()
     {
+        EnsureDefaultPresetsCreated();
+
         var presets = new List<RenderPreset>();
         var dir = GetPresetsDirectory();
-            
-        if (!Directory.Exists(dir)) return presets;
+        if (!Directory.Exists(dir))
+        {
+            foreach (var b in DefaultPresets)
+            {
+                presets.Add(b.Clone());
+            }
+            return presets;
+        }
 
         try
         {
             var files = Directory.GetFiles(dir, "*.json");
+            var serializerSettings = new JsonSerializerSettings();
+            serializerSettings.Converters.Add(new ColorJsonConverter());
+            var serializer = JsonSerializer.Create(serializerSettings);
+
             foreach (var file in files)
             {
                 try
@@ -146,9 +297,20 @@ internal static class PresetManager
                         }
                     }
                             
-                    var preset = jObject.ToObject<RenderPreset>();
-                    if (preset != null && !string.IsNullOrEmpty(preset.Name))
+                    var preset = jObject.ToObject<RenderPreset>(serializer);
+                    if (preset != null)
                     {
+                        var fileBaseName = Path.GetFileNameWithoutExtension(file);
+                        if (string.IsNullOrWhiteSpace(preset.Name))
+                        {
+                            preset.Name = fileBaseName;
+                        }
+
+                        if (presets.Any(p => string.Equals(p.Name, preset.Name, StringComparison.OrdinalIgnoreCase)))
+                        {
+                            continue;
+                        }
+
                         presets.Add(preset);
                     }
                 }
@@ -177,13 +339,44 @@ internal static class PresetManager
 
     public static void DeletePreset(string name)
     {
+        if (string.IsNullOrWhiteSpace(name)) return;
+
         var dir = GetPresetsDirectory();
+        if (!Directory.Exists(dir)) return;
+
         var safeName = GetSafeFileName(name);
         var filePath = Path.Combine(dir, safeName + ".json");
 
         if (File.Exists(filePath))
         {
             File.Delete(filePath);
+            return;
+        }
+
+        foreach (var file in Directory.GetFiles(dir, "*.json"))
+        {
+            try
+            {
+                var fileBaseName = Path.GetFileNameWithoutExtension(file);
+                if (string.Equals(fileBaseName, name, StringComparison.OrdinalIgnoreCase))
+                {
+                    File.Delete(file);
+                    return;
+                }
+
+                var json = File.ReadAllText(file);
+                var jObject = JsonConvert.DeserializeObject<JObject>(json);
+                var pName = (string?)jObject?["Name"];
+                if (string.Equals(pName, name, StringComparison.OrdinalIgnoreCase))
+                {
+                    File.Delete(file);
+                    return;
+                }
+            }
+            catch
+            {
+                // Ignore read errors during cleanup search
+            }
         }
     }
 }

Core/RenderManager.cs

@@ -37,6 +37,7 @@ internal static class RenderContext
     public static string? OutputPath;
         
     public static bool Notification = true;
+    public static readonly List<Action<FrameHookContext>> SessionFrameHooks = new();
         
     private static readonly Func<bool> EndConditionDefault = () => scrController.instance.state == States.Won;
     public static Func<bool> EndCondition = EndConditionDefault;
@@ -64,6 +65,7 @@ internal static class RenderContext
         OutputPath = null;
 
         Notification = true;
+        SessionFrameHooks.Clear();
             
         EndCondition = EndConditionDefault;
         OnComplete = OnCompleteDefault;
@@ -103,6 +105,49 @@ internal class RenderManager : MonoBehaviour
     private AudioSyncCalculator SyncCalculator { get; set; } = null!;
 
     private FrameReader? _frameReader;
+    private FrameHookPipeline? _frameHookPipeline;
+    private readonly List<Action<FrameHookContext>> _activeHooksCache = new();
+    private int _cachedGlobalHooksVersion = -1;
+    private bool _hasActiveHooksCached;
+
+    public bool HasActiveFrameHooks
+    {
+        get
+        {
+            EnsureActiveHooksUpToDate();
+            return _hasActiveHooksCached;
+        }
+    }
+
+    private void EnsureActiveHooksUpToDate()
+    {
+        var globalVersion = RenderSession.GlobalHooksVersion;
+        if (_cachedGlobalHooksVersion == globalVersion) return;
+
+        _cachedGlobalHooksVersion = globalVersion;
+        _activeHooksCache.Clear();
+        if (RenderContext.SessionFrameHooks.Count > 0)
+        {
+            _activeHooksCache.AddRange(RenderContext.SessionFrameHooks);
+        }
+        RenderSession.CopyGlobalFrameHooksTo(_activeHooksCache);
+        _hasActiveHooksCached = _activeHooksCache.Count > 0;
+    }
+
+    private List<Action<FrameHookContext>> GetActiveFrameHooks()
+    {
+        EnsureActiveHooksUpToDate();
+        return _activeHooksCache;
+    }
+
+    private void ResetFrameHookState()
+    {
+        _frameHookPipeline?.Dispose();
+        _frameHookPipeline = null;
+        _activeHooksCache.Clear();
+        _cachedGlobalHooksVersion = -1;
+        _hasActiveHooksCached = false;
+    }
 
     public long frameCountForVideo;
     public long lastVideoFrameIndex = -1;
@@ -117,6 +162,7 @@ internal class RenderManager : MonoBehaviour
         public int Length;
         public byte[]? ManagedBuffer; // Non-null if it's a managed buffer (e.g. black frame)
         public ReadbackRequestState? ReadbackState; // Associated state to recycle
+        public bool IsColorConverted;
     }
 
     // Thread and Queue State
@@ -159,6 +205,8 @@ internal class RenderManager : MonoBehaviour
             
         AudioSpectrumGenerator.Clear();
 
+        ResetFrameHookState();
+
         if (_activeVideoFFmpeg != null)
         {
             Melon<RenderMod>.Logger.Msg("Game exit or RenderManager destruction detected: Disposing FFmpeg native encoder resources.");
@@ -315,7 +363,23 @@ internal class RenderManager : MonoBehaviour
         {
             lastVideoFrameIndex = videoFrameIndex;
             lastRequestedVideoFrameIndex = videoFrameIndex;
-            _frameReader?.RequestFrameCapture(texture, videoFrameIndex);
+
+            var targetTexture = texture;
+            if (HasActiveFrameHooks && _frameHookPipeline != null)
+            {
+                var videoTime = effectiveVideoFps > 0 ? videoFrameIndex / effectiveVideoFps : 0.0;
+                targetTexture = _frameHookPipeline.Process(
+                    texture,
+                    videoFrameIndex,
+                    currentFrame,
+                    videoTime,
+                    renderFPS,
+                    effectiveVideoFps,
+                    GetActiveFrameHooks()
+                ) ?? texture;
+            }
+
+            _frameReader?.RequestFrameCapture(targetTexture, videoFrameIndex);
         }
     }
 
@@ -386,6 +450,10 @@ internal class RenderManager : MonoBehaviour
             
         _frameReader?.Dispose();
         _frameReader = null;
+        _frameHookPipeline?.Dispose();
+        _frameHookPipeline = new FrameHookPipeline();
+        _cachedGlobalHooksVersion = -1;
+        EnsureActiveHooksUpToDate();
         try
         {
             StartFFmpegThread();
@@ -394,6 +462,7 @@ internal class RenderManager : MonoBehaviour
         catch (Exception ex)
         {
             Melon<RenderMod>.Logger.Error($"Encoder initialization error: {ex}");
+            ResetFrameHookState();
             CommonWarningDialogUI.ShowDialog(
                 "Encoder Error",
                 $"Failed to initialize video encoder.\nError: {ex.Message}",
@@ -546,7 +615,7 @@ internal class RenderManager : MonoBehaviour
                         {
                             if (frame.ManagedBuffer.Length > 0)
                             {
-                                videoFFmpeg.SendDataFromBuffer(frame.ManagedBuffer, frame.Length);
+                                videoFFmpeg.SendDataFromBuffer(frame.ManagedBuffer, frame.Length, frame.IsColorConverted);
                                 Interlocked.Increment(ref framesSent);
                                     
                                 ArrayPool<byte>.Shared.Return(frame.ManagedBuffer);
@@ -554,7 +623,7 @@ internal class RenderManager : MonoBehaviour
                         }
                         else if (frame.NativePointer != IntPtr.Zero && frame.Length > 0)
                         {
-                            videoFFmpeg.SendDataFromNativeBuffer(frame.NativePointer, frame.Length);
+                            videoFFmpeg.SendDataFromNativeBuffer(frame.NativePointer, frame.Length, frame.IsColorConverted);
                             Interlocked.Increment(ref framesSent);
 
                             if (frame.ReadbackState != null)
@@ -686,6 +755,7 @@ internal class RenderManager : MonoBehaviour
             }
                 
             _frameReader?.Dispose();
+            ResetFrameHookState();
 
             // Clean up Debug Monitor UI
             if (_debugMonitorObj)
@@ -775,6 +845,7 @@ internal class RenderManager : MonoBehaviour
         }
 
         _frameReader?.Dispose();
+        ResetFrameHookState();
         AudioMixer?.Reset(); AudioMixer = null;
         SyncCalculator.Reset();
 

Data/ColorJsonConverter.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Globalization;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using UnityEngine;
+
+namespace ADOFAIRenderer.Data;
+
+/// <summary>
+/// Converts Unity <see cref="Color"/> and nullable <see cref="Color"/> to and from hex string (#RRGGBBAA).
+/// Pure C# implementation to completely avoid Unity internal native ECalls (such as Color.linear or ColorUtility.TryParseHtmlString).
+/// </summary>
+public class ColorJsonConverter : JsonConverter
+{
+    public override bool CanConvert(Type objectType)
+    {
+        return objectType == typeof(Color) || objectType == typeof(Color?);
+    }
+
+    public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+    {
+        if (value == null)
+        {
+            writer.WriteNull();
+            return;
+        }
+
+        var color = (Color)value;
+        writer.WriteValue(ToHex(color));
+    }
+
+    public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+    {
+        bool isNullable = Nullable.GetUnderlyingType(objectType) != null || !objectType.IsValueType;
+
+        if (reader.TokenType == JsonToken.Null)
+        {
+            return isNullable ? null : (object)default(Color);
+        }
+
+        if (reader.TokenType == JsonToken.String)
+        {
+            var str = (string?)reader.Value;
+            if (TryParseHex(str, out var parsedColor))
+            {
+                return parsedColor;
+            }
+
+            return isNullable ? null : (object)default(Color);
+        }
+
+        if (reader.TokenType == JsonToken.StartObject)
+        {
+            var obj = JObject.Load(reader);
+            float r = (float?)obj["r"] ?? 0f;
+            float g = (float?)obj["g"] ?? 0f;
+            float b = (float?)obj["b"] ?? 0f;
+            float a = (float?)obj["a"] ?? 1f;
+            return new Color(r, g, b, a);
+        }
+
+        return isNullable ? null : (object)default(Color);
+    }
+
+    public static string ToHex(Color color)
+    {
+        byte r = (byte)Math.Clamp((int)Math.Round(color.r * 255f), 0, 255);
+        byte g = (byte)Math.Clamp((int)Math.Round(color.g * 255f), 0, 255);
+        byte b = (byte)Math.Clamp((int)Math.Round(color.b * 255f), 0, 255);
+        byte a = (byte)Math.Clamp((int)Math.Round(color.a * 255f), 0, 255);
+        return $"#{r:X2}{g:X2}{b:X2}{a:X2}";
+    }
+
+    public static bool TryParseHex(string? hex, out Color color)
+    {
+        color = default;
+        if (string.IsNullOrWhiteSpace(hex)) return false;
+
+        var str = hex.Trim();
+        if (str.StartsWith("#"))
+        {
+            str = str.Substring(1);
+        }
+
+        if (str.Length == 6)
+        {
+            if (byte.TryParse(str.Substring(0, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var r) &&
+                byte.TryParse(str.Substring(2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var g) &&
+                byte.TryParse(str.Substring(4, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var b))
+            {
+                color = new Color(r / 255f, g / 255f, b / 255f, 1f);
+                return true;
+            }
+        }
+        else if (str.Length == 8)
+        {
+            if (byte.TryParse(str.Substring(0, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var r) &&
+                byte.TryParse(str.Substring(2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var g) &&
+                byte.TryParse(str.Substring(4, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var b) &&
+                byte.TryParse(str.Substring(6, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var a))
+            {
+                color = new Color(r / 255f, g / 255f, b / 255f, a / 255f);
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

Data/RenderConfig.cs

@@ -1,4 +1,5 @@
 using System.Diagnostics.CodeAnalysis;
+using Newtonsoft.Json;
 using UnityEngine;
 
 namespace ADOFAIRenderer.Data;
@@ -18,6 +19,28 @@ public class RenderConfig
 
     public double DelayAfterEnd { get; set; } = 15;
     public bool ShowJudgementText { get; set; } = false;
+
+    public void CopyFrom(RenderConfig? source)
+    {
+        if (source == null) return;
+        RenderFPS = source.RenderFPS;
+        VideoFPS = source.VideoFPS;
+        RenderWidth = source.RenderWidth;
+        RenderHeight = source.RenderHeight;
+        DelayAfterEnd = source.DelayAfterEnd;
+        ShowJudgementText = source.ShowJudgementText;
+
+        VideoConfig.CopyFrom(source.VideoConfig);
+        AudioConfig.CopyFrom(source.AudioConfig);
+        AdvancedConfig.CopyFrom(source.AdvancedConfig);
+    }
+
+    public RenderConfig Clone()
+    {
+        var clone = new RenderConfig();
+        clone.CopyFrom(this);
+        return clone;
+    }
 }
 
 [SuppressMessage("ReSharper", "RedundantDefaultMemberInitializer")]
@@ -28,9 +51,33 @@ public class AdvancedConfig
     public bool NonTile { get; set; } = false;
     public string FileExtension { get; set; } = "mkv";
 
+    [JsonConverter(typeof(ColorJsonConverter))]
     public Color? firePlanetColor = null;
+
+    [JsonConverter(typeof(ColorJsonConverter))]
     public Color? icePlanetColor = null;
+
+    [JsonConverter(typeof(ColorJsonConverter))]
     public Color? windPlanetColor = null;
+
+    public void CopyFrom(AdvancedConfig? source)
+    {
+        if (source == null) return;
+        RandomSeed = source.RandomSeed;
+        ProcessAudio = source.ProcessAudio;
+        NonTile = source.NonTile;
+        FileExtension = source.FileExtension;
+        firePlanetColor = source.firePlanetColor;
+        icePlanetColor = source.icePlanetColor;
+        windPlanetColor = source.windPlanetColor;
+    }
+
+    public AdvancedConfig Clone()
+    {
+        var clone = new AdvancedConfig();
+        clone.CopyFrom(this);
+        return clone;
+    }
 }
 
 public class VideoEncodingConfig
@@ -44,6 +91,25 @@ public class VideoEncodingConfig
     public int QP { get; set; } = 18;
     public double KeyframeInterval { get; set; } = 2.0;
     public bool ForceSoftwareEncoder { get; set; }
+
+    public void CopyFrom(VideoEncodingConfig? source)
+    {
+        if (source == null) return;
+        Codec = source.Codec;
+        RateControlMode = source.RateControlMode;
+        Bitrate = source.Bitrate;
+        MaxBitrate = source.MaxBitrate;
+        QP = source.QP;
+        KeyframeInterval = source.KeyframeInterval;
+        ForceSoftwareEncoder = source.ForceSoftwareEncoder;
+    }
+
+    public VideoEncodingConfig Clone()
+    {
+        var clone = new VideoEncodingConfig();
+        clone.CopyFrom(this);
+        return clone;
+    }
 }
 
 public class AudioEncodingConfig
@@ -71,4 +137,20 @@ public class AudioEncodingConfig
         get => _audioBitrate <= 0 ? 256000 : _audioBitrate;
         set => _audioBitrate = value <= 0 ? 256000 : value;
     }
+
+    public void CopyFrom(AudioEncodingConfig? source)
+    {
+        if (source == null) return;
+        RenderAudio = source.RenderAudio;
+        AudioSampleRate = source.AudioSampleRate;
+        AudioChannels = source.AudioChannels;
+        AudioBitrate = source.AudioBitrate;
+    }
+
+    public AudioEncodingConfig Clone()
+    {
+        var clone = new AudioEncodingConfig();
+        clone.CopyFrom(this);
+        return clone;
+    }
 }␍

Localization/Locale/en.json

@@ -1,5 +1,18 @@
 {
   "ui.render_config.window_title": "Render Config",
+  "ui.render_config.presets": "Presets",
+  "ui.render_config.preset_select": "Preset",
+  "ui.render_config.preset_name_placeholder": "New preset name...",
+  "ui.render_config.preset_save": "Save",
+  "ui.render_config.preset_delete": "Delete",
+  "ui.render_config.preset_overwrite_title": "Overwrite Preset",
+  "ui.render_config.preset_overwrite_desc": "A preset named '{0}' already exists. Do you want to overwrite it?",
+  "ui.render_config.preset_delete_title": "Delete Preset",
+  "ui.render_config.preset_delete_desc": "Are you sure you want to delete preset '{0}'?",
+  "ui.render_config.preset_name_empty": "Please enter a preset name.",
+  "ui.render_config.preset_custom": "(Modified)",
+  "ui.render_config.confirm": "Confirm",
+  "ui.render_config.cancel": "Cancel",
   "ui.render_config.render_fps": "Render FPS",
   "ui.render_config.video_fps": "Video FPS",
   "ui.render_config.render_width": "Render Width",
@@ -32,5 +45,9 @@
   "ui.render_config.validation_title": "Invalid Settings",
   "ui.render_config.validation_error": "Please check your input values:\n- Width and Height must be integers > 0\n- Render FPS and Video FPS must be > 0\n- Delay After End must be >= 0",
   "ui.render_config.invalid_path": "Output directory path is invalid:\n{0}",
+  "ui.render_config.planet_colors": "Planet Colors (Optional)",
+  "ui.render_config.fire_planet": "Fire Planet",
+  "ui.render_config.ice_planet": "Ice Planet",
+  "ui.render_config.wind_planet": "Wind Planet",
   "ui.render_config.expired": "(Expired)"
 }

Localization/Locale/ko.json

@@ -1,15 +1,28 @@
 {
   "ui.render_config.window_title": "렌더 설정",
+  "ui.render_config.presets": "프리셋",
+  "ui.render_config.preset_select": "프리셋 선택",
+  "ui.render_config.preset_name_placeholder": "새 프리셋 이름...",
+  "ui.render_config.preset_save": "저장",
+  "ui.render_config.preset_delete": "삭제",
+  "ui.render_config.preset_overwrite_title": "프리셋 덮어쓰기",
+  "ui.render_config.preset_overwrite_desc": "'{0}' 프리셋이 이미 존재합니다. 덮어쓰시겠습니까?",
+  "ui.render_config.preset_delete_title": "프리셋 삭제",
+  "ui.render_config.preset_delete_desc": "'{0}' 프리셋을 정말 삭제하시겠습니까?",
+  "ui.render_config.preset_name_empty": "프리셋 이름을 입력해 주세요.",
+  "ui.render_config.preset_custom": "(수정됨)",
+  "ui.render_config.confirm": "확인",
+  "ui.render_config.cancel": "취소",
   "ui.render_config.render_fps": "렌더링 FPS",
   "ui.render_config.video_fps": "영상 FPS",
   "ui.render_config.render_width": "렌더링 너비",
   "ui.render_config.render_height": "렌더링 높이",
   "ui.render_config.delay_after_end": "종료 후 대기 시간 (초)",
   "ui.render_config.show_judgement": "판정 텍스트 표시",
-  "ui.render_config.video_encoding": "Video Encoding Config",
-  "ui.render_config.audio_encoding": "Audio Encoding Config",
-  "ui.render_config.global_settings": "Global Settings",
-  "ui.render_config.advanced_settings": "Advanced Settings",
+  "ui.render_config.video_encoding": "비디오 인코딩 설정",
+  "ui.render_config.audio_encoding": "오디오 인코딩 설정",
+  "ui.render_config.global_settings": "전역 설정",
+  "ui.render_config.advanced_settings": "고급 설정",
   "ui.render_config.go_render": "렌더 시작",
   "ui.render_config.codec": "코덱",
   "ui.render_config.rate_control": "비트레이트 제어 모드",
@@ -32,5 +45,9 @@
   "ui.render_config.validation_title": "설정 오류",
   "ui.render_config.validation_error": "입력값을 확인해 주세요:\n- 너비와 높이는 0보다 큰 정수여야 합니다.\n- 렌더 FPS와 영상 FPS는 0보다 커야 합니다.\n- 종료 후 대기 시간은 0 이상이어야 합니다.",
   "ui.render_config.invalid_path": "출력 디렉토리 경로가 올바르지 않습니다:\n{0}",
+  "ui.render_config.planet_colors": "행성 색상 설정 (선택 사항)",
+  "ui.render_config.fire_planet": "불 행성",
+  "ui.render_config.ice_planet": "얼음 행성",
+  "ui.render_config.wind_planet": "바람 행성",
   "ui.render_config.expired": "(만료됨)"
 }

Patch/Game/PersistencePatch.cs

@@ -18,4 +18,20 @@ public static class PersistencePatch
             __result = SkipIntroBehavior.Off;
         }
     }
+
+    [HarmonyPostfix]
+    [HarmonyPatch("GetPlayerColor")]
+    // ReSharper disable once InconsistentNaming
+    public static void OverridePlayerColor(bool red, ref PlanetColor __result)
+    {
+        if (!RenderManager.Instance || RenderManager.Instance.stage == RenderStage.None) return;
+        var advConf = RenderManager.Instance.Configuration.AdvancedConfig;
+
+        __result = red switch
+        {
+            true when advConf.firePlanetColor.HasValue => new PlanetColor(advConf.firePlanetColor.Value),
+            false when advConf.icePlanetColor.HasValue => new PlanetColor(advConf.icePlanetColor.Value),
+            _ => __result
+        };
+    }
 }

Patch/Game/PlanetRendererPatch.cs

@@ -1,30 +0,0 @@
-using ADOFAIRenderer.Core;
-using HarmonyLib;
-using UnityEngine;
-
-namespace ADOFAIRenderer.Patch.Game;
-
-[HarmonyPatch(typeof(PlanetRenderer))]
-public static class PlanetRendererPatch
-{
-    [HarmonyPrefix]
-    [HarmonyPatch("SetColor")]
-    // ReSharper disable once InconsistentNaming
-    private static void OverrideColor(PlanetRenderer __instance, ref PlanetColor planetColor)
-    {
-        if (RenderManager.Instance.stage == RenderStage.None) return;
-        
-        var advConf = RenderManager.Instance.Configuration.AdvancedConfig;
-        ApplyColor(ref planetColor, scrController.instance.planetRed, advConf.firePlanetColor);
-        ApplyColor(ref planetColor, scrController.instance.planetBlue, advConf.icePlanetColor);
-        ApplyColor(ref planetColor, scrController.instance.planetGreen, advConf.windPlanetColor);
-
-        return;
-
-        void ApplyColor(ref PlanetColor planetColor, scrPlanet? targetPlanet, Color? customColor)
-        {
-            if (targetPlanet != null && __instance == targetPlanet.planetRenderer && customColor != null)
-                planetColor = new PlanetColor(customColor.Value);
-        }
-    }
-}

Patch/Game/PlanetarySystemPatch.cs

@@ -0,0 +1,35 @@
+using ADOFAIRenderer.Core;
+using HarmonyLib;
+
+namespace ADOFAIRenderer.Patch.Game;
+
+[HarmonyPatch(typeof(PlanetarySystem))]
+public static class PlanetarySystemPatch
+{
+    [HarmonyPostfix]
+    [HarmonyPatch("Init")]
+    // ReSharper disable once InconsistentNaming
+    public static void OnInit(PlanetarySystem __instance)
+    {
+        ApplyWindPlanetColor(__instance);
+    }
+
+    [HarmonyPostfix]
+    [HarmonyPatch("ApplyMultiplanetColors")]
+    // ReSharper disable once InconsistentNaming
+    public static void OnApplyMultiplanetColors(PlanetarySystem __instance)
+    {
+        ApplyWindPlanetColor(__instance);
+    }
+
+    private static void ApplyWindPlanetColor(PlanetarySystem planetarySystem)
+    {
+        if (RenderManager.Instance == null || RenderManager.Instance.stage == RenderStage.None) return;
+
+        var advConf = RenderManager.Instance.Configuration.AdvancedConfig;
+        if (advConf.windPlanetColor.HasValue && planetarySystem.planetGreen)
+        {
+            planetarySystem.planetGreen.planetRenderer.SetColor(new PlanetColor(advConf.windPlanetColor.Value));
+        }
+    }
+}

Patch/Game/scnGamePatch.cs

@@ -77,7 +77,7 @@ public static class scnGamePatch
         if (!RenderManager.IsActive)
         {
             // Remove FFmpeg player if it was attached previously
-            var oldPlayer = __instance.videoBG.gameObject.GetComponent<FFmpegVideoBGPlayer>();
+            var oldPlayer = __instance.videoBG.gameObject.GetComponent<VideoBGPlayer>();
             if (oldPlayer) Object.Destroy(oldPlayer);
             
             // Re-enable native player component
@@ -123,9 +123,9 @@ public static class scnGamePatch
         __instance.videoBG.enabled = false;
 
         // Add or retrieve our custom FFmpeg video background player
-        if (!__instance.videoBG.gameObject.TryGetComponent<FFmpegVideoBGPlayer>(out var player))
+        if (!__instance.videoBG.gameObject.TryGetComponent<VideoBGPlayer>(out var player))
         {
-            player = __instance.videoBG.gameObject.AddComponent<FFmpegVideoBGPlayer>();
+            player = __instance.videoBG.gameObject.AddComponent<VideoBGPlayer>();
         }
 
         var isLooping = __instance.levelData.miscSettings.GetBool("loopVideo");

Patch/Game/scrDecorationPatch.cs

@@ -1,40 +0,0 @@
-using HarmonyLib;
-
-namespace ADOFAIRenderer.Patch.Game;
-
-[HarmonyPatch(typeof(scrDecoration))]
-// ReSharper disable once InconsistentNaming
-public static class scrDecorationPatch
-{
-    [HarmonyPrefix]
-    [HarmonyPatch("SetRotation")]
-    // ReSharper disable once InconsistentNaming
-    public static bool SetRotationPrefix(scrDecoration __instance)
-    {
-        return __instance != null && __instance && __instance.pivotTrans != null;
-    }
-
-    [HarmonyPrefix]
-    [HarmonyPatch("SetScale")]
-    // ReSharper disable once InconsistentNaming
-    public static bool SetScalePrefix(scrDecoration __instance)
-    {
-        return __instance != null && __instance && __instance.pivotTrans != null;
-    }
-
-    [HarmonyPrefix]
-    [HarmonyPatch("SetOpacity")]
-    // ReSharper disable once InconsistentNaming
-    public static bool SetOpacityPrefix(scrDecoration __instance)
-    {
-        return __instance != null && __instance;
-    }
-
-    [HarmonyPrefix]
-    [HarmonyPatch("UpdatePosition")]
-    // ReSharper disable once InconsistentNaming
-    public static bool UpdatePositionPrefix(scrDecoration __instance)
-    {
-        return __instance != null && __instance && __instance.pivotTrans != null;
-    }
-}

README.md

@@ -13,6 +13,8 @@
 
 By decoupling the game's simulation timestep from wall-clock time, ADOFAI Renderer enables creators to produce smooth, ultra-high-definition game videos with perfect audio sync, regardless of hardware limitations or level complexity.
 
+> Generative AI technology was partially utilized in the development of this mod.
+
 ---
 
 ## ✨ Key Features

RenderMod.cs

@@ -2,7 +2,6 @@ using System;
 using ADOFAIRenderer;
 using ADOFAIRenderer.Core;
 using ADOFAIRenderer.Core.Data;
-using ADOFAIRenderer.Data;
 using ADOFAIRenderer.UI;
 using FFmpeg.AutoGen;
 using MelonLoader;
@@ -10,7 +9,7 @@ using MelonLoader.Utils;
 using UnityEngine;
 using Object = UnityEngine.Object;
 
-[assembly: MelonInfo(typeof(RenderMod), "ADOFAI Renderer", "0.2.1-INDEV", "ADOFAI Editor Forum")]
+[assembly: MelonInfo(typeof(RenderMod), "ADOFAI Renderer", "0.2.4-INDEV", "ADOFAI Editor Forum")]
 [assembly: MelonGame("7th Beat Games", "A Dance of Fire and Ice")]
 
 namespace ADOFAIRenderer;

Util/FFmpeg/FFmpegNativeEncoder.cs

@@ -974,29 +974,22 @@ namespace ADOFAIRenderer.Util.FFmpeg
         /// Encodes a frame from IntPtr (native pointer).
         /// Can be used from external native plugins or custom capture sources.
         /// </summary>
-        public void SendDataFromNativeBuffer(IntPtr pointer, int length)
+        public void SendDataFromNativeBuffer(IntPtr pointer, int length, bool isColorConverted)
         {
             lock (_lock)
             {
                 if (_disposed || !_isInitialized) return;
-                var preConvertedSize = _settings.Width * _settings.Height * 3 / 2;
                 
                 if (!_loggedConversionMode)
                 {
                     _loggedConversionMode = true;
-                    Melon<RenderMod>.Logger.Msg(length == preConvertedSize
-                        ? "[Encoder] High-speed GPU color conversion enabled (NV12/YUV420P Direct Write, bypassing sws_scale)"
+                    Melon<RenderMod>.Logger.Msg(isColorConverted
+                        ? "[Encoder] GPU color conversion enabled (NV12/YUV420P Direct Write, bypassing sws_scale)"
                         : "[Encoder] CPU color conversion fallback enabled (RGBA Input, using sws_scale)");
                 }
 
-                if (length == preConvertedSize)
-                {
-                    WritePreConvertedFrame((byte*)pointer.ToPointer());
-                }
-                else
-                {
-                    WriteFrameFromBuffer((byte*)pointer.ToPointer());
-                }
+                if (isColorConverted) WritePreConvertedFrame((byte*)pointer.ToPointer());
+                else WriteFrameFromBuffer((byte*)pointer.ToPointer());
             }
         }
 
@@ -1004,31 +997,23 @@ namespace ADOFAIRenderer.Util.FFmpeg
         /// Encodes a frame from a managed byte[].
         /// Pins the array using fixed keyword to prevent GC from moving it before passing the pointer.
         /// </summary>
-        public void SendDataFromBuffer(byte[] buffer, int length)
+        public void SendDataFromBuffer(byte[] buffer, int length, bool isColorConverted)
         {
             lock (_lock)
             {
                 if (_disposed || !_isInitialized) return;
                 fixed (byte* pBuffer = buffer)
                 {
-                    var preConvertedSize = _settings.Width * _settings.Height * 3 / 2;
-                    
                     if (!_loggedConversionMode)
                     {
                         _loggedConversionMode = true;
-                        Melon<RenderMod>.Logger.Msg(length == preConvertedSize
+                        Melon<RenderMod>.Logger.Msg(isColorConverted
                             ? "[Encoder] High-speed GPU color conversion enabled (NV12/YUV420P Direct Write, bypassing sws_scale)"
                             : "[Encoder] CPU color conversion fallback enabled (RGBA Input, using sws_scale)");
                     }
 
-                    if (length == preConvertedSize)
-                    {
-                        WritePreConvertedFrame(pBuffer);
-                    }
-                    else
-                    {
-                        WriteFrameFromBuffer(pBuffer);
-                    }
+                    if (isColorConverted) WritePreConvertedFrame(pBuffer);
+                    else WriteFrameFromBuffer(pBuffer);
                 }
             }
         }
@@ -1145,33 +1130,7 @@ namespace ADOFAIRenderer.Util.FFmpeg
                     throw new NotSupportedException($"This pixel format ({_dstPixFmt}) does not support direct copying of pre-converted buffers.");
             }
 
-            // QSV acceleration handling or encoder send
-            if (_isQsvEncoder)
-            {
-                ffmpeg.av_frame_unref(_pHwFrame);
-                try
-                {
-                    var ret = ffmpeg.av_hwframe_get_buffer(_pCodecContext->hw_frames_ctx, _pHwFrame, 0);
-                    if (ret < 0)
-                        throw new Exception($"Failed to allocate QSV hardware frame buffer — {GetFFmpegErrorString(ret)} (Code: {ret})");
-
-                    ret = ffmpeg.av_hwframe_transfer_data(_pHwFrame, _pDstFrame, 0);
-                    if (ret < 0)
-                        throw new Exception($"Failed to upload QSV frame — {GetFFmpegErrorString(ret)} (Code: {ret})");
-
-                    _pHwFrame->pts = _frameIndex++;
-                    SendFrameAndWritePackets(_pHwFrame);
-                }
-                finally
-                {
-                    ffmpeg.av_frame_unref(_pHwFrame);
-                }
-            }
-            else
-            {
-                _pDstFrame->pts = _frameIndex++;
-                SendFrameAndWritePackets(_pDstFrame);
-            }
+            SubmitDstFrame();
         }
 
         /// <summary>
@@ -1209,6 +1168,11 @@ namespace ADOFAIRenderer.Util.FFmpeg
                 _pDstFrame->data, _pDstFrame->linesize
             );
 
+            SubmitDstFrame();
+        }
+
+        private void SubmitDstFrame()
+        {
             if (_isQsvEncoder)
             {
                 // ── QSV hw_frames_ctx mode: System memory → GPU surface upload ──

Util/FFmpegVideoBGPlayer.cs

@@ -1,518 +0,0 @@
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using ADOFAIRenderer.UI;
-using ADOFAIRenderer.Util.FFmpeg;
-using MelonLoader;
-using UnityEngine;
-using FFmpeg.AutoGen;
-
-namespace ADOFAIRenderer.Util
-{
-    // ReSharper disable once InconsistentNaming
-    internal class FFmpegVideoBGPlayer : MonoBehaviour
-    {
-        private static readonly int YTex = Shader.PropertyToID("_YTex");
-        private static readonly int UVTex = Shader.PropertyToID("_UVTex");
-        private static readonly int Result = Shader.PropertyToID("_Result");
-        private static readonly int Width = Shader.PropertyToID("Width");
-        private static readonly int Height = Shader.PropertyToID("Height");
-        private static readonly int UTex = Shader.PropertyToID("_UTex");
-        private static readonly int VTex = Shader.PropertyToID("_VTex");
-        private static readonly int ColorRange = Shader.PropertyToID("ColorRange");
-
-        [SuppressMessage("ReSharper", "InconsistentNaming")]
-        private enum GPUMode
-        {
-            None,
-            YUV420P,
-            NV12
-        }
-
-        private FFmpegNativeDecoder? _decoder;
-        
-        // CPU fallback rendering
-        // ReSharper disable once InconsistentNaming
-        private Texture2D? _textureRGBA;
-
-        // GPU conversion textures
-        private Texture2D? _textureY;
-        private Texture2D? _textureU;
-        private Texture2D? _textureV;
-        private Texture2D? _textureUV;
-
-        // Compute Shader variables
-        private ComputeShader? _computeShader;
-        private RenderTexture? _renderTexture;
-        private int _kernelIndex = -1;
-
-        private double _currentFrameTimestamp;
-        private double _nextFrameTimestamp;
-        private GPUMode _gpuMode = GPUMode.None;
-        private RenderTexture? _targetTexture;
-        private bool _isLooping;
-        private bool _isInitialized;
-
-        private GameObject? _quad;
-        private Material? _material;
-
-        // ReSharper disable once InconsistentNaming
-        public void Init(string videoPath, RenderTexture? targetTexture, bool loop, Camera? targetCamera, GameObject videoBGGo)
-        {
-            CleanUp();
-
-            _targetTexture = targetTexture;
-            _isLooping = loop;
-
-            if (_targetTexture == null && targetCamera != null)
-            {
-                SetupBackgroundQuad(targetCamera, videoBGGo);
-            }
-
-            if (!File.Exists(videoPath))
-            {
-                Melon<RenderMod>.Logger.Warning($"[FFmpegVideoBGPlayer] Video file does not exist: {videoPath}");
-                return;
-            }
-
-            try
-            {
-                _decoder = new FFmpegNativeDecoder(videoPath);
-                _computeShader = ModAssets.ColorConversionShader;
-
-                var w = _decoder.Width;
-                var h = _decoder.Height;
-                var pixFmt = _decoder.PixelFormat;
-
-                var gpuInitSuccess = false;
-
-                if (_computeShader != null)
-                {
-                    switch (pixFmt)
-                    {
-                        case AVPixelFormat.AV_PIX_FMT_NV12:
-                            try
-                            {
-                                _kernelIndex = _computeShader.FindKernel("CSMain_NV12ToRGBA");
-                            
-                                _textureY = new Texture2D(w, h, TextureFormat.R8, false);
-                                _textureUV = new Texture2D(w / 2, h / 2, TextureFormat.RG16, false);
-                                ConfigureTexture(_textureY);
-                                ConfigureTexture(_textureUV);
-
-                                _gpuMode = GPUMode.NV12;
-                                gpuInitSuccess = true;
-                                Melon<RenderMod>.Logger.Msg("[FFmpegVideoBGPlayer] Initialized Compute Shader NV12 mode successfully");
-                            }
-                            catch
-                            {
-                                // ignored
-                            }
-
-                            break;
-                        case AVPixelFormat.AV_PIX_FMT_YUV420P:
-                        case AVPixelFormat.AV_PIX_FMT_YUVJ420P:
-                            try
-                            {
-                                _kernelIndex = _computeShader.FindKernel("CSMain_YUV420PToRGBA");
-                            
-                                _textureY = new Texture2D(w, h, TextureFormat.R8, false);
-                                _textureU = new Texture2D(w / 2, h / 2, TextureFormat.R8, false);
-                                _textureV = new Texture2D(w / 2, h / 2, TextureFormat.R8, false);
-                                ConfigureTexture(_textureY);
-                                ConfigureTexture(_textureU);
-                                ConfigureTexture(_textureV);
-
-                                _gpuMode = GPUMode.YUV420P;
-                                gpuInitSuccess = true;
-                                Melon<RenderMod>.Logger.Msg("[FFmpegVideoBGPlayer] Initialized Compute Shader YUV420P mode successfully");
-                            }
-                            catch
-                            {
-                                // ignored
-                            }
-
-                            break;
-                        default:
-                            Melon<RenderMod>.Logger.Msg("[FFmpegVideoBGPlayer] Cannot use Compute Shader for colorspace conversion.");
-                            break;
-                    }
-                }
-
-                if (gpuInitSuccess && _computeShader != null)
-                {
-                    _renderTexture = new RenderTexture(w, h, 0, RenderTextureFormat.ARGB32)
-                    {
-                        enableRandomWrite = true
-                    };
-                    _renderTexture.Create();
-                }
-                else
-                {
-                    _textureRGBA = new Texture2D(w, h, TextureFormat.RGBA32, false);
-                    ConfigureTexture(_textureRGBA);
-                    _gpuMode = GPUMode.None;
-                    Melon<RenderMod>.Logger.Warning("[FFmpegVideoBGPlayer] GPU acceleration unsupported or failed to load, falling back to CPU (RGBA).");
-                }
-
-                _currentFrameTimestamp = 0.0;
-                _nextFrameTimestamp = 0.0;
-                _isInitialized = true;
-
-                Melon<RenderMod>.Logger.Msg($"[FFmpegVideoBGPlayer] Successfully initialized - Resolution: {w}x{h}, FPS: {_decoder.FPS:F2}");
-            }
-            catch (Exception ex)
-            {
-                Melon<RenderMod>.Logger.Error($"[FFmpegVideoBGPlayer] Error during initialization: {ex}");
-                CleanUp();
-            }
-        }
-
-        private static void ConfigureTexture(Texture2D tex)
-        {
-            tex.wrapMode = TextureWrapMode.Clamp;
-            tex.filterMode = FilterMode.Bilinear;
-        }
-
-        private void LateUpdate()
-        {
-            if (!_isInitialized || _decoder == null) return;
-
-            var cond = scrConductor.instance;
-            if (!cond || !cond.hasSongStarted) return;
-            
-            var pitch = cond.song.pitch;
-            var separateCountdownOffset = cond.separateCountdownTime ? 
-                cond.crotchetAtStart * cond.adjustedCountdownTicks : 0.0;
-            var songTime = (cond.dspTime - cond.dspTimeSong) * pitch - cond.addoffset - separateCountdownOffset;
-
-            var vidOffset = scrVfxPlus.instance ? scrVfxPlus.instance.vidOffset : 0.0;
-            var targetVideoTime = songTime + vidOffset;
-
-            if (targetVideoTime < 0)
-            {
-                if (_targetTexture)
-                {
-                    var active = RenderTexture.active;
-                    RenderTexture.active = _targetTexture;
-                    GL.Clear(true, true, Color.black);
-                    RenderTexture.active = active;
-                }
-                if (_quad)
-                {
-                    _quad.SetActive(false);
-                }
-                return;
-            }
-
-
-            if (ADOBase.customLevel)
-            {
-                ADOBase.customLevel.ShowTutorialBackground(false);
-            }
-
-            try
-            {
-                if (targetVideoTime < _currentFrameTimestamp || targetVideoTime - _currentFrameTimestamp > 1.0)
-                {
-                    _decoder.SeekToTime(targetVideoTime);
-                    _currentFrameTimestamp = targetVideoTime;
-                    _nextFrameTimestamp = targetVideoTime;
-                }
-
-                bool frameUpdated = false;
-                while (targetVideoTime >= _nextFrameTimestamp)
-                {
-                    double timestamp = 0.0;
-                    bool success = false;
-
-                    if (_gpuMode == GPUMode.NV12 && _textureY && _textureUV)
-                    {
-                        success = _decoder.TryReadNV12Frame(
-                            _textureY.GetRawTextureData<byte>(),
-                            _textureUV.GetRawTextureData<byte>(),
-                            out timestamp
-                        );
-                    }
-                    else if (_gpuMode == GPUMode.YUV420P && _textureY && _textureU && _textureV)
-                    {
-                        success = _decoder.TryReadYUV420PFrame(
-                            _textureY.GetRawTextureData<byte>(),
-                            _textureU.GetRawTextureData<byte>(),
-                            _textureV.GetRawTextureData<byte>(),
-                            out timestamp
-                        );
-                    }
-                    else
-                    {
-                        if (_textureRGBA != null)
-                        {
-                            success = _decoder.TryReadFrame(
-                                _textureRGBA.GetRawTextureData<byte>(),
-                                vflip: true,
-                                out timestamp
-                            );
-                        }
-                    }
-
-                    if (success)
-                    {
-                        _currentFrameTimestamp = timestamp;
-                        _nextFrameTimestamp = timestamp + (1.0 / _decoder.FPS);
-                        frameUpdated = true;
-                    }
-                    else
-                    {
-                        if (_isLooping)
-                        {
-                            _decoder.SeekToTime(0);
-                            _currentFrameTimestamp = 0;
-                            _nextFrameTimestamp = 1.0 / _decoder.FPS;
-                            break;
-                        }
-                        else
-                        {
-                            break;
-                        }
-                    }
-                }
-
-                if (frameUpdated)
-                {
-                    RenderToTarget();
-                }
-            }
-            catch (Exception ex)
-            {
-                Melon<RenderMod>.Logger.Error($"[FFmpegVideoBGPlayer] Error during playback update: {ex}");
-                _isInitialized = false;
-            }
-        }
-
-        private void RenderToTarget()
-        {
-            if (_decoder == null) return;
-
-            int w = _decoder.Width;
-            int h = _decoder.Height;
-
-            if (_gpuMode == GPUMode.NV12 && _textureY && _textureUV && _computeShader && _renderTexture)
-            {
-                _textureY.Apply();
-                _textureUV.Apply();
-
-                _computeShader.SetTexture(_kernelIndex, YTex, _textureY);
-                _computeShader.SetTexture(_kernelIndex, UVTex, _textureUV);
-                _computeShader.SetTexture(_kernelIndex, Result, _renderTexture);
-                _computeShader.SetInt(Width, w);
-                _computeShader.SetInt(Height, h);
-                _computeShader.SetInt(ColorRange, _decoder.ColorRange == AVColorRange.AVCOL_RANGE_JPEG ? 1 : 0);
-
-                int threadGroupsX = (w + 7) / 8;
-                int threadGroupsY = (h + 7) / 8;
-                _computeShader.Dispatch(_kernelIndex, threadGroupsX, threadGroupsY, 1);
-
-                if (_targetTexture)
-                {
-                    Graphics.Blit(_renderTexture, _targetTexture);
-                }
-                else if (_material)
-                {
-                    if (_material.mainTexture != _renderTexture)
-                    {
-                        _material.mainTexture = _renderTexture;
-                    }
-                    if (_quad != null && !_quad.activeSelf)
-                    {
-                        _quad.SetActive(true);
-                    }
-                }
-            }
-            else if (_gpuMode == GPUMode.YUV420P && _textureY && _textureU && _textureV && _computeShader && _renderTexture)
-            {
-                _textureY.Apply();
-                _textureU.Apply();
-                _textureV.Apply();
-
-                _computeShader.SetTexture(_kernelIndex, YTex, _textureY);
-                _computeShader.SetTexture(_kernelIndex, UTex, _textureU);
-                _computeShader.SetTexture(_kernelIndex, VTex, _textureV);
-                _computeShader.SetTexture(_kernelIndex, Result, _renderTexture);
-                _computeShader.SetInt(Width, w);
-                _computeShader.SetInt(Height, h);
-                _computeShader.SetInt(ColorRange, _decoder.ColorRange == AVColorRange.AVCOL_RANGE_JPEG ? 1 : 0);
-
-                int threadGroupsX = (w + 7) / 8;
-                int threadGroupsY = (h + 7) / 8;
-                _computeShader.Dispatch(_kernelIndex, threadGroupsX, threadGroupsY, 1);
-
-                if (_targetTexture)
-                {
-                    Graphics.Blit(_renderTexture, _targetTexture);
-                }
-                else if (_material)
-                {
-                    if (_material.mainTexture != _renderTexture)
-                    {
-                        _material.mainTexture = _renderTexture;
-                    }
-                    if (_quad != null && !_quad.activeSelf)
-                    {
-                        _quad.SetActive(true);
-                    }
-                }
-            }
-            else if (_textureRGBA)
-            {
-                _textureRGBA.Apply();
-                if (_targetTexture)
-                {
-                    Graphics.Blit(_textureRGBA, _targetTexture);
-                }
-                else if (_material)
-                {
-                    if (_material.mainTexture != _textureRGBA)
-                    {
-                        _material.mainTexture = _textureRGBA;
-                    }
-                    if (_quad != null && !_quad.activeSelf)
-                    {
-                        _quad.SetActive(true);
-                    }
-                }
-            }
-        }
-
-        private void OnDestroy()
-        {
-            CleanUp();
-        }
-
-        public void CleanUp()
-        {
-            _isInitialized = false;
-
-            if (_decoder != null)
-            {
-                _decoder.Dispose();
-                _decoder = null;
-                Melon<RenderMod>.Logger.Msg("[FFmpegVideoBGPlayer] Decoder successfully disposed.");
-            }
-
-            if (_textureRGBA != null)
-            {
-                Destroy(_textureRGBA);
-                _textureRGBA = null;
-            }
-
-            if (_textureY != null) Destroy(_textureY);
-            if (_textureU != null) Destroy(_textureU);
-            if (_textureV != null) Destroy(_textureV);
-            if (_textureUV != null) Destroy(_textureUV);
-
-            _textureY = null;
-            _textureU = null;
-            _textureV = null;
-            _textureUV = null;
-
-            if (_renderTexture != null)
-            {
-                _renderTexture.Release();
-                Destroy(_renderTexture);
-                _renderTexture = null;
-            }
-
-            if (_quad != null)
-            {
-                Destroy(_quad);
-                _quad = null;
-            }
-
-            if (_material != null)
-            {
-                Destroy(_material);
-                _material = null;
-            }
-        }
-
-        // ReSharper disable once InconsistentNaming
-        private void SetupBackgroundQuad(Camera targetCamera, GameObject videoBGGo)
-        {
-            _quad = GameObject.CreatePrimitive(PrimitiveType.Quad);
-            _quad.name = "FFmpegVideoBGQuad";
-            
-            // ReSharper disable once Unity.UnresolvedComponentOrScriptableObject
-            var col = _quad.GetComponent("MeshCollider");
-            if (col) Destroy(col);
-            
-            _quad.transform.parent = targetCamera.transform;
-            
-            var zPos = targetCamera.farClipPlane - 0.5f;
-            _quad.transform.localPosition = new Vector3(0f, 0f, zPos);
-            _quad.transform.localRotation = Quaternion.identity;
-            
-            float height;
-            float width;
-            if (targetCamera.orthographic)
-            {
-                height = 2.0f * targetCamera.orthographicSize;
-                width = height * targetCamera.aspect;
-            }
-            else
-            {
-                height = 2.0f * zPos * Mathf.Tan(targetCamera.fieldOfView * 0.5f * Mathf.Deg2Rad);
-                width = height * targetCamera.aspect;
-            }
-            _quad.transform.localScale = new Vector3(width, height, 1.0f);
-            _quad.layer = videoBGGo.layer;
-
-            // Set vertex colors to white so Sprites/Default works properly (otherwise it may draw transparently)
-            var meshFilter = _quad.GetComponent<MeshFilter>();
-            if (meshFilter != null && meshFilter.mesh != null)
-            {
-                var mesh = meshFilter.mesh;
-                var colors = new Color[mesh.vertexCount];
-                for (var i = 0; i < colors.Length; i++)
-                {
-                    colors[i] = Color.white;
-                }
-                mesh.colors = colors;
-            }
-
-            Shader? shader = null;
-            if (scrCamera.instance != null)
-            {
-                try
-                {
-                    var camQuadMeshField = typeof(scrCamera).GetField("camQuadMesh", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
-                    if (camQuadMeshField != null)
-                    {
-                        var renderer = camQuadMeshField.GetValue(scrCamera.instance) as MeshRenderer;
-                        if (renderer != null && renderer.sharedMaterial != null)
-                        {
-                            shader = renderer.sharedMaterial.shader;
-                        }
-                    }
-                }
-                catch (Exception)
-                {
-                    // ignored
-                }
-            }
-            
-            if (shader == null) shader = Shader.Find("Sprites/Default");
-            if (shader == null) shader = Shader.Find("Unlit/Texture");
-            if (shader == null) shader = Shader.Find("Standard");
-            
-            _material = new Material(shader)
-            {
-                color = Color.white
-            };
-
-            _quad.GetComponent<MeshRenderer>().material = _material;
-            
-            // Set inactive initially to prevent white flash
-            _quad.SetActive(false);
-        }
-    }
-}

Util/FolderDialogUtil.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Text;
@@ -9,6 +10,8 @@ using MelonLoader;
 
 namespace ADOFAIRenderer.Util;
 
+[SuppressMessage("ReSharper", "InconsistentNaming")]
+[SuppressMessage("ReSharper", "UnusedMember.Local")]
 internal static class FolderDialogUtil
 {
     private static int _isDialogOpen;
@@ -187,14 +190,12 @@ internal static class FolderDialogUtil
 
     private static string? OpenWindowsFolderBrowserModern(string initialDirectory, IntPtr ownerHandle)
     {
-        IFileOpenDialog? dialog = null;
-
         // 1. Try native CoCreateInstance first (works on Mono and .NET without class registration)
         var clsid = CLSID_FileOpenDialog;
         var iid = IID_IFileOpenDialog;
-        int createHr = CoCreateInstance(ref clsid, IntPtr.Zero, 1 /* CLSCTX_INPROC_SERVER */, ref iid, out dialog);
+        int createHr = CoCreateInstance(ref clsid, IntPtr.Zero, 1 /* CLSCTX_INPROC_SERVER */, ref iid, out var dialog);
 
-        if (createHr != 0 || dialog == null)
+        if (createHr != 0)
         {
             // 2. Fallback to Activator via Type.GetTypeFromCLSID
             var comType = Type.GetTypeFromCLSID(CLSID_FileOpenDialog);
@@ -224,7 +225,7 @@ internal static class FolderDialogUtil
                     {
                         var shellItemGuid = IID_IShellItem;
                         int itemHr = SHCreateItemFromParsingName(normalized, IntPtr.Zero, ref shellItemGuid, out var initialItem);
-                        if (itemHr == 0 && initialItem != null)
+                        if (itemHr == 0)
                         {
                             try
                             {
@@ -263,7 +264,6 @@ internal static class FolderDialogUtil
             }
 
             dialog.GetResult(out var resultItem);
-            if (resultItem == null) return null;
 
             try
             {
@@ -319,7 +319,7 @@ internal static class FolderDialogUtil
                     if (Directory.Exists(normalized))
                     {
                         initialDirPtr = Marshal.StringToHGlobalUni(normalized);
-                        callback = (hwnd, uMsg, lParam, lpData) =>
+                        callback = (hwnd, uMsg, _, lpData) =>
                         {
                             if (uMsg == BFFM_INITIALIZED && lpData != IntPtr.Zero)
                             {

Util/FrameReader.cs

@@ -27,11 +27,33 @@ namespace ADOFAIRenderer.Util
         private bool _isInitialized;
         private volatile bool _isDisposed;
 
-        private readonly AVPixelFormat _targetFormat;
+        private readonly ComputeShader? _computeShader;
+        private readonly int _kernelIndex = -1;
+        private readonly bool _useGPUConversion;
+        private readonly AVPixelFormat _expectedFormat;
 
         public FrameReader(AVPixelFormat targetFormat)
         {
-            _targetFormat = targetFormat;
+            _computeShader = ModAssets.ColorConversionShader;
+            if (_computeShader)
+            {
+                var kernelName = targetFormat switch
+                {
+                    AVPixelFormat.AV_PIX_FMT_NV12 => "CSMain_NV12",
+                    AVPixelFormat.AV_PIX_FMT_YUV420P => "CSMain_YUV420P",
+                    _ => null
+                };
+
+                if (kernelName != null)
+                {
+                    try { _kernelIndex = _computeShader.FindKernel(kernelName); }
+                    catch { _kernelIndex = -1; }
+                }
+            }
+
+            _useGPUConversion = _kernelIndex >= 0;
+            _expectedFormat = _useGPUConversion ? targetFormat : AVPixelFormat.AV_PIX_FMT_RGBA;
+
             InitializePool();
         }
 
@@ -71,72 +93,35 @@ namespace ADOFAIRenderer.Util
                 state.IsInFlight = true;
             }
 
-            // Check if GPU color conversion is enabled
-            bool useGPUConversion = ModAssets.ColorConversionShader;
-            AVPixelFormat expectedFmt = AVPixelFormat.AV_PIX_FMT_RGBA;
-            
-            if (useGPUConversion)
-            {
-                expectedFmt = _targetFormat;
-                // Compute Shader only supports NV12 and YUV420P; fallback to CPU for other formats
-                if (expectedFmt != AVPixelFormat.AV_PIX_FMT_NV12 && expectedFmt != AVPixelFormat.AV_PIX_FMT_YUV420P)
-                {
-                    useGPUConversion = false;
-                }
-            }
-
             var bufferSize = texture.width * texture.height * 4; // RGBA = 4 channel
-            state.Setup(currentFrame, bufferSize, useGPUConversion, expectedFmt, texture.width, texture.height);
+            state.Setup(currentFrame, bufferSize, _useGPUConversion, _expectedFormat, texture.width, texture.height);
 
-            if (useGPUConversion && state.GPUBuffer != null && ModAssets.ColorConversionShader)
+            if (_useGPUConversion && state.GPUBuffer != null && _computeShader)
             {
-                int kernelIndex = -1;
-                if (expectedFmt == AVPixelFormat.AV_PIX_FMT_NV12)
-                {
-                    kernelIndex = ModAssets.ColorConversionShader.FindKernel("CSMain_NV12");
-                }
-                else if (expectedFmt == AVPixelFormat.AV_PIX_FMT_YUV420P)
-                {
-                    kernelIndex = ModAssets.ColorConversionShader.FindKernel("CSMain_YUV420P");
-                }
+                _computeShader.SetTexture(_kernelIndex, SourceTexture, texture);
+                _computeShader.SetBuffer(_kernelIndex, DestinationBuffer, state.GPUBuffer);
+                _computeShader.SetInt(Width, texture.width);
+                _computeShader.SetInt(Height, texture.height);
 
-                if (kernelIndex >= 0)
-                {
-                    ModAssets.ColorConversionShader.SetTexture(kernelIndex, SourceTexture, texture);
-                    ModAssets.ColorConversionShader.SetBuffer(kernelIndex, DestinationBuffer, state.GPUBuffer);
-                    ModAssets.ColorConversionShader.SetInt(Width, texture.width);
-                    ModAssets.ColorConversionShader.SetInt(Height, texture.height);
+                var threadGroupsX = _expectedFormat == AVPixelFormat.AV_PIX_FMT_NV12
+                    ? (texture.width + 31) / 32
+                    : (texture.width + 63) / 64;
+                var threadGroupsY = (texture.height + 15) / 16;
 
-                    var threadGroupsX = expectedFmt == AVPixelFormat.AV_PIX_FMT_NV12
-                        ? (texture.width + 31) / 32
-                        : (texture.width + 63) / 64;
-                    var threadGroupsY = (texture.height + 15) / 16;
+                _computeShader.Dispatch(_kernelIndex, threadGroupsX, threadGroupsY, 1);
 
-                    ModAssets.ColorConversionShader.Dispatch(kernelIndex, threadGroupsX, threadGroupsY, 1);
-
-                    AsyncGPUReadback.Request(
-                        state.GPUBuffer,
-                        state.CachedCallback
-                    );
-                }
-                else
-                {
-                    // If kernel is not found, fallback to standard RGBA texture readback
-                    AsyncGPUReadback.RequestIntoNativeArray(
-                        ref state.NativeBuffer,
-                        texture,
-                        0,
-                        state.CachedCallback
-                    );
-                }
+                AsyncGPUReadback.RequestIntoNativeArray(
+                    ref state.NativeBuffer, state.GPUBuffer, state.CachedCallback
+                );
+                /*AsyncGPUReadback.Request(
+                    state.GPUBuffer,
+                    state.CachedCallback
+                );*/
             }
             else
             {
                 AsyncGPUReadback.RequestIntoNativeArray(
-                    ref state.NativeBuffer,
-                    texture,
-                    0,
-                    state.CachedCallback
+                    ref state.NativeBuffer, texture, 0, state.CachedCallback
                 );
             }
         }
@@ -169,16 +154,14 @@ namespace ADOFAIRenderer.Util
                 }
                 Melon<RenderMod>.Logger.Warning($"[OOM Prevent] GPU Readback failed for frame {frame}. Queue deadlock prevented by sending a black frame.");
 
-                var byteSize = state.IsGPUConversion
-                    ? state.Width * state.Height * 3 / 2
-                    : state.Width * state.Height * 4;
+                var byteSize = state.Width * state.Height * 3 / 2;
                 var blackFrame = ArrayPool<byte>.Shared.Rent(byteSize);
                 Array.Clear(blackFrame, 0, byteSize);
                 
                 var capFrame = new RenderManager.CapturedFrame
                 {
-                    ManagedBuffer = blackFrame,
-                    Length = byteSize
+                    ManagedBuffer = blackFrame, Length = byteSize,
+                    IsColorConverted = true
                 };
                 PushToQueue(frame, capFrame);
                 RecycleState(state);
@@ -187,19 +170,20 @@ namespace ADOFAIRenderer.Util
             {
                 unsafe
                 {
+                    /*
                     if (state.IsGPUConversion)
                     {
                         var data = request.GetData<byte>();
                         // Copy async request buffer data to persistent NativeBuffer memory
                         NativeArray<byte>.Copy(data, state.NativeBuffer, data.Length);
                     }
+                    */
                     
                     var ptr = (IntPtr)state.NativeBuffer.GetUnsafeReadOnlyPtr();
                     var capFrame = new RenderManager.CapturedFrame
                     {
-                        NativePointer = ptr,
-                        Length = state.NativeBuffer.Length,
-                        ReadbackState = state
+                        NativePointer = ptr, Length = state.NativeBuffer.Length,
+                        ReadbackState = state, IsColorConverted = state.IsGPUConversion
                     };
                     PushToQueue(frame, capFrame);
                 }

Util/VideoBGPlayer.cs

@@ -0,0 +1,517 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using ADOFAIRenderer.UI;
+using ADOFAIRenderer.Util.FFmpeg;
+using MelonLoader;
+using UnityEngine;
+using FFmpeg.AutoGen;
+
+namespace ADOFAIRenderer.Util;
+
+// ReSharper disable once InconsistentNaming
+internal class VideoBGPlayer : MonoBehaviour
+{
+    private static readonly int YTex = Shader.PropertyToID("_YTex");
+    private static readonly int UVTex = Shader.PropertyToID("_UVTex");
+    private static readonly int Result = Shader.PropertyToID("_Result");
+    private static readonly int Width = Shader.PropertyToID("Width");
+    private static readonly int Height = Shader.PropertyToID("Height");
+    private static readonly int UTex = Shader.PropertyToID("_UTex");
+    private static readonly int VTex = Shader.PropertyToID("_VTex");
+    private static readonly int ColorRange = Shader.PropertyToID("ColorRange");
+
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    private enum GPUMode
+    {
+        None,
+        YUV420P,
+        NV12
+    }
+
+    private FFmpegNativeDecoder? _decoder;
+        
+    // CPU fallback rendering
+    // ReSharper disable once InconsistentNaming
+    private Texture2D? _textureRGBA;
+
+    // GPU conversion textures
+    private Texture2D? _textureY;
+    private Texture2D? _textureU;
+    private Texture2D? _textureV;
+    private Texture2D? _textureUV;
+
+    // Compute Shader variables
+    private ComputeShader? _computeShader;
+    private RenderTexture? _renderTexture;
+    private int _kernelIndex = -1;
+
+    private double _currentFrameTimestamp;
+    private double _nextFrameTimestamp;
+    private GPUMode _gpuMode = GPUMode.None;
+    private RenderTexture? _targetTexture;
+    private bool _isLooping;
+    private bool _isInitialized;
+
+    private GameObject? _quad;
+    private Material? _material;
+
+    // ReSharper disable once InconsistentNaming
+    public void Init(string videoPath, RenderTexture? targetTexture, bool loop, Camera? targetCamera, GameObject videoBGGo)
+    {
+        CleanUp();
+
+        _targetTexture = targetTexture;
+        _isLooping = loop;
+
+        if (_targetTexture == null && targetCamera != null)
+        {
+            SetupBackgroundQuad(targetCamera, videoBGGo);
+        }
+
+        if (!File.Exists(videoPath))
+        {
+            Melon<RenderMod>.Logger.Warning($"[FFmpegVideoBGPlayer] Video file does not exist: {videoPath}");
+            return;
+        }
+
+        try
+        {
+            _decoder = new FFmpegNativeDecoder(videoPath);
+            _computeShader = ModAssets.ColorConversionShader;
+
+            var w = _decoder.Width;
+            var h = _decoder.Height;
+            var pixFmt = _decoder.PixelFormat;
+
+            var gpuInitSuccess = false;
+
+            if (_computeShader != null)
+            {
+                switch (pixFmt)
+                {
+                    case AVPixelFormat.AV_PIX_FMT_NV12:
+                        try
+                        {
+                            _kernelIndex = _computeShader.FindKernel("CSMain_NV12ToRGBA");
+                            
+                            _textureY = new Texture2D(w, h, TextureFormat.R8, false);
+                            _textureUV = new Texture2D(w / 2, h / 2, TextureFormat.RG16, false);
+                            ConfigureTexture(_textureY);
+                            ConfigureTexture(_textureUV);
+
+                            _gpuMode = GPUMode.NV12;
+                            gpuInitSuccess = true;
+                            Melon<RenderMod>.Logger.Msg("[FFmpegVideoBGPlayer] Initialized Compute Shader NV12 mode successfully");
+                        }
+                        catch
+                        {
+                            // ignored
+                        }
+
+                        break;
+                    case AVPixelFormat.AV_PIX_FMT_YUV420P:
+                    case AVPixelFormat.AV_PIX_FMT_YUVJ420P:
+                        try
+                        {
+                            _kernelIndex = _computeShader.FindKernel("CSMain_YUV420PToRGBA");
+                            
+                            _textureY = new Texture2D(w, h, TextureFormat.R8, false);
+                            _textureU = new Texture2D(w / 2, h / 2, TextureFormat.R8, false);
+                            _textureV = new Texture2D(w / 2, h / 2, TextureFormat.R8, false);
+                            ConfigureTexture(_textureY);
+                            ConfigureTexture(_textureU);
+                            ConfigureTexture(_textureV);
+
+                            _gpuMode = GPUMode.YUV420P;
+                            gpuInitSuccess = true;
+                            Melon<RenderMod>.Logger.Msg("[FFmpegVideoBGPlayer] Initialized Compute Shader YUV420P mode successfully");
+                        }
+                        catch
+                        {
+                            // ignored
+                        }
+
+                        break;
+                    default:
+                        Melon<RenderMod>.Logger.Msg("[FFmpegVideoBGPlayer] Cannot use Compute Shader for colorspace conversion.");
+                        break;
+                }
+            }
+
+            if (gpuInitSuccess && _computeShader != null)
+            {
+                _renderTexture = new RenderTexture(w, h, 0, RenderTextureFormat.ARGB32)
+                {
+                    enableRandomWrite = true
+                };
+                _renderTexture.Create();
+            }
+            else
+            {
+                _textureRGBA = new Texture2D(w, h, TextureFormat.RGBA32, false);
+                ConfigureTexture(_textureRGBA);
+                _gpuMode = GPUMode.None;
+                Melon<RenderMod>.Logger.Warning("[FFmpegVideoBGPlayer] GPU acceleration unsupported or failed to load, falling back to CPU (RGBA).");
+            }
+
+            _currentFrameTimestamp = 0.0;
+            _nextFrameTimestamp = 0.0;
+            _isInitialized = true;
+
+            Melon<RenderMod>.Logger.Msg($"[FFmpegVideoBGPlayer] Successfully initialized - Resolution: {w}x{h}, FPS: {_decoder.FPS:F2}");
+        }
+        catch (Exception ex)
+        {
+            Melon<RenderMod>.Logger.Error($"[FFmpegVideoBGPlayer] Error during initialization: {ex}");
+            CleanUp();
+        }
+    }
+
+    private static void ConfigureTexture(Texture2D tex)
+    {
+        tex.wrapMode = TextureWrapMode.Clamp;
+        tex.filterMode = FilterMode.Bilinear;
+    }
+
+    private void LateUpdate()
+    {
+        if (!_isInitialized || _decoder == null) return;
+
+        var cond = scrConductor.instance;
+        if (!cond || !cond.hasSongStarted) return;
+            
+        var pitch = cond.song.pitch;
+        var separateCountdownOffset = cond.separateCountdownTime ? 
+            cond.crotchetAtStart * cond.adjustedCountdownTicks : 0.0;
+        var songTime = (cond.dspTime - cond.dspTimeSong) * pitch - cond.addoffset - separateCountdownOffset;
+
+        var vidOffset = scrVfxPlus.instance ? scrVfxPlus.instance.vidOffset : 0.0;
+        var targetVideoTime = songTime + vidOffset;
+
+        if (targetVideoTime < 0)
+        {
+            if (_targetTexture)
+            {
+                var active = RenderTexture.active;
+                RenderTexture.active = _targetTexture;
+                GL.Clear(true, true, Color.black);
+                RenderTexture.active = active;
+            }
+            if (_quad)
+            {
+                _quad.SetActive(false);
+            }
+            return;
+        }
+
+
+        if (ADOBase.customLevel)
+        {
+            ADOBase.customLevel.ShowTutorialBackground(false);
+        }
+
+        try
+        {
+            if (targetVideoTime < _currentFrameTimestamp || targetVideoTime - _currentFrameTimestamp > 1.0)
+            {
+                _decoder.SeekToTime(targetVideoTime);
+                _currentFrameTimestamp = targetVideoTime;
+                _nextFrameTimestamp = targetVideoTime;
+            }
+
+            bool frameUpdated = false;
+            while (targetVideoTime >= _nextFrameTimestamp)
+            {
+                double timestamp = 0.0;
+                bool success = false;
+
+                if (_gpuMode == GPUMode.NV12 && _textureY && _textureUV)
+                {
+                    success = _decoder.TryReadNV12Frame(
+                        _textureY.GetRawTextureData<byte>(),
+                        _textureUV.GetRawTextureData<byte>(),
+                        out timestamp
+                    );
+                }
+                else if (_gpuMode == GPUMode.YUV420P && _textureY && _textureU && _textureV)
+                {
+                    success = _decoder.TryReadYUV420PFrame(
+                        _textureY.GetRawTextureData<byte>(),
+                        _textureU.GetRawTextureData<byte>(),
+                        _textureV.GetRawTextureData<byte>(),
+                        out timestamp
+                    );
+                }
+                else
+                {
+                    if (_textureRGBA != null)
+                    {
+                        success = _decoder.TryReadFrame(
+                            _textureRGBA.GetRawTextureData<byte>(),
+                            vflip: true,
+                            out timestamp
+                        );
+                    }
+                }
+
+                if (success)
+                {
+                    _currentFrameTimestamp = timestamp;
+                    _nextFrameTimestamp = timestamp + (1.0 / _decoder.FPS);
+                    frameUpdated = true;
+                }
+                else
+                {
+                    if (_isLooping)
+                    {
+                        _decoder.SeekToTime(0);
+                        _currentFrameTimestamp = 0;
+                        _nextFrameTimestamp = 1.0 / _decoder.FPS;
+                        break;
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+            }
+
+            if (frameUpdated)
+            {
+                RenderToTarget();
+            }
+        }
+        catch (Exception ex)
+        {
+            Melon<RenderMod>.Logger.Error($"[FFmpegVideoBGPlayer] Error during playback update: {ex}");
+            _isInitialized = false;
+        }
+    }
+
+    private void RenderToTarget()
+    {
+        if (_decoder == null) return;
+
+        int w = _decoder.Width;
+        int h = _decoder.Height;
+
+        if (_gpuMode == GPUMode.NV12 && _textureY && _textureUV && _computeShader && _renderTexture)
+        {
+            _textureY.Apply();
+            _textureUV.Apply();
+
+            _computeShader.SetTexture(_kernelIndex, YTex, _textureY);
+            _computeShader.SetTexture(_kernelIndex, UVTex, _textureUV);
+            _computeShader.SetTexture(_kernelIndex, Result, _renderTexture);
+            _computeShader.SetInt(Width, w);
+            _computeShader.SetInt(Height, h);
+            _computeShader.SetInt(ColorRange, _decoder.ColorRange == AVColorRange.AVCOL_RANGE_JPEG ? 1 : 0);
+
+            int threadGroupsX = (w + 7) / 8;
+            int threadGroupsY = (h + 7) / 8;
+            _computeShader.Dispatch(_kernelIndex, threadGroupsX, threadGroupsY, 1);
+
+            if (_targetTexture)
+            {
+                Graphics.Blit(_renderTexture, _targetTexture);
+            }
+            else if (_material)
+            {
+                if (_material.mainTexture != _renderTexture)
+                {
+                    _material.mainTexture = _renderTexture;
+                }
+                if (_quad != null && !_quad.activeSelf)
+                {
+                    _quad.SetActive(true);
+                }
+            }
+        }
+        else if (_gpuMode == GPUMode.YUV420P && _textureY && _textureU && _textureV && _computeShader && _renderTexture)
+        {
+            _textureY.Apply();
+            _textureU.Apply();
+            _textureV.Apply();
+
+            _computeShader.SetTexture(_kernelIndex, YTex, _textureY);
+            _computeShader.SetTexture(_kernelIndex, UTex, _textureU);
+            _computeShader.SetTexture(_kernelIndex, VTex, _textureV);
+            _computeShader.SetTexture(_kernelIndex, Result, _renderTexture);
+            _computeShader.SetInt(Width, w);
+            _computeShader.SetInt(Height, h);
+            _computeShader.SetInt(ColorRange, _decoder.ColorRange == AVColorRange.AVCOL_RANGE_JPEG ? 1 : 0);
+
+            int threadGroupsX = (w + 7) / 8;
+            int threadGroupsY = (h + 7) / 8;
+            _computeShader.Dispatch(_kernelIndex, threadGroupsX, threadGroupsY, 1);
+
+            if (_targetTexture)
+            {
+                Graphics.Blit(_renderTexture, _targetTexture);
+            }
+            else if (_material)
+            {
+                if (_material.mainTexture != _renderTexture)
+                {
+                    _material.mainTexture = _renderTexture;
+                }
+                if (_quad != null && !_quad.activeSelf)
+                {
+                    _quad.SetActive(true);
+                }
+            }
+        }
+        else if (_textureRGBA)
+        {
+            _textureRGBA.Apply();
+            if (_targetTexture)
+            {
+                Graphics.Blit(_textureRGBA, _targetTexture);
+            }
+            else if (_material)
+            {
+                if (_material.mainTexture != _textureRGBA)
+                {
+                    _material.mainTexture = _textureRGBA;
+                }
+                if (_quad != null && !_quad.activeSelf)
+                {
+                    _quad.SetActive(true);
+                }
+            }
+        }
+    }
+
+    private void OnDestroy()
+    {
+        CleanUp();
+    }
+
+    public void CleanUp()
+    {
+        _isInitialized = false;
+
+        if (_decoder != null)
+        {
+            _decoder.Dispose();
+            _decoder = null;
+            Melon<RenderMod>.Logger.Msg("[FFmpegVideoBGPlayer] Decoder successfully disposed.");
+        }
+
+        if (_textureRGBA != null)
+        {
+            Destroy(_textureRGBA);
+            _textureRGBA = null;
+        }
+
+        if (_textureY != null) Destroy(_textureY);
+        if (_textureU != null) Destroy(_textureU);
+        if (_textureV != null) Destroy(_textureV);
+        if (_textureUV != null) Destroy(_textureUV);
+
+        _textureY = null;
+        _textureU = null;
+        _textureV = null;
+        _textureUV = null;
+
+        if (_renderTexture != null)
+        {
+            _renderTexture.Release();
+            Destroy(_renderTexture);
+            _renderTexture = null;
+        }
+
+        if (_quad != null)
+        {
+            Destroy(_quad);
+            _quad = null;
+        }
+
+        if (_material != null)
+        {
+            Destroy(_material);
+            _material = null;
+        }
+    }
+
+    // ReSharper disable once InconsistentNaming
+    private void SetupBackgroundQuad(Camera targetCamera, GameObject videoBGGo)
+    {
+        _quad = GameObject.CreatePrimitive(PrimitiveType.Quad);
+        _quad.name = "FFmpegVideoBGQuad";
+            
+        // ReSharper disable once Unity.UnresolvedComponentOrScriptableObject
+        var col = _quad.GetComponent("MeshCollider");
+        if (col) Destroy(col);
+            
+        _quad.transform.parent = targetCamera.transform;
+            
+        var zPos = targetCamera.farClipPlane - 0.5f;
+        _quad.transform.localPosition = new Vector3(0f, 0f, zPos);
+        _quad.transform.localRotation = Quaternion.identity;
+            
+        float height;
+        float width;
+        if (targetCamera.orthographic)
+        {
+            height = 2.0f * targetCamera.orthographicSize;
+            width = height * targetCamera.aspect;
+        }
+        else
+        {
+            height = 2.0f * zPos * Mathf.Tan(targetCamera.fieldOfView * 0.5f * Mathf.Deg2Rad);
+            width = height * targetCamera.aspect;
+        }
+        _quad.transform.localScale = new Vector3(width, height, 1.0f);
+        _quad.layer = videoBGGo.layer;
+
+        // Set vertex colors to white so Sprites/Default works properly (otherwise it may draw transparently)
+        var meshFilter = _quad.GetComponent<MeshFilter>();
+        if (meshFilter != null && meshFilter.mesh != null)
+        {
+            var mesh = meshFilter.mesh;
+            var colors = new Color[mesh.vertexCount];
+            for (var i = 0; i < colors.Length; i++)
+            {
+                colors[i] = Color.white;
+            }
+            mesh.colors = colors;
+        }
+
+        Shader? shader = null;
+        if (scrCamera.instance != null)
+        {
+            try
+            {
+                var camQuadMeshField = typeof(scrCamera).GetField("camQuadMesh", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+                if (camQuadMeshField != null)
+                {
+                    var renderer = camQuadMeshField.GetValue(scrCamera.instance) as MeshRenderer;
+                    if (renderer != null && renderer.sharedMaterial != null)
+                    {
+                        shader = renderer.sharedMaterial.shader;
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                // ignored
+            }
+        }
+            
+        if (shader == null) shader = Shader.Find("Sprites/Default");
+        if (shader == null) shader = Shader.Find("Unlit/Texture");
+        if (shader == null) shader = Shader.Find("Standard");
+            
+        _material = new Material(shader)
+        {
+            color = Color.white
+        };
+
+        _quad.GetComponent<MeshRenderer>().material = _material;
+            
+        // Set inactive initially to prevent white flash
+        _quad.SetActive(false);
+    }
+}