@woosh/meep-engine 2.165.6 → 2.166.0

package/src/engine/graphics/ecs/path/tube/TubePathStyle.d.ts

@@ -1,35 +1,114 @@
-import {Color} from "../../../../../core/color/Color";
-import {TubeMaterialType} from "./TubeMaterialType";
-import {StandardMaterialDefinition} from "./StandardMaterialDefinition";
-import {MatcapMaterialDefinition} from "./MatcapMaterialDefinition";
-import {CapType} from "./CapType";
-import Vector3 from "../../../../../core/geom/Vector3";
-import {PathNormalType} from "./PathNormalType";
-
-export class TubePathStyle {
-    public color: Color
-    public material_type: TubeMaterialType
-    public material: StandardMaterialDefinition | MatcapMaterialDefinition
-    public opacity: number
-    public width: number
-    public resolution: number
-    /**
-     * @deprecated
-     */
-    public radial_resolution: number
-    /**
-     * Profile shape of the path, such as a circle or a square
-     * Defined as a sequence of 2d points: [x0,y0,x1,y1, ... xN, yN]
-     */
-    public shape: ArrayLike<number>
-    /**
-     * Optional, contains 2d normals of the profile shape, if not set - smooth normals will be automatically computed
-     */
-    public shape_normals: ArrayLike<number>
-    public cast_shadow: boolean
-    public receive_shadow: boolean
-    public path_mask: number[]
-    public cap_type: CapType
-    public path_normal: Vector3
-    public path_normal_type: PathNormalType
-}
+export class TubePathStyle {
+    static fromJSON(j: any): TubePathStyle;
+    /**
+     *
+     * @type {Color}
+     */
+    color: Color;
+    /**
+     * @type {TubeMaterialType}
+     */
+    material_type: {
+        Unknown: string;
+        Basic: string;
+        Standard: string;
+        Matcap: string;
+    };
+    /**
+     *
+     * @type {StandardMaterialDefinition|MatcapMaterialDefinition|BasicMaterialDefinition|null}
+     */
+    material: StandardMaterialDefinition | MatcapMaterialDefinition | BasicMaterialDefinition | null;
+    /**
+     *
+     * @type {number}
+     */
+    opacity: number;
+    /**
+     *
+     * @type {number}
+     */
+    width: number;
+    /**
+     *
+     * @type {number[]}
+     */
+    shape: number[];
+    /**
+     *
+     * @type {number[]|Float32Array|null}
+     */
+    shape_normals: number[] | Float32Array | null;
+    /**
+     *
+     * @type {number}
+     */
+    resolution: number;
+    /**
+     *
+     * @type {boolean}
+     */
+    cast_shadow: boolean;
+    /**
+     *
+     * @type {boolean}
+     */
+    receive_shadow: boolean;
+    /**
+     * @type {PathNormalType}
+     */
+    path_normal_type: PathNormalType;
+    /**
+     *
+     * @type {Vector3}
+     */
+    path_normal: Vector3;
+    /**
+     * Which parts of the path to visualise, in normalized offsets
+     * @example [ 0, 1 ] = whole path
+     * @example [ 0, 0.5 ] = first half of the path
+     * @example [ 0.5, 0.6 ] = segment from 50% along the path, to 60% along the path
+     * @example [ 0, 0.1, 0.9, 1] = first 10% of the path, and last 10% of the path
+     * @type {number[]}
+     */
+    path_mask: number[];
+    /**
+     * @type {CapType}
+     */
+    cap_type: CapType;
+    /**
+     * @deprecated
+     * @param {number} v
+     */
+    set radial_resolution(arg: number);
+    /**
+     *
+     * @param {string|{r:number,g:number,b:number}} color
+     * @param material_type
+     * @param material
+     * @param opacity
+     * @param width
+     * @param radial_resolution
+     * @param resolution
+     * @param cast_shadow
+     * @param receive_shadow
+     * @param path_mask
+     * @param cap_type
+     * @param shape
+     * @param path_normal
+     * @param path_normal_type
+     */
+    fromJSON({ color, material_type, material, opacity, width, radial_resolution, resolution, cast_shadow, receive_shadow, path_mask, cap_type, shape, path_normal, path_normal_type }: string | {
+        r: number;
+        g: number;
+        b: number;
+    }): void;
+}
+import { Color } from "../../../../../core/color/Color.js";
+import { StandardMaterialDefinition } from "./StandardMaterialDefinition.js";
+import { MatcapMaterialDefinition } from "./MatcapMaterialDefinition.js";
+import { BasicMaterialDefinition } from "./BasicMaterialDefinition.js";
+import { PathNormalType } from "./PathNormalType.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+import { CapType } from "./CapType.js";
+//# sourceMappingURL=TubePathStyle.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"TubePathStyle.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/path/tube/TubePathStyle.js"],"names":[],"mappings":"AAYA;IAkGI,uCAMC;IAtGG;;;OAGG;IACH,OAFU,KAAK,CAEgB;IAE/B;;OAEG;IACH,eAFU,gBAAgB,CAEmB;IAE7C;;;OAGG;IACH,UAFU,0BAA0B,GAAC,wBAAwB,GAAC,uBAAuB,GAAC,IAAI,CAEtE;IAEpB;;;OAGG;IACH,SAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,OAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,OAFU,MAAM,EAAE,CAEiB;IAEnC;;;OAGG;IACH,eAFU,MAAM,EAAE,GAAC,YAAY,GAAC,IAAI,CAEX;IAEzB;;;OAGG;IACH,YAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,aAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,gBAFU,OAAO,CAEU;IAE3B;;OAEG;IACH,kBAFU,cAAc,CAEwB;IAEhD;;;OAGG;IACH,aAFU,OAAO,CAEY;IAE7B;;;;;;;OAOG;IACH,WAFU,MAAM,EAAE,CAEK;IAEvB;;OAEG;IACH,UAFU,OAAO,CAEW;IAGhC;;;OAGG;IACH,mCAIC;IAUD;;;;;;;;;;;;;;;;OAgBG;IACH,oLAfW,MAAM,GAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QA8F7C;CACJ;sBAvNqB,oCAAoC;iCACzB,uBAAuB;2CAIb,iCAAiC;yCAFnC,+BAA+B;wCAGhC,8BAA8B;+BACvC,qBAAqB;oBAChC,qCAAqC;wBAJjC,cAAc"}
+{"version":3,"file":"TubePathStyle.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/path/tube/TubePathStyle.js"],"names":[],"mappings":"AAYA;IAkGI,uCAMC;IAtGG;;;OAGG;IACH,OAFU,KAAK,CAEgB;IAE/B;;OAEG;IACH;;;;;MAA6C;IAE7C;;;OAGG;IACH,UAFU,0BAA0B,GAAC,wBAAwB,GAAC,uBAAuB,GAAC,IAAI,CAEtE;IAEpB;;;OAGG;IACH,SAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,OAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,OAFU,MAAM,EAAE,CAEiB;IAEnC;;;OAGG;IACH,eAFU,MAAM,EAAE,GAAC,YAAY,GAAC,IAAI,CAEX;IAEzB;;;OAGG;IACH,YAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,aAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,gBAFU,OAAO,CAEU;IAE3B;;OAEG;IACH,kBAFU,cAAc,CAEwB;IAEhD;;;OAGG;IACH,aAFU,OAAO,CAEY;IAE7B;;;;;;;OAOG;IACH,WAFU,MAAM,EAAE,CAEK;IAEvB;;OAEG;IACH,UAFU,OAAO,CAEW;IAGhC;;;OAGG;IACH,mCAIC;IAUD;;;;;;;;;;;;;;;;OAgBG;IACH,oLAfW,MAAM,GAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QA8F7C;CACJ;sBAvNqB,oCAAoC;2CAKf,iCAAiC;yCAFnC,+BAA+B;wCAGhC,8BAA8B;+BACvC,qBAAqB;oBAChC,qCAAqC;wBAJjC,cAAc"}

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

@@ -1 +1 @@
-{"version":3,"file":"estimatePathViaIterativeIntegral.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/path/tube/build/estimatePathViaIterativeIntegral.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,sEAFW,MAAM,UA6BhB"}
+{"version":3,"file":"estimatePathViaIterativeIntegral.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/path/tube/build/estimatePathViaIterativeIntegral.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,sEAFW,MAAM,UA+BhB"}

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

@@ -19,14 +19,16 @@ export function estimatePathViaIterativeIntegral(path, epsilon) {
     }
 
     for (let p = epsilon; ; p += epsilon) {
-        const ended = path.sample(p1, p);
+        // sample returns false once the offset is clamped to the last point (offset >= length)
+        const on_path = path.sample(p1, p);
 
-        if (ended) {
+        // close the current segment either way; the final iteration adds the last piece up to the end point
+        sum += p0.distanceTo(p1);
+
+        if (!on_path) {
             break;
         }
 
-        sum += p0.distanceTo(p1);
-
         const swap = p1;
 
         p1 = p0;

package/src/engine/graphics/ecs/trail2d/Trail2DSystem.d.ts

@@ -1,6 +1,85 @@
-import {System} from "../../../ecs/System";
-import Engine from "../../../Engine";
-
-export default class Trail2DSystem extends System {
-    constructor(engine: Engine)
-}
+export default Trail2DSystem;
+declare class Trail2DSystem extends System<any> {
+    /**
+     * @param {Engine} engine
+     * @constructor
+     */
+    constructor(engine: Engine);
+    dependencies: (typeof Transform | typeof Trail2D)[];
+    components_used: ResourceAccessSpecification<typeof Trail2D>[];
+    /**
+     *
+     * @type {RibbonXFixedPhysicsSimulator}
+     */
+    simulator: RibbonXFixedPhysicsSimulator;
+    /**
+     *
+     * @type {Reference<RibbonXPlugin>}
+     * @private
+     */
+    private __ribbon_plugin;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    private __timeDelta;
+    /**
+     * @private
+     * @type {BVH}
+     */
+    private bvh;
+    /**
+     *
+     * @type {Engine}
+     * @private
+     */
+    private __engine;
+    /**
+     *
+     * @type {GraphicsEngine}
+     */
+    graphics: GraphicsEngine;
+    /**
+     *
+     * @type {RenderLayer|null}
+     */
+    renderLayer: RenderLayer | null;
+    startup(entityManager: any): Promise<void>;
+    shutdown(entityManager: any): Promise<void>;
+    /**
+     *
+     * @param {Trail2D} trail
+     * @param {Transform} transform
+     * @private
+     */
+    private __build_trail;
+    /**
+     *
+     * @param {Transform} transform
+     * @param {Trail2D} trail
+     * @param {number} entityId
+     */
+    link(trail: Trail2D, transform: Transform, entityId: number): void;
+    /**
+     *
+     * @param {Trail2D} component
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    unlink(component: Trail2D, transform: Transform, entity: number): void;
+    /**
+     *
+     * @param {Trail2D} trail
+     * @param {Transform} transform
+     */
+    updateTrailEntity(trail: Trail2D, transform: Transform): void;
+    update(timeDelta: any): void;
+}
+import { System } from '../../../ecs/System.js';
+import { Transform } from '../../../ecs/transform/Transform.js';
+import Trail2D from './Trail2D.js';
+import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
+import { RibbonXFixedPhysicsSimulator } from "../../trail/x/simulator/RibbonXFixedPhysicsSimulator.js";
+import { GraphicsEngine } from "../../GraphicsEngine.js";
+//# sourceMappingURL=Trail2DSystem.d.ts.map

package/src/engine/graphics/ecs/trail3d/Trail3DSystem.d.ts

@@ -1,5 +1,5 @@
 export default Trail3DSystem;
-declare class Trail3DSystem extends System<any, any, any, any, any> {
+declare class Trail3DSystem extends System<any> {
     /**
      * @param {Engine} engine
      * @constructor

package/src/engine/graphics/ecs/water/WaterSerializationAdapter.d.ts

@@ -1,7 +1,6 @@
 export class WaterSerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof Water;
-    version: number;
     /**
      *
      * @param {BinaryBuffer} buffer

package/src/engine/graphics/ecs/water/WaterSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WaterSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,oBAAc;IACd,gBAAY;IAEZ;;;;OAIG;IACH,uCAFW,KAAK,QAmBf;IAED;;;;OAIG;IACH,yCAFW,KAAK,QAyBf;CACJ;gDA7D+C,gEAAgE;kBAC9F,YAAY"}
+{"version":3,"file":"WaterSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,oBAAc;IAGd;;;;OAIG;IACH,uCAFW,KAAK,QAmBf;IAED;;;;OAIG;IACH,yCAFW,KAAK,QAyBf;CACJ;gDA7D+C,gEAAgE;kBAC9F,YAAY"}

package/src/engine/graphics/ecs/water/WaterSystem.d.ts

@@ -1,5 +1,5 @@
 export default WaterSystem;
-declare class WaterSystem extends System<any, any, any, any, any> {
+declare class WaterSystem extends System<any> {
     /**
      *
      * @param {GraphicsEngine} graphics

package/src/engine/graphics/ecs/water/WaterSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterSystem.js"],"names":[],"mappings":";AAaA;IAyBI;;;;OAIG;IACH,sCAmBC;IAhDD,+BAAuB;IAEvB;;;OAGG;IACH,cAFU,GAAG,CAEG;IAGhB,cAAY;IAEZ;;;OAGG;IACH,aAFU,KAAK,EAAE,CAEA;IAEjB;;;;OAIG;IACH,qBAAiB;IAWb,+BAA8B;IAE9B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAEvB;;;;OAIG;IACH,wBAA2B;IAK/B,4CASC;IAED,2CAkEC;IAED;;;;OAIG;IACH,gBAHW,KAAK,UACL,MAAM,QAsDhB;IAED;;;;OAIG;IACH,kBAHW,KAAK,UACL,MAAM,QAgBhB;IAED,2BAgCC;IAED;;;;;OAKG;IACH,0BAUC;IAED,6BAcC;CACJ;;;;uBA/RsB,wBAAwB;kBAM7B,YAAY;oBARV,mCAAmC"}
+{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterSystem.js"],"names":[],"mappings":";AAaA;IAyBI;;;;OAIG;IACH,sCAmBC;IAhDD,+BAAuB;IAEvB;;;OAGG;IACH,cAFU,GAAG,CAEG;IAGhB,cAAY;IAEZ;;;OAGG;IACH,aAFU,KAAK,EAAE,CAEA;IAEjB;;;;OAIG;IACH,qBAAiB;IAWb,+BAA8B;IAE9B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAEvB;;;;OAIG;IACH,wBAA2B;IAK/B,4CASC;IAED,2CAwEC;IAED;;;;OAIG;IACH,gBAHW,KAAK,UACL,MAAM,QAsDhB;IAED;;;;OAIG;IACH,kBAHW,KAAK,UACL,MAAM,QAgBhB;IAED,2BAgCC;IAED;;;;;OAKG;IACH,0BAUC;IAED,6BAcC;CACJ;;;;uBArSsB,wBAAwB;kBAM7B,YAAY;oBARV,mCAAmC"}

package/src/engine/graphics/ecs/water/WaterSystem.js

@@ -81,7 +81,12 @@ class WaterSystem extends System {
 
         this.renderLayer = graphicsEngine.layers.create(WaterSystem.RENDER_LAYER_NAME);
 
-        const viewport_size = graphicsEngine.viewport.size;
+        // the water shader reads the shared depth attachment at `gl_FragCoord.xy / vScreenResolution`,
+        // so the uniform has to name that attachment's own texel grid. `output_resolution` is the value
+        // the frame buffers are sized from, whole texels and all; recomputing it here from the CSS
+        // viewport size and a freshly read `window.devicePixelRatio` reproduced it only up to rounding,
+        // and only while the DPR had not moved since the last resize
+        const output_resolution = graphicsEngine.output_resolution;
 
         this.renderLayer.buildVisibleSet = make_bvh_visibility_builder(
             this.entityManager, this.bvh,
@@ -125,7 +130,8 @@ class WaterSystem extends System {
                 return;
             }
 
-            const pixelRatio = graphicsEngine.computeTotalPixelRatio();
+            const resolution_x = output_resolution.x;
+            const resolution_y = output_resolution.y;
 
             dataset.traverseComponents(Water, function (component, entity) {
                 const shader = component.__shader;
@@ -133,7 +139,7 @@ class WaterSystem extends System {
                 shader.uniforms.fCameraNear.value = camera.near;
                 shader.uniforms.fCameraFar.value = camera.far;
 
-                shader.uniforms.vScreenResolution.value.set(viewport_size.x * pixelRatio, viewport_size.y * pixelRatio);
+                shader.uniforms.vScreenResolution.value.set(resolution_x, resolution_y);
 
             });
         }

package/src/engine/graphics/geometry/AttributeGroupSpec.d.ts

@@ -1,25 +1,75 @@
-import {AttributeSpec} from "./AttributeSpec";
-
-export class AttributeGroupSpec {
-    readonly attributes: AttributeSpec[]
-
-    static from(...attributes: AttributeSpec[]): AttributeGroupSpec
-
-    getAttributeByName(name: string): AttributeSpec | undefined
-
-    add(attribute: AttributeSpec): this
-
-    setAttributes(attributes: AttributeSpec[]): void
-
-    equals(other: AttributeGroupSpec): boolean
-
-    hash(): number
-
-    toJSON(): any
-
-    fromJSON(json: any): void
-
-    getByteSize(): number
-
-    readonly isVertexDataSpec: true
-}
+/**
+ * Describes a set of data attributes. A good analogy would be "all data associated with geometry vertex"
+ * @example "uv","position" and "normal" attributes of geometry vertices
+ */
+export class AttributeGroupSpec {
+    /**
+     *
+     * @param {AttributeSpec} attributes
+     * @returns {AttributeGroupSpec}
+     */
+    static from(...attributes: AttributeSpec): AttributeGroupSpec;
+    /**
+     * @readonly
+     * @type {AttributeSpec[]}
+     */
+    readonly attributes: AttributeSpec[];
+    /**
+     *
+     * @param {string} name
+     * @return {AttributeSpec|undefined}
+     */
+    getAttributeByName(name: string): AttributeSpec | undefined;
+    /**
+     * @returns {number} -1 if not found
+     * @param {string} name
+     */
+    getAttributeIndexByName(name: string): number;
+    /**
+     *
+     * @param {AttributeSpec[]} attributes
+     * @throws {Error} if any there are any name collisions
+     */
+    addMany(attributes: AttributeSpec[]): void;
+    /**
+     *
+     * @param {AttributeSpec} attribute
+     * @return {AttributeGroupSpec}
+     * @throws {Error} if attribute with that name is already present
+     */
+    add(attribute: AttributeSpec): AttributeGroupSpec;
+    /**
+     * Replace existing attributes
+     * @param {AttributeSpec[]} attributes
+     */
+    setAttributes(attributes: AttributeSpec[]): void;
+    clear(): void;
+    /**
+     *
+     * @param {AttributeGroupSpec} other
+     * @returns {boolean}
+     */
+    equals(other: AttributeGroupSpec): boolean;
+    computeHash(): number;
+    hash(): number;
+    toJSON(): {
+        attributes: any[];
+    };
+    fromJSON({ attributes }: {
+        attributes?: any[];
+    }): void;
+    /**
+     * Size of a single element of all attributes.
+     * @example 2 attributes float32 and uin8 will produce result of 5 ( = (32 + 8) / 8 )
+     * @returns {number}
+     */
+    getByteSize(): number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isAttributeGroupSpec: boolean;
+    #private;
+}
+import { AttributeSpec } from "./AttributeSpec.js";
+//# sourceMappingURL=AttributeGroupSpec.d.ts.map

package/src/engine/graphics/geometry/AttributeSpec.d.ts

@@ -1,12 +1,85 @@
-import {BinaryDataType} from "../../../core/binary/type/BinaryDataType";
-
-export class AttributeSpec {
-    readonly name: string
-    readonly type: BinaryDataType
-    readonly itemSize: number
-    readonly normalized: boolean
-
-    fromJSON(json: { name: string, type: BinaryDataType, itemSize: number, normalized: boolean })
-
-    static fromJSON(json: { name: string, type: BinaryDataType, itemSize: number, normalized: boolean }): AttributeSpec
-}
+/**
+ * Describes data structure of a single data attribute, such as a scalar, or a vector
+ * This structure is designed to map well to GPU shader formats and is intended for larger datasets, such as meshes or particle clouds
+ */
+export class AttributeSpec {
+    /**
+     * Utility constructor
+     * @param {BinaryDataType} type
+     * @param {number} itemSize
+     * @param {boolean} [normalized]
+     * @param {string} [name]
+     * @returns {AttributeSpec}
+     */
+    static from(type: BinaryDataType, itemSize: number, normalized?: boolean, name?: string): AttributeSpec;
+    static fromJSON(j: any): AttributeSpec;
+    /**
+     * Sorting comparator
+     * @param {AttributeSpec} a
+     * @param {AttributeSpec} b
+     * @return {number}
+     */
+    static byName(a: AttributeSpec, b: AttributeSpec): number;
+    /**
+     * Typically unique within a given set, used to identify the attribute
+     * @type {string}
+     */
+    name: string;
+    /**
+     * How the attribute is stored in memory and interpreted
+     * @type {BinaryDataType}
+     */
+    type: BinaryDataType;
+    /**
+     * How many elements the attribute uses. This is cardinality of a vector.
+     * 1 means the attribute is a scalar
+     * must be greater or equal to 1
+     * @type {number}
+     */
+    itemSize: number;
+    /**
+     * Normalized values will be automatically converted to float32 in the shader
+     * This gives good optimization opportunities for things like normal vectors
+     * Applies to integer types only
+     * @type {boolean}
+     */
+    normalized: boolean;
+    fromJSON({ name, type, itemSize, normalized }: {
+        name?: string;
+        type: any;
+        itemSize: any;
+        normalized?: boolean;
+    }): void;
+    toJSON(): {
+        name: string;
+        type: string;
+        itemSize: number;
+        normalized: boolean;
+    };
+    toString(): string;
+    hash(): number;
+    /**
+     *
+     * @param {AttributeSpec} other
+     * @returns {boolean}
+     */
+    equals(other: AttributeSpec): boolean;
+    /**
+     *
+     * @param {AttributeSpec} other
+     */
+    copy(other: AttributeSpec): void;
+    clone(): AttributeSpec;
+    /**
+     * How much space a single attribute value takes up
+     * @returns {number} in bytes
+     */
+    getByteSize(): number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isAttributeSpec: boolean;
+}
+import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
+//# sourceMappingURL=AttributeSpec.d.ts.map

package/src/engine/graphics/geometry/instancing/InstancedMeshGroup.d.ts

@@ -100,7 +100,7 @@ export class InstancedMeshGroup {
      *
      * @param {DrawMode} v
      */
-    set draw_mode(arg: DrawMode);
+    set draw_mode(arg: number);
     /**
      *
      * @param {Usage} v
@@ -196,5 +196,4 @@ export type CacheKey = {
 };
 import { BufferGeometry } from 'three';
 import { Mesh } from 'three';
-import { DrawMode } from "../../ecs/mesh-v2/DrawMode.js";
 //# sourceMappingURL=InstancedMeshGroup.d.ts.map

package/src/engine/graphics/geometry/instancing/InstancedMeshGroup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InstancedMeshGroup.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/instancing/InstancedMeshGroup.js"],"names":[],"mappings":"AAyCA;IAqiBI;;;;;OAKG;IACH,sBAJW,oBAAoB,uBAElB,kBAAkB,CAS9B;IA5iBG;;;;OAIG;IACH,wBAA2B;IAE3B;;;;OAIG;IACH,gCAAmC;IAEnC;;;OAGG;IACH,cAAc;IAEd;;;OAGG;IACH,UAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,YAFU,MAAM,CAEK;IACrB;;;OAGG;IACH,cAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,cAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,gBAFU,MAAM,CAEQ;IAExB;;;;OAIG;IACH,6BAAgC;IAEhC;;;;OAIG;IACH,kCAAqC;IAGrC;;;;;OAKG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,8BAAiC;IAEjC;;;;OAIG;IACH,wBAAuC;IAEvC;;;;OAIG;IACH,mBAAsB;IAEtB,eAAiB;IACjB,kBAAoB;IAEpB;;;;OAIG;IACH,oBAAqC;IAErC,kFAAqC;IAErC,mBAAqB;IAGzB,qBA8BC;IAED;;;OAGG;IACH,6BAUC;IAED;;;OAGG;IACH,+BAcC;IAED;;;OAGG;IACH,4BAEC;IAED,gBAIC;IAED;;;OAGG;IACH,sBAFW,oBAAoB,QAU9B;IA4CD;;;OAGG;IACH,4BAFW,MAAM,QAAQ,GAAC,MAAM,cAAc,QAS7C;IAED;;;OAGG;IACH,kBAFW,MAAM,QAWhB;IAED;;;OAGG;IACH,qBAFW,MAAM,QA6BhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,aACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,QAIjD;IAED;;;;OAIG;IACH,kBAHW,MAAM,SACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,QAIjD;IAED;;;;;;;OAOG;IACH,6BANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAWhB;IAED,+BAMC;IAED;;;;OAIG;IACH,qCAEC;IAED;;;OAGG;IACH,0BAKC;IAED;;;OAGG;IACH,YAFY,MAAM,MAAI,CAIrB;IAED;;;;OAIG;IACH,yBAUC;IAED;;;;OAIG;IACH,sDAcC;IAED;;;OAGG;IACH,6BAoDC;IAED,cAiEC;;CAgBJ;;;;;+BAllBM,OAAO;qBAAP,OAAO;yBASW,+BAA+B"}
+{"version":3,"file":"InstancedMeshGroup.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/instancing/InstancedMeshGroup.js"],"names":[],"mappings":"AAyCA;IAqiBI;;;;;OAKG;IACH,sBAJW,oBAAoB,uBAElB,kBAAkB,CAS9B;IA5iBG;;;;OAIG;IACH,wBAA2B;IAE3B;;;;OAIG;IACH,gCAAmC;IAEnC;;;OAGG;IACH,cAAc;IAEd;;;OAGG;IACH,UAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,YAFU,MAAM,CAEK;IACrB;;;OAGG;IACH,cAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,cAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,gBAFU,MAAM,CAEQ;IAExB;;;;OAIG;IACH,6BAAgC;IAEhC;;;;OAIG;IACH,kCAAqC;IAGrC;;;;;OAKG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,8BAAiC;IAEjC;;;;OAIG;IACH,wBAAuC;IAEvC;;;;OAIG;IACH,mBAAsB;IAEtB,eAAiB;IACjB,kBAAoB;IAEpB;;;;OAIG;IACH,oBAAqC;IAErC,kFAAqC;IAErC,mBAAqB;IAGzB,qBA8BC;IAED;;;OAGG;IACH,2BAUC;IAED;;;OAGG;IACH,+BAcC;IAED;;;OAGG;IACH,4BAEC;IAED,gBAIC;IAED;;;OAGG;IACH,sBAFW,oBAAoB,QAU9B;IA4CD;;;OAGG;IACH,4BAFW,MAAM,QAAQ,GAAC,MAAM,cAAc,QAS7C;IAED;;;OAGG;IACH,kBAFW,MAAM,QAWhB;IAED;;;OAGG;IACH,qBAFW,MAAM,QA6BhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,aACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,QAIjD;IAED;;;;OAIG;IACH,kBAHW,MAAM,SACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,QAIjD;IAED;;;;;;;OAOG;IACH,6BANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAWhB;IAED,+BAMC;IAED;;;;OAIG;IACH,qCAEC;IAED;;;OAGG;IACH,0BAKC;IAED;;;OAGG;IACH,YAFY,MAAM,MAAI,CAIrB;IAED;;;;OAIG;IACH,yBAUC;IAED;;;;OAIG;IACH,sDAcC;IAED;;;OAGG;IACH,6BAoDC;IAED,cAiEC;;CAgBJ;;;;;+BAllBM,OAAO;qBAAP,OAAO"}

package/src/engine/graphics/impostors/octahedral/grid/OctahedralUvEncoder.d.ts

@@ -1,4 +1,6 @@
-import {UvEncoder} from "./UvEncoder";
-
-export declare class OctahedralUvEncoder extends UvEncoder {
-}
+export class OctahedralUvEncoder extends UvEncoder {
+    uv_to_unit(output: any, input: any): void;
+    unit_to_uv(output: any, input: any): void;
+}
+import { UvEncoder } from "./UvEncoder.js";
+//# sourceMappingURL=OctahedralUvEncoder.d.ts.map

package/src/engine/graphics/material/manager/MaterialManager.d.ts

@@ -17,6 +17,18 @@ export class MaterialManager {
      * @private
      */
     private __reverse_library;
+    /**
+     * Identity-keyed shortcut over {@link __library} + {@link __reverse_library}.
+     * Maps both a source material and its compiled material (by object identity) to
+     * the managed container, letting {@link obtain} skip the content-hash lookups
+     * for exact repeat calls - the common case. Kept in lockstep with
+     * {@link __library} membership: entries are added when a material is registered
+     * and removed in {@link __handle_last_reference_removed}, so a hit here always
+     * denotes a library-resident (live) material and never a cached one.
+     * @type {WeakMap<Material, ManagedMaterial>}
+     * @private
+     */
+    private __reverse_library_weak;
     /**
      *
      * @type {AbstractMaterialTransformer[]}

package/src/engine/graphics/material/manager/MaterialManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MaterialManager.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/material/manager/MaterialManager.js"],"names":[],"mappings":"AAMA;IAGQ;;;;OAIG;IACH,kBAIE;IAEF;;;;OAIG;IACH,gBAIE;IAEF;;;;OAIG;IACH,0BAIE;IAIF;;;;OAIG;IACH,0BAA2B;IAG/B;;;;;OAKG;IACH,2BAEC;IAED;;;;OAIG;IACH,wCAUC;IAED;;;;OAIG;IACH,sCAFY,6BAA6B,CAIxC;IAED;;;OAGG;IACH,uDAEC;IAED;;;;OAIG;IACH,qDAFa,OAAO,CAYnB;IAED;;;;;OAKG;IACH,kBAcC;IAGD;;;;OAIG;IACH,8CAmCC;CACJ"}
+{"version":3,"file":"MaterialManager.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/material/manager/MaterialManager.js"],"names":[],"mappings":"AAMA;IAEI;;;;OAIG;IACH,kBAIG;IAEH;;;;OAIG;IACH,gBAIG;IAEH;;;;OAIG;IACH,0BAIG;IAEH;;;;;;;;;;OAUG;IACH,+BAAuC;IAEvC;;;;OAIG;IACH,0BAAuB;IAOvB;;;;;OAKG;IACH,2BAEC;IAED;;;;OAIG;IACH,wCAcC;IAED;;;;OAIG;IACH,sCAFY,6BAA6B,CAIxC;IAED;;;OAGG;IACH,uDAEC;IAED;;;;OAIG;IACH,qDAFa,OAAO,CAYnB;IAED;;;;;OAKG;IACH,kBAcC;IAGD;;;;OAIG;IACH,8CAsDC;CACJ"}