@woosh/meep-engine 2.35.16 → 2.36.1

package/engine/graphics/geometry/MikkT/MikkTSpace.spec.js

@@ -0,0 +1,22 @@
+import { genTangSpace, SMikkTSpaceContext } from "./MikkTSpace.js";
+
+test('empty geometry', () => {
+    const ctx = new SMikkTSpaceContext();
+
+    expect(() => {
+        genTangSpace(ctx);
+    }).not.toThrow();
+
+});
+
+test('single triangle', () => {
+    const ctx = new SMikkTSpaceContext();
+
+    ctx.geometry_buffer_index = [0, 1, 2];
+    ctx.geometry_buffer_vertex_position = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+    ctx.geometry_buffer_vertex_normal = [0, 1, 0, 0, 1, 0, 0, 1, 0];
+    ctx.geometry_buffer_vertex_uv = [0, 0, 0, 0, 0, 0];
+
+    genTangSpace(ctx);
+
+});

package/engine/graphics/geometry/MikkT/buffer_geometry_ensure_tangents.js

@@ -0,0 +1,34 @@
+import { buffer_geometry_generate_tangents } from "./buffer_geometry_generate_tangents.js";
+
+/**
+ *
+ * @param {THREE.BufferGeometry} geo
+ */
+export function buffer_geometry_ensure_tangents(geo) {
+    if (geo.getAttribute('tangent') !== undefined) {
+        // already got tangents
+        return;
+    }
+
+    if (geo.getIndex() === null) {
+        // non-indexed, unsupported
+        return;
+    }
+
+    if (geo.getAttribute('normal') === undefined) {
+        // no normals
+        return;
+    }
+
+    if (geo.getAttribute('uv') === undefined) {
+        // UVs are required by the algorithm
+        return;
+    }
+
+    if (geo.getAttribute('position') === undefined) {
+        // positions are required as well
+        return;
+    }
+
+    buffer_geometry_generate_tangents(geo);
+}

package/engine/graphics/geometry/MikkT/buffer_geometry_generate_tangents.js

@@ -0,0 +1,28 @@
+import { BufferAttribute } from "three";
+import { genTangSpace, SMikkTSpaceContext } from "./MikkTSpace.js";
+
+/**
+ * only works with indexed geometries
+ * @param {THREE.BufferGeometry} geo
+ */
+export function buffer_geometry_generate_tangents(geo) {
+
+    const attribute_position = geo.getAttribute('position');
+
+    if (geo.getAttribute('tangent') === undefined) {
+        geo.setAttribute('tangent', new BufferAttribute(new Float32Array(attribute_position.count * 4), 4, false));
+    }
+
+    const attribute_tangent = geo.getAttribute('tangent');
+
+
+    const ctx = new SMikkTSpaceContext();
+
+    ctx.geometry_buffer_index = geo.getIndex().array;
+    ctx.geometry_buffer_vertex_position = attribute_position.array;
+    ctx.geometry_buffer_vertex_normal = geo.getAttribute('normal').array;
+    ctx.geometry_buffer_vertex_uv = geo.getAttribute('uv').array;
+    ctx.geometry_buffer_vertex_tangent = attribute_tangent.array;
+
+    genTangSpace(ctx);
+}

package/engine/graphics/geometry/instancing/InstancedMeshGroup.js

@@ -1,10 +1,10 @@
 import {
     BufferGeometry,
+    DynamicDrawUsage,
     InstancedBufferAttribute,
     InstancedBufferGeometry,
     MeshDepthMaterial,
-    RGBADepthPacking,
-    StreamDrawUsage
+    RGBADepthPacking
 } from 'three';
 import ThreeFactory from "../../three/ThreeFactory.js";
 import { StaticMaterialCache } from "../../../asset/loaders/material/StaticMaterialCache.js";
@@ -77,6 +77,13 @@ export class InstancedMeshGroup {
          */
         this.__attributeTransformArray = null;
 
+        /**
+         *
+         * @type {Usage}
+         * @private
+         */
+        this.__instanceUsage = DynamicDrawUsage;
+
         /**
          *
          * @type {Material}
@@ -90,6 +97,30 @@ export class InstancedMeshGroup {
         this.mesh = ThreeFactory.createMesh();
     }
 
+    /**
+     *
+     * @param {Usage} v
+     */
+    set instance_usage(v) {
+        if (this.__instanceUsage === v) {
+            return;
+        }
+
+        this.__instanceUsage = v;
+
+        if (this.__attributeTransform !== null) {
+            this.__attributeTransform.setUsage(v);
+        }
+    }
+
+    /**
+     *
+     * @return {Usage}
+     */
+    get instance_usage() {
+        return this.__instanceUsage;
+    }
+
     dispose() {
         if (this.__threeGeometry !== null) {
             this.__threeGeometry.dispose();
@@ -367,7 +398,7 @@ export class InstancedMeshGroup {
         //rewrite old attributes
         this.__attributeTransformArray = newTransformArray;
         this.__attributeTransform = new InstancedBufferAttribute(newTransformArray, 16);
-        this.__attributeTransform.setUsage(StreamDrawUsage);
+        this.__attributeTransform.setUsage(this.__instanceUsage);
 
         //add attributes to newly created geometry
         geometry.setAttribute("instanceMatrix", this.__attributeTransform);

package/engine/graphics/geometry/skining/computeSkinnedMeshBoundingVolumes.js

@@ -3,7 +3,7 @@ import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
 import Vector4 from "../../../../core/geom/Vector4.js";
 import { computeBoundingSphereFromVertexData } from "../computeBoundingSphereFromVertexData.js";
 import { Box3, Sphere as ThreeSphere, Vector3 as ThreeVector3 } from "three";
-import { computeBoundingBoxFromVertexData } from "../../util/computeBoundingBoxFromVertexData.js";
+import { computeBoundingBoxFromVertexData } from "../../../../core/geom/3d/aabb/computeBoundingBoxFromVertexData.js";
 
 /**
  *

package/engine/graphics/micron/format/serialization/collection/geometry_collection_serialization.js

@@ -0,0 +1,83 @@
+import { MicronGeometryBinarySerializationAdapter } from "../MicronGeometryBinarySerializationAdapter.js";
+import { MicronGeometry } from "../../MicronGeometry.js";
+
+const SUPPORTED_ADAPTER_VERSION = 0;
+const HEADER_MAGIC_TEXT = 'MICRON#001';
+
+function obtain_micron_adapter() {
+
+    const ga = new MicronGeometryBinarySerializationAdapter();
+
+    if (ga.version !== SUPPORTED_ADAPTER_VERSION) {
+        throw new Error(`Incorrect version of serialization adapter, expected ${SUPPORTED_ADAPTER_VERSION}, instead got ${ga.version}`);
+    }
+
+    return ga;
+}
+
+/**
+ *
+ * @param {MicronGeometry[]} destination
+ * @param {BinaryBuffer} buffer
+ * @returns {number} how many geometries were read
+ */
+export function deserialize_geometry_collection(destination, buffer) {
+    // read header
+    const header_text = buffer.readASCIICharacters(HEADER_MAGIC_TEXT.length);
+
+    if (header_text !== HEADER_MAGIC_TEXT) {
+        throw new Error(`Wrong header magic, expected '${HEADER_MAGIC_TEXT}', instead got '${header_text}'`);
+    }
+
+    // read how many geometries we're expecting
+    const geometry_occupies_count = buffer.readUint32();
+
+    const ga = obtain_micron_adapter();
+
+    for (let i = 0; i < geometry_occupies_count; i++) {
+        // read key
+        const key = buffer.readUint32();
+
+        const geometry = new MicronGeometry();
+
+        ga.deserialize(buffer, geometry);
+
+        destination[key] = geometry;
+    }
+
+    return geometry_occupies_count;
+}
+
+/**
+ *
+ * @param {MicronGeometry[]} geometries
+ * @param {BinaryBuffer} buffer
+ */
+export function serialize_geometry_collection(geometries, buffer) {
+    // write header
+    buffer.writeASCIIString(HEADER_MAGIC_TEXT); // magic bytes
+
+    // count geometries
+    let geometry_occupied_count = 0;
+    const geometry_count = geometries.length;
+    for (let i = 0; i < geometry_count; i++) {
+        if (geometries[i] === undefined) {
+            geometry_occupied_count++;
+        }
+    }
+
+    buffer.writeUint32(geometry_occupied_count); // how many geometries to expect
+
+    const ga = obtain_micron_adapter();
+
+    for (let i = 0; i < geometry_count; i++) {
+        const geometry = geometries[i];
+        if (geometry === undefined) {
+            continue;
+        }
+
+        buffer.writeUint32(i); // key
+
+        ga.serialize(buffer, geometry);
+    }
+}

package/engine/graphics/micron/format/serialization/collection/geometry_collection_serialization.spec.js

@@ -0,0 +1,24 @@
+import { deserialize_geometry_collection, serialize_geometry_collection } from "./geometry_collection_serialization.js";
+import { BinaryBuffer } from "../../../../../../core/binary/BinaryBuffer.js";
+
+test('serialize empty', () => {
+    const bb = new BinaryBuffer();
+
+    expect(() => {
+        serialize_geometry_collection([], bb);
+    }).not.toThrow();
+
+});
+
+test('serialize/deserialize empty', () => {
+    const bb = new BinaryBuffer();
+
+    serialize_geometry_collection([], bb);
+
+    bb.position = 0;
+
+    const destination = [];
+    deserialize_geometry_collection(destination, bb);
+
+    expect(destination.length).toBe(0);
+});

package/engine/graphics/micron/plugin/GLTFAssetTransformer.js

@@ -1,15 +1,15 @@
 import { AssetTransformer } from "../../../asset/AssetTransformer.js";
-import { MicronGeometryBinarySerializationAdapter } from "../format/serialization/MicronGeometryBinarySerializationAdapter.js";
-import { MICRON_URI_FIELD } from "../MICRON_URI_FIELD.js";
 import { computePathDirectory } from "../../../../core/FilePath.js";
 import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
 import { MicronGeometry } from "../format/MicronGeometry.js";
 import { MICRON_GEOMETRY_FIELD } from "../MICRON_GEOMETRY_FIELD.js";
 import { async_traverse_three_object } from "../../../asset/loaders/async_traverse_three_object.js";
 import { convert_three_object_to_micron } from "../convert_three_object_to_micron.js";
-import { compute_geometry_polycount } from "../../compute_geometry_polycount.js";
+import { compute_geometry_polycount } from "../../geometry/compute_geometry_polycount.js";
 import { traverseThreeObject } from "../../ecs/highlight/renderer/traverseThreeObject.js";
 import { max2 } from "../../../../core/math/max2.js";
+import { deserialize_geometry_collection } from "../format/serialization/collection/geometry_collection_serialization.js";
+import { GLTF_MICRON_ID_FIELD } from "./GLTF_MICRON_ID_FIELD.js";
 
 export const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
 
@@ -85,10 +85,10 @@ export class GLTFAssetTransformer extends AssetTransformer {
 
         /**
          *
-         * @type {MicronGeometryBinarySerializationAdapter}
+         * @type {MicronGeometry[]}
          * @private
          */
-        this.__serde = new MicronGeometryBinarySerializationAdapter();
+        this.__active_mesh_micron_cache = [];
     }
 
     /**
@@ -116,23 +116,52 @@ export class GLTFAssetTransformer extends AssetTransformer {
          */
         const geometry = object.geometry;
 
-        const micron_uri = geometry.userData[MICRON_URI_FIELD];
+        const micron_geometry_index = geometry.userData[GLTF_MICRON_ID_FIELD];
 
-        if (typeof micron_uri !== "string") {
+        if (typeof micron_geometry_index !== "number") {
             return;
         }
 
+        const micron_geometry = this.__active_mesh_micron_cache[micron_geometry_index];
 
-        /**
-         * @type {AssetDescription}
-         */
-        const ad = ctx.asset;
+        if (micron_geometry === undefined) {
+            console.error(`Micron geometry '${micron_geometry_index}' not found`);
+            return;
+        }
+
+        // set proxy for raycasting
+        micron_geometry.proxy = geometry;
+
+        geometry[MICRON_GEOMETRY_FIELD] = micron_geometry;
+    }
+
+
+    /**
+     *
+     * @param {{userData:{}}} gltf
+     * @param {AssetDescription} ad
+     * @private
+     */
+    async __load_mesh_micron_data(gltf, ad) {
+        // clear active cache
+        this.__active_mesh_micron_cache = [];
+
+        const micron_metadata = gltf.userData.micron;
+
+        if (micron_metadata === undefined) {
+            return;
+        }
+
+        const uri = micron_metadata.geometry_data_uri;
+        if (uri === undefined) {
+            return;
+        }
 
         const base = computePathDirectory(ad.path);
 
         let micron_data;
 
-        const micron_path = `${base}/${micron_uri}`;
+        const micron_path = `${base}/${uri}`;
 
         try {
             micron_data = await this.__am.promise(micron_path, ASSET_TYPE_ARRAY_BUFFER);
@@ -143,14 +172,8 @@ export class GLTFAssetTransformer extends AssetTransformer {
 
         // deserialize micron data
         const buffer = BinaryBuffer.fromArrayBuffer(micron_data.create());
-        const micron_geometry = new MicronGeometry();
 
-        this.__serde.deserialize(buffer, micron_geometry);
-
-        // set proxy for raycasting
-        micron_geometry.proxy = geometry;
-
-        geometry[MICRON_GEOMETRY_FIELD] = micron_geometry;
+        deserialize_geometry_collection(this.__active_mesh_micron_cache, buffer);
     }
 
 

package/engine/graphics/micron/plugin/GLTF_MICRON_ID_FIELD.js

@@ -0,0 +1,5 @@
+/**
+ *
+ * @type {string}
+ */
+export const GLTF_MICRON_ID_FIELD = '@micron_geometry_index';

package/engine/graphics/micron/plugin/MicronRenderPlugin.js

@@ -135,10 +135,6 @@ export class MicronRenderPlugin extends EnginePlugin {
         view.on.preRender.remove(observer);
     }
 
-    __ingest_cache() {
-        this.engine.storage.lo
-    }
-
     async startup() {
 
         const engine = this.engine;

package/engine/graphics/micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js

@@ -90,6 +90,16 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
             pixelRatio = renderer.getPixelRatio();
         }
 
+        //  clear context
+        const material_contexts = this.ctx.contexts_array;
+        const contexts_count = material_contexts.length;
+        for (let i = 0; i < contexts_count; i++) {
+            const mc = material_contexts[i];
+
+            mc.instances.clear();
+        }
+
+        // initialize geometry builder
         const vg_builder = this.ctx.builder;
 
         vg_builder.resolution.set(resolution.x * pixelRatio, resolution.y * pixelRatio);

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -38,7 +38,9 @@ import { DRACOLoader } from "three/examples/jsm/loaders/DRACOLoader.js";
 import { TextureAttachmentsByMaterialType } from "../../asset/loaders/material/TextureAttachmensByMaterialType.js";
 import { distributePointsOnMesh } from "../particles/particular/engine/utils/distrubuteParticlesOnMesh.js";
 import { BinaryNode } from "../../../core/bvh2/BinaryNode.js";
-import { queryBinaryNode_SphereIntersections_Data } from "../../../core/bvh2/traversal/queryBinaryNode_SphereIntersections.js";
+import {
+    queryBinaryNode_SphereIntersections_Data
+} from "../../../core/bvh2/traversal/queryBinaryNode_SphereIntersections.js";
 import { ensureGeometryBoundingSphere } from "../geometry/buffered/ensureGeometryBoundingSphere.js";
 import { StaticMaterialCache } from "../../asset/loaders/material/StaticMaterialCache.js";
 import convertSampler2D2Canvas from "../texture/sampler/Sampler2D2Canvas.js";
@@ -461,7 +463,7 @@ function init() {
 
     // sample_gltf_sponza();
     // gltf_sample('data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf');
-    // sample_lucy();
+    sample_lucy();
     // sample_dragon();
     // sample_gltf_hapro_2();
     // sample_gltf_hapro_1();
@@ -481,7 +483,7 @@ function init() {
     // gltf_sample('moicon/03_Jan_22_Demo/8-assets/model.gltf');
     // gltf_sample('moicon/03_Jan_22_Demo/worker_test/model.gltf');
     // gltf_sample('moicon/A4/A4/model.gltf');
-    gltf_sample('moicon/06_04_hapro/08-clickable-assets-new/model.gltf');
+    // gltf_sample('moicon/06_04_hapro/08-clickable-assets-new/model.gltf');
     // gltf_sample('moicon/ztest_object_many_pieces/model.gltf');
     // gltf_grid('moicon/ztest_object_many_pieces/model.gltf', 3, 3);
 

package/engine/graphics/micron/render/refinement/ActivePatchList.js

@@ -2,7 +2,7 @@ import { ActivePatchRecord } from "./ActivePatchRecord.js";
 import { ActivePatchFlags } from "./ActivePatchFlags.js";
 import { aabb3_project_to_2d } from "../../../../../core/geom/3d/aabb/aabb3_compute_projected_area.js";
 import { BitSet } from "../../../../../core/binary/BitSet.js";
-import { aabb3_intersects_frustum_array } from "../../../../../core/bvh2/aabb3/aabb3_intersects_frustum_array.js";
+import { aabb3_array_intersects_frustum_array } from "../../../../../core/bvh2/aabb3/aabb3_array_intersects_frustum_array.js";
 
 export class ActivePatchList {
     constructor() {
@@ -199,7 +199,7 @@ export class ActivePatchList {
              check if node is in view frustum
              NOTE: following suggestion in "FastMesh: Efficient View-dependent Meshing" by Renato Pajarola et al, we can do a more coarse frustum test approximating frustum as a cone initially
              */
-            const in_view_frustum = aabb3_intersects_frustum_array(node.bounding_box, frustum_planes);
+            const in_view_frustum = aabb3_array_intersects_frustum_array(node.bounding_box, frustum_planes);
 
             if (!in_view_frustum) {
                 // outside of view frustum, cull

package/engine/graphics/micron/render/refinement/get_geometry_patch_cut.js

@@ -1,5 +1,5 @@
 import { BitSet } from "../../../../../core/binary/BitSet.js";
-import { aabb3_intersects_frustum_array } from "../../../../../core/bvh2/aabb3/aabb3_intersects_frustum_array.js";
+import { aabb3_array_intersects_frustum_array } from "../../../../../core/bvh2/aabb3/aabb3_array_intersects_frustum_array.js";
 import { aabb3_estimate_projected_area2 } from "../../../../../core/geom/3d/aabb/aabb3_estimate_projected_area2.js";
 
 
@@ -67,7 +67,7 @@ export function get_geometry_patch_cut(
          check if node is in view frustum
          NOTE: following suggestion in "FastMesh: Efficient View-dependent Meshing" by Renato Pajarola et al, we can do a more coarse frustum test approximating frustum as a cone initially
          */
-        const in_view_frustum = aabb3_intersects_frustum_array(patch.bounding_box, frustum_planes);
+        const in_view_frustum = aabb3_array_intersects_frustum_array(patch.bounding_box, frustum_planes);
 
         if (!in_view_frustum) {
             continue;

package/engine/graphics/micron/render/v1/MicronRenderContext.js

@@ -5,12 +5,6 @@ import Signal from "../../../../../core/events/signal/Signal.js";
 import { MaterialContext } from "./MaterialContext.js";
 import { MaterialVertexSpec, MaterialVertexSpecFlags } from "./MaterialVertexSpec.js";
 
-/**
- *
- * @type {MaterialVertexSpec}
- */
-const scratch_mvc = new MaterialVertexSpec();
-
 export class MicronRenderContext {
     constructor() {
 

package/engine/graphics/render/forward_plus/LightManager.js

@@ -25,7 +25,9 @@ import { read_frustum_planes_to_array } from "./cluster/read_frustum_planes_to_a
 import { compute_cluster_planes_from_points } from "./cluster/compute_cluster_planes_from_points.js";
 import { TextureBackedMemoryRegion } from "./data/TextureBackedMemoryRegion.js";
 import { assert } from "../../../../core/assert.js";
-import { DataType2TypedArrayConstructorMapping } from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+import {
+    DataType2TypedArrayConstructorMapping
+} from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
 import { NumericType } from "./data/NumericType.js";
 import { computeDataType } from "./data/computeDataType.js";
 import { computeThreeTextureTypeFromDataType } from "./data/computeThreeTextureTypeFromDataType.js";

package/engine/graphics/util/composeMatrix4.js

@@ -1,56 +1,4 @@
-/**
- *
- * @param {number[]|Float32Array|mat4} result
- * @param {Vector3} position
- * @param {Quaternion} rotation
- * @param {Vector3} scale
- */
-export function compose_matrix4_array(result, position, rotation, scale) {
-    const x = rotation.x;
-    const y = rotation.y;
-    const z = rotation.z;
-    const w = rotation.w;
-
-    const x2 = x + x;
-    const y2 = y + y;
-    const z2 = z + z;
-
-    const xx = x * x2;
-    const xy = x * y2;
-    const xz = x * z2;
-
-    const yy = y * y2;
-    const yz = y * z2;
-    const zz = z * z2;
-
-    const wx = w * x2;
-    const wy = w * y2;
-    const wz = w * z2;
-
-    const sx = scale.x;
-    const sy = scale.y;
-    const sz = scale.z;
-
-    result[0] = (1 - (yy + zz)) * sx;
-    result[1] = (xy + wz) * sx;
-    result[2] = (xz - wy) * sx;
-    result[3] = 0;
-
-    result[4] = (xy - wz) * sy;
-    result[5] = (1 - (xx + zz)) * sy;
-    result[6] = (yz + wx) * sy;
-    result[7] = 0;
-
-    result[8] = (xz + wy) * sz;
-    result[9] = (yz - wx) * sz;
-    result[10] = (1 - (xx + yy)) * sz;
-    result[11] = 0;
-
-    result[12] = position.x;
-    result[13] = position.y;
-    result[14] = position.z;
-    result[15] = 1;
-}
+import { compose_matrix4_array } from "../../../core/geom/3d/compose_matrix4_array.js";
 
 /**
  *

package/engine/graphics/util/composeMatrix4RotationScale.js

@@ -1,5 +1,5 @@
-import { compose_matrix4_array } from "./composeMatrix4.js";
 import Vector3 from "../../../core/geom/Vector3.js";
+import { compose_matrix4_array } from "../../../core/geom/3d/compose_matrix4_array.js";
 
 /**
  *

package/engine/intelligence/behavior/ecs/BehaviorComponent.js

@@ -31,7 +31,7 @@ export class BehaviorComponent {
 
     /**
      *
-     * @param {function} f
+     * @param {function(timeDelta:number)} f
      * @param {*} [thisArg]
      * @returns {BehaviorComponent}
      */

package/engine/intelligence/blackboard/AbstractBlackboard.js

@@ -48,6 +48,15 @@ export class AbstractBlackboard {
         return this.acquire(name, DataType.Number, initialValue);
     }
 
+    /**
+     *
+     * @param {string} name
+     * @returns {void}
+     */
+    incrementNumber(name) {
+        this.acquireNumber(name).increment();
+    }
+
     /**
      *
      * @param {string} name

package/engine/notify/Notification.js

@@ -16,7 +16,7 @@ export class Notification {
      * @constructor
      */
     constructor({ title = "", description = "", image = "", classList = [] }) {
-        assert.ok(Array.isArray(classList), 'classList must be an array, was something else instead');
+        assert.isArray(classList, 'classList');
 
         this.title = title;
 

package/engine/ui/DraggableAspect.js

@@ -12,7 +12,7 @@ export class DraggableAspect {
      *
      * @param {EventTarget} el
      * @param {function} [dragStart=noop]
-     * @param {function} [drag=noop]
+     * @param {(position:Vector2,origin:Vector2)=>*} [drag=noop]
      * @param {function} [dragEnd=noop]
      * @param {boolean} [stopPropagation=true] prevent propagation of pointer events up the DOM tree
      */
@@ -34,6 +34,8 @@ export class DraggableAspect {
         const pointerGlobal = this.pointerGlobal = new PointerDevice(window);
 
         const dragOriginalPosition = new Vector2();
+        const delta = new Vector2();
+        const pointer_position_last = new Vector2();
 
         if (stopPropagation) {
             this.pointerLocal.on.down.add((p, e) => {
@@ -43,6 +45,7 @@ export class DraggableAspect {
 
         this.pointerLocal.on.dragStart.add((position) => {
             dragOriginalPosition.copy(position);
+            pointer_position_last.copy(position);
             pointerGlobal.start();
 
             dragStart(position);

package/engine/ui/notification/ViewEmitter.js

@@ -1,7 +1,9 @@
 import Vector2 from "../../../core/geom/Vector2.js";
 import { AnimatedObjectEmitter } from "./AnimatedObjectEmitter.js";
 
-
+/**
+ * @template T
+ */
 class ViewEmitter {
     /**
      *
@@ -24,6 +26,10 @@ class ViewEmitter {
             return view;
         };
 
+        /**
+         *
+         * @type {(T)=>View}
+         */
         this.viewFactory = null;
 
         /**