@woosh/meep-engine 2.87.6 → 2.88.1

package/src/core/geom/2d/hash-grid/shg_query_elements_circle.spec.js

@@ -0,0 +1,85 @@
+import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
+import { seededRandom } from "../../../math/random/seededRandom.js";
+import { shg_query_elements_circle } from "./shg_query_elements_circle.js";
+import { SpatialHashGrid } from "./SpatialHashGrid.js";
+
+test("performance, 10k objects, 1m queries", () => {
+    const OBJECT_COUNT = 30000;
+    const QUERY_COUNT = 1e6;
+
+    const QUERY_DISTANCE_MIN = 0.1;
+    const QUERY_DISTANCE_MAX = 0.2;
+
+    const grid = new SpatialHashGrid(128, 128, 2);
+
+    const grid_bounds_x1 = grid.size_x * grid.scale;
+    const grid_bounds_y1 = grid.size_y * grid.scale;
+
+    const random = seededRandom();
+
+    // fill
+    for (let i = 0; i < OBJECT_COUNT; i++) {
+        const el = grid.element_allocate();
+
+        grid.element_set_user_data(el, i);
+
+        const width = randomFloatBetween(random, 0.2, 1);
+        const height = randomFloatBetween(random, 0.2, 1);
+        const x0 = randomFloatBetween(random, 0, grid_bounds_x1 - width);
+        const y0 = randomFloatBetween(random, 0, grid_bounds_y1 - height);
+
+        grid.element_set_bounds_primitive(el,
+            x0,
+            y0,
+            x0 + width,
+            y0 + height
+        );
+
+        grid.element_insert(el);
+    }
+
+
+    const queries = new Float32Array(QUERY_COUNT * 3);
+
+    // build queries
+    for (let i = 0; i < QUERY_COUNT; i++) {
+
+        const offset = i * 3;
+
+        // pick radius
+        const radius = randomFloatBetween(random, QUERY_DISTANCE_MIN, QUERY_DISTANCE_MAX);
+
+        // pick starting point
+        const ax = randomFloatBetween(random, radius, grid_bounds_x1 - radius);
+        const ay = randomFloatBetween(random, radius, grid_bounds_y1 - radius);
+
+        queries[offset] = ax;
+        queries[offset + 1] = ay;
+
+        queries[offset + 2] = radius;
+    }
+
+    // execute
+    const t0 = performance.now();
+
+    const result = [];
+
+    for (let i = 0; i < QUERY_COUNT; i++) {
+
+        const offset = i * 3;
+
+        shg_query_elements_circle(
+            result, 0, grid,
+            queries[offset],
+            queries[offset + 1],
+            queries[offset + 2],
+        );
+    }
+
+    const duration = performance.now() - t0;
+
+    const duration_seconds = duration * 1e-3;
+
+    console.log(`Duration ${duration_seconds}s, ${(QUERY_COUNT / duration_seconds).toFixed(2)} cycles per second`);
+
+});

package/src/core/geom/2d/hash-grid/shg_query_elements_line.d.ts

@@ -0,0 +1,14 @@
+/**
+ *
+ * Note that line coordinates MUST lie within the grid
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {SpatialHashGrid} grid
+ * @param {number} x0 first line point X
+ * @param {number} y0 first line point Y
+ * @param {number} x1 second line point X
+ * @param {number} y1 second line point Y
+ * @returns {number} number of elements added to result array
+ */
+export function shg_query_elements_line(result: number[], result_offset: number, grid: SpatialHashGrid, x0: number, y0: number, x1: number, y1: number): number;
+//# sourceMappingURL=shg_query_elements_line.d.ts.map

package/src/core/geom/2d/hash-grid/shg_query_elements_line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shg_query_elements_line.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/shg_query_elements_line.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;GAWG;AACH,gDATW,MAAM,EAAE,iBACR,MAAM,6BAEN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CA0GlB"}

package/src/core/geom/2d/hash-grid/shg_query_elements_line.js

@@ -0,0 +1,132 @@
+import { assert } from "../../../assert.js";
+import { aabb2_clip_line_cohen_sutherland } from "../aabb/aabb2_clip_line_cohen_sutherland.js";
+import { line2_distance_to_point_sqr } from "../line/line2_distance_to_point_sqr.js";
+import {
+    COLUMN_ELEMENT_X0,
+    COLUMN_ELEMENT_X1,
+    COLUMN_ELEMENT_Y0,
+    COLUMN_ELEMENT_Y1,
+    NULL_POINTER
+} from "./SpatialHashGrid.js";
+
+const scratch_float32 = new Float32Array(4);
+
+/**
+ *
+ * Note that line coordinates MUST lie within the grid
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {SpatialHashGrid} grid
+ * @param {number} x0 first line point X
+ * @param {number} y0 first line point Y
+ * @param {number} x1 second line point X
+ * @param {number} y1 second line point Y
+ * @returns {number} number of elements added to result array
+ */
+export function shg_query_elements_line(
+    result, result_offset,
+    grid,
+    x0, y0,
+    x1, y1
+) {
+
+    // shg_query_elements_line.visited.splice(0, shg_query_elements_line.visited.length); // DEBUG
+
+    assert.ok(x0 <= grid.size_x * grid.scale && x0 >= 0, `x0(=${x0}) out of bounds`);
+    assert.ok(x1 <= grid.size_x * grid.scale && x1 >= 0, `x1(=${x1}) out of bounds`);
+    assert.ok(y0 <= grid.size_y * grid.scale && y0 >= 0, `y0(=${y0}) out of bounds`);
+    assert.ok(y1 <= grid.size_y * grid.scale && y1 >= 0, `y1(=${y1}) out of bounds`);
+
+    // rasterize line
+    const scale_inverse = grid.scale_inverse;
+
+    // below is a modified version of Bresenham's line algorithm
+    const grid_x0 = x0 * scale_inverse;
+    const grid_y0 = y0 * scale_inverse;
+    const grid_x1 = x1 * scale_inverse;
+    const grid_y1 = y1 * scale_inverse;
+
+    let igrid_x0 = Math.floor(grid_x0);
+    let igrid_y0 = Math.floor(grid_y0);
+    let igrid_x1 = Math.floor(grid_x1);
+    let igrid_y1 = Math.floor(grid_y1);
+
+    const step_x = igrid_x0 < igrid_x1 ? 1 : -1;
+    const step_y = igrid_y0 < igrid_y1 ? 1 : -1;
+
+    const element_pool = grid.element_pool;
+    const element_float32 = element_pool.data_float32;
+
+    let result_count = 0;
+
+    let x = igrid_x0;
+    let y = igrid_y0;
+
+    for (; ;) {
+
+        const cell_index = grid.cell_position_to_index(x, y);
+
+        // shg_query_elements_line.visited.push(x, y); // DEBUG
+
+        let node = grid.cell_get_first_node(cell_index);
+
+        while (node !== NULL_POINTER) {
+
+            const element = grid.node_get_element(node);
+
+            // check element bounds
+            const element_address = element_pool.element_word(element);
+
+            const element_x0 = element_float32[element_address + COLUMN_ELEMENT_X0];
+            const element_y0 = element_float32[element_address + COLUMN_ELEMENT_Y0];
+            const element_x1 = element_float32[element_address + COLUMN_ELEMENT_X1];
+            const element_y1 = element_float32[element_address + COLUMN_ELEMENT_Y1];
+
+            if (aabb2_clip_line_cohen_sutherland(
+                scratch_float32, 0,
+                element_x0, element_y0,
+                element_x1, element_y1,
+                x0, y0, x1, y1
+            )) {
+                //  intersection with the element
+                result[result_offset + result_count] = element;
+
+                result_count++;
+            }
+
+
+            // read out next element in the linked list
+            node = grid.node_get_same_cell_next_node(node);
+
+        }
+
+        if (x === igrid_x1 && y === igrid_y1) {
+            // we're done
+            break;
+        }
+
+        // check moves forward
+        const move_x_distance = line2_distance_to_point_sqr(
+            grid_x0, grid_y0, grid_x1, grid_y1,
+            x + step_x + 0.5, y + 0.5
+        );
+
+        const move_y_distance = line2_distance_to_point_sqr(
+            grid_x0, grid_y0, grid_x1, grid_y1,
+            x + 0.5, y + step_y + 0.5
+        );
+
+        if (move_x_distance <= move_y_distance && x !== igrid_x1) {
+            x += step_x;
+        } else if (y !== igrid_y1) {
+            y += step_y;
+        } else {
+            // unexpected, or we just reached the end
+            break;
+        }
+    }
+
+    return result_count;
+}
+
+// shg_query_elements_line.visited = []; // DEBUG

package/src/core/geom/2d/hash-grid/shg_query_elements_line.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=shg_query_elements_line.spec.d.ts.map

package/src/core/geom/2d/hash-grid/shg_query_elements_line.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shg_query_elements_line.spec.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/shg_query_elements_line.spec.js"],"names":[],"mappings":""}

package/src/core/geom/2d/hash-grid/shg_query_elements_line.spec.js

@@ -0,0 +1,102 @@
+import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
+import { seededRandom } from "../../../math/random/seededRandom.js";
+import { shg_query_elements_line } from "./shg_query_elements_line.js";
+import { SpatialHashGrid } from "./SpatialHashGrid.js";
+
+test.skip("performance, 10k objects, 100k queries", () => {
+    const OBJECT_COUNT = 30000;
+    const QUERY_COUNT = 100000;
+
+    const QUERY_DISTANCE_MIN = 0.1;
+    const QUERY_DISTANCE_MAX = 0.2;
+
+    const grid = new SpatialHashGrid(128, 128, 1);
+
+    const grid_bounds_x1 = grid.size_x * grid.scale;
+    const grid_bounds_y1 = grid.size_y * grid.scale;
+
+    const random = seededRandom();
+
+    // fill
+    for (let i = 0; i < OBJECT_COUNT; i++) {
+        const el = grid.element_allocate();
+
+        grid.element_set_user_data(el, i);
+
+        const width = randomFloatBetween(random, 0.2, 1);
+        const height = randomFloatBetween(random, 0.2, 1);
+        const x0 = randomFloatBetween(random, 0, grid_bounds_x1 - width);
+        const y0 = randomFloatBetween(random, 0, grid_bounds_y1 - height);
+
+        grid.element_set_bounds_primitive(el,
+            x0,
+            y0,
+            x0 + width,
+            y0 + height
+        );
+
+        grid.element_insert(el);
+    }
+
+
+    const queries = new Float32Array(QUERY_COUNT * 4);
+
+    // build queries
+    for (let i = 0; i < QUERY_COUNT; i++) {
+
+        const offset = i * 4;
+
+        // pick starting point
+        const ax = randomFloatBetween(random, 0.001, grid_bounds_x1 - 0.001);
+        const ay = randomFloatBetween(random, 0.001, grid_bounds_y1 - 0.001);
+
+
+        const angle = randomFloatBetween(random, -Math.PI, Math.PI);
+
+        let direction_x = Math.cos(angle);
+        let direction_y = Math.sin(angle);
+
+        if (direction_x * (ax - grid_bounds_x1 * 0.5) > 0) {
+            direction_x = -direction_x;
+        }
+        if (direction_y * (ay - grid_bounds_y1 * 0.5) > 0) {
+            direction_y = -direction_y;
+        }
+
+        const query_distance = randomFloatBetween(random, QUERY_DISTANCE_MIN, QUERY_DISTANCE_MAX);
+
+        const bx = ax + direction_x * query_distance;
+        const by = ay + direction_y * query_distance;
+
+        queries[offset] = ax;
+        queries[offset + 1] = ay;
+
+        queries[offset + 2] = bx;
+        queries[offset + 3] = by;
+    }
+
+    // execute
+    const t0 = performance.now();
+
+    const result = [];
+
+    for (let i = 0; i < QUERY_COUNT; i++) {
+
+        const offset = i * 4;
+
+        shg_query_elements_line(
+            result, 0, grid,
+            queries[offset],
+            queries[offset + 1],
+            queries[offset + 2],
+            queries[offset + 3],
+        );
+    }
+
+    const duration = performance.now() - t0;
+
+    const duration_seconds = duration * 1e-3;
+
+    console.log(`Duration ${duration_seconds}s, ${(QUERY_COUNT / duration_seconds).toFixed(2)} cycles per second`);
+
+});

package/src/core/geom/2d/line/line2_distance_to_point_sqr.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Computes squared shortest distance between a line segment(defined by 2 points) and a point
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} px
+ * @param {number} py
+ */
+export function line2_distance_to_point_sqr(x0: number, y0: number, x1: number, y1: number, px: number, py: number): number;
+//# sourceMappingURL=line2_distance_to_point_sqr.d.ts.map

package/src/core/geom/2d/line/line2_distance_to_point_sqr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line2_distance_to_point_sqr.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/line2_distance_to_point_sqr.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,gDAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,UA4BhB"}

package/src/core/geom/2d/line/line2_distance_to_point_sqr.js

@@ -0,0 +1,39 @@
+import { clamp01 } from "../../../math/clamp01.js";
+import { v2_distance_sqr } from "../../vec2/v2_distance_sqr.js";
+
+/**
+ * Computes squared shortest distance between a line segment(defined by 2 points) and a point
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} px
+ * @param {number} py
+ */
+export function line2_distance_to_point_sqr(
+    x0, y0,
+    x1, y1,
+    px, py
+) {
+    // get line delta
+    const line_delta_x = x1 - x0;
+    const line_delta_y = y1 - y0;
+
+    // find closest point
+    const sp0_x = px - x0;
+    const sp0_y = py - y0;
+
+    //
+    const d2 = line_delta_x * line_delta_x + line_delta_y * line_delta_y;
+
+    const d3 = line_delta_x * sp0_x + line_delta_y * sp0_y;
+
+    const t = clamp01(d3 / d2);
+
+    // compute point on the line
+    const lp_x = line_delta_x * t + x0;
+    const lp_y = line_delta_y * t + y0;
+
+    // compute distance from the point in question to the point on the line
+    return v2_distance_sqr(px, py, lp_x, lp_y);
+}

package/src/core/geom/2d/quad-tree/QuadTreeNode.spec.js

@@ -1,4 +1,6 @@
 import { jest } from "@jest/globals";
+import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
+import { seededRandom } from "../../../math/random/seededRandom.js";
 import { QuadTreeDatum } from "./QuadTreeDatum.js";
 import { QuadTreeNode } from "./QuadTreeNode.js";
 
@@ -180,3 +182,54 @@ test('test traverseRectangleIntersections', () => {
     expect(visitor0).toHaveBeenCalledWith(d, 0, 0, 3, 3);
     expect(visitor0).toHaveBeenCalledWith(e, 0, 0, 3, 3);
 });
+
+test.skip("performance, insertion 1m random", () => {
+    const tree = new QuadTreeNode(0, 0, 100, 100);
+
+    const random = seededRandom(42);
+
+    const N = 1000000;
+
+    const boxes = new Float32Array(N * 4);
+
+    for (let i = 0; i < N; i++) {
+
+        const position_x = randomFloatBetween(random, 0, 98);
+        const position_y = randomFloatBetween(random, 0, 98);
+
+        const size_x = randomFloatBetween(random, 0.1, 2);
+        const size_y = randomFloatBetween(random, 0.1, 2);
+
+
+        const i4 = i * 4;
+        boxes[i4] = position_x;
+        boxes[i4 + 1] = position_y;
+        boxes[i4 + 2] = position_x + size_x;
+        boxes[i4 + 3] = position_y + size_y;
+    }
+
+    // perform insertion
+    const t0 = performance.now();
+
+    for (let i = 0; i < N; i++) {
+        const i4 = i * 4;
+
+        const x0 = boxes[i4];
+        const y0 = boxes[i4 + 1];
+        const x1 = boxes[i4 + 2];
+        const y1 = boxes[i4 + 3];
+
+        tree.add(i,
+            x0,
+            y0,
+            x1,
+            y1
+        );
+    }
+
+    const duration = performance.now() - t0;
+
+    const duration_seconds = duration * 1e-3;
+
+    console.log(`Duration ${duration_seconds}s, ${(N / duration_seconds).toFixed(2)} records per second`);
+});

package/src/core/geom/2d/quad-tree/qt_match_data_by_circle.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=qt_match_data_by_circle.spec.d.ts.map

package/src/core/geom/2d/quad-tree/qt_match_data_by_circle.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qt_match_data_by_circle.spec.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/qt_match_data_by_circle.spec.js"],"names":[],"mappings":""}

package/src/core/geom/2d/quad-tree/qt_match_data_by_circle.spec.js

@@ -0,0 +1,86 @@
+import { returnTrue } from "../../../function/returnTrue.js";
+import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
+import { seededRandom } from "../../../math/random/seededRandom.js";
+import { qt_match_data_by_circle } from "./qt_match_data_by_circle.js";
+import { QuadTreeNode } from "./QuadTreeNode.js";
+
+test.skip("performance, 10k objects, 1m queries", () => {
+    const OBJECT_COUNT = 30000;
+    const QUERY_COUNT = 1e6;
+
+    const QUERY_DISTANCE_MIN = 0.1;
+    const QUERY_DISTANCE_MAX = 0.2;
+
+    const grid_bounds_x1 = 256;
+    const grid_bounds_y1 = 256;
+
+    const tree = new QuadTreeNode(0, 0, grid_bounds_x1, grid_bounds_y1);
+
+
+    const random = seededRandom();
+
+    // fill
+    for (let i = 0; i < OBJECT_COUNT; i++) {
+
+        const width = randomFloatBetween(random, 0.2, 1);
+        const height = randomFloatBetween(random, 0.2, 1);
+        const x0 = randomFloatBetween(random, 0, grid_bounds_x1 - width);
+        const y0 = randomFloatBetween(random, 0, grid_bounds_y1 - height);
+
+        tree.add(i,
+            x0,
+            y0,
+            x0 + width,
+            y0 + height
+        )
+
+    }
+
+
+    const queries = new Float32Array(QUERY_COUNT * 3);
+
+    // build queries
+    for (let i = 0; i < QUERY_COUNT; i++) {
+
+        const offset = i * 3;
+
+        // pick radius
+        const radius = randomFloatBetween(random, QUERY_DISTANCE_MIN, QUERY_DISTANCE_MAX);
+
+        // pick starting point
+        const ax = randomFloatBetween(random, radius, grid_bounds_x1 - radius);
+        const ay = randomFloatBetween(random, radius, grid_bounds_y1 - radius);
+
+        queries[offset] = ax;
+        queries[offset + 1] = ay;
+
+        queries[offset + 2] = radius;
+    }
+
+    // execute
+    const t0 = performance.now();
+
+    const result = [];
+
+    for (let i = 0; i < QUERY_COUNT; i++) {
+
+        const offset = i * 3;
+
+        qt_match_data_by_circle(
+            result,
+            0,
+            tree,
+            queries[offset],
+            queries[offset + 1],
+            queries[offset + 2],
+            returnTrue
+        );
+    }
+
+    const duration = performance.now() - t0;
+
+    const duration_seconds = duration * 1e-3;
+
+    console.log(`Duration ${duration_seconds}s, ${(QUERY_COUNT / duration_seconds).toFixed(2)} cycles per second`);
+
+});

package/src/core/model/ObservedString.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ObservedString.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedString.js"],"names":[],"mappings":";AASA;IACI;;;;OAIG;IACH,4BAaC;IARG;;;;OAIG;IACH,gBAAoB;IAEpB,0DAA6B;IAmBjC;;;;OAIG;IACH,oBAFa,cAAc,CAa1B;IAED;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,2BAIC;IAED,iBAEC;IAED,yBAEC;IAED;;;OAGG;IACH,2CAEC;IAED;;;OAGG;IACH,6CAIC;IAED,eAEC;IAGL;;;;OAIG;IACH,2BAFU,OAAO,CAEwB;CAPxC;mBA1HkB,4BAA4B"}
+{"version":3,"file":"ObservedString.d.ts","sourceRoot":"","sources":["../../../../src/core/model/ObservedString.js"],"names":[],"mappings":";AASA;IACI;;;;OAIG;IACH,oBAHW,MAAM,EAgBhB;IARG;;;;OAIG;IACH,gBAAoB;IAEpB,0DAA6B;IAmBjC;;;;OAIG;IACH,oBAFa,cAAc,CAa1B;IAED;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,2BAIC;IAED,iBAEC;IAED,yBAEC;IAED;;;OAGG;IACH,2CAEC;IAED;;;OAGG;IACH,6CAIC;IAED,eAEC;IAGL;;;;OAIG;IACH,2BAFU,OAAO,CAEwB;CAPxC;mBA1HkB,4BAA4B"}

package/src/core/model/ObservedString.js

@@ -10,7 +10,7 @@ import { computeStringHash } from "../primitives/strings/computeStringHash.js";
 class ObservedString extends String {
     /**
      *
-     * @param {String} [value]
+     * @param {string} [value]
      * @constructor
      */
     constructor(value = "") {

package/src/engine/animation/curve/ecd_bind_animation_curve.js

@@ -1,4 +1,4 @@
-import Name from "../../../../../model/game/ecs/component/Name.js";
+import Name from "../../ecs/name/Name.js";
 import { AnimatedValueBinding } from "../../graphics/ecs/mesh-v2/aggregate/animation/AnimatedValueBinding.js";
 import { BoundQuaternionWriter } from "../../graphics/ecs/mesh-v2/aggregate/animation/BoundQuaternionWriter.js";
 import { BoundValueWriter } from "../../graphics/ecs/mesh-v2/aggregate/animation/BoundValueWriter.js";

package/src/engine/ecs/name/Name.d.ts

@@ -0,0 +1,25 @@
+export default Name;
+declare class Name extends ObservedString {
+    /**
+     *
+     * @param {string} [value]
+     */
+    constructor(value?: string);
+    /**
+     *
+     * @returns {string}
+     */
+    getLocalizationKey(): string;
+    /**
+     *
+     * @param {Localization} localization
+     * @returns {string}
+     */
+    getLocalizedValue(localization: Localization): string;
+    clone(): Name;
+}
+declare namespace Name {
+    let typeName: string;
+}
+import ObservedString from "../../../core/model/ObservedString.js";
+//# sourceMappingURL=Name.d.ts.map

package/src/engine/ecs/name/Name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Name.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/name/Name.js"],"names":[],"mappings":";AAEA;IACI;;;OAGG;IACH,oBAFW,MAAM,EAIhB;IAED;;;OAGG;IACH,sBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,+CAFa,MAAM,CAIlB;IAED,cAMC;CACJ;;;;2BAnC0B,uCAAuC"}

package/src/engine/ecs/name/Name.js

@@ -0,0 +1,42 @@
+import ObservedString from "../../../core/model/ObservedString.js";
+
+class Name extends ObservedString {
+    /**
+     *
+     * @param {string} [value]
+     */
+    constructor(value = "") {
+        super(value);
+    }
+
+    /**
+     *
+     * @returns {string}
+     */
+    getLocalizationKey() {
+        return `component.name.${this.getValue()}`;
+    }
+
+    /**
+     *
+     * @param {Localization} localization
+     * @returns {string}
+     */
+    getLocalizedValue(localization) {
+        return localization.getString(this.getLocalizationKey());
+    }
+
+    clone() {
+        const clone = new Name();
+
+        clone.copy(this);
+
+        return clone;
+    }
+}
+
+Name.typeName = "Name";
+
+
+export default Name;
+

package/src/engine/ecs/name/NameSerializationAdapter.d.ts

@@ -0,0 +1,18 @@
+export class NameSerializationAdapter extends BinaryClassSerializationAdapter {
+    klass: typeof Name;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {Name} value
+     */
+    serialize(buffer: BinaryBuffer, value: Name): void;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {Name} value
+     */
+    deserialize(buffer: BinaryBuffer, value: Name): void;
+}
+import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
+import Name from "./Name.js";
+//# sourceMappingURL=NameSerializationAdapter.d.ts.map

package/src/engine/ecs/name/NameSerializationAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NameSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/name/NameSerializationAdapter.js"],"names":[],"mappings":"AAGA;IACI,mBAAa;IAGb;;;;OAIG;IACH,uCAFW,IAAI,QAId;IAGD;;;;OAIG;IACH,yCAFW,IAAI,QAMd;CAEJ;gDA5B+C,sDAAsD;iBACrF,WAAW"}