@woosh/meep-engine 2.33.38 → 2.33.42

package/core/bvh2/binary/2/BinaryUint32BVH.js

@@ -434,11 +434,11 @@ export class BinaryUint32BVH {
      * Assemble leaf nodes into hierarchy, set binary node bounds iteratively bottom up
      */
     build() {
-        const nodeCount = this.__node_count_binary;
+        const binary_node_count = this.__node_count_binary;
 
-        const leaf_node_block_address = this.__node_count_binary * BVH_BINARY_NODE_SIZE;
+        const leaf_node_block_address = binary_node_count * BVH_BINARY_NODE_SIZE;
 
-        let level = Math.floor(Math.log(nodeCount) / Math.log(2));
+        let level = Math.floor(Math.log(binary_node_count) / Math.log(2));
 
         let i, offset, level_node_count;
         //NOTE: building first level separately allows to avoid some switching logic needed to determine what is the type of lower level node

package/core/collection/array/typed/typed_array_copy.js

@@ -3,8 +3,8 @@ import { array_copy } from "../copyArray.js";
 
 /**
  * Assumes arrays have the same type
- * @param {TypedArray|Float32Array} source
- * @param {TypedArray|Float32Array} destination
+ * @param {TypedArray|Float32Array|Uint8Array} source
+ * @param {TypedArray|Float32Array|Uint8Array} destination
  */
 export function typed_array_copy(source, destination) {
     const destination_size = destination.length;

package/core/geom/3d/aabb/aabb3_matrix4_project_by_corners.js

@@ -4,7 +4,7 @@ import { assert } from "../../../assert.js";
  *
  * @param {number[]|Float32Array} result
  * @param {number[]|Float32Array|Float64Array} aabb_corners
- * @param {number[]|Float32Array} projection_matrix
+ * @param {number[]|Float32Array|mat4} projection_matrix
  */
 export function aabb3_matrix4_project_by_corners(result, aabb_corners, projection_matrix) {
     assert.greaterThanOrEqual(result.length, 6, 'result.length must >= 6');

package/core/geom/3d/morton/mortonEncode_magicbits.js

@@ -1,10 +1,12 @@
 /**
  * method to separate bits from a given integer 3 positions apart
  * we only look at the first 10 bits
+ *
+ * @example when input is ABC, output bits are A00B00C
  * @param {number} a
  * @returns {number}
  */
-function splitBy3(a) {
+function split_by_3(a) {
     let x = a;
     x = (x | x << 16) & 0x30000ff;
     x = (x | x << 8) & 0x0300f00f;
@@ -25,10 +27,9 @@ function splitBy3(a) {
  */
 export function mortonEncode_magicbits(x, y, z) {
 
-    const x_bits = splitBy3(x);
-    const y_bits = splitBy3(y) << 1;
-    const z_bit = splitBy3(z) << 2;
-
-    return x_bits | y_bits | z_bit;
+    const x_bits = split_by_3(x);
+    const y_bits = split_by_3(y) << 1;
+    const z_bits = split_by_3(z) << 2;
 
+    return x_bits | y_bits | z_bits;
 }

package/core/geom/3d/morton/v3_morton_encode_transformed.js

@@ -1,4 +1,5 @@
 import { mortonEncode_magicbits } from "./mortonEncode_magicbits.js";
+import { clamp } from "../../../math/clamp.js";
 
 /**
  * Assumes that coordinates will be mapped to -1..1 range after transform
@@ -16,18 +17,21 @@ export function v3_morton_encode_transformed(x, y, z, matrix) {
     const _z = matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14];
     const _w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
 
-    const d = 1 / _w;
+    const d = 511.5 / _w;
 
-    // apply perspective divide, values are now in Normalized Coordinate system (-1,1)
-    const px = _x * d;
-    const py = _y * d;
-    const pz = _z * d;
+    // apply perspective divide as well as scaling to 10 bits
+    const ndc_x = _x * d;
+    const ndc_y = _y * d;
+    const ndc_z = _z * d;
 
-    // scale each value up to 10 bits (for 10 bits, the multiplier = 1024. As we have -1,1 range, we do (v+1)/2. 1024/2 = 512)
+    // Normalize values (0,1023) and clamp to prevent wrapping
+    const px = clamp(ndc_x + 511.5, 0, 1023);
+    const py = clamp(ndc_y + 511.5, 0, 1023);
+    const pz = clamp(ndc_z + 511.5, 0, 1023);
 
-    const cx = ((px + 1) * 512) | 0;
-    const cy = ((py + 1) * 512) | 0;
-    const cz = ((pz + 1) * 512) | 0;
-
-    return mortonEncode_magicbits(cx, cy, cz);
+    return mortonEncode_magicbits(
+        Math.round(px),
+        Math.round(py),
+        Math.round(pz)
+    );
 }

package/core/geom/3d/tetrahedra/tetrahedra_collection.js

@@ -2,18 +2,34 @@ import { tetrahedron_contains_point } from "./tetrahedron_contains_point.js";
 import { assert } from "../../../assert.js";
 import { point_in_tetrahedron_circumsphere } from "./point_in_tetrahedron_circumsphere.js";
 import { BitSet } from "../../../binary/BitSet.js";
+import { typed_array_copy } from "../../../collection/array/typed/typed_array_copy.js";
+import { max3 } from "../../../math/max3.js";
 
 /**
  * @readonly
  * @type {number}
  */
 const LAYOUT_TETRA_BYTE_SIZE = 9 * 4;
+
+/**
+ * @readonly
+ * @type {number}
+ */
 const INVALID_NEIGHBOUR = 0xFFFFFFFF;
 
 class Cavity {
     constructor() {
         this.indices = [];
-        this.__size = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.size = 0;
+    }
+
+    update() {
+        // compute in/out state for each side of each tetra
     }
 
     /**
@@ -21,7 +37,7 @@ class Cavity {
      * @param {number} i
      */
     push(i) {
-        this.indices[this.__size++] = i;
+        this.indices[this.size++] = i;
     }
 
     /**
@@ -30,7 +46,7 @@ class Cavity {
      * @returns {boolean}
      */
     includes(i) {
-        const n = this.__size;
+        const n = this.size;
         for (let j = 0; j < n; j++) {
             if (this.indices[j] === i) {
                 return true;
@@ -41,7 +57,7 @@ class Cavity {
     }
 
     reset() {
-        this.__size = 0;
+        this.size = 0;
     }
 }
 
@@ -63,7 +79,7 @@ const SCRATCH_CAVITY = new Cavity();
  */
 export class TetrahedraCollection {
     constructor(initial_size) {
-        this.__buffer = new ArrayBuffer(initial_size * 4 * 9);
+        this.__buffer = new ArrayBuffer(initial_size * LAYOUT_TETRA_BYTE_SIZE);
 
         this.__view = new DataView(this.__buffer);
 
@@ -79,6 +95,49 @@ export class TetrahedraCollection {
         this.__occupancy = new BitSet();
     }
 
+    /**
+     *
+     * @param {number} n
+     */
+    setCapacity(n) {
+        if (n === this.__capacity) {
+            // do nothing
+            return;
+        }
+
+        if (n < this.__length) {
+            throw new Error('Dropping information, not supported');
+        }
+
+        // allocate new buffer
+        const new_buffer = new ArrayBuffer(n * LAYOUT_TETRA_BYTE_SIZE);
+
+        // move data across from old buffer to the new one
+        const destination_uint8 = new Uint8Array(new_buffer);
+        const source_uint8 = new Uint8Array(this.__buffer);
+
+        typed_array_copy(source_uint8, destination_uint8);
+
+        // set new buffer
+        this.__buffer = new_buffer;
+        this.__view = new DataView(new_buffer);
+    }
+
+    /**
+     *
+     * @param {number} n
+     */
+    ensureCapacity(n) {
+
+        const new_capacity = max3(
+            n,
+            this.__capacity * 1.2,
+            this.__capacity + 32
+        );
+
+        this.setCapacity(new_capacity);
+    }
+
     /**
      *
      * @param {number} tetra_index
@@ -90,6 +149,17 @@ export class TetrahedraCollection {
         return this.__view.getUint32(tetra_address + (4 + neighbour_index) * 4);
     }
 
+    /**
+     *
+     * @param {number} tetra_index
+     * @param {number} neighbour_index which neighbour to set (0..11)
+     * @param {number} neighbour index of the neighbour
+     */
+    setNeighbour(tetra_index, neighbour_index, neighbour) {
+        const tetra_address = LAYOUT_TETRA_BYTE_SIZE * tetra_index;
+        return this.__view.setUint32(tetra_address + (4 + neighbour_index) * 4, neighbour);
+    }
+
     /**
      *
      * @param {number[]|Float32Array} points
@@ -97,12 +167,16 @@ export class TetrahedraCollection {
      * @param {number} b
      * @param {number} c
      * @param {number} d
+     * @returns {number} index of the new tetra
      */
     append(points, a, b, c, d) {
-        const tetra_index = this.__length;
+        const tetra_index = this.__occupancy.nextClearBit(0);
         const address = tetra_index * LAYOUT_TETRA_BYTE_SIZE;
 
-        // TODO check if there's enough room
+        if (tetra_index >= this.__capacity) {
+            // needs to be increased in size
+            this.ensureCapacity(tetra_index);
+        }
 
         const view = this.__view;
 
@@ -120,6 +194,8 @@ export class TetrahedraCollection {
         this.__occupancy.set(tetra_index, true);
 
         this.__length++;
+
+        return tetra_index;
     }
 
     /**
@@ -127,7 +203,27 @@ export class TetrahedraCollection {
      * @param {number} tera_index
      */
     remove(tera_index) {
+
+        // find neighbours and remove reference to self
+        for (let i = 0; i < 4; i++) {
+            const neighbour_encoded = this.getNeighbour(tera_index, i);
+
+            if (neighbour_encoded === INVALID_NEIGHBOUR) {
+                // no neighbour
+                continue;
+            }
+
+            // get tetrahedra index and point index
+            const neighbour_index = neighbour_encoded >> 2;
+            const neighbour_point = neighbour_encoded & 4;
+
+            // clear reference to self
+            this.setNeighbour(neighbour_index, neighbour_point, INVALID_NEIGHBOUR);
+        }
+
+        // mark as dead
         this.__occupancy.clear(tera_index);
+        this.__length--;
     }
 
     /**
@@ -140,12 +236,11 @@ export class TetrahedraCollection {
     removeTetrasConnectedToPoints(points, range_start, range_end) {
         const data_view = this.__view;
 
-        const n = this.__length;
-
         let i = 0;
         let j = 0;
 
-        for (; i < n; i++) {
+        const occupancy = this.__occupancy;
+        for (i = occupancy.nextSetBit(0); i !== -1; i = occupancy.nextSetBit(i + 1)) {
 
             const tet_address = i * LAYOUT_TETRA_BYTE_SIZE;
 
@@ -155,6 +250,7 @@ export class TetrahedraCollection {
                 if (point_index >= range_start && point_index <= range_end) {
                     // point index is in range, tetra should be removed
                     this.remove(i);
+                    break;
                 }
             }
         }
@@ -228,18 +324,19 @@ export class TetrahedraCollection {
 
             // get neighbours
             for (let i = 0; i < 4; i++) {
-                const neighbour = this.getNeighbour(tetra, i);
+                const neighbour_encoded = this.getNeighbour(tetra, i);
+                const neighbour_tetra_index = neighbour_encoded >> 2;
 
                 if (
-                    (neighbour === INVALID_NEIGHBOUR) // no neighbour
-                    || closed_set.includes(neighbour)   // already visited
-                    || open_set.includes(neighbour) // already in open set
+                    (neighbour_encoded === INVALID_NEIGHBOUR) // no neighbour
+                    || closed_set.includes(neighbour_tetra_index)   // already visited
+                    || open_set.includes(neighbour_tetra_index) // already in open set
                 ) {
 
                     continue;
                 }
 
-                const neighbour_address = neighbour * LAYOUT_TETRA_BYTE_SIZE;
+                const neighbour_address = neighbour_tetra_index * LAYOUT_TETRA_BYTE_SIZE;
 
                 const a = data_view.getUint32(neighbour_address);
                 const b = data_view.getUint32(neighbour_address + 4);
@@ -250,10 +347,10 @@ export class TetrahedraCollection {
                 const is_in_sphere = point_in_tetrahedron_circumsphere(points, a, b, c, d, index);
 
                 if (is_in_sphere) {
-                    open_set.push(neighbour);
+                    open_set.push(neighbour_tetra_index);
                 } else {
                     // move directly to closed set
-                    closed_set.push(neighbour);
+                    closed_set.push(neighbour_tetra_index);
                 }
 
 
@@ -270,10 +367,88 @@ export class TetrahedraCollection {
         // Compute the cavity, that is the set of tetrahedra that need to be removed and rebuilt
         this.computeCavity(SCRATCH_CAVITY, points, index);
 
+
         // identify cavity "edge" - the set of tetras that are neighbours of the tetras that form the cavity
+        const cavity_size = SCRATCH_CAVITY.size;
+        const cavity_indices = SCRATCH_CAVITY.indices;
+        const data = this.__view;
+
+        for (let i = 0; i < cavity_size; i++) {
+            const cavity_index = cavity_indices[i];
+
+            // take each side of the tetra
+            const tetra_address = cavity_index * LAYOUT_TETRA_BYTE_SIZE;
+
+            const a = data.getUint32(tetra_address);
+            const b = data.getUint32(tetra_address + 4);
+            const c = data.getUint32(tetra_address + 8);
+            const d = data.getUint32(tetra_address + 12);
+
+            // attempt to form 4 tetras using the sides of the cavity
+            const a_neighbour = data.getUint32(tetra_address + 16);
+            const a_neighbour_index = a_neighbour >> 2;
+
+            const b_neighbour = data.getUint32(tetra_address + 20);
+            const b_neighbour_index = b_neighbour >> 2;
+
+            const c_neighbour = data.getUint32(tetra_address + 24);
+            const c_neighbour_index = c_neighbour >> 2;
+
+            const d_neighbour = data.getUint32(tetra_address + 28);
+            const d_neighbour_index = d_neighbour >> 2;
+
+
+            if (a_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(a_neighbour_index) === 0) {
+                // ABC is a valid side
+                const tet = this.append(points, b, d, c, index);
+                // patch in neighbours
+                if (a_neighbour !== INVALID_NEIGHBOUR) {
+                    this.setNeighbour(tet, 3, a_neighbour);
+                    this.setNeighbour(a_neighbour_index, a_neighbour & 3, tet);
+                }
+            }
+            if (b_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(b_neighbour_index) === 0) {
+                // ABC is a valid side
+                const tet = this.append(points, c, d, a, index);
+                if (b_neighbour !== INVALID_NEIGHBOUR) {
+                    this.setNeighbour(tet, 3, b_neighbour);
+                    this.setNeighbour(b_neighbour_index, b_neighbour & 3, tet);
+                }
+            }
+            if (c_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(c_neighbour_index) === 0) {
+                // ABC is a valid side
+                const tet = this.append(points, d, b, a, index);
+                if (c_neighbour !== INVALID_NEIGHBOUR) {
+                    this.setNeighbour(tet, 3, c_neighbour);
+                    this.setNeighbour(c_neighbour_index, c_neighbour & 3, tet);
+                }
+            }
+            if (d_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(d_neighbour_index) === 0) {
+                // ABC is a valid side
+                const tet = this.append(points, a, b, c, index);
+                if (d_neighbour !== INVALID_NEIGHBOUR) {
+                    this.setNeighbour(tet, 3, d_neighbour);
+                    this.setNeighbour(d_neighbour_index, d_neighbour & 3, tet);
+                }
+            }
+        }
+
 
         // 3. remove the cavity tetrahedrons
+        for (let i = 0; i < cavity_size; i++) {
+            const cavity_index = cavity_indices[i];
+
+            // clear out cavity, connectivity was already patched in the previous step
+            this.__occupancy.set(cavity_index, false);
+        }
+    }
+
+    /**
+     * optimize tetrahedrons to reduce number of thin and long tetras
+     * @see https://gitlab.onelab.info/gmsh/gmsh/-/blob/master/contrib/hxt/tetMesh/src/HXTSPR.c
+     */
+    optimize() {
 
-        // 4. fill the cavity by creating new tetrahedrons connecting the point to the faces of cavity boundary
+        throw new Error('Not Implemented');
     }
 }

package/core/geom/3d/tetrahedra/tetrahedron_contains_point.js

@@ -17,7 +17,8 @@ import { orient3d_fast } from "../plane/orient3d_fast.js";
  * @returns {boolean}
  */
 export function tetrahedron_contains_point(points, a, b, c, d, e) {
-    return !(orient3d_fast(points, b, d, c, e) > 0
+    return !(
+        orient3d_fast(points, b, d, c, e) > 0
         || orient3d_fast(points, c, d, a, e) > 0
         || orient3d_fast(points, d, b, a, e) > 0
         || orient3d_fast(points, a, b, c, e) > 0

package/engine/asset/loaders/GLTFAssetLoader.js

@@ -337,16 +337,12 @@ export class GLTFAssetLoader extends AssetLoader {
                 return;
             }
 
-            //find a child that is a mesh
-            const meshes = scene.children.filter(isMesh);
 
-            let root;
+            let root = scene;
 
-            if (meshes.length !== 1) {
-                //use the whole scene
-                root = scene;
-            } else {
-                root = meshes[0];
+            if (children.length === 1 && isMesh(children[0])) {
+                // scene only contains a single mesh, use that directly
+                root = children[0];
             }
 
             traverseThreeObject(root, this.__prepareObjectMaterial, this);

package/engine/ecs/System.d.ts

@@ -1,3 +1,26 @@
-export class System {
+import {EntityManager} from "./EntityManager";
 
+interface Type<T> extends Function {
+    new(...args: any[]): T;
+}
+
+export class System<A, B = any, C = any, D = any, E = any> {
+    dependencies: Type<any>[]
+
+    startup(em: EntityManager, ready_callback: () => void, error_callback: () => void): void
+
+    shutdown(em: EntityManager, ready_callback: () => void, error_callback: () => void): void
+
+    link(a: A, entity: number): void
+    link(a: A, b: B, entity: number): void
+    link(a: A, b: B, c: C, entity: number): void
+    link(a: A, b: B, c: C, d: D, entity: number): void
+    link(a: A, b: B, c: C, d: D, e: E, entity: number): void
+
+    unlink(a: A, entity: number): void
+    unlink(a: A, b: B, entity: number): void
+    unlink(a: A, b: B, c: C, d: D, entity: number): void
+    unlink(a: A, b: B, c: C, d: D, e: E, entity: number): void
+
+    update(time_delta: number): void
 }

package/engine/graphics/ecs/light/binding/fp/FPLightBinding.js

@@ -1,5 +1,5 @@
 import { LightBinding } from "../LightBinding.js";
-import { PointLight } from "../../../../render/forward_plus/PointLight.js";
+import { PointLight } from "../../../../render/forward_plus/model/PointLight.js";
 
 export class FPLightBinding extends LightBinding {
     constructor() {

package/engine/graphics/particles/particular/engine/parameter/ParameterLookupTable.js

@@ -2,7 +2,6 @@ import { inverseLerp } from "../../../../../../core/math/inverseLerp.js";
 import { assert } from "../../../../../../core/assert.js";
 import { max2 } from "../../../../../../core/math/max2.js";
 import { min2 } from "../../../../../../core/math/min2.js";
-import { mix } from "../../../../../../core/math/mix.js";
 import { ParameterLookupTableFlags } from "./ParameterLookupTableFlags.js";
 import { ParameterLookupTableSerializationAdapter } from "../emitter/serde/ParameterLookupTableSerializationAdapter.js";
 import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
@@ -125,7 +124,7 @@ export class ParameterLookupTable {
      */
     sample(position, result) {
         assert.isNumber(position, 'position');
-        assert.greaterThanOrEqual(position, 0, 'position');
+        // assert.greaterThanOrEqual(position, 0, 'position');
         // assert.ok(position >= 0 && position <= 1, `position must be between 0 and 1, instead was ${position}`);
 
         const itemSize = this.itemSize;
@@ -140,32 +139,28 @@ export class ParameterLookupTable {
         let highIndex = lowIndex;
         let fraction = 0;
 
-        //find position index
-        for (i = 0; i < numValues; i++) {
-            //NOTE: no complex search is used, since for small data sizes linear scan is typically faster
-            const p = positions[i];
+        if (position <= positions[0]) {
 
-            if (p === position) {
+            // special case, seek position is at or before the start of the table
+            lowIndex = 0;
+            highIndex = 0;
 
-                // found the exact match
-                lowIndex = i;
-                highIndex = i;
-                fraction = 0;
-                break;
+        } else {
+
+            //find position index
+            for (i = 1; i < numValues; i++) {
+                //NOTE: no complex search is used, since for small data sizes linear scan is typically faster
+                const p = positions[i];
 
-            } else if (p > position) {
-                // next position if over the seek position
-                highIndex = i;
-                if (i === 0) {
-                    lowIndex = i;
-                    fraction = 0;
-                } else {
+                if (p >= position) {
+                    // next position if over the seek position
+                    highIndex = i;
                     lowIndex = i - 1;
-                    const prevPosition = positions[lowIndex];
-                    fraction = inverseLerp(prevPosition, p, position);
-                }
 
-                break;
+                    fraction = inverseLerp(positions[lowIndex], p, position);
+
+                    break;
+                }
             }
         }
 
@@ -177,7 +172,8 @@ export class ParameterLookupTable {
             const lowValue = data[low_offset + i];
             const highValue = data[high_offset + i];
 
-            const value = mix(lowValue, highValue, fraction);
+            // inlined for speed: mix(low, high, fraction)
+            const value = lowValue * (1 - fraction) + highValue * fraction;
 
             result[i] = value;
         }

package/engine/graphics/particles/particular/engine/shader/ShaderManager.js

@@ -117,7 +117,7 @@ export class ShaderManager {
             generateMipmaps: true,
             minFilter: LinearMipMapLinearFilter,
             magFilter: LinearFilter,
-            anisotropy: 0
+            anisotropy: 0 // sprites are always facing the screen, anisotropic filtering would be pointless
         });
 
         this.spriteTexture.name = 'Sprite sheet';

package/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -609,8 +609,8 @@ async function main(engine) {
 
     engine.graphics.renderer.setClearColor('rgba(99,99,99,1)');
 
-    // await sample_scene_nam(engine);
-    await sample_scene_0(engine);
+    await sample_scene_nam(engine);
+    // await sample_scene_0(engine);
 }
 
 /**

package/engine/graphics/render/buffer/simple-fx/DepthLimitedBlur.js

@@ -26,14 +26,16 @@ export class DepthLimitedBlur {
             uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
             defines: Object.assign({}, DepthLimitedBlurShader.defines),
             vertexShader: DepthLimitedBlurShader.vertexShader,
-            fragmentShader: DepthLimitedBlurShader.fragmentShader
+            fragmentShader: DepthLimitedBlurShader.fragmentShader,
+            blending: NoBlending
         });
 
         this.__material_blur_y = new ShaderMaterial({
             uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
             defines: Object.assign({}, DepthLimitedBlurShader.defines),
             vertexShader: DepthLimitedBlurShader.vertexShader,
-            fragmentShader: DepthLimitedBlurShader.fragmentShader
+            fragmentShader: DepthLimitedBlurShader.fragmentShader,
+            blending: NoBlending
         });
 
 
@@ -97,7 +99,10 @@ export class DepthLimitedBlur {
      */
     execute(renderer) {
         // update intermediate buffer size based on input size
-        if (this.__intermediate.width !== this.__rt_output.width || this.__intermediate.height !== this.__rt_output.height) {
+        if (
+            this.__intermediate.width !== this.__rt_output.width
+            || this.__intermediate.height !== this.__rt_output.height
+        ) {
             this.__intermediate.setSize(this.__rt_output.width, this.__rt_output.height);
         }
 
@@ -118,7 +123,7 @@ export class DepthLimitedBlur {
 
         renderer.setRenderTarget(this.__rt_output);
         renderer.clearColor();
-        
+
         renderScreenSpace(renderer, my);
 
         // restore state

package/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js

@@ -286,7 +286,13 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
 
         const size = graphics.viewport.size;
 
-        this.__render_target.setSize(size.x, size.y);
+        const target_resolution_x = Math.ceil(size.x * this.__resolution_scale);
+        const target_resolution_y = Math.ceil(size.y * this.__resolution_scale);
+
+        this.__render_target.setSize(
+            target_resolution_x,
+            target_resolution_y
+        );
     }
 
     async startup() {