Fix ScreenshotTools (#16081)

* Fix oneffecterrorobs

* Fix NormalMaterial with ThinInstances

* Fix Animation loop in CreateAndStartAnimation

* Fix lineMesh cloned alpha values

* Fix recursive loop in onPointerOutAction

* Fix ScreenshotTools

Author: sebavan

packages/dev/core/src/Meshes/csg.ts

@@ -568,6 +568,10 @@ export class CSG {
         }
 
         const subMeshes = mesh.subMeshes;
+        if (!subMeshes) {
+            // eslint-disable-next-line no-throw-literal
+            throw "BABYLON.CSG: Mesh has no submeshes";
+        }
 
         for (let sm = 0, sml = subMeshes.length; sm < sml; sm++) {
             for (let i = subMeshes[sm].indexStart, il = subMeshes[sm].indexCount + subMeshes[sm].indexStart; i < il; i += 3) {

packages/dev/core/src/Misc/screenshotTools.ts

@@ -259,8 +259,32 @@ export function CreateScreenshotUsingRenderTarget(
     // Prevent engine to render on screen while we do the screenshot
     engine.skipFrameRender = true;
 
-    const originalSize = { width: engine.getRenderWidth(), height: engine.getRenderHeight() };
-    engine.setSize(width, height); // we need this call to trigger onResizeObservable with the screenshot width/height on all the subsystems that are observing this event and that needs to (re)create some resources with the right dimensions
+    const originalGetRenderWidth = engine.getRenderWidth;
+    const originalGetRenderHeight = engine.getRenderHeight;
+
+    // Override getRenderWidth and getRenderHeight to return the desired size of the render
+    // A few internal methods are relying on the canvas size to compute the render size
+    // so we need to override these methods to ensure the correct size is used during the preparation of the render
+    // as well as the screenshot
+    engine.getRenderWidth = (useScreen = false) => {
+        if (!useScreen && engine._currentRenderTarget) {
+            return engine._currentRenderTarget.width;
+        }
+
+        return width;
+    };
+    engine.getRenderHeight = (useScreen = false) => {
+        if (!useScreen && engine._currentRenderTarget) {
+            return engine._currentRenderTarget.height;
+        }
+
+        return height;
+    };
+
+    // Trigger a resize event to ensure the intermediate renders have the correct size
+    if (engine.onResizeObservable.hasObservers()) {
+        engine.onResizeObservable.notifyObservers(engine);
+    }
 
     const scene = camera.getScene();
 
@@ -312,15 +336,47 @@ export function CreateScreenshotUsingRenderTarget(
                 });
                 scene.incrementRenderId();
                 scene.resetCachedMaterial();
-                texture.render(true);
-                engine.setSize(originalSize.width, originalSize.height);
-                camera.getProjectionMatrix(true); // Force cache refresh;
 
-                engine.skipFrameRender = false;
+                // Record the original scene setup
+                const originalCamera = scene.activeCamera;
+                const originalCameras = scene.activeCameras;
+                const originalOutputRenderTarget = camera.outputRenderTarget;
+                const originalSpritesEnabled = scene.spritesEnabled;
+
+                // Swap with the requested one
+                scene.activeCamera = camera;
+                scene.activeCameras = null;
+                camera.outputRenderTarget = texture;
+                scene.spritesEnabled = renderSprites;
+
+                // render the scene on the RTT
+                try {
+                    scene.render();
+                } finally {
+                    // Restore the original scene camera setup
+                    scene.activeCamera = originalCamera;
+                    scene.activeCameras = originalCameras;
+                    camera.outputRenderTarget = originalOutputRenderTarget;
+                    scene.spritesEnabled = originalSpritesEnabled;
+
+                    engine.getRenderWidth = originalGetRenderWidth;
+                    engine.getRenderHeight = originalGetRenderHeight;
+
+                    // Trigger a resize event to ensure the intermediate renders have the correct size
+                    if (engine.onResizeObservable.hasObservers()) {
+                        engine.onResizeObservable.notifyObservers(engine);
+                    }
+
+                    camera.getProjectionMatrix(true); // Force cache refresh;
+
+                    engine.skipFrameRender = false;
+                }
             },
             () => {
                 // Restore engine frame rendering on error
                 engine.skipFrameRender = false;
+                engine.getRenderWidth = originalGetRenderWidth;
+                engine.getRenderHeight = originalGetRenderHeight;
             }
         );
     };

packages/dev/core/src/PostProcesses/RenderPipeline/Pipelines/ssao2RenderingPipeline.ts

@@ -467,7 +467,8 @@ export class SSAO2RenderingPipeline extends PostProcessRenderPipeline {
                 return;
             }
 
-            const ssaoCombineSize = horizontal ? this._ssaoCombinePostProcess.width : this._ssaoCombinePostProcess.height;
+            const ratio = this._ratio.blurRatio || this._ratio;
+            const ssaoCombineSize = horizontal ? this._originalColorPostProcess.width * ratio : this._originalColorPostProcess.height * ratio;
             const originalColorSize = horizontal ? this._originalColorPostProcess.width : this._originalColorPostProcess.height;
 
             effect.setFloat("outSize", ssaoCombineSize > 0 ? ssaoCombineSize : originalColorSize);