@mml-io/3d-web-client-core 0.22.0 → 0.23.1

package/build/character/instancing/vendor/core/feature/Capacity.d.ts

@@ -0,0 +1,13 @@
+declare module "../InstancedMesh2" {
+    interface InstancedMesh2 {
+        /**
+         * Resizes internal buffers to accommodate the specified capacity.
+         * This ensures that the buffers are large enough to handle the required number of instances.
+         * @param capacity The new capacity of the buffers.
+         * @returns The current `InstancedMesh2` instance.
+         */
+        resizeBuffers(capacity: number): this;
+        /** @internal */ setInstancesArrayCount(count: number): void;
+    }
+}
+export {};

package/build/character/instancing/vendor/core/feature/FrustumCulling.d.ts

@@ -0,0 +1,37 @@
+import { Camera } from "three";
+import { InstancedRenderItem } from "../utils/InstancedRenderList";
+import { LODRenderList } from "./LOD";
+/**
+ * A custom sorting callback for render items.
+ */
+export type CustomSortCallback = (list: InstancedRenderItem[]) => void;
+/**
+ * Callback invoked when an instance is within the frustum.
+ * @param index The index of the instance.
+ * @param camera The camera used for rendering.
+ * @param cameraLOD The camera used for LOD calculations (provided only if LODs are initialized).
+ * @param LODindex The LOD level of the instance (provided only if LODs are initialized and `sortObjects` is false).
+ * @returns True if the instance should be rendered, false otherwise.
+ */
+export type OnFrustumEnterCallback = (index: number, camera: Camera, cameraLOD?: Camera, LODindex?: number) => boolean;
+declare module "../InstancedMesh2" {
+    interface InstancedMesh2 {
+        /**
+         * Performs frustum culling and manages LOD visibility.
+         * @param camera The main camera used for rendering.
+         * @param cameraLOD An optional camera for LOD calculations. Defaults to the main camera.
+         */
+        performFrustumCulling(camera: Camera, cameraLOD?: Camera): void;
+        /** @internal */ frustumCulling(camera: Camera): void;
+        /** @internal */ updateIndexArray(): void;
+        /** @internal */ updateRenderList(): void;
+        /** @internal */ BVHCulling(camera: Camera): void;
+        /** @internal */ linearCulling(camera: Camera): void;
+        /** @internal */ frustumCullingLOD(LODrenderList: LODRenderList, camera: Camera, cameraLOD: Camera): void;
+        /** @internal */ BVHCullingLOD(LODrenderList: LODRenderList, indexes: Uint32Array[], sortObjects: boolean, camera: Camera, cameraLOD: Camera): void;
+        /** @internal */ linearCullingLOD(LODrenderList: LODRenderList, indexes: Uint32Array[], sortObjects: boolean, camera: Camera, cameraLOD: Camera): void;
+        /** @internal */ getObjectLODIndexForDistance(levels: {
+            distance: number;
+        }[], distance: number): number;
+    }
+}

package/build/character/instancing/vendor/core/feature/Instances.d.ts

@@ -0,0 +1,49 @@
+import { InstancedEntity } from "../InstancedEntity";
+/**
+ * Represents an extended entity type with custom data.
+ */
+export type Entity<T> = InstancedEntity & T;
+/**
+ * A callback function used to update or initialize an entity.
+ */
+export type UpdateEntityCallback<T = InstancedEntity> = (obj: Entity<T>, index: number) => void;
+declare module "../InstancedMesh2" {
+    interface InstancedMesh2<TData = {}> {
+        /**
+         * Updates instances by applying a callback function to each instance. It calls `updateMatrix` for each instance.
+         * @param onUpdate A callback function to update each entity.
+         * @returns The current `InstancedMesh2` instance.
+         */
+        updateInstances(onUpdate: UpdateEntityCallback<Entity<TData>>): this;
+        /**
+         * Updates instances position by applying a callback function to each instance. It calls `updateMatrixPosition` for each instance.
+         * This method updates only the position attributes of the matrix.
+         * @param onUpdate A callback function to update each entity.
+         * @returns The current `InstancedMesh2` instance.
+         */
+        updateInstancesPosition(onUpdate: UpdateEntityCallback<Entity<TData>>): this;
+        /**
+         * Adds new instances and optionally initializes them using a callback function.
+         * @param count The number of new instances to add.
+         * @param onCreation An optional callback to initialize each new entity.
+         * @returns The current `InstancedMesh2` instance.
+         */
+        addInstances(count: number, onCreation?: UpdateEntityCallback<Entity<TData>>): this;
+        /**
+         * Removes instances by their ids.
+         * @param ids The ids of the instances to remove.
+         * @returns The current `InstancedMesh2` instance.
+         */
+        removeInstances(...ids: number[]): this;
+        /**
+         * Clears all instances and resets the instance count.
+         * @returns The current `InstancedMesh2` instance.
+         */
+        clearInstances(): this;
+        /** @internal */ clearTempInstance(index: number): InstancedEntity;
+        /** @internal */ clearTempInstancePosition(index: number): InstancedEntity;
+        /** @internal */ clearInstance(instance: InstancedEntity): InstancedEntity;
+        /** @internal */ createEntities(start: number): this;
+        /** @internal */ addInstance(id: number, onCreation?: UpdateEntityCallback): void;
+    }
+}

package/build/character/instancing/vendor/core/feature/LOD.d.ts

@@ -0,0 +1,89 @@
+import { BufferGeometry, Material } from "three";
+import { InstancedMesh2 } from "../InstancedMesh2";
+/**
+ * Represents information about Level of Detail (LOD).
+ * @template TData Type for additional instance data.
+ */
+export interface LODInfo<TData = {}> {
+    /**
+     * Render settings for the LOD.
+     */
+    render: LODRenderList<TData>;
+    /**
+     * Shadow rendering settings for the LOD.
+     */
+    shadowRender: LODRenderList<TData>;
+    /**
+     * List of `InstancedMesh2` associated to LODs.
+     */
+    objects: InstancedMesh2<TData>[];
+}
+/**
+ * Represents a list of render levels for LOD.
+ * @template TData Type for additional instance data.
+ */
+export interface LODRenderList<TData = {}> {
+    /**
+     * Array of LOD levels.
+     */
+    levels: LODLevel<TData>[];
+    /**
+     * Array of instance counts per LOD level, used internally.
+     */
+    count: number[];
+}
+/**
+ * Represents a single LOD level.
+ * @template TData Type for additional instance data.
+ */
+export interface LODLevel<TData = {}> {
+    /**
+     * The squared distance at which this LOD level becomes active.
+     */
+    distance: number;
+    /**
+     * Hysteresis value to prevent LOD flickering when transitioning.
+     */
+    hysteresis: number;
+    /**
+     * The `InstancedMesh2` object associated with this LOD level.
+     */
+    object: InstancedMesh2<TData>;
+}
+declare module "../InstancedMesh2" {
+    interface InstancedMesh2 {
+        /**
+         * Retrieves the index of the LOD level for a given distance.
+         * @param levels The array of LOD levels.
+         * @param distance The squared distance from the camera to the object.
+         * @returns The index of the LOD level that should be used.
+         */
+        getObjectLODIndexForDistance(levels: LODLevel[], distance: number): number;
+        /**
+         * Sets the first LOD (using current geometry) distance and hysteresis.
+         * @param distance The distance for the first LOD.
+         * @param hysteresis The hysteresis value for the first LOD.
+         * @returns The current `InstancedMesh2` instance.
+         */
+        setFirstLODDistance(distance?: number, hysteresis?: number): this;
+        /**
+         * Adds a new LOD level with the given geometry, material, and distance.
+         * @param geometry The geometry for the LOD level.
+         * @param material The material for the LOD level.
+         * @param distance The distance for this LOD level.
+         * @param hysteresis The hysteresis value for this LOD level.
+         * @returns The current `InstancedMesh2` instance.
+         */
+        addLOD(geometry: BufferGeometry, material: Material | Material[], distance?: number, hysteresis?: number): this;
+        /**
+         * Adds a shadow-specific LOD level with the given geometry and distance.
+         * @param geometry The geometry for the shadow LOD.
+         * @param distance The distance for this LOD level.
+         * @param hysteresis The hysteresis value for this LOD level.
+         * @returns The current `InstancedMesh2` instance.
+         */
+        addShadowLOD(geometry: BufferGeometry, distance?: number, hysteresis?: number): this;
+        /** @internal */ addLevel(renderList: LODRenderList, geometry: BufferGeometry, material: Material | Material[], distance: number, hysteresis: number): InstancedMesh2;
+        /** @internal */ patchLevel(obj: InstancedMesh2): void;
+    }
+}

package/build/character/instancing/vendor/core/feature/Morph.d.ts

@@ -0,0 +1,18 @@
+import { Mesh } from "three";
+declare module "../InstancedMesh2" {
+    interface InstancedMesh2 {
+        /**
+         * Gets the morph target data for a specific instance.
+         * @param id The index of the instance.
+         * @param object Optional `Mesh` to store the morph target data.
+         * @returns The mesh object with updated morph target influences.
+         */
+        getMorphAt(id: number, object?: Mesh): Mesh;
+        /**
+         * Sets the morph target influences for a specific instance.
+         * @param id The index of the instance.
+         * @param object The `Mesh` containing the morph target influences to apply.
+         */
+        setMorphAt(id: number, object: Mesh): void;
+    }
+}

package/build/character/instancing/vendor/core/feature/Raycasting.d.ts

@@ -0,0 +1,7 @@
+import { Intersection, Raycaster } from "three";
+declare module "../InstancedMesh2" {
+    interface InstancedMesh2 {
+        /** @internal */ raycastInstances(raycaster: Raycaster, result: Intersection[]): void;
+        /** @internal */ checkObjectIntersection(raycaster: Raycaster, objectIndex: number, result: Intersection[]): void;
+    }
+}

package/build/character/instancing/vendor/core/feature/Skeleton.d.ts

@@ -0,0 +1,19 @@
+import { Matrix4, Skeleton } from "three";
+declare module "../InstancedMesh2" {
+    interface InstancedMesh2 {
+        /**
+         * Initialize the skeleton of the instances.
+         * @param skeleton The skeleton to initialize.
+         * @param disableMatrixAutoUpdate Whether to disable the matrix auto update of the bones. Default is `true`.
+         */
+        initSkeleton(skeleton: Skeleton, disableMatrixAutoUpdate?: boolean): void;
+        /**
+         * Set the bones of the skeleton to the instance at the specified index.
+         * @param id The index of the instance.
+         * @param updateBonesMatrices Whether to update the matrices of the bones. Default is `true`.
+         * @param excludeBonesSet An optional set of bone names to exclude from updates, skipping their local matrix updates.
+         */
+        setBonesAt(id: number, updateBonesMatrices?: boolean): void;
+        /** internal */ multiplyBoneMatricesAt(instanceIndex: number, boneIndex: number, m1: Matrix4, m2: Matrix4): void;
+    }
+}

package/build/character/instancing/vendor/core/feature/Uniforms.d.ts

@@ -0,0 +1,42 @@
+import { ChannelSize, UniformMap, UniformType, UniformValue, UniformValueObj } from "../utils/SquareDataTexture";
+type UniformSchema = {
+    [x: string]: UniformType;
+};
+type UniformSchemaShader = {
+    vertex?: UniformSchema;
+    fragment?: UniformSchema;
+};
+type UniformSchemaResult = {
+    channels: ChannelSize;
+    pixelsPerInstance: number;
+    uniformMap: UniformMap;
+    fetchInFragmentShader: boolean;
+};
+declare module "../InstancedMesh2" {
+    interface InstancedMesh2 {
+        /**
+         * Retrieves a uniform value for a specific instance.
+         * @param id The index of the instance.
+         * @param name The name of the uniform.
+         * @param target Optional target object to store the uniform value.
+         * @returns The uniform value for the specified instance.
+         */
+        getUniformAt(id: number, name: string, target?: UniformValueObj): UniformValue;
+        /**
+         * Sets a uniform value for a specific instance.
+         * @param id The index of the instance.
+         * @param name The name of the uniform.
+         * @param value The value to set for the uniform.
+         */
+        setUniformAt(id: number, name: string, value: UniformValue): void;
+        /**
+         * Initializes per-instance uniforms using a schema.
+         * @param schema The schema defining the uniforms.
+         */
+        initUniformsPerInstance(schema: UniformSchemaShader): void;
+        /** @internal */ getUniformSchemaResult(schema: UniformSchemaShader): UniformSchemaResult;
+        /** @internal */ getUniformOffset(size: number, tempOffset: number[]): number;
+        /** @internal */ getUniformSize(type: UniformType): number;
+    }
+}
+export {};

package/build/character/instancing/vendor/core/utils/GLInstancedBufferAttribute.d.ts

@@ -0,0 +1,42 @@
+import { GLBufferAttribute, TypedArray, WebGLRenderer } from "three";
+/**
+ * A class that extends `GLBufferAttribute` to handle instanced buffer attributes.
+ * This class was specifically created to allow updating instanced buffer attributes during the `onBeforeRender` callback,
+ * providing an efficient way to modify the buffer data dynamically before rendering.
+ */
+export declare class GLInstancedBufferAttribute extends GLBufferAttribute {
+    /**
+     * Indicates if this is an `isGLInstancedBufferAttribute`.
+     */
+    isGLInstancedBufferAttribute: boolean;
+    /**
+     * The number of meshes that share the same attribute data.
+     */
+    meshPerAttribute: number;
+    /**
+     * The data array that holds the attribute values.
+     */
+    array: TypedArray;
+    protected _cacheArray: TypedArray;
+    /** @internal */ _needsUpdate: boolean;
+    /** @internal */ isInstancedBufferAttribute: boolean;
+    /**
+     * @param gl The WebGL2RenderingContext used to create the buffer.
+     * @param type The type of data in the attribute.
+     * @param itemSize The number of elements per attribute.
+     * @param elementSize The size of individual elements in the array.
+     * @param array The data array that holds the attribute values.
+     * @param meshPerAttribute The number of meshes that share the same attribute data.
+     */
+    constructor(gl: WebGL2RenderingContext, type: GLenum, itemSize: number, elementSize: 1 | 2 | 4, array: TypedArray, meshPerAttribute?: number);
+    /**
+     * Updates the buffer data.
+     * This method is designed to be called during the `onBeforeRender` callback.
+     * It ensures that the attribute data is updated just before the rendering process begins.
+     * @param renderer The WebGLRenderer used to render the scene.
+     * @param count The number of elements to update in the buffer.
+     */
+    update(renderer: WebGLRenderer, count: number): void;
+    /** @internal */
+    clone(): this;
+}

package/build/character/instancing/vendor/core/utils/InstancedRenderList.d.ts

@@ -0,0 +1,25 @@
+export type InstancedRenderItem = {
+    index: number;
+    depth: number;
+    depthSort: number;
+};
+/**
+ * A class that creates and manages a list of render items, used to determine the rendering order based on depth.
+ */
+export declare class InstancedRenderList {
+    /**
+     * The main array that holds the list of render items for instanced rendering.
+     */
+    array: InstancedRenderItem[];
+    protected pool: InstancedRenderItem[];
+    /**
+     * Adds a new render item to the list.
+     * @param depth The depth value used for sorting or determining the rendering order.
+     * @param index The unique instance id of the render item.
+     */
+    push(depth: number, index: number): void;
+    /**
+     * Resets the render list by clearing the array.
+     */
+    reset(): void;
+}

package/build/character/instancing/vendor/core/utils/SquareDataTexture.d.ts

@@ -0,0 +1,156 @@
+import { Color, DataTexture, Matrix3, Matrix4, PixelFormat, TextureDataType, TypedArray, Vector2, Vector3, Vector4, WebGLRenderer, WebGLUtils } from "three";
+/**
+ * Represents the number of elements per pixel.
+ */
+export type ChannelSize = 1 | 2 | 3 | 4;
+/**
+ * A constructor signature for creating TypedArray.
+ */
+export type TypedArrayConstructor = new (count: number) => TypedArray;
+/**
+ * Represents the texture information including its data, size, format, and data type.
+ */
+export type TextureInfo = {
+    array: TypedArray;
+    size: number;
+    format: PixelFormat;
+    type: TextureDataType;
+};
+/**
+ * Represents information for updating rows in the texture, including the row index and number of rows.
+ */
+export type UpdateRowInfo = {
+    row: number;
+    count: number;
+};
+/**
+ * Defines the possible types of uniforms that can be used in shaders.
+ */
+export type UniformType = "float" | "vec2" | "vec3" | "vec4" | "mat3" | "mat4";
+/**
+ * Represents a value that can be used as a uniform.
+ */
+export type UniformValueObj = Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | Color;
+/**
+ * Defines a uniform value as either a number or a compatible Three.js object.
+ */
+export type UniformValue = number | UniformValueObj;
+/**
+ * Represents the schema for a uniform, defining its offset, size, and type.
+ */
+export type UniformMapType = {
+    offset: number;
+    size: number;
+    type: UniformType;
+};
+/**
+ * Represents a map of uniform names to their schema definitions.
+ */
+export type UniformMap = Map<string, UniformMapType>;
+/**
+ * Calculates the square texture size based on the capacity and pixels per instance.
+ * This ensures the texture is large enough to store all instances in a square layout.
+ * @param capacity The maximum number of instances allowed in the texture.
+ * @param pixelsPerInstance The number of pixels required for each instance.
+ * @returns The size of the square texture needed to store all the instances.
+ */
+export declare function getSquareTextureSize(capacity: number, pixelsPerInstance: number): number;
+/**
+ * Generates texture information (size, format, type) for a square texture based on the provided parameters.
+ * @param arrayType The constructor for the TypedArray.
+ * @param channels The number of channels in the texture.
+ * @param pixelsPerInstance The number of pixels required for each instance.
+ * @param capacity The maximum number of instances allowed in the texture.
+ * @returns An object containing the texture's array, size, format, and data type.
+ */
+export declare function getSquareTextureInfo(arrayType: TypedArrayConstructor, channels: ChannelSize, pixelsPerInstance: number, capacity: number): TextureInfo;
+/**
+ * A class that extends `DataTexture` to manage a square texture optimized for instances rendering.
+ * It supports dynamic resizing, partial update based on rows, and allows setting/getting uniforms per instance.
+ */
+export declare class SquareDataTexture extends DataTexture {
+    /**
+     * Whether to enable partial texture updates by row. If `false`, the entire texture will be updated.
+     * @default true.
+     */
+    partialUpdate: boolean;
+    /**
+     * The maximum number of update calls per frame.
+     * @default Infinity
+     */
+    maxUpdateCalls: number;
+    /** @internal */ _data: TypedArray;
+    protected _channels: ChannelSize;
+    protected _pixelsPerInstance: number;
+    protected _stride: number;
+    protected _rowToUpdate: boolean[];
+    protected _uniformMap?: UniformMap;
+    protected _fetchUniformsInFragmentShader?: boolean;
+    protected _utils?: WebGLUtils;
+    protected _lastWidth?: number;
+    /**
+     * @param arrayType The constructor for the TypedArray.
+     * @param channels The number of channels in the texture.
+     * @param pixelsPerInstance The number of pixels required for each instance.
+     * @param capacity The total number of instances.
+     * @param uniformMap Optional map for handling uniform values.
+     * @param fetchInFragmentShader Optional flag that determines if uniform values should be fetched in the fragment shader instead of the vertex shader.
+     */
+    constructor(arrayType: TypedArrayConstructor, channels: ChannelSize, pixelsPerInstance: number, capacity: number, uniformMap?: UniformMap, fetchInFragmentShader?: boolean);
+    /**
+     * Resizes the texture to accommodate a new number of instances.
+     * @param count The new total number of instances.
+     */
+    resize(count: number): void;
+    /**
+     * Marks a row of the texture for update during the next render cycle.
+     * This helps in optimizing texture updates by only modifying the rows that have changed.
+     * @param index The index of the instance to update.
+     */
+    enqueueUpdate(index: number): void;
+    /**
+     * Updates the texture data based on the rows that need updating.
+     * This method is optimized to only update the rows that have changed, improving performance.
+     * @param renderer The WebGLRenderer used for rendering.
+     */
+    update(renderer: WebGLRenderer): void;
+    protected getUpdateRowsInfo(): UpdateRowInfo[];
+    protected updateRows(textureProperties: any, renderer: WebGLRenderer, info: UpdateRowInfo[]): void;
+    /**
+     * Sets a uniform value at the specified instance ID in the texture.
+     * @param id The instance ID to set the uniform for.
+     * @param name The name of the uniform.
+     * @param value The value to set for the uniform.
+     */
+    setUniformAt(id: number, name: string, value: UniformValue): void;
+    /**
+     * Retrieves a uniform value at the specified instance ID from the texture.
+     * @param id The instance ID to retrieve the uniform from.
+     * @param name The name of the uniform.
+     * @param target Optional target object to store the uniform value.
+     * @returns The uniform value for the specified instance.
+     */
+    getUniformAt(id: number, name: string, target?: UniformValueObj): UniformValue;
+    /**
+     * Generates the GLSL code for accessing the uniform data stored in the texture.
+     * @param textureName The name of the texture in the GLSL shader.
+     * @param indexName The name of the index in the GLSL shader.
+     * @param indexType The type of the index in the GLSL shader.
+     * @returns An object containing the GLSL code for the vertex and fragment shaders.
+     */
+    getUniformsGLSL(textureName: string, indexName: string, indexType: string): {
+        vertex: string;
+        fragment: string;
+    };
+    protected getUniformsVertexGLSL(textureName: string, indexName: string, indexType: string): string;
+    protected getUniformsFragmentGLSL(textureName: string, indexName: string, indexType: string): string;
+    protected texelsFetchGLSL(textureName: string, indexName: string): string;
+    protected getFromTexelsGLSL(): string;
+    protected getVarying(): {
+        declareVarying: string;
+        assignVarying: string;
+        getVarying: string;
+    };
+    protected getUniformComponents(offset: number, size: number): string;
+    copy(source: SquareDataTexture): this;
+}

package/build/character/instancing/vendor/index.d.ts

@@ -0,0 +1,25 @@
+export * from "./core/InstancedEntity";
+export * from "./core/InstancedMesh2";
+export * from "./core/InstancedMeshBVH";
+import "./core/feature/Capacity";
+import "./core/feature/FrustumCulling";
+import "./core/feature/LOD";
+import "./core/feature/Morph";
+import "./core/feature/Raycasting";
+import "./core/feature/Skeleton";
+import "./core/feature/Uniforms";
+export type { Entity, UpdateEntityCallback } from "./core/feature/Instances";
+import "./core/feature/Instances";
+export * from "./core/utils/GLInstancedBufferAttribute";
+export * from "./core/utils/InstancedRenderList";
+export * from "./core/utils/SquareDataTexture";
+export * from "./shaders/ShaderChunk";
+export * from "./shaders/chunks/instanced_pars_vertex";
+export * from "./shaders/chunks/instanced_color_pars_vertex";
+export * from "./shaders/chunks/instanced_color_vertex";
+export * from "./shaders/chunks/instanced_material_color_pars_vertex";
+export * from "./shaders/chunks/instanced_material_color_vertex";
+export * from "./shaders/chunks/instanced_vertex";
+export * from "./shaders/chunks/instanced_skinning_pars_vertex";
+export * from "./utils/SortingUtils";
+export * from "./utils/CreateFrom";

package/build/character/instancing/vendor/shaders/ShaderChunk.d.ts

@@ -0,0 +1 @@
+export declare function patchShader(shader: string): string;

package/build/character/instancing/vendor/shaders/chunks/instanced_color_pars_vertex.d.ts

@@ -0,0 +1 @@
+export declare const instanced_color_pars_vertex = "\n\n#ifdef USE_INSTANCING_COLOR_INDIRECT\n  uniform highp sampler2D colorsTexture;\n\n  #ifdef USE_COLOR_ALPHA\n    vec4 getColorTexture() {\n      int size = textureSize( colorsTexture, 0 ).x;\n      int j = int( instanceIndex );\n      int x = j % size;\n      int y = j / size;\n      return texelFetch( colorsTexture, ivec2( x, y ), 0 );\n    }\n  #else\n    vec3 getColorTexture() {\n      int size = textureSize( colorsTexture, 0 ).x;\n      int j = int( instanceIndex );\n      int x = j % size;\n      int y = j / size;\n      return texelFetch( colorsTexture, ivec2( x, y ), 0 ).rgb;\n    }\n  #endif\n#endif\n";

package/build/character/instancing/vendor/shaders/chunks/instanced_color_vertex.d.ts

@@ -0,0 +1 @@
+export declare const instanced_color_vertex = "\n#ifdef USE_INSTANCING_COLOR_INDIRECT\n  #ifdef USE_VERTEX_COLOR\n    vColor = color;\n  #else\n    #ifdef USE_COLOR_ALPHA\n      vColor = vec4( 1.0 );\n    #else\n      vColor = vec3( 1.0 );\n    #endif\n  #endif\n#endif\n";

package/build/character/instancing/vendor/shaders/chunks/instanced_material_color_pars_vertex.d.ts

@@ -0,0 +1 @@
+export declare const instanced_material_color_pars_vertex = "\n#ifdef USE_INSTANCING_MATERIAL_COLORS\n  uniform highp sampler2D materialColorsTexture;\n\n  // material indices for the LUT\n  #define MATERIAL_HAIR 0\n  #define MATERIAL_SHIRT_SHORT 1\n  #define MATERIAL_SHIRT_LONG 2\n  #define MATERIAL_PANTS_SHORT 3\n  #define MATERIAL_PANTS_LONG 4\n  #define MATERIAL_SHOES 5\n  #define MATERIAL_SKIN 6\n  #define MATERIAL_LIPS 7\n\n  vec3 getMaterialColorTexture(int materialIndex) {\n    int size = textureSize(materialColorsTexture, 0).x;\n    int instanceId = int(instanceIndex);\n    int colorIndex = instanceId * 8 + materialIndex;\n    int x = colorIndex % size;\n    int y = colorIndex / size;\n    return texelFetch(materialColorsTexture, ivec2(x, y), 0).rgb;\n  }\n#endif\n";

package/build/character/instancing/vendor/shaders/chunks/instanced_material_color_vertex.d.ts

@@ -0,0 +1 @@
+export declare const instanced_material_color_vertex = "\n#ifdef USE_INSTANCING_MATERIAL_COLORS\n  #ifdef USE_VERTEX_COLOR\n    vec3 vertexColor = color;\n    vec3 instanceColor = vec3(1.0);\n    \n    if (vertexColor.r == 0.0 && vertexColor.g == 0.0 && vertexColor.b == 0.0) {\n      // Hair material (0, 0, 0)\n      instanceColor = getMaterialColorTexture(MATERIAL_HAIR);\n    } else if (vertexColor.r == 0.0 && vertexColor.g == 0.0 && vertexColor.b == 1.0) {\n      // Shirt short material (0, 0, 1)\n      instanceColor = getMaterialColorTexture(MATERIAL_SHIRT_SHORT);\n    } else if (vertexColor.r == 0.0 && vertexColor.g == 1.0 && vertexColor.b == 0.0) {\n      // Shirt long material (0, 1, 0)\n      instanceColor = getMaterialColorTexture(MATERIAL_SHIRT_LONG);\n    } else if (vertexColor.r == 0.0 && vertexColor.g == 1.0 && vertexColor.b == 1.0) {\n      // Pants short material (0, 1, 1)\n      instanceColor = getMaterialColorTexture(MATERIAL_PANTS_SHORT);\n    } else if (vertexColor.r == 1.0 && vertexColor.g == 0.0 && vertexColor.b == 0.0) {\n      // Pants long material (1, 0, 0)\n      instanceColor = getMaterialColorTexture(MATERIAL_PANTS_LONG);\n    } else if (vertexColor.r == 1.0 && vertexColor.g == 0.0 && vertexColor.b == 1.0) {\n      // Shoes material (1, 0, 1)\n      instanceColor = getMaterialColorTexture(MATERIAL_SHOES);\n    } else if (vertexColor.r == 1.0 && vertexColor.g == 1.0 && vertexColor.b == 0.0) {\n      // Skin material (1, 1, 0)\n      instanceColor = getMaterialColorTexture(MATERIAL_SKIN);\n    } else if (vertexColor.r == 1.0 && vertexColor.g == 1.0 && vertexColor.b == 1.0) {\n      // Lips material (1, 1, 1)\n      instanceColor = getMaterialColorTexture(MATERIAL_LIPS);\n    } else if (vertexColor.r == 0.5 && vertexColor.g == 0.0 && vertexColor.b == 0.0) {\n      // Eyes black material (0.5, 0, 0)\n      instanceColor = getMaterialColorTexture(MATERIAL_SKIN); // Using skin index for now\n    } else if (vertexColor.r == 0.0 && vertexColor.g == 0.5 && vertexColor.b == 0.0) {\n      // Eyes white material (0, 0.5, 0)\n      instanceColor = getMaterialColorTexture(MATERIAL_SKIN); // Using skin index for now\n    }\n    \n    vColor = instanceColor;\n  #else\n    vColor = vec3(1.0);\n  #endif\n#endif\n";

package/build/character/instancing/vendor/shaders/chunks/instanced_pars_vertex.d.ts

@@ -0,0 +1 @@
+export declare const instanced_pars_vertex = "\n#ifdef USE_INSTANCING_INDIRECT\n  attribute uint instanceIndex;\n  uniform highp sampler2D matricesTexture;  \n\n  mat4 getInstancedMatrix() {\n    int size = textureSize( matricesTexture, 0 ).x;\n    int j = int( instanceIndex ) * 4;\n    int x = j % size;\n    int y = j / size;\n    vec4 v1 = texelFetch( matricesTexture, ivec2( x, y ), 0 );\n    vec4 v2 = texelFetch( matricesTexture, ivec2( x + 1, y ), 0 );\n    vec4 v3 = texelFetch( matricesTexture, ivec2( x + 2, y ), 0 );\n    vec4 v4 = texelFetch( matricesTexture, ivec2( x + 3, y ), 0 );\n    return mat4( v1, v2, v3, v4 );\n  }\n#endif\n";

package/build/character/instancing/vendor/shaders/chunks/instanced_skinning_pars_vertex.d.ts

@@ -0,0 +1 @@
+export declare const instanced_skinning_pars_vertex = "\n#ifdef USE_SKINNING\n  uniform mat4 bindMatrix;\n  uniform mat4 bindMatrixInverse;\n  uniform highp sampler2D boneTexture;\n\n  #ifdef USE_INSTANCING_SKINNING\n    uniform int bonesPerInstance;\n  #endif\n\n  mat4 getBoneMatrix( const in float i ) {\n    int size = textureSize( boneTexture, 0 ).x;\n\n    #ifdef USE_INSTANCING_SKINNING\n      int j = ( bonesPerInstance * int( instanceIndex ) + int( i ) ) * 4;\n    #else\n      int j = int( i ) * 4;\n    #endif\n\n    int x = j % size;\n    int y = j / size;\n    vec4 v1 = texelFetch( boneTexture, ivec2( x, y ), 0 );\n    vec4 v2 = texelFetch( boneTexture, ivec2( x + 1, y ), 0 );\n    vec4 v3 = texelFetch( boneTexture, ivec2( x + 2, y ), 0 );\n    vec4 v4 = texelFetch( boneTexture, ivec2( x + 3, y ), 0 );\n    return mat4( v1, v2, v3, v4 );\n  }\n#endif\n";

package/build/character/instancing/vendor/shaders/chunks/instanced_vertex.d.ts

@@ -0,0 +1 @@
+export declare const instanced_vertex = "\n#ifdef USE_INSTANCING_INDIRECT\n  mat4 instanceMatrix = getInstancedMatrix();\n\n  #ifdef USE_INSTANCING_COLOR_INDIRECT\n    vColor *= getColorTexture();\n  #endif\n#endif\n";

package/build/character/instancing/vendor/utils/CreateFrom.d.ts

@@ -0,0 +1,9 @@
+import { Mesh } from "three";
+import { InstancedMesh2, InstancedMesh2Params } from "../core/InstancedMesh2";
+/**
+ * Create an `InstancedMesh2` instance from an existing `Mesh` or `InstancedMesh`.
+ * @param mesh The `Mesh` or `InstancedMesh` to create an `InstanceMesh2` from.
+ * @param params  Optional configuration parameters object. See `InstancedMesh2Params` for details.
+ * @returns The created `InstancedMesh2` instance.
+ */
+export declare function createInstancedMesh2From<TData = object>(mesh: Mesh, params?: InstancedMesh2Params): InstancedMesh2<TData>;

package/build/character/instancing/vendor/utils/SortingUtils.d.ts

@@ -0,0 +1,16 @@
+import { InstancedMesh2 } from "../core/InstancedMesh2";
+import { InstancedRenderItem } from "../core/utils/InstancedRenderList";
+type radixSortCallback = (list: InstancedRenderItem[]) => void;
+/**
+ * Creates a radix sort function specifically for sorting `InstancedMesh2` instances.
+ * The sorting is based on the `depth` property of each `InstancedRenderItem`.
+ * This function dynamically adjusts for transparent materials by reversing the sort order if necessary.
+ * @param target The `InstancedMesh2` instance that contains the instances to be sorted.
+ * @returns A radix sort function.
+ */
+export declare function createRadixSort(target: InstancedMesh2): radixSortCallback;
+/** @internal */
+export declare function sortOpaque(a: InstancedRenderItem, b: InstancedRenderItem): number;
+/** @internal */
+export declare function sortTransparent(a: InstancedRenderItem, b: InstancedRenderItem): number;
+export {};

package/build/character/loading/CharacterModelLoader.d.ts

@@ -0,0 +1,11 @@
+import { AnimationClip, Object3D } from "three";
+export declare class CharacterModelLoader {
+    private debug;
+    private readonly modelLoader;
+    private workerPool;
+    constructor(debug?: boolean);
+    loadModel(fileUrl: string, maxTextureSize: number, abortController?: AbortController): Promise<Object3D | null>;
+    loadAnimation(fileUrl: string, abortController?: AbortController): Promise<AnimationClip | null>;
+    private processGLTFInWorker;
+    private loadFromBuffer;
+}

package/build/character/loading/GLTFLoadingWorker.worker.d.ts

@@ -0,0 +1,2 @@
+declare const placeholder = "";
+export default placeholder;

package/build/character/loading/GLTFLoadingWorkerBrowserCache.d.ts

@@ -0,0 +1,8 @@
+export declare class GLTFLoadingWorkerBrowserCache {
+    private readonly cacheName;
+    private cache;
+    init(): Promise<void>;
+    private generateCacheKey;
+    get(fileUrl: string, maxTextureSize: number): Promise<ArrayBuffer | null>;
+    set(fileUrl: string, maxTextureSize: number, data: ArrayBuffer): Promise<void>;
+}

package/build/character/loading/GLTFLoadingWorkerPool.d.ts

@@ -0,0 +1,22 @@
+/**
+ * GLTFLoadingWorkerPool - gLTF loading and texture processing using Web Workers
+ *
+ * Features:
+ * - Loads gLTF files entirely in workers (off main thread)
+ * - Uses gltf-transform for gLTF manipulation
+ * - Processes and resizes textures in the worker
+ * - Caches processed gLTF files
+ */
+export declare class GLTFLoadingWorkerPool {
+    private workers;
+    private activeJobs;
+    private workerIndex;
+    private readonly maxWorkers;
+    constructor();
+    private handleWorkerMessage;
+    private handleWorkerError;
+    private getNextWorker;
+    processGLTF(fileUrl: string, maxTextureSize: number, abortController?: AbortController): Promise<ArrayBuffer>;
+    dispose(): void;
+}
+export declare const TextureWorkerPool: typeof GLTFLoadingWorkerPool;