Add optional video downscaling

Author: genail

Documentation.html

@@ -112,6 +112,7 @@ <h3>Configuration</h3>
             <ul>
                 <li><strong>Frame Rate</strong>: Default is 30. Higher rates may increase file size and resource usage.</li>
                 <li><strong>Recording Duration</strong>: Default is 60 seconds.</li>
+                <li><strong>Downscale Video</strong>: <em>Off by default.</em> If enabled, the video will be downscaled to a maximum resolution (default: 1920x1080) if your game runs at a higher resolution. This helps reduce CPU usage and file size when recording on high-resolution displays. Enable this option in the inspector if you notice high CPU usage or stuttering during recording at large resolutions.</li>
             </ul>
         </li>
     </ul>

Runtime/Scripts/GameRecorder.cs

@@ -12,6 +12,15 @@ public class GameRecorder : MonoBehaviour
 
         public int RecordingDuration = 60;
 
+        [Tooltip("If true, the video will be downscaled if the screen resolution is higher than the maximum video height and width.")]
+        public bool DownscaleVideo = false;
+
+        [Tooltip("The maximum height of the video. The video will be downscaled if the screen resolution is higher.")]
+        public int MaxVideoHeight = 1080;
+
+        [Tooltip("The maximum width of the video. The video will be downscaled if the screen resolution is higher.")]
+        public int MaxVideoWidth = 1920;
+
         private Texture2D _screenShot;
 
         public bool IsRecording { get; private set; }
@@ -22,6 +31,8 @@ public class GameRecorder : MonoBehaviour
 
         private int _gameWidth;
         private int _gameHeight;
+        private int _outputWidth;
+        private int _outputHeight;
 
         private float _captureInterval;
         private float _nextCaptureTime;
@@ -37,6 +48,26 @@ void Start()
             _gameWidth = Screen.width % 2 == 0 ? Screen.width : Screen.width - 1;
             _gameHeight = Screen.height % 2 == 0 ? Screen.height : Screen.height - 1;
 
+            // Determine target (output) resolution
+            _outputWidth = _gameWidth;
+            _outputHeight = _gameHeight;
+            float aspect = (float)_gameWidth / _gameHeight;
+            if (DownscaleVideo && (_gameWidth > MaxVideoWidth || _gameHeight > MaxVideoHeight))
+            {
+                _outputHeight = Mathf.Min(_gameHeight, MaxVideoHeight);
+                _outputWidth = Mathf.RoundToInt(_outputHeight * aspect);
+                if (_outputWidth > MaxVideoWidth)
+                {
+                    _outputWidth = MaxVideoWidth;
+                    _outputHeight = Mathf.RoundToInt(_outputWidth / aspect);
+                }
+                // Ensure both dimensions are even
+                _outputWidth -= _outputWidth % 2;
+                _outputHeight -= _outputHeight % 2;
+
+                UnityEngine.Debug.Log($"Video is to be downscaled to {_outputWidth}x{_outputHeight}");
+            }
+
             // Create a Texture2D with the adjusted resolution
             _screenShot = new Texture2D(_gameWidth, _gameHeight, TextureFormat.RGB24, false);
             _texturePainter = new TexturePainter(_screenShot);
@@ -48,8 +79,8 @@ void Start()
                 outputDirectory = "BH_Recording";
             }
 
-            // Initialize the video encoder with the adjusted resolution
-            _videoEncoder = new VideoEncoder(_gameWidth, _gameHeight, FrameRate, RecordingDuration, outputDirectory);
+            // Initialize the video encoder with the output resolution
+            _videoEncoder = new VideoEncoder(_outputWidth, _outputHeight, FrameRate, RecordingDuration, outputDirectory);
 
             _captureInterval = 1.0f / FrameRate;
             _nextCaptureTime = Time.time;
@@ -110,6 +141,17 @@ public string StopRecordingAndSaveLastMinute()
 
         private IEnumerator CaptureFrames()
         {
+            UnityEngine.Debug.Log($"Game resolution: {_gameWidth}x{_gameHeight}");
+            UnityEngine.Debug.Log($"Output resolution: {_outputWidth}x{_outputHeight}");
+
+            RenderTexture scaledRT = null;
+            Texture2D scaledTexture = null;
+            if (_outputWidth != _gameWidth || _outputHeight != _gameHeight)
+            {
+                scaledRT = new RenderTexture(_outputWidth, _outputHeight, 0, RenderTextureFormat.ARGB32);
+                scaledTexture = new Texture2D(_outputWidth, _outputHeight, TextureFormat.RGB24, false);
+            }
+
             while (IsRecording)
             {
                 yield return new WaitForEndOfFrame();
@@ -118,22 +160,43 @@ private IEnumerator CaptureFrames()
                 {
                     _nextCaptureTime += _captureInterval;
 
-                    // Capture the screen content into the Texture2D
+                    // 1. Capture the full-res frame
                     _screenShot.ReadPixels(new Rect(0, 0, _gameWidth, _gameHeight), 0, 0);
                     _screenShot.Apply();
 
-                    // Draw a vertical progress bar as an example
-                    // float cpuUsage = 0.5f; // Replace this with actual CPU usage value
-                    // texturePainter.DrawVerticalProgressBar(10, 10, 20, 100, cpuUsage, Color.green, Color.black);
+                    byte[] frameData;
 
-                    // Draw a number as an example
-                    // texturePainter.DrawNumber(50, 10, (int) fps, Color.white, 4);
-                    _texturePainter.DrawNumber(5, 5, (int)_fps, Color.white, 2);
+                    if (scaledRT != null)
+                    {
+                        // 2a. Blit (scale) to RT
+                        Graphics.Blit(_screenShot, scaledRT);
+
+                        // 2b. Read pixels from scaled RT
+                        RenderTexture.active = scaledRT;
+                        scaledTexture.ReadPixels(new Rect(0, 0, _outputWidth, _outputHeight), 0, 0);
+                        scaledTexture.Apply();
+                        RenderTexture.active = null;
+
+                        // 3a. Draw overlays on the scaled texture
+                        var painter = new TexturePainter(scaledTexture);
+                        painter.DrawNumber(5, 5, (int)_fps, Color.white, 2);
+
+                        frameData = scaledTexture.GetRawTextureData();
+                    }
+                    else
+                    {
+                        // 2b. Draw overlays on the original screenshot
+                        _texturePainter.DrawNumber(5, 5, (int)_fps, Color.white, 2);
+                        frameData = _screenShot.GetRawTextureData();
+                    }
 
-                    byte[] frameData = _screenShot.GetRawTextureData();
                     _videoEncoder.AddFrame(frameData);
                 }
             }
+
+            // Clean up if needed
+            if (scaledTexture != null) Destroy(scaledTexture);
+            if (scaledRT != null) scaledRT.Release();
         }
     }
 }