@woosh/meep-engine 2.47.2 → 2.47.8

package/src/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 "../../../../core/geom/3d/aabb/computeBoundingBoxFromVertexData.js";
+import { aabb3_from_v3_array } from "../../../../core/geom/3d/aabb/aabb3_from_v3_array.js";
 
 /**
  *
@@ -21,7 +21,8 @@ export function computeSkinnedMeshBoundingVolumes(mesh) {
     const aabb3 = new AABB3(0, 0, 0, 0, 0, 0);
     const sphere = new Vector4();
 
-    computeBoundingBoxFromVertexData(vertices, aabb3);
+
+    aabb3_from_v3_array(aabb3, vertices, vertices.length);
     computeBoundingSphereFromVertexData(vertices, sphere);
 
     const min = new ThreeVector3(aabb3.x0, aabb3.y0, aabb3.z0);

package/src/engine/graphics/micron/format/MicronGeometry.js

@@ -2,7 +2,7 @@ import { VertexDataSpec } from "../../geometry/VertexDataSpec.js";
 import { assert } from "../../../../core/assert.js";
 import { computeTriangleRayIntersection } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
-import { aabb3_array_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_array_intersects_ray.js";
+import { aabb3_array_intersects_ray } from "../../../../core/geom/3d/aabb/aabb3_array_intersects_ray.js";
 import { sphere_array_intersects_ray } from "../../../../core/geom/3d/sphere/sphere_array_intersects_ray.js";
 import { BitSet } from "../../../../core/binary/BitSet.js";
 import { micron_build_proxy_geometry } from "./micron_build_proxy_geometry.js";

package/src/engine/graphics/micron/format/validate_patch_bounds.js

@@ -1,5 +1,5 @@
 import { noop } from "../../../../core/function/Functions.js";
-import { aabb3_array_contains_point } from "../../../../core/bvh2/aabb3/aabb3_array_contains_point.js";
+import { aabb3_array_contains_point } from "../../../../core/geom/3d/aabb/aabb3_array_contains_point.js";
 import { sphere_array_intersects_point } from "../../../../core/geom/3d/sphere/sphere_array_intersects_point.js";
 
 /**

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

@@ -4,7 +4,7 @@ import { aabb3_project_to_2d } from "../../../../../core/geom/3d/aabb/aabb3_comp
 import { BitSet } from "../../../../../core/binary/BitSet.js";
 import {
     aabb3_array_intersects_frustum_array
-} from "../../../../../core/bvh2/aabb3/aabb3_array_intersects_frustum_array.js";
+} from "../../../../../core/geom/3d/aabb/aabb3_array_intersects_frustum_array.js";
 
 export class ActivePatchList {
     constructor() {

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

@@ -1,8 +1,9 @@
 import { BitSet } from "../../../../../core/binary/BitSet.js";
 import {
     aabb3_array_intersects_frustum_array
-} from "../../../../../core/bvh2/aabb3/aabb3_array_intersects_frustum_array.js";
+} from "../../../../../core/geom/3d/aabb/aabb3_array_intersects_frustum_array.js";
 import { aabb3_estimate_projected_area2 } from "../../../../../core/geom/3d/aabb/aabb3_estimate_projected_area2.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 
 
 /**
@@ -12,12 +13,7 @@ import { aabb3_estimate_projected_area2 } from "../../../../../core/geom/3d/aabb
 const scratch_traversal_bitset = new BitSet();
 scratch_traversal_bitset.preventShrink();
 
-/**
- * Using a pre-allocated continuous chunk of memory gets us better cache coherence
- * @readonly
- * @type {number[]}
- */
-const scratch_traversal_stack = new Uint32Array(781250);
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
@@ -41,16 +37,20 @@ export function get_geometry_patch_cut(
 
     const geometry_id = geometry.id;
 
-    const destination_patch_address = destination.patch_count;
-    let output_patch_cursor = destination_patch_address;
+    let output_patch_cursor = destination.patch_count;
 
     let i;
-    let stack_cursor = 1;
 
     // initialize stack
-    const stack = scratch_traversal_stack;
     const root = geometry.root;
-    stack[0] = root.id;
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
+    stack[stack_top] = root.id;
 
     const included_set = scratch_traversal_bitset;
     included_set.reset();
@@ -60,10 +60,10 @@ export function get_geometry_patch_cut(
     const patches = geometry.patches;
     const destination_patches = destination.patches;
 
-    while (stack_cursor > 0) {
-        stack_cursor--;
+    while (stack.pointer > stack_top) {
+        stack.pointer--;
 
-        const patch_id = stack[stack_cursor];
+        const patch_id = stack[stack.pointer];
         const patch = patches[patch_id];
 
         /*
@@ -101,7 +101,7 @@ export function get_geometry_patch_cut(
                         continue;
                     }
 
-                    stack[stack_cursor++] = child_id;
+                    stack[stack.pointer++] = child_id;
                 }
 
                 continue;

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

@@ -1133,14 +1133,17 @@ export class LightManager {
         assert.isNumber(x, 'x');
         assert.isNonNegativeInteger(x, 'x');
         assert.isFiniteNumber(x, 'x');
+        assert.greaterThan(x,0,'x must be > 0');
 
         assert.isNumber(y, 'y');
         assert.isNonNegativeInteger(y, 'y');
         assert.isFiniteNumber(y, 'y');
+        assert.greaterThan(y,0,'y must be > 0');
 
         assert.isNumber(z, 'z');
         assert.isNonNegativeInteger(z, 'z');
         assert.isFiniteNumber(z, 'z');
+        assert.greaterThan(z,0,'z must be > 0');
 
         const r = this.__tiles_resolution;
 

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

@@ -20,7 +20,7 @@ test('correct cluster content (empty)', () => {
 
     const tex = lm.getTextureClusters();
 
-    expect(Array.from(tex.image.data)).toEqual([0, 0, 0]);
+    expect(Array.from(tex.image.data)).toEqual([0, 0, 0, 0]);
 });
 
 test('correct cluster content (single small light)', () => {
@@ -35,7 +35,7 @@ test('correct cluster content (single small light)', () => {
 
     const camera = new PerspectiveCamera(45, 1, 1, 10);
     camera.lookAt(0, 0, 5);
-    
+
     camera.updateProjectionMatrix();
     camera.updateMatrix();
     camera.updateMatrixWorld(true);
@@ -46,7 +46,7 @@ test('correct cluster content (single small light)', () => {
 
     const tex = lm.getTextureClusters();
 
-    expect(Array.from(tex.image.data)).toEqual([0, 1, 0]);
+    expect(Array.from(tex.image.data)).toEqual([0, 1, 0, 0]);
 });
 
 test('correct cluster content (single huge light)', () => {
@@ -68,7 +68,7 @@ test('correct cluster content (single huge light)', () => {
 
     const tex = lm.getTextureClusters();
 
-    expect(Array.from(tex.image.data)).toEqual([0, 1, 0]);
+    expect(Array.from(tex.image.data)).toEqual([0, 1, 0, 0]);
 });
 
 test('correct cluster content (single huge light overlapping)', () => {
@@ -90,5 +90,5 @@ test('correct cluster content (single huge light overlapping)', () => {
 
     const tex = lm.getTextureClusters();
 
-    expect(Array.from(tex.image.data)).toEqual([0, 1, 0]);
+    expect(Array.from(tex.image.data)).toEqual([0, 1, 0, 0]);
 });

package/src/engine/graphics/render/forward_plus/materials/FP_SHADER_CHUNK_APPLY_DECALS.js

@@ -54,6 +54,10 @@ export const FP_SHADER_CHUNK_APPLY_DECALS = `
                             
             vec4 decal_color = texture2D(fp_t_decal_atlas,decal_uv, -0.2);
             
+            vec4 decal_color_tint = texelFetch(fp_t_light_data, address_to_data_texture_coordinates(light_address+5u), 0);
+            
+            decal_color*= decal_color_tint;
+            
             // compute decal alpha
             float decal_alpha = decal_color.a * decal_surface_angle_fade;
             

package/src/engine/graphics/render/forward_plus/model/Decal.js

@@ -19,6 +19,11 @@ export class Decal extends AbstractLight {
         this.transform_inverse = new Float32Array(16);
         this.uv = new Float32Array(4);
 
+        this.color = new Float32Array(4);
+        // initialize color to full white
+        this.color.fill(1);
+
+
         /**
          *
          * @type {Sampler2D}
@@ -98,8 +103,11 @@ export class Decal extends AbstractLight {
         array_copy(this.uv, 0, destination, address + 16, 4);
 
         // required for sorting
-        destination[address + 20] = this.draw_priority;
-        destination[address + 21] = this.id;
+        // destination[address + 20] = this.draw_priority;
+        // destination[address + 21] = this.id;
+
+        // color
+        array_copy(this.color, 0, destination, address + 20, 4);
 
         return 24;
     }

package/src/engine/graphics/render/forward_plus/query/query_bvh_frustum_from_objects.js

@@ -1,5 +1,5 @@
 import {
-    aabb3_computeDistanceAbovePlane_max
+    aabb3_compute_distance_above_plane_max
 } from "../../../../../core/geom/3d/aabb/aabb3_compute_distance_above_plane_max.js";
 import { point_light_inside_volume } from "./point_light_inside_volume.js";
 import { spot_light_inside_volume } from "./spot_light_inside_volume.js";
@@ -52,7 +52,7 @@ export function query_bvh_frustum_from_objects(
                 const plane_normal_z = planes[plane_address + 2];
                 const plane_constant = planes[plane_address + 3];
 
-                const distanceAbovePlane = aabb3_computeDistanceAbovePlane_max(
+                const distanceAbovePlane = aabb3_compute_distance_above_plane_max(
                     plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
                     n.x0, n.y0, n.z0,
                     n.x1, n.y1, n.z1

package/src/engine/graphics/render/forward_plus/query/query_bvh_frustum_from_texture.js

@@ -1,14 +1,11 @@
 import {
-    aabb3_computeDistanceAbovePlane_max
+    aabb3_compute_distance_above_plane_max
 } from "../../../../../core/geom/3d/aabb/aabb3_compute_distance_above_plane_max.js";
 import { point_light_inside_volume } from "./point_light_inside_volume.js";
 import { BVH_BINARY_NODE_SIZE, BVH_LEAF_NODE_SIZE } from "../../../../../core/bvh2/binary/2/BinaryUint32BVH.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 
-/**
- *
- * @type {number[]}
- */
-const stack = [];
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
@@ -33,7 +30,7 @@ function frustum_check(data_view, address, planes) {
         const plane_normal_z = planes[plane_address + 2];
         const plane_constant = planes[plane_address + 3];
 
-        const distanceAbovePlane = aabb3_computeDistanceAbovePlane_max(
+        const distanceAbovePlane = aabb3_compute_distance_above_plane_max(
             plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
             n_x0, n_y0, n_z0,
             n_x1, n_y1, n_z1
@@ -70,8 +67,6 @@ export function query_bvh_frustum_from_texture(
     source_data,
     planes, points
 ) {
-
-    let stackPointer = 1;
     let result = 0;
 
     const binary_node_count = root.getBinaryNodeCount();
@@ -81,19 +76,26 @@ export function query_bvh_frustum_from_texture(
         return 0;
     }
 
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
     /**
      * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
      * @type {number}
      */
-    stack[0] = 0;
+    stack[stack_top] = 0;
 
     const last_valid_index = binary_node_count + root.getLeafNodeCount();
     const data_view = root.getDataView();
 
-    while (stackPointer-- > 0) {
+    do {
+        stack.pointer--;
 
         // query_bvh_frustum_from_objects.iteration_count++;
-        const node_index = stack[stackPointer];
+        const node_index = stack[stack.pointer];
 
         if (node_index < binary_node_count) {
             // is intermediate node
@@ -108,11 +110,11 @@ export function query_bvh_frustum_from_texture(
 
             // left node ends up on top of the stack, which aligns with the desired access sequence
             if (right_index < last_valid_index) {
-                stack[stackPointer++] = right_index;
+                stack[stack.pointer++] = right_index;
                 // micro-optimization, since we know that right node is valid and left appears before that, left is valid too
-                stack[stackPointer++] = left_index;
+                stack[stack.pointer++] = left_index;
             } else if (left_index < last_valid_index) {
-                stack[stackPointer++] = left_index;
+                stack[stack.pointer++] = left_index;
             }
 
 
@@ -160,7 +162,7 @@ export function query_bvh_frustum_from_texture(
             result++;
         }
 
-    }
+    }while (stack.pointer > stack_top)
 
     return result;
 }

package/src/engine/graphics/render/gizmo/GizmoShapeRenderingInterface.js

@@ -35,6 +35,8 @@ function add_instance(group, matrix, color) {
         Math.round(color[2] * 255),
         Math.round(color[3] * 255)
     );
+
+    group.requestAttributeUpdate();
 }
 
 /**

package/src/engine/graphics/render/visibility/IncrementalDeltaSet.js

@@ -229,18 +229,31 @@ export class IncrementalDeltaSet {
     finalizeUpdate() {
         assert.equal(this.state, IncrementalDeltaSetState.Building, `Expected BUILDING state, instead got '${this.state}'`);
 
-        this.size = this.__elements_cursor;
+        const array_main_count = this.__elements_cursor;
+        const array_previous_count = this.__swap_elements_count;
+
+        this.size = array_main_count;
 
         // sort newly populated elements array
-        array_shrink_to_size(this.__elements, this.size);
-        this.__elements.sort(this.__compare);
+        const array_main = this.__elements;
+        const array_previous = this.__swap_elements;
+
+        const compare = this.__compare;
+
+        const onAdded = this.onAdded;
+        const onRemoved = this.onRemoved;
+
+        array_shrink_to_size(array_main, array_main_count);
+        array_main.sort(compare);
+
 
         let i0 = 0, i1 = 0;
-        while (i0 < this.size && i1 < this.__swap_elements_count) {
-            const el_0 = this.__elements[i0];
-            const el_1 = this.__swap_elements[i1];
 
-            const diff = this.__compare(el_0, el_1);
+        while (i0 < array_main_count && i1 < array_previous_count) {
+            const el_0 = array_main[i0];
+            const el_1 = array_previous[i1];
+
+            const diff = compare(el_0, el_1);
 
             if (diff === 0) {
                 i0++;
@@ -249,20 +262,20 @@ export class IncrementalDeltaSet {
             } else if (diff < 0) {
                 i0++;
                 // addition
-                this.onAdded.send1(el_0);
+                onAdded.send1(el_0);
             } else {
                 i1++;
                 // removal
-                this.onRemoved.send1(el_1);
+                onRemoved.send1(el_1);
             }
         }
 
         // process remainders
-        for (; i0 < this.size; i0++) {
-            this.onAdded.send1(this.__elements[i0]);
+        for (; i0 < array_main_count; i0++) {
+            onAdded.send1(array_main[i0]);
         }
-        for (; i1 < this.__swap_elements_count; i1++) {
-            this.onRemoved.send1(this.__swap_elements[i1]);
+        for (; i1 < array_previous_count; i1++) {
+            onRemoved.send1(array_previous[i1]);
         }
 
         this.state = IncrementalDeltaSetState.Ready;

package/src/engine/graphics/sh3/path_tracer/GeometryBVHBatched.js

@@ -2,7 +2,9 @@ import {
     ExplicitBinaryBoundingVolumeHierarchy
 } from "../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
 import { bvh_query_leaves_ray } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_ray.js";
-import { aabb3_signed_distance_sqr_to_point } from "../../../../core/bvh2/aabb3/aabb3_signed_distance_sqr_to_point.js";
+import {
+    aabb3_signed_distance_sqr_to_point
+} from "../../../../core/geom/3d/aabb/aabb3_signed_distance_sqr_to_point.js";
 import {
     computeTriangleRayIntersectionBarycentric
 } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
@@ -197,7 +199,11 @@ export class GeometryBVHBatched {
 
                 bvh.node_get_aabb(node_id, temp_aabb3);
 
-                const distance = aabb3_signed_distance_sqr_to_point(temp_aabb3[0], temp_aabb3[1], temp_aabb3[2], temp_aabb3[3], temp_aabb3[4], temp_aabb3[5], ray[0], ray[1], ray[2]);
+                const distance = aabb3_signed_distance_sqr_to_point(
+                    temp_aabb3[0], temp_aabb3[1], temp_aabb3[2],
+                    temp_aabb3[3], temp_aabb3[4], temp_aabb3[5],
+                    ray[0], ray[1], ray[2]
+                );
 
                 if (distance > best_t * best_t) {
                     // whole AABB is too far

package/src/engine/graphics/sh3/path_tracer/PathTracer.js

@@ -92,8 +92,8 @@ export class PathTracer {
         this.geo_cache = new Map();
 
         /**
-         *
-         * @type {Map<THREE.Texture, Sampler2D>}
+         * Maps {@link Texture.id} to relevant sampler
+         * @type {Map<number, Sampler2D>}
          */
         this.textures = new Map();
 
@@ -171,7 +171,7 @@ export class PathTracer {
 
     /**
      *
-     * @param {THREE.Light} light
+     * @param {AbstractLight} light
      */
     addLight(light) {
         this.__lights.push(light);

package/src/engine/graphics/sh3/path_tracer/prototypePathTracer.js

@@ -397,8 +397,8 @@ function* render(target, pt, camera, progress = { current: 0, total: 0 }) {
     camera.matrixWorldInverse.copy(camera.matrixWorld);
     camera.matrixWorldInverse.invert();
 
-    const out = [];
-    const out2 = [];
+    const pixel_color = [];
+    const pixel_accummulation = [];
     const ray = [];
 
     const ray_origin = new Vector3();
@@ -414,7 +414,7 @@ function* render(target, pt, camera, progress = { current: 0, total: 0 }) {
     const pixel_scale_x = 1 / (width - 1);
     const pixel_scale_y = 1 / (height - 1);
 
-    const pixel_sample_count = 500;
+    const pixel_sample_count = 4;
 
     progress.total = width * height;
 
@@ -446,9 +446,13 @@ function* render(target, pt, camera, progress = { current: 0, total: 0 }) {
                     const u = x * pixel_scale_x;
                     const _x = u * 2 - 1;
 
-                    out2[0] = 0;
-                    out2[1] = 0;
-                    out2[2] = 0;
+                    pixel_accummulation[0] = 0;
+                    pixel_accummulation[1] = 0;
+                    pixel_accummulation[2] = 0;
+
+                    const pixel_address = ((max_y - y) * width + x) * 4;
+
+                    target.data[pixel_address + 3] = 255;
 
                     for (let i = 0; i < pixel_sample_count; i++) {
 
@@ -464,22 +468,20 @@ function* render(target, pt, camera, progress = { current: 0, total: 0 }) {
                             ray_direction.x, ray_direction.y, ray_direction.z
                         );
 
-                        pt.path_trace(out, ray, Infinity, 4, random);
+                        pt.path_trace(pixel_color, ray, Infinity, 4, random);
 
-                        out2[0] += out[0];
-                        out2[1] += out[1];
-                        out2[2] += out[2];
+                        pixel_accummulation[0] += pixel_color[0];
+                        pixel_accummulation[1] += pixel_color[1];
+                        pixel_accummulation[2] += pixel_color[2];
 
 
                         sample_count++;
                     }
 
-                    const pixel_address = ((max_y - y) * width + x) * 4;
+                    target.data[pixel_address] = float2uint8(pixel_accummulation[0] / pixel_sample_count);
+                    target.data[pixel_address + 1] = float2uint8(pixel_accummulation[1] / pixel_sample_count);
+                    target.data[pixel_address + 2] = float2uint8(pixel_accummulation[2] / pixel_sample_count);
 
-                    target.data[pixel_address] = float2uint8(out2[0] / pixel_sample_count);
-                    target.data[pixel_address + 1] = float2uint8(out2[1] / pixel_sample_count);
-                    target.data[pixel_address + 2] = float2uint8(out2[2] / pixel_sample_count);
-                    target.data[pixel_address + 3] = 255;
 
                     progress.current++;
 
@@ -515,6 +517,7 @@ async function start_renderer(camera) {
     camera.aspect = vCanvas.size.x / vCanvas.size.y;
 
     // const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
+    const path = 'data/models/pica_pica/pica_pica.gltf';
     // const path = 'data/models/road_bike/road_bike.gltf'; //large CAD-type model
 
     // await prepare_scene_lucy(pt, camera);

package/src/engine/graphics/texture/sampler/sampler2d_channel_compute_max.js

@@ -35,7 +35,7 @@ export function sampler2d_channel_compute_max(sampler, channel=0){
 
     }
 
-    const width = this.width;
+    const width = sampler.width;
 
     const itemIndex = (bestIndex / itemSize) | 0;
 

package/src/engine/graphics/texture/sampler/sampler2d_channel_compute_min.js

@@ -35,7 +35,7 @@ export function sampler2d_channel_compute_min(sampler, channel=0){
 
     }
 
-    const width = this.width;
+    const width = sampler.width;
 
     const itemIndex = (bestIndex / itemSize) | 0;
 

package/src/engine/graphics/three/three_computeObjectBoundingBox.js

@@ -0,0 +1,56 @@
+import { Box3 } from "three";
+
+/**
+ *
+ * @param {Object3D} object
+ * @param {AABB3} result
+ */
+export function three_computeObjectBoundingBox(object, result) {
+    const _sX = object.scale.x;
+    const _sY = object.scale.y;
+    const _sZ = object.scale.z;
+
+    object.scale.set(1, 1, 1);
+
+    const box3 = new Box3();
+
+    box3.expandByObject(object);
+
+    object.scale.set(_sX, _sY, _sZ);
+
+    const min = box3.min;
+    const max = box3.max;
+
+    let x0 = min.x;
+    let y0 = min.y;
+    let z0 = min.z;
+    let x1 = max.x;
+    let y1 = max.y;
+    let z1 = max.z;
+
+    // validate and fix missing bounds
+    if (x1 < x0) {
+        // no bounds
+        x0 = 0;
+        x1 = 0;
+    }
+
+    if (y1 < y0) {
+        // no bounds
+        y0 = 0;
+        y1 = 0;
+    }
+
+    if (z1 < z0) {
+        // no bounds
+        z0 = 0;
+        z1 = 0;
+    }
+
+
+    result.setBounds(
+        x0, y0, z0,
+        x1, y1, z1
+    );
+
+}

package/src/engine/input/devices/{InputDeviceButton.d.ts → InputDeviceSwitch.d.ts}

@@ -1,6 +1,6 @@
 import Signal from "../../../core/events/signal/Signal";
 
-export class InputDeviceButton{
+export class InputDeviceSwitch {
     readonly up: Signal
     readonly down: Signal
     readonly is_down: boolean

package/src/engine/input/devices/{InputDeviceButton.js → InputDeviceSwitch.js}

@@ -3,7 +3,7 @@ import Signal from "../../../core/events/signal/Signal.js";
 /**
  * Representation of an input device key
  */
-export class InputDeviceButton {
+export class InputDeviceSwitch {
     /**
      * Button press
      * @type {Signal}

package/src/engine/input/devices/KeyboardDevice.d.ts

@@ -1,4 +1,4 @@
-import {InputDeviceButton} from "./InputDeviceButton";
+import {InputDeviceSwitch} from "./InputDeviceSwitch";
 import Signal from "../../../core/events/signal/Signal";
 
 export default class KeyboardDevice {
@@ -6,7 +6,7 @@ export default class KeyboardDevice {
 
     readonly on: {up:Signal,down:Signal}
 
-    readonly keys:{[key:string]:InputDeviceButton}
+    readonly keys:{[key:string]:InputDeviceSwitch}
 
     start():void