@woosh/meep-engine 2.96.0 → 2.98.0

package/src/engine/graphics/ecs/camera/Camera.js

@@ -3,18 +3,18 @@
  */
 
 
-import {Frustum} from 'three';
-import {assert} from "../../../../core/assert.js";
-import {plane3_compute_ray_intersection} from "../../../../core/geom/3d/plane/plane3_compute_ray_intersection.js";
-import {v3_distance_above_plane} from "../../../../core/geom/vec3/v3_distance_above_plane.js";
+import { Frustum } from 'three';
+import { assert } from "../../../../core/assert.js";
+import { plane3_compute_ray_intersection } from "../../../../core/geom/3d/plane/plane3_compute_ray_intersection.js";
+import { v3_distance_above_plane } from "../../../../core/geom/vec3/v3_distance_above_plane.js";
 import Vector1 from "../../../../core/geom/Vector1.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 import ObservedBoolean from "../../../../core/model/ObservedBoolean.js";
 import ObservedEnum from "../../../../core/model/ObservedEnum.js";
-import {frustum_from_camera} from "./frustum_from_camera.js";
-import {invertQuaternionOrientation} from "./InvertQuaternionOrientation.js";
-import {ProjectionType} from "./ProjectionType.js";
-import {unprojectPoint} from "./unprojectPoint.js";
+import { frustum_from_camera } from "./frustum_from_camera.js";
+import { invertQuaternionOrientation } from "./InvertQuaternionOrientation.js";
+import { ProjectionType } from "./ProjectionType.js";
+import { unprojectPoint } from "./unprojectPoint.js";
 
 /**
  * @class
@@ -164,10 +164,14 @@ export class Camera {
      * @param {Camera|THREE.PerspectiveCamera|THREE.OrthographicCamera} camera
      * @param {number} x
      * @param {number} y
-     * @param {Vector3} source
-     * @param {Vector3} direction
+     * @param {Vector3} out_source
+     * @param {Vector3} out_direction
      */
-    static projectRay(camera, x, y, source, direction) {
+    static projectRay(
+        camera,
+        x, y,
+        out_source, out_direction
+    ) {
         assert.defined(camera, "camera");
         assert.defined(camera.position, "Camera.position");
 
@@ -182,7 +186,10 @@ export class Camera {
         // assert.ok(y <= 1, `Y(=${y}) must be less than or equal to 1.0, not a clip-space coordinate`);
 
         if (camera.isPerspectiveCamera || camera.isOrthographicCamera) {
-            scratch_v3_1.setFromMatrixPosition(camera.matrixWorld.elements);
+            const m4_world = camera.matrixWorld.elements;
+            const m4_projection_inverse = camera.projectionMatrixInverse.elements;
+
+            scratch_v3_1.setFromMatrixPosition(m4_world);
 
             scratch_v3_0.set(x, y, 0.5);
 
@@ -191,16 +198,16 @@ export class Camera {
             unprojectPoint(
                 scratch_v3_0,
                 scratch_v3_0,
-                camera.projectionMatrixInverse.elements,
-                camera.matrixWorld.elements
+                m4_projection_inverse,
+                m4_world
             );
 
             //get direction
             scratch_v3_0.sub(scratch_v3_1);
             scratch_v3_0.normalize();
 
-            source.copy(scratch_v3_1);
-            direction.copy(scratch_v3_0);
+            out_source.copy(scratch_v3_1);
+            out_direction.copy(scratch_v3_0);
 
         } else {
             throw new Error('Unsupported camera type');

package/src/engine/graphics/ecs/path/testPathDisplaySystem.js

@@ -1,3 +1,4 @@
+import { MeshStandardMaterial, OctahedronBufferGeometry } from "three";
 import '../../../../../../../../css/game.scss';
 import FacingDirectionSystem from "../../../../../../model/game/ecs/system/FacingDirectionSystem.js";
 import { makeEngineOptionsModel } from "../../../../../../model/game/options/makeEngineOptionsModel.js";
@@ -47,6 +48,7 @@ import Highlight from "../highlight/Highlight.js";
 import MeshHighlightSystem from "../highlight/system/MeshHighlightSystem.js";
 import { ShadedGeometryHighlightSystem } from "../highlight/system/ShadedGeometryHighlightSystem.js";
 import LightSystem from "../light/LightSystem.js";
+import { ShadedGeometry } from "../mesh-v2/ShadedGeometry.js";
 import { ShadedGeometrySystem } from "../mesh-v2/ShadedGeometrySystem.js";
 import Mesh from "../mesh/Mesh.js";
 import { MeshSystem } from "../mesh/MeshSystem.js";
@@ -412,7 +414,35 @@ function makePath({
     return new Entity()
         .add(_p)
         .add(pathDisplay)
-        .add(Highlight.fromOne(0, 1, 1, 1));
+    // .add(Highlight.fromOne(0, 1, 1, 1));
+
+}
+
+/**
+ *
+ * @param {Path} path
+ * @param {EntityComponentDataset} ecd
+ */
+function drawControlPoints(path, ecd) {
+
+    const point_count = path.getPointCount();
+
+    const geo = new OctahedronBufferGeometry(1, 3);
+    const mat = new MeshStandardMaterial({});
+
+    for (let i = 0; i < point_count; i++) {
+        const t = new Transform();
+
+        t.scale.setScalar(0.4);
+
+        path.getPosition(i, t.position);
+
+        new Entity()
+            .add(t)
+            .add(ShadedGeometry.from(geo, mat))
+            .build(ecd)
+    }
+
 
 }
 
@@ -424,18 +454,120 @@ function main(engine) {
     const cam = ecd.getAnyComponent(Camera);
     // cam.component.projectionType.set(ProjectionType.Orthographic);
 
+    const points = [
+        84,
+        20,
+        100,
+        68.36000061035156,
+        5.840000152587891,
+        31.1200008392334,
+        69.01000213623047,
+        8,
+        24.020000457763672,
+        88.19000244140625,
+        35,
+        22.729999542236328,
+        114.80999755859375,
+        35,
+        10.970000267028809,
+        71,
+        35,
+        -69.01000213623047,
+        -31.809999465942383,
+        25,
+        -27.850000381469727,
+        -11.130000114440918,
+        25,
+        30.770000457763672,
+        20.75,
+        25,
+        6.539999961853027,
+        13.0600004196167,
+        25,
+        -6.28000020980835,
+        7.75,
+        17.760000228881836,
+        14.109999656677246,
+        4.260000228881836,
+        10.529999732971191,
+        8.869999885559082,
+        -5.96999979019165,
+        8.079999923706055,
+        -2.180000066757202,
+        -5.369999885559082,
+        6.059999942779541,
+        -12.010000228881836,
+        -9.359999656677246,
+        6.059999942779541,
+        -12.369999885559082,
+        -10.579999923706055,
+        4.789999961853027,
+        -15.300000190734863,
+        -9.130000114440918,
+        4.639999866485596,
+        -16.350000381469727,
+        -9.119999885559082,
+        4.639999866485596,
+        -16.360000610351562,
+        -9.109999656677246,
+        4.639999866485596,
+        -16.360000610351562,
+        -9.100000381469727,
+        4.630000114440918,
+        -16.360000610351562,
+        -4.429999828338623,
+        5,
+        -9.720000267028809,
+        -7.309999942779541,
+        5,
+        6.059999942779541,
+        -4.170000076293945,
+        0.1599999964237213,
+        10.720000267028809,
+        -1.4600000381469727,
+        0.1599999964237213,
+        12.109999656677246,
+        -0.4399999976158142,
+        0.1599999964237213,
+        19.25,
+        0.5099999904632568,
+        0.1599999964237213,
+        21.65999984741211,
+        2,
+        0.1599999964237213,
+        21.56999969482422,
+        7.880000114440918,
+        2.859999895095825,
+        21.610000610351562,
+        12.039999961853027,
+        2.859999895095825,
+        21.860000610351562,
+        14.369999885559082,
+        3.2100000381469727,
+        21.760000228881836,
+        14.1899995803833,
+        4.440000057220459,
+        25.639999389648438,
+        14.130000114440918,
+        5.53000020980835,
+        29.149999618530273,
+        15.15999984741211,
+        7.159999847412109,
+        29.899999618530273,
+        19.540000915527344,
+        700,
+        51.060001373291016
+    ];
+
     makePath({
-        points: [
-            3, 1, 1,
-            3, 1, 3,
-            7, 1, 3,
-            7, 1, 7,
-            3, 1, 7,
-            3, 1, 8
-        ],
-        interp: InterpolationType.Linear
+        points: points,
+        interp: InterpolationType.CatmullRom
     }).build(ecd);
 
+    drawControlPoints(Path.fromJSON({
+        points
+    }), ecd);
+
     makePath({
         points: [
             17.600000381469727, 3.2100000381469727, -16.34000015258789,

package/src/engine/graphics/ecs/path/tube/build/TubePathBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TubePathBuilder.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/path/tube/build/TubePathBuilder.js"],"names":[],"mappings":"AAoFA;IAEQ;;;OAGG;IACH,OAFU,gBAAc,IAAI,CAEX;IAEjB;;;OAGG;IACH,MAFU,OAAK,IAAI,CAEH;IAEhB;;;OAGG;IACH,WAFU,kBAAgB,IAAI,CAET;IAErB;;;OAGG;IACH,cAFU,eAAa,IAAI,CAEH;IAG5B,yBAEC;IAED,2BAEC;IAED,2BAEC;IAED,yCAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,EAAE,QAyElB;CACJ;mBAzMkB,8BAA8B"}
+{"version":3,"file":"TubePathBuilder.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/path/tube/build/TubePathBuilder.js"],"names":[],"mappings":"AAoFA;IAEQ;;;OAGG;IACH,OAFU,gBAAc,IAAI,CAEX;IAEjB;;;OAGG;IACH,MAFU,OAAK,IAAI,CAEH;IAEhB;;;OAGG;IACH,WAFU,kBAAgB,IAAI,CAET;IAErB;;;OAGG;IACH,cAFU,eAAa,IAAI,CAEH;IAG5B,yBAEC;IAED,2BAEC;IAED,2BAEC;IAED,yCAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,EAAE,QAyElB;CACJ;mBAvMkB,8BAA8B"}

package/src/engine/graphics/ecs/path/tube/build/TubePathBuilder.js

@@ -1,17 +1,17 @@
 import { BufferGeometry, MeshBasicMaterial, MeshMatcapMaterial, MeshStandardMaterial } from "three";
-import { InterpolationType } from "../../../../../navigation/ecs/components/InterpolationType.js";
+import { assert } from "../../../../../../core/assert.js";
+import { m3_rm_compose_transform } from "../../../../../../core/geom/mat3/m3_rm_compose_transform.js";
+import { GameAssetType } from "../../../../../asset/GameAssetType.js";
 import Entity from "../../../../../ecs/Entity.js";
 import { Transform } from "../../../../../ecs/transform/Transform.js";
-import { TubeMaterialType } from "../TubeMaterialType.js";
-import { GameAssetType } from "../../../../../asset/GameAssetType.js";
-import { build_geometry_linear } from "./build_geometry_linear.js";
-import { build_geometry_catmullrom } from "./build_geometry_catmullrom.js";
+import { InterpolationType } from "../../../../../navigation/ecs/components/InterpolationType.js";
 import { ShadedGeometry } from "../../../mesh-v2/ShadedGeometry.js";
 import { ShadedGeometryFlags } from "../../../mesh-v2/ShadedGeometryFlags.js";
-import { fix_shape_normal_order } from "./fix_shape_normal_order.js";
+import { TubeMaterialType } from "../TubeMaterialType.js";
+import { build_geometry_catmullrom } from "./build_geometry_catmullrom.js";
+import { build_geometry_linear } from "./build_geometry_linear.js";
 import { compute_smooth_profile_normals } from "./compute_smooth_profile_normals.js";
-import { assert } from "../../../../../../core/assert.js";
-import { m3_rm_compose_transform } from "../../../../../../core/geom/mat3/m3_rm_compose_transform.js";
+import { fix_shape_normal_order } from "./fix_shape_normal_order.js";
 
 /**
  *
@@ -61,7 +61,7 @@ function make_material(style, am) {
     } else if (material_type === TubeMaterialType.Standard) {
         material_def = new MeshStandardMaterial({
             metalness: style.material.metalness,
-            roughness: style.material.roughness
+            roughness: style.material.roughness,
         });
     } else if (material_type === TubeMaterialType.Matcap) {
 

package/src/engine/graphics/ecs/path/tube/build/build_geometry_catmullrom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_geometry_catmullrom.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/path/tube/build/build_geometry_catmullrom.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,mFAPW,MAAM,EAAE,gBACR,MAAM,EAAE,GAAC,YAAY,mBACrB,MAAM,EAAE,iBACR,MAAM,eACN,MAAM,GACL,MAAM,cAAc,CA4D/B"}
+{"version":3,"file":"build_geometry_catmullrom.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/path/tube/build/build_geometry_catmullrom.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;GAUG;AACH,mFAPW,MAAM,EAAE,gBACR,MAAM,EAAE,GAAC,YAAY,mBACrB,MAAM,EAAE,iBACR,MAAM,eACN,MAAM,GACL,MAAM,cAAc,CAoI/B"}

package/src/engine/graphics/ecs/path/tube/build/build_geometry_catmullrom.js

@@ -1,7 +1,85 @@
+import { v3_dot } from "../../../../../../core/geom/vec3/v3_dot.js";
+import { clamp } from "../../../../../../core/math/clamp.js";
+import { max2 } from "../../../../../../core/math/max2.js";
+import {
+    computeNonuniformCaltmullRomSplineDerivative
+} from "../../../../../../core/math/spline/computeNonuniformCaltmullRomSplineDerivative.js";
+import { PathNormalType } from "../PathNormalType.js";
 import { computeFrenetFrames } from "./computeFrenetFrames.js";
 import { makeTubeGeometry } from "./makeTubeGeometry.js";
-import Vector3 from "../../../../../../core/geom/Vector3.js";
-import { PathNormalType } from "../PathNormalType.js";
+
+
+const scratch_array_0 = [];
+const scratch_array_1 = [];
+const scratch_array_2 = [];
+const scratch_array_3 = [];
+
+/**
+ *
+ * @param {number[]} positions
+ * @param {number[]} derivatives
+ * @param {number} result_offset
+ * @param {Path} path
+ * @param {number} offset
+ */
+function sample_path(positions, derivatives, result_offset, path, offset) {
+
+
+    if (!path.find_index_and_normalized_distance(scratch_array_0, offset)) {
+        return 0;
+    }
+
+
+    /**
+     *
+     * @type {number}
+     */
+    const i1 = scratch_array_0[0];
+
+    /**
+     *
+     * @type {number}
+     */
+    const t = scratch_array_0[1];
+
+
+    const input_length = path.getPointCount();
+
+    const max_index = input_length - 1;
+
+    const i0 = clamp(i1 - 1, 0, max_index);
+    const i2 = clamp(i1 + 1, 0, max_index);
+    const i3 = clamp(i1 + 2, 0, max_index);
+
+    path.readPositionToArray(i0, scratch_array_0, 0);
+    path.readPositionToArray(i1, scratch_array_1, 0);
+    path.readPositionToArray(i2, scratch_array_2, 0);
+    path.readPositionToArray(i3, scratch_array_3, 0);
+
+    computeNonuniformCaltmullRomSplineDerivative(
+        positions, result_offset,
+        derivatives, result_offset,
+        scratch_array_0, scratch_array_1, scratch_array_2, scratch_array_3,
+        3, t, 0.5
+    );
+
+    // normalize derivative
+    const dx = derivatives[result_offset];
+    const dy = derivatives[result_offset + 1];
+    const dz = derivatives[result_offset + 2];
+
+    const mag = Math.hypot(dx, dy, dz);
+
+    if (mag !== 0) {
+        const inv_mag = 1 / mag;
+
+        derivatives[result_offset] = dx * inv_mag;
+        derivatives[result_offset + 1] = dy * inv_mag;
+        derivatives[result_offset + 2] = dz * inv_mag;
+    }
+
+    return i1;
+}
 
 /**
  *
@@ -25,51 +103,123 @@ export function build_geometry_catmullrom(
     // resample curve
     const total_points = Math.ceil(point_count * style.resolution);
 
-    const path_length = path.length;
+    const reference_step_size = 1 / max2(0.00001, style.resolution);
+    const reference_min_step_size = reference_step_size * 0.25;
 
-    const point = new Vector3();
+    let step_size = reference_step_size;
 
-    const points_f32 = [];
+    const path_length = path.length;
 
+    const sample_positions_f32 = [];
+    const sample_derivatives_f32 = [];
 
     let added_points = 0;
-    let i;
 
     // initial segment
-    path.sample_catmull_rom(point, segment_start * path_length);
-
-    point.writeToArray(points_f32, added_points * 3);
+    let last_knot_index = sample_path(
+        sample_positions_f32,
+        sample_derivatives_f32,
+        added_points * 3,
+        path,
+        segment_start * path_length
+    );
 
     added_points++;
 
-    const max_i = segment_end * (total_points - 1);
-    for (i = Math.ceil(segment_start * total_points + 0.0001); i < max_i; i++) {
-        // TODO initial i value can potentially result in sample being produced before the "segment start"
-        const t = i / (total_points - 1);
-
-        path.sample_catmull_rom(point, path_length * t);
-
-        point.writeToArray(points_f32, added_points * 3);
+    let current_offset = segment_start * path_length;
+
+    let step_resized_direction = 0;
+
+    const absolute_end_offset = segment_end * path_length;
+
+    for (; current_offset < absolute_end_offset; current_offset += step_size) {
+
+
+        const point_address = added_points * 3;
+
+        const knot_index = sample_path(
+            sample_positions_f32,
+            sample_derivatives_f32,
+            point_address,
+            path,
+            current_offset
+        );
+
+        // check difference with previous derivative
+        const previous_point_index = added_points - 1;
+        const previous_point_address = previous_point_index * 3;
+
+        // derivatives are basically normals, and dot product is has Cosine value of angle between two vectors
+        const dot = v3_dot(
+            sample_derivatives_f32[previous_point_address], sample_derivatives_f32[previous_point_address + 1], sample_derivatives_f32[previous_point_address + 2],
+            sample_derivatives_f32[point_address], sample_derivatives_f32[point_address + 1], sample_derivatives_f32[point_address + 2]
+        );
+
+        // angular difference results in larger visual error for longer runs
+        const error_size = (1 - dot) * step_size;
+
+        if (
+            (step_size > reference_min_step_size)
+            && (
+                (
+                    // check if we jumped over a knot, so that we can sample down to get closer to it
+                    knot_index > last_knot_index
+                    && step_size > reference_min_step_size
+                )
+                || (
+                    error_size * 10 > reference_min_step_size
+                    && step_resized_direction <= 0
+                )
+                || (
+                    // check if we're getting too close to the end of the segment, this lets us create a nice end
+                    current_offset + step_size > absolute_end_offset
+                )
+            )
+        ) {
+
+            // step looks to be too large
+            current_offset -= step_size;
+            step_size *= 0.5;
+            step_resized_direction = -1;
+            continue; // retry
+
+        } else if (
+            error_size < 0.02
+            && step_resized_direction >= 0
+        ) {
+
+            // step looks to be too small
+            current_offset -= step_size;
+            step_size *= 2;
+            step_resized_direction = 1;
+            continue; // retry
+
+        }
+
+        // reset adaptive step direction
+        step_resized_direction = 0;
+        // remember the last knot, so we know when we get to the end of the segment
+        last_knot_index = knot_index;
 
         added_points++
     }
 
-    if (segment_end - ((i - 1) / (total_points - 1)) > 0.0001) {
+    if ((absolute_end_offset - current_offset + step_size) > 0.0001) {
         // end
 
-        path.sample_catmull_rom(point, segment_end * path_length);
-
-        point.writeToArray(points_f32, added_points * 3);
+        sample_path(sample_positions_f32, sample_derivatives_f32, added_points * 3, path, absolute_end_offset);
 
         added_points++;
     }
 
+    // console.log(`Total Points ${added_points}`) // DEBUG info
+
     const normal_hint = style.path_normal_type === PathNormalType.FixedStart ? style.path_normal : undefined;
 
-    const frames = computeFrenetFrames(points_f32, false, normal_hint);
+    const frames = computeFrenetFrames(sample_positions_f32, false, normal_hint);
 
     return makeTubeGeometry(
-        points_f32, frames.normals, frames.binormals, frames.tangents,
+        sample_positions_f32, frames.normals, frames.binormals, frames.tangents,
         shape, shape_normal, shape.length / 2, shape_transform, false, style.cap_type
     );
 }

package/src/engine/graphics/ecs/path/tube/prototypeAnimatedPathMask.js

@@ -2,7 +2,7 @@ import FacingDirectionSystem from "../../../../../../../model/game/ecs/system/Fa
 import { makeEngineOptionsModel } from "../../../../../../../model/game/options/makeEngineOptionsModel.js";
 import { enableEditor } from "../../../../../../editor/enableEditor.js";
 import Vector3 from "../../../../../core/geom/Vector3.js";
-import { pingpong } from "../../../../../core/math/pingpong.js";
+import { clamp01 } from "../../../../../core/math/clamp01.js";
 import { computeCatmullRomSpline } from "../../../../../core/math/spline/computeCatmullRomSpline.js";
 import { CanvasView } from "../../../../../view/elements/CanvasView.js";
 import { GameAssetType } from "../../../../asset/GameAssetType.js";
@@ -64,6 +64,7 @@ import { PathDisplaySpec } from "../PathDisplaySpec.js";
 import { PathDisplaySystem } from "../PathDisplaySystem.js";
 import { PathDisplayType } from "../PathDisplayType.js";
 import { RibbonPathStyle } from "../ribbon/RibbonPathStyle.js";
+import { CapType } from "./CapType.js";
 import { MatcapMaterialDefinition } from "./MatcapMaterialDefinition.js";
 import { TubeMaterialType } from "./TubeMaterialType.js";
 import { TubePathStyle } from "./TubePathStyle.js";
@@ -308,6 +309,8 @@ function sample_style_tube() {
     style.material.texture = "data/textures/matcap/nidorx/3E2335_D36A1B_8E4A2E_2842A5.jpg";
 
     style.width = 0.1;
+    style.resolution = 50;
+    style.cap_type = CapType.None;
 
     style.path_mask = [
         0, 1,
@@ -370,7 +373,18 @@ function main(engine) {
     new Entity()
         .add(BehaviorComponent.looping_function((delta) => {
             time += delta * 0.01;
-            tube_style.path_mask[1] = pingpong(time, 1);
+
+            const segment_count = 23;
+
+            tube_style.path_mask = [];
+            for (let i = 0; i < segment_count; i++) {
+                const offset_start = (i / (segment_count - 1) + time) % 1;
+                const offset_end = offset_start + 1 / (segment_count * 1.5);
+
+                tube_style.path_mask.push(
+                    clamp01(offset_start), clamp01(offset_end)
+                );
+            }
 
             path_entity.sendEvent(PathEvents.Changed);
         }))

package/src/engine/graphics/filter/ImageFilter.d.ts

@@ -5,7 +5,7 @@ export default processTexture;
  * @param {number} width
  * @param {number} height
  * @param {{vertexShader?:string,fragmentShader:string, uniforms?:Object, defines?:Object}} processShader
- * @param {Uint8Array} [destination]
+ * @param {Uint8Array|Uint8ClampedArray} [destination]
  * @return {{array: Uint8Array, renderer: WebGLRenderer}}
  */
 declare function processTexture(renderer: WebGLRenderer, width: number, height: number, processShader: {
@@ -13,7 +13,7 @@ declare function processTexture(renderer: WebGLRenderer, width: number, height:
     fragmentShader: string;
     uniforms?: any;
     defines?: any;
-}, destination?: Uint8Array): {
+}, destination?: Uint8Array | Uint8ClampedArray): {
     array: Uint8Array;
     renderer: WebGLRenderer;
 };

package/src/engine/graphics/filter/ImageFilter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageFilter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/filter/ImageFilter.js"],"names":[],"mappings":";AASA;;;;;;;;GAQG;AACH,gEANW,MAAM,UACN,MAAM,iBACN;IAAC,YAAY,CAAC,EAAC,MAAM,CAAC;IAAA,cAAc,EAAC,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAQ;IAAC,OAAO,CAAC,MAAO;CAAC,gBAC/E,UAAU,GACT;IAAC,KAAK,EAAE,UAAU,CAAC;IAAC,QAAQ,gBAAe;CAAC,CAiEvD"}
+{"version":3,"file":"ImageFilter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/filter/ImageFilter.js"],"names":[],"mappings":";AASA;;;;;;;;GAQG;AACH,gEANW,MAAM,UACN,MAAM,iBACN;IAAC,YAAY,CAAC,EAAC,MAAM,CAAC;IAAA,cAAc,EAAC,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAQ;IAAC,OAAO,CAAC,MAAO;CAAC,gBAC/E,UAAU,GAAC,iBAAiB,GAC3B;IAAC,KAAK,EAAE,UAAU,CAAC;IAAC,QAAQ,gBAAe;CAAC,CAiEvD"}

package/src/engine/graphics/filter/ImageFilter.js

@@ -4,8 +4,8 @@
 
 
 import { DoubleSide, LinearFilter, Mesh, OrthographicCamera, Scene, ShaderMaterial, WebGLRenderTarget } from 'three';
-import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
 import { FULL_SCREEN_QUAD_VERTEX_SHADER } from "../FULL_SCREEN_QUAD_VERTEX_SHADER.js";
+import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
 
 /**
  *
@@ -13,7 +13,7 @@ import { FULL_SCREEN_QUAD_VERTEX_SHADER } from "../FULL_SCREEN_QUAD_VERTEX_SHADE
  * @param {number} width
  * @param {number} height
  * @param {{vertexShader?:string,fragmentShader:string, uniforms?:Object, defines?:Object}} processShader
- * @param {Uint8Array} [destination]
+ * @param {Uint8Array|Uint8ClampedArray} [destination]
  * @return {{array: Uint8Array, renderer: WebGLRenderer}}
  */
 function processTexture(
@@ -24,7 +24,7 @@ function processTexture(
     destination
 ) {
     if (destination === undefined) {
-        destination = new Uint8Array(width * height * 4);
+        destination = new Uint8ClampedArray(width * height * 4);
     }
 
     //make a webgl renderer with orthographic camera

package/src/engine/graphics/render/RendererPool.d.ts

@@ -1,13 +1,26 @@
 export class WebGLRendererPool {
     static global: WebGLRendererPool;
     used: Set<any>;
-    get(options: any): WebGLRenderer;
+    get(): WebGLRenderer;
     /**
      *
      * @param {THREE.WebGLRenderer} renderer
      * @returns {boolean}
      */
     release(renderer: THREE.WebGLRenderer): boolean;
+    /**
+     * After callback returns, renderer is released back into the pool
+     * @template T
+     * @param {function(renderer:WebGLRenderer):T} callback
+     * @param {*} [thisArg]
+     */
+    use<T>(callback: any, thisArg?: any): any;
+    /**
+     * @template T
+     * @param {function(renderer:WebGLRenderer):Promise<T>} callback
+     * @param {*} [thisArg]
+     */
+    useAsync<T_1>(callback: any, thisArg?: any): Promise<void>;
 }
 import { WebGLRenderer } from 'three';
 //# sourceMappingURL=RendererPool.d.ts.map

package/src/engine/graphics/render/RendererPool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RendererPool.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/render/RendererPool.js"],"names":[],"mappings":"AAGA;IAuCI,iCAAwC;IArCxC,eAAiB;IAEjB,iCAcC;IAED;;;;OAIG;IACH,kBAHW,mBAAmB,GACjB,OAAO,CAcnB;CAGJ;8BA3C6B,OAAO"}
+{"version":3,"file":"RendererPool.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/render/RendererPool.js"],"names":[],"mappings":"AAGA;IAiFI,iCAAwC;IA/ExC,eAAiB;IAEjB,qBAcC;IAED;;;;OAIG;IACH,kBAHW,mBAAmB,GACjB,OAAO,CAcnB;IAED;;;;;OAKG;IACH,0CAkBC;IAED;;;;OAIG;IACH,2DASC;CAGJ;8BArF6B,OAAO"}