@woosh/meep-engine 2.165.7 → 2.167.0

package/src/engine/ecs/fow/shader/FogOfWarRenderer.js

@@ -1,145 +1,155 @@
-import { Mesh, OrthographicCamera, Scene } from "three";
-import { assert } from "../../../../core/assert.js";
-import { isValueBetweenInclusive } from "../../../../core/math/interval/isValueBetweenInclusive.js";
-import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../../../graphics/geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
-import { buildScreenSpaceFogOfWarShader } from "./screenSpaceFogOfWarShader.js";
-
-/**
- *
- * @param {FogOfWar} fow
- * @param {function(number, number, number, number)} callback
- */
-export function computeUvTransformFromFogOfWar(fow, callback) {
-
-    const sampler = fow.sampler;
-
-    const samplerWidth = sampler.width;
-    const samplerHeight = sampler.height;
-
-
-    const scaleX = (fow.scale * fow.size.x) * (samplerWidth / (samplerWidth - 3));
-    const scaleY = (fow.scale * fow.size.y) * (samplerHeight / (samplerHeight - 3));
-
-    const offsetX = 1.5 / samplerWidth;
-    const offsetY = 1.5 / samplerHeight;
-
-    callback(offsetX, offsetY, 1 / scaleX, 1 / scaleY);
-}
-
-export class FogOfWarRenderer {
-    constructor() {
-        /**
-         *
-         * @type {ShaderMaterial}
-         */
-        this.material = buildScreenSpaceFogOfWarShader();
-
-        this.quad = new Mesh(FULL_SCREEN_TRIANGLE_GEOMETRY, this.material);
-
-        this.camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
-        this.scene = new Scene();
-        this.scene.add(this.quad);
-    }
-
-    /**
-     *
-     * @param {FogOfWar} fow
-     */
-    setUvTransformFromFog(fow) {
-        computeUvTransformFromFogOfWar(fow, (offsetX, offsetY, scaleX, scaleY) => {
-
-            this.setUvTransform(offsetX, offsetY, scaleX, scaleY);
-        });
-    }
-
-    /**
-     *
-     * @param {number} offsetX UV u offset, between 0 and 1
-     * @param {number} offsetY UV v offset, between 0 and 1
-     * @param {number} scaleX Transform scale from world coordinate position to UV u coordinate, minus offsetX
-     * @param {number} scaleY Transform scale from world coordinate position to UV v coordinate, minus offsetY
-     */
-    setUvTransform(offsetX, offsetY, scaleX, scaleY) {
-        assert.isNumber(offsetX, 'offsetX');
-        assert.notNaN(offsetX, 'offsetX');
-        assert.ok(isValueBetweenInclusive(offsetX, 0, 1), `expected offsetX to be between 0 and 1, instead was '${offsetX}'`);
-
-        assert.isNumber(offsetY,  'offsetY');
-        assert.notNaN(offsetY, 'offsetY');
-        assert.ok(isValueBetweenInclusive(offsetY, 0, 1), `expected offsetY to be between 0 and 1, instead was '${offsetY}'`);
-
-
-        assert.isNumber(scaleX,  'scaleX');
-        assert.notNaN(scaleX, 'scaleX');
-        assert.isFinite(scaleX, 'scaleX');
-
-        assert.isNumber(scaleY, 'scaleY');
-        assert.notNaN(scaleY, 'scaleY');
-        assert.isFinite(scaleY, 'scaleY');
-
-        this.material.uniforms.uFogUvTransform.value.set(offsetX, offsetY, scaleX, scaleY);
-    }
-
-    /**
-     *
-     * @param {Texture} texture
-     */
-    setDepthBuffer(texture) {
-        // assert.equal(texture.type, UnsignedShortType, `expected texture type to be UnsignedShort(=${UnsignedShortType}), instead got something else (=${texture.type})`)
-
-        this.material.uniforms.tDepth.value = texture;
-    }
-
-    /**
-     *
-     * @param {Texture} buffer
-     */
-    setFogBuffer(buffer) {
-        this.material.uniforms.tFog.value = buffer;
-
-    }
-
-    /**
-     * Resolution of the fog texture
-     * @param {number} x
-     * @param {number} y
-     */
-    setResolution(x, y) {
-        this.material.uniforms.uResolution.value.set(x, y);
-    }
-
-    /**
-     *
-     * @param {Vector4} color
-     */
-    setFogColor(color) {
-        this.material.uniforms.uColor.value.copy(color);
-    }
-
-    /**
-     *
-     * @param {WebGLRenderer} renderer
-     * @param {PerspectiveCamera|OrthographicCamera} camera
-     * @param {Scene} scene
-     * @param {WebGLRenderTarget} target
-     */
-    render(renderer, camera, scene, target) {
-        assert.ok(camera.isCamera, 'Not a camera');
-        assert.ok(camera.isPerspectiveCamera || camera.isOrthographicCamera, 'Unsupported Camera type. Expected PerspectiveCamera or OrthographicCamera');
-
-
-        //set up uniforms
-        const uniforms = this.material.uniforms;
-
-        uniforms.uProjectionInverse.value.copy(camera.projectionMatrixInverse);
-        uniforms.uViewInverse.value.copy(camera.matrixWorld);
-
-        renderer.setRenderTarget(target);
-        renderer.clearColor();
-
-        renderer.render(this.scene, this.camera);
-
-
-        renderer.setRenderTarget(null);
-    }
-}
+import { Mesh, OrthographicCamera, Scene } from "three";
+import { assert } from "../../../../core/assert.js";
+import { isValueBetweenInclusive } from "../../../../core/math/interval/isValueBetweenInclusive.js";
+import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../../../graphics/geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
+import { FogOfWarEdgeMode } from "../FogOfWarEdgeMode.js";
+import { buildScreenSpaceFogOfWarShader } from "./screenSpaceFogOfWarShader.js";
+
+/**
+ *
+ * @param {FogOfWar} fow
+ * @param {function(number, number, number, number)} callback
+ */
+export function computeUvTransformFromFogOfWar(fow, callback) {
+
+    const sampler = fow.sampler;
+
+    const samplerWidth = sampler.width;
+    const samplerHeight = sampler.height;
+
+
+    const scaleX = (fow.scale * fow.size.x) * (samplerWidth / (samplerWidth - 3));
+    const scaleY = (fow.scale * fow.size.y) * (samplerHeight / (samplerHeight - 3));
+
+    const offsetX = 1.5 / samplerWidth;
+    const offsetY = 1.5 / samplerHeight;
+
+    callback(offsetX, offsetY, 1 / scaleX, 1 / scaleY);
+}
+
+export class FogOfWarRenderer {
+    constructor() {
+        /**
+         *
+         * @type {ShaderMaterial}
+         */
+        this.material = buildScreenSpaceFogOfWarShader();
+
+        this.quad = new Mesh(FULL_SCREEN_TRIANGLE_GEOMETRY, this.material);
+
+        this.camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
+        this.scene = new Scene();
+        this.scene.add(this.quad);
+    }
+
+    /**
+     *
+     * @param {FogOfWar} fow
+     */
+    setUvTransformFromFog(fow) {
+        computeUvTransformFromFogOfWar(fow, (offsetX, offsetY, scaleX, scaleY) => {
+
+            this.setUvTransform(offsetX, offsetY, scaleX, scaleY);
+        });
+    }
+
+    /**
+     *
+     * @param {number} offsetX UV u offset, between 0 and 1
+     * @param {number} offsetY UV v offset, between 0 and 1
+     * @param {number} scaleX Transform scale from world coordinate position to UV u coordinate, minus offsetX
+     * @param {number} scaleY Transform scale from world coordinate position to UV v coordinate, minus offsetY
+     */
+    setUvTransform(offsetX, offsetY, scaleX, scaleY) {
+        assert.isNumber(offsetX, 'offsetX');
+        assert.notNaN(offsetX, 'offsetX');
+        assert.ok(isValueBetweenInclusive(offsetX, 0, 1), `expected offsetX to be between 0 and 1, instead was '${offsetX}'`);
+
+        assert.isNumber(offsetY,  'offsetY');
+        assert.notNaN(offsetY, 'offsetY');
+        assert.ok(isValueBetweenInclusive(offsetY, 0, 1), `expected offsetY to be between 0 and 1, instead was '${offsetY}'`);
+
+
+        assert.isNumber(scaleX,  'scaleX');
+        assert.notNaN(scaleX, 'scaleX');
+        assert.isFinite(scaleX, 'scaleX');
+
+        assert.isNumber(scaleY, 'scaleY');
+        assert.notNaN(scaleY, 'scaleY');
+        assert.isFinite(scaleY, 'scaleY');
+
+        this.material.uniforms.uFogUvTransform.value.set(offsetX, offsetY, scaleX, scaleY);
+    }
+
+    /**
+     *
+     * @param {Texture} texture
+     */
+    setDepthBuffer(texture) {
+        // assert.equal(texture.type, UnsignedShortType, `expected texture type to be UnsignedShort(=${UnsignedShortType}), instead got something else (=${texture.type})`)
+
+        this.material.uniforms.tDepth.value = texture;
+    }
+
+    /**
+     *
+     * @param {Texture} buffer
+     */
+    setFogBuffer(buffer) {
+        this.material.uniforms.tFog.value = buffer;
+
+    }
+
+    /**
+     * Resolution of the fog texture
+     * @param {number} x
+     * @param {number} y
+     */
+    setResolution(x, y) {
+        this.material.uniforms.uResolution.value.set(x, y);
+    }
+
+    /**
+     *
+     * @param {Vector4} color
+     */
+    setFogColor(color) {
+        this.material.uniforms.uColor.value.copy(color);
+    }
+
+    /**
+     * What the fog does outside the fogged area. See {@link FogOfWarEdgeMode}.
+     *
+     * @param {FogOfWarEdgeMode} mode
+     */
+    setEdgeMode(mode) {
+        this.material.uniforms.uEdgeExtend.value = (mode === FogOfWarEdgeMode.Extend) ? 1 : 0;
+    }
+
+    /**
+     *
+     * @param {WebGLRenderer} renderer
+     * @param {PerspectiveCamera|OrthographicCamera} camera
+     * @param {Scene} scene
+     * @param {WebGLRenderTarget} target
+     */
+    render(renderer, camera, scene, target) {
+        assert.ok(camera.isCamera, 'Not a camera');
+        assert.ok(camera.isPerspectiveCamera || camera.isOrthographicCamera, 'Unsupported Camera type. Expected PerspectiveCamera or OrthographicCamera');
+
+
+        //set up uniforms
+        const uniforms = this.material.uniforms;
+
+        uniforms.uProjectionInverse.value.copy(camera.projectionMatrixInverse);
+        uniforms.uViewInverse.value.copy(camera.matrixWorld);
+
+        renderer.setRenderTarget(target);
+        renderer.clearColor();
+
+        renderer.render(this.scene, this.camera);
+
+
+        renderer.setRenderTarget(null);
+    }
+}

package/src/engine/ecs/fow/shader/screenSpaceFogOfWarShader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"screenSpaceFogOfWarShader.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/fow/shader/screenSpaceFogOfWarShader.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,kDAFW,cAAc,CAmKxB;+BAxKyE,OAAO"}
+{"version":3,"file":"screenSpaceFogOfWarShader.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/fow/shader/screenSpaceFogOfWarShader.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,kDAFW,cAAc,CA4LxB;+BAjMyE,OAAO"}

package/src/engine/ecs/fow/shader/screenSpaceFogOfWarShader.js

@@ -22,9 +22,12 @@ export function buildScreenSpaceFogOfWarShader() {
         uniform vec2 uResolution;
                 
         uniform vec4 uColor;
-        
+
+        // FogOfWarEdgeMode as a float: 0 = Conceal (legacy), 1 = Extend
+        uniform float uEdgeExtend;
+
         varying vec2 vUv;
-        
+
         const float   c_samplesX    = 5.0;
         const float   c_samplesY    = 5.0;
 
@@ -43,11 +46,9 @@ export function buildScreenSpaceFogOfWarShader() {
         // per tap, so a 5-tap kernel reaches +/-2 texels either side of centre.
         const float texelSpacing = 1.0;
         
-	     vec3 computeWorldPosition(){
+	     vec3 computeWorldPosition(const in float normalizedDepth){
                 // Convert screen coordinates to normalized device coordinates (NDC)
-                
-                float normalizedDepth = texture2D( tDepth, vUv).x ; 
-                
+
                 vec4 ndc = vec4(
                     (vUv.x - 0.5) * 2.0,
                     (vUv.y - 0.5) * 2.0,
@@ -105,9 +106,28 @@ export function buildScreenSpaceFogOfWarShader() {
 	     }
 	     	        
         void main(){
+            float sceneDepth = texture2D( tDepth, vUv ).x;
+
+            // NOTHING WAS DRAWN HERE. The depth is the buffer's clear value, so
+            // the position reconstructed from it lands on the far plane: a point
+            // with no relationship to the scene, whose fog lookup is whatever the
+            // sampler's clamp happens to return. In a world with a visible
+            // boundary that is the concealed border ring, and it gets painted
+            // across the entire void as a hard rectangle on the world's edge.
+            // Under Extend, leave such a pixel alone rather than fog it on the
+            // strength of a reconstruction that means nothing.
+            //
+            // Under Conceal this branch never taken, so the legacy path is
+            // bit-identical — including the one case Extend gives up, a real
+            // surface sitting exactly on the far plane.
+            if (uEdgeExtend > 0.5 && sceneDepth >= 1.0) {
+                gl_FragColor = vec4(0.0);
+                return;
+            }
+
             //get world fragment position
-            vec3 worldPosition = computeWorldPosition();
-            
+            vec3 worldPosition = computeWorldPosition(sceneDepth);
+
             vec2 fogUv = worldPosition.xz * uFogUvTransform.zw + uFogUvTransform.xy;
             
             float fogValue = getFog( fogUv );
@@ -144,6 +164,11 @@ export function buildScreenSpaceFogOfWarShader() {
         uViewInverse: { type: 'm4', value: new Matrix4() },
         uProjectionInverse: { type: 'm4', value: new Matrix4() },
         uColor: { type: 'c', value: new Vector4(0, 0, 0, 1) },
+        /**
+         * {@link FogOfWarEdgeMode} as a float. Defaults to Conceal, so a consumer
+         * that never sets it keeps the pre-option behaviour.
+         */
+        uEdgeExtend: { type: 'f', value: 0 },
         uFogUvTransform: { type: 'v4', value: new Vector4(0, 0, 1, 1) },
         /**
          * Fog texture resolution

package/src/engine/ecs/storage/binary/collection/BinaryCollectionDeSerializer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinaryCollectionDeSerializer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/storage/binary/collection/BinaryCollectionDeSerializer.js"],"names":[],"mappings":"AAkBA;;;;GAIG;AACH;IAEI;;;OAGG;IACH,iBAAgB;IAEhB;;;OAGG;IACH,eAAc;IAEd;;;;OAIG;IACH,4BAA4B;IAC5B;;;;OAIG;IACH,0BAA0B;IAE1B;;;OAGG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,gBAAe;IAEf;;;OAGG;IACH,kBAAiB;IAEjB;;;;OAIG;IACH,yBAAsC;IACtC;;;;OAIG;IACH,yBAAsC;IAEtC;;;OAGG;IACH,cAAsB;IAGtB;;;OAGG;IACH,yDAKC;IAED;;;OAGG;IACH,2CAEC;IAED;;;OAGG;IACH,kBAFW,YAAY,QAOtB;IAED;;;OAGG;IACH,mBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAFa,WAAS,IAAI,CAUzB;IAED;;;OAGG;IACH,wDAFyB,MAAM,QAgF9B;IAED,iBAWC;IAED;;;OAGG;IACH,uBAeC;IAED;;;OAGG;IACH;;aAF6B,MAAM;MA8DlC;CAEJ;6BAvV4B,4CAA4C"}
+{"version":3,"file":"BinaryCollectionDeSerializer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/storage/binary/collection/BinaryCollectionDeSerializer.js"],"names":[],"mappings":"AAkBA;;;;GAIG;AACH;IAEI;;;OAGG;IACH,iBAAgB;IAEhB;;;OAGG;IACH,eAAc;IAEd;;;;OAIG;IACH,4BAA4B;IAC5B;;;;OAIG;IACH,0BAA0B;IAE1B;;;OAGG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,gBAAe;IAEf;;;OAGG;IACH,kBAAiB;IAEjB;;;;OAIG;IACH,yBAAsC;IACtC;;;;OAIG;IACH,yBAAsC;IAEtC;;;OAGG;IACH,cAAsB;IAGtB;;;OAGG;IACH,yDAKC;IAED;;;OAGG;IACH,2CAEC;IAED;;;OAGG;IACH,kBAFW,YAAY,QAOtB;IAED;;;OAGG;IACH,mBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAFa,WAAS,IAAI,CAUzB;IAED;;;OAGG;IACH,wDAFyB,MAAM,QAgF9B;IAED,iBAWC;IAED;;;OAGG;IACH,uBAeC;IAED;;;OAGG;IACH;;aAF6B,MAAM;MAgElC;CAEJ;6BAzV4B,4CAA4C"}

package/src/engine/ecs/storage/binary/collection/BinaryCollectionDeSerializer.js

@@ -315,7 +315,9 @@ export class BinaryCollectionDeSerializer {
                     header = buffer.readUint32LE();
                 }
 
-                const offset = header >> 2;
+                // unsigned: for a first-occurrence offset >= 2^29 the header sets bit 31, and a signed
+                // shift would sign-extend it into a negative (wrong) offset
+                const offset = header >>> 2;
 
                 //read address
                 const address = offset + this.startAddress;

package/src/engine/graphics/GraphicsEngine.d.ts

@@ -35,7 +35,11 @@ export class GraphicsEngine {
      */
     pixelRatio: Vector1;
     /**
-     * Final render-target resolution, in device pixels: `viewport.size × pixelRatio × devicePixelRatio`.
+     * Final render-target resolution, in whole device pixels: `viewport.size × pixelRatio ×
+     * devicePixelRatio`, floored and clamped the same way the attachments themselves are. This is
+     * the authority every full-resolution buffer is sized from -- frame buffers, composit layers,
+     * and anything that has to sample them on their own texel grid. Zero until the viewport has
+     * been sized for the first time.
      * Kept in sync by {@link GraphicsEngine#updateSize}. Subscribe to `output_resolution.onChanged` to
      * react to any change in the actual rendered resolution (viewport resize, supersample, or DPR change).
      * @readonly

package/src/engine/graphics/GraphicsEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics/GraphicsEngine.js"],"names":[],"mappings":"AAiEA;IAOI;;;;;OAKG;IACH,+BAJW,MAAM,EAgLhB;IAtLD,gCAEC;IAgBG;;;;OAIG;IACH,2BAA+C;IAK/C;;;;;QAOI;;WAEG;;QAEH;;WAEG;;;;;MAMN;IAED;;OAEG;IACH,YAFU,OAAO,CAEe;IAEhC;;;;;;OAMG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;OAGG;IACH,QAFU,kBAAkB,CAEU;IAWtC;;;OAGG;IACH,aAAkB;IAGlB;;;OAGG;IACH,cAFU,KAAK,CAEgB;IAK/B;;;OAGG;IACH,QAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,UAFU,aAAa,CAEH;IAGpB,+BAA0C;IAU1C;;OAEG;IACH,eAA+B;IAI/B;;;OAGG;IACH,uBAFU,kBAAkB,CAEgB;IAE5C;;;OAGG;IACH,oBAFU,iBAAiB,CAEsB;IAEjD;;;OAGG;IACH,gBAFU,iBAAiB,CAES;IAEpC;;;OAGG;IACH,sBAAoC;IAGpC;;;;OAIG;IACH,UAFU,OAAO,CAEG;IAEpB;;;OAGG;IACH,UAFU,OAAO,CAEG;IAEpB;;;OAGG;IACH,YAFU,MAAM,CAEG;IACnB,kKAcI;IAGR;;;OAGG;IACH,sBAFa,eAAe,CAI3B;IAED;;;OAGG;IACH,eAFa,aAAa,CAIzB;IAED;;;;;;;;;;;;;OAaG;IACH,iCAHW,MAAM,OAAO,eACb,4BAA4B,QAkCtC;IAED,mBA8BC;IAED;;;;OAIG;IACH,iCAEC;IAED;;;OAGG;IACH,0BAFa,MAAM,CAIlB;IAED,+BAcC;IAED,cAgEC;IAzBsB,8BAA0C;IA2BjE;;;OAGG;IACH,cAFa,MAAM,CAYlB;IAED;;OAEG;IACH,aAQC;IAED;;OAEG;IACH,yBAQC;IAED;;;;;;OAMG;IACH,yBALW,MAAM,KACN,MAAM,6CAMhB;IAED;;;;OAIG;IACH,8BAHW,OAAO,UAAQ,UACf,OAAO,UAAQ,QAczB;IAED;;;;;OAKG;IACH,8BAQC;IAED,0BAEC;IAED;;;OAGG;IACH,4BAFW,cAAc,QA8BxB;IAED;;OAEG;IACH,qBAqBC;IAED;;OAEG;IACH,0BAeC;IAED;;OAEG;IACH,eA8CC;;CACJ;mBA7oBkB,oCAAoC;oBACnC,4BAA4B;wBACxB,4BAA4B;mCAajB,uCAAuC;sBAlBnE,OAAO;uBAaS,wBAAwB;8BAbxC,OAAO;4BAYc,+BAA+B;mCAKxB,uCAAuC;kCAKxC,gCAAgC;kCADhC,oCAAoC;gCAPtC,uCAAuC;6CAW1B,2CAA2C;+BANzD,4BAA4B"}
+{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics/GraphicsEngine.js"],"names":[],"mappings":"AAiEA;IAOI;;;;;OAKG;IACH,+BAJW,MAAM,EAoLhB;IA1LD,gCAEC;IAgBG;;;;OAIG;IACH,2BAA+C;IAK/C;;;;;QAOI;;WAEG;;QAEH;;WAEG;;;;;MAMN;IAED;;OAEG;IACH,YAFU,OAAO,CAEe;IAEhC;;;;;;;;;;OAUG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;OAGG;IACH,QAFU,kBAAkB,CAEU;IAWtC;;;OAGG;IACH,aAAkB;IAGlB;;;OAGG;IACH,cAFU,KAAK,CAEgB;IAK/B;;;OAGG;IACH,QAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,UAFU,aAAa,CAEH;IAGpB,+BAA0C;IAU1C;;OAEG;IACH,eAA+B;IAI/B;;;OAGG;IACH,uBAFU,kBAAkB,CAEgB;IAE5C;;;OAGG;IACH,oBAFU,iBAAiB,CAEsB;IAEjD;;;OAGG;IACH,gBAFU,iBAAiB,CAES;IAEpC;;;OAGG;IACH,sBAAoC;IAGpC;;;;OAIG;IACH,UAFU,OAAO,CAEG;IAEpB;;;OAGG;IACH,UAFU,OAAO,CAEG;IAEpB;;;OAGG;IACH,YAFU,MAAM,CAEG;IACnB,kKAcI;IAGR;;;OAGG;IACH,sBAFa,eAAe,CAI3B;IAED;;;OAGG;IACH,eAFa,aAAa,CAIzB;IAED;;;;;;;;;;;;;OAaG;IACH,iCAHW,MAAM,OAAO,eACb,4BAA4B,QAkCtC;IAED,mBAqCC;IAED;;;;OAIG;IACH,iCAEC;IAED;;;OAGG;IACH,0BAFa,MAAM,CAIlB;IAED,+BAcC;IAED,cAgEC;IAzBsB,8BAA0C;IA2BjE;;;OAGG;IACH,cAFa,MAAM,CAYlB;IAED;;OAEG;IACH,aAQC;IAED;;OAEG;IACH,yBAQC;IAED;;;;;;OAMG;IACH,yBALW,MAAM,KACN,MAAM,6CAMhB;IAED;;;;OAIG;IACH,8BAHW,OAAO,UAAQ,UACf,OAAO,UAAQ,QAczB;IAED;;;;;OAKG;IACH,8BAQC;IAED,0BAEC;IAED;;;OAGG;IACH,4BAFW,cAAc,QA8BxB;IAED;;OAEG;IACH,qBAqBC;IAED;;OAEG;IACH,0BAeC;IAED;;OAEG;IACH,eA8CC;;CACJ;mBAxpBkB,oCAAoC;oBACnC,4BAA4B;wBACxB,4BAA4B;mCAajB,uCAAuC;sBAlBnE,OAAO;uBAaS,wBAAwB;8BAbxC,OAAO;4BAYc,+BAA+B;mCAKxB,uCAAuC;kCAKxC,gCAAgC;kCADhC,oCAAoC;gCAPtC,uCAAuC;6CAW1B,2CAA2C;+BANzD,4BAA4B"}

package/src/engine/graphics/GraphicsEngine.js

@@ -121,7 +121,11 @@ export class GraphicsEngine {
         this.pixelRatio = new Vector1(1);
 
         /**
-         * Final render-target resolution, in device pixels: `viewport.size × pixelRatio × devicePixelRatio`.
+         * Final render-target resolution, in whole device pixels: `viewport.size × pixelRatio ×
+         * devicePixelRatio`, floored and clamped the same way the attachments themselves are. This is
+         * the authority every full-resolution buffer is sized from -- frame buffers, composit layers,
+         * and anything that has to sample them on their own texel grid. Zero until the viewport has
+         * been sized for the first time.
          * Kept in sync by {@link GraphicsEngine#updateSize}. Subscribe to `output_resolution.onChanged` to
          * react to any change in the actual rendered resolution (viewport resize, supersample, or DPR change).
          * @readonly
@@ -342,8 +346,15 @@ export class GraphicsEngine {
         this.frameBuffers.setSize(_w, _h);
 
         // publish the final device-pixel render resolution; `_w/_h` already fold in the engine pixelRatio,
-        // so this matches the framebuffers/composit layers and what getResolution historically computed
-        this.output_resolution.set(_w * devicePixelRatio, _h * devicePixelRatio);
+        // so this matches the framebuffers/composit layers and what getResolution historically computed.
+        // Floored for the same reason three.js floors the drawing buffer: these are whole texels, and
+        // every buffer sized off this value must land on exactly the same grid. Clamped to 1 to match
+        // those buffers too -- a collapsed viewport still allocates 1x1 attachments, because a 0-sized
+        // one trips GL_INVALID_FRAMEBUFFER_OPERATION on clear/draw
+        this.output_resolution.set(
+            max2(1, Math.floor(_w * devicePixelRatio)),
+            max2(1, Math.floor(_h * devicePixelRatio))
+        );
     }
 
     /**

package/src/engine/graphics/composit/CompositLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CompositLayer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/composit/CompositLayer.js"],"names":[],"mappings":"AAsCA;IACI;;;;;OAKG;IACH,2DAJW,MAAM,iBAAiB,EAyDjC;IAhDG;;;OAGG;IACH,MAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,YAFU,YAAY,CAEI;IAC1B;;;OAGG;IACH,gCAAgC;IAEhC;;;OAGG;IACH,mBAFU,MAAM,CAE0B;IAE1C,6DAA2E;IAE3E;;;OAGG;IACH,OAFU,MAAM,CAEF;IAEd,cAAyB;IAEzB;;;OAGG;IACH,WAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,SAFU,MAAM,CAEA;IAEhB;;MAEC;IAOL,0BAQC;IAZD,uBAEC;IAYD;;;OAGG;IACH,uBAIC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,0BAMC;IAED;;;OAGG;IACH,uBAEC;IAED,eAKC;IAED,gBAKC;IAED;;;;OAIG;IACH,WAHW,MAAM,KACN,MAAM,QAKhB;IAED,+BAaC;IAED;;;OAGG;IACH,4BAFW,MAAM,QAShB;IAED;;;;OAIG;IACH,4CAKC;IAGD,gCAoCC;CACJ;6BA/O4B,oCAAoC;+BAN1D,OAAO;qBAAP,OAAO;oBAGM,+BAA+B;mBADhC,uCAAuC"}
+{"version":3,"file":"CompositLayer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/composit/CompositLayer.js"],"names":[],"mappings":"AAsCA;IACI;;;;;OAKG;IACH,2DAJW,MAAM,iBAAiB,EAyDjC;IAhDG;;;OAGG;IACH,MAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,YAFU,YAAY,CAEI;IAC1B;;;OAGG;IACH,gCAAgC;IAEhC;;;OAGG;IACH,mBAFU,MAAM,CAE0B;IAE1C,6DAA2E;IAE3E;;;OAGG;IACH,OAFU,MAAM,CAEF;IAEd,cAAyB;IAEzB;;;OAGG;IACH,WAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,SAFU,MAAM,CAEA;IAEhB;;MAEC;IAOL,0BAQC;IAZD,uBAEC;IAYD;;;OAGG;IACH,uBAIC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,0BAMC;IAED;;;OAGG;IACH,uBAEC;IAED,eAKC;IAED,gBAKC;IAED;;;;OAIG;IACH,WAHW,MAAM,KACN,MAAM,QAKhB;IAED,+BAgBC;IAED;;;OAGG;IACH,4BAFW,MAAM,QAShB;IAED;;;;OAIG;IACH,4CAKC;IAGD,gCAoCC;CACJ;6BAlP4B,oCAAoC;+BAN1D,OAAO;qBAAP,OAAO;oBAGM,+BAA+B;mBADhC,uCAAuC"}