@kingsy/viewer 2.25.7

package/dist/modules/loaders/KingSy/KingSyConverter.d.ts

@@ -0,0 +1,118 @@
+import { type TreeNode, WorldTree } from '../../tree/WorldTree.js';
+import { type KingSyObject } from '../../../index.js';
+import { ObjectLoader2 } from '@kingsy/objectloader2';
+export type ConverterResultDelegate = () => Promise<void>;
+export type KingSyConverterNodeDelegate = ((object: KingSyObject, node: TreeNode) => Promise<void>) | null;
+/**
+ * Utility class providing some top level conversion methods.
+ * Warning: HIC SVNT DRACONES.
+ */
+export default class KingSyConverter {
+    protected objectLoader: ObjectLoader2;
+    protected activePromises: number;
+    protected maxChildrenPromises: number;
+    protected spoofIDs: boolean;
+    protected tree: WorldTree;
+    protected subtree: TreeNode;
+    protected typeLookupTable: {
+        [type: string]: string;
+    };
+    protected instanceDefinitionLookupTable: {
+        [id: string]: TreeNode;
+    };
+    protected instancedObjectsLookupTable: {
+        [id: string]: KingSyObject;
+    };
+    protected instanceProxies: {
+        [id: string]: TreeNode;
+    };
+    protected renderMaterialMap: {
+        [id: string]: KingSyObject;
+    };
+    protected colorMap: {
+        [id: string]: KingSyObject;
+    };
+    protected instanceCounter: number;
+    protected readonly NodeConverterMapping: {
+        [name: string]: KingSyConverterNodeDelegate;
+    };
+    protected readonly IgnoreNodes: string[];
+    constructor(objectLoader: ObjectLoader2, tree: WorldTree);
+    /**
+     * If the object is convertible (there is a direct conversion routine), it will invoke the callback with the conversion result.
+     * If the object is not convertible, it will recursively iterate through it (arrays & objects) and invoke the callback on any positive conversion result.
+     * @param  {[type]}   obj      [description]
+     * @param  {Function} callback [description]
+     * @return {[type]}            [description]
+     */
+    traverse(objectURL: string, obj: KingSyObject, callback: ConverterResultDelegate, node?: TreeNode | null): Promise<void>;
+    private getNodeId;
+    /**
+     * Takes an array composed of chunked references and dechunks it.
+     * @param  {[type]} arr [description]
+     * @return {[type]}     [description]
+     */
+    private dechunk;
+    /**
+     * Resolves an object reference by waiting for the loader to load it up.
+     * @param  {[type]} obj [description]
+     * @return {[type]}     [description]
+     */
+    private resolveReference;
+    /**
+     * Gets the kingsy type of an object in various scenarios.
+     * @param  {[type]} obj [description]
+     * @return {[type]}     [description]
+     */
+    private getKingSyType;
+    private getKingSyTypeChain;
+    private directNodeConverterExists;
+    private convertToNode;
+    private getDisplayValue;
+    private getElementsValue;
+    private getBlockDefinition;
+    private getBlockDefinitionGeometry;
+    /** We're wasting a few milis here, but it is what it is */
+    private getCompoundId;
+    private getEmptyTransformData;
+    /**
+     *
+      NODES
+     */
+    private View3DToNode;
+    /** This is only used for Blocks to search for convertible objects, without using the main 'traverse' function
+     *  It's only looking for 'elements' and 'displayValues'
+     *  I think it can be used for RevitInstances as well to replace it's current lookup, but I'm afraid to do it
+     */
+    private displayableLookup;
+    private parseInstanceDefinitionGeometry;
+    private parseInstanceElement;
+    private BlockInstanceToNode;
+    private RevitInstanceToNode;
+    private InstanceDefinitionProxyToNode;
+    private InstanceProxyToNode;
+    private RenderMaterialProxyToNode;
+    private ColorProxyToNode;
+    private getInstanceProxyDefinitionId;
+    private getInstanceProxyTransform;
+    private getInstanceProxyDefinitionObjects;
+    private createTransformNode;
+    private ConvertInstanceProxyToNode;
+    convertInstances(): Promise<void>;
+    applyMaterials(): Promise<void>;
+    private PointcloudToNode;
+    private BrepToNode;
+    private MeshToNode;
+    private RegionToNode;
+    private TextToNode;
+    private DimensionToNode;
+    private PointToNode;
+    private LineToNode;
+    private PolylineToNode;
+    private BoxToNode;
+    private PolycurveToNode;
+    private CurveToNode;
+    private CircleToNode;
+    private ArcToNode;
+    private EllipseToNode;
+}

package/dist/modules/loaders/KingSy/KingSyGeometryConverter.d.ts

@@ -0,0 +1,127 @@
+import { type GeometryData } from '../../converter/Geometry.js';
+import { type NodeData } from '../../tree/WorldTree.js';
+import { Vector2, Vector3 } from 'three';
+import { GeometryConverter, KingSyType } from '../GeometryConverter.js';
+export declare class KingSyGeometryConverter extends GeometryConverter {
+    typeLookupTable: {
+        [type: string]: KingSyType;
+    };
+    meshTriangulationTime: number;
+    actualTriangulateTime: number;
+    pushTime: number;
+    getKingSyType(node: NodeData): KingSyType;
+    convertNodeToGeometryData(node: NodeData): GeometryData | null;
+    disposeNodeGeometryData(node: NodeData): void;
+    protected View3DToGeometryData(node: NodeData): GeometryData;
+    protected TransformToGeometryData(node: NodeData): GeometryData;
+    /** BLOCK INSTANCE */
+    protected BlockInstanceToGeometryData(node: NodeData): GeometryData | null;
+    /** REVIT INSTANCE */
+    protected RevitInstanceToGeometryData(node: NodeData): GeometryData | null;
+    /** DUI3 INSTANCE PROXY */
+    protected InstanceProxyToGeometyData(node: NodeData): GeometryData | null;
+    /**
+     * POINT CLOUD
+     */
+    protected PointcloudToGeometryData(node: NodeData): GeometryData | null;
+    /**
+     * BREP
+     */
+    protected BrepToGeometryData(node: NodeData): GeometryData | null;
+    /**
+     * REGION
+     */
+    protected RegionGeometyData(node: NodeData): GeometryData | null;
+    /**
+     * MESH
+     */
+    protected MeshToGeometryData(node: NodeData): GeometryData | null;
+    /**
+     * TEXT
+     */
+    protected TextToGeometryData(node: NodeData): GeometryData | null;
+    /**
+     * POINT
+     */
+    protected PointToGeometryData(node: NodeData): GeometryData | null;
+    /**
+     * LINE
+     */
+    protected LineToGeometryData(node: NodeData): GeometryData | null;
+    /**
+     * POLYLINE
+     */
+    protected PolylineToGeometryData(node: NodeData): GeometryData | null;
+    /**
+     * BOX
+     */
+    protected BoxToGeometryData(node: NodeData): GeometryData | null;
+    /**
+     * POLYCURVE
+     */
+    protected PolycurveToGeometryData(node: NodeData): GeometryData | null;
+    /**
+     * CURVE
+     */
+    protected CurveToGeometryData(node: NodeData): GeometryData | null;
+    /**
+     * CIRCLE
+     */
+    protected CircleToGeometryData(node: NodeData): GeometryData | null;
+    /**
+     * ARC
+     */
+    protected ArcToGeometryData(node: NodeData): GeometryData | null;
+    /**
+     * ELLIPSE
+     */
+    protected EllipseToGeometryData(node: NodeData): GeometryData | null;
+    /**
+     * UTILS
+     */
+    protected getCircularCurvePoints(plane: {
+        xdir: {
+            value: Array<number>;
+            units: string;
+        } & {
+            x: number;
+            y: number;
+            z: number;
+        };
+        ydir: {
+            value: Array<number>;
+            units: string;
+        } & {
+            x: number;
+            y: number;
+            z: number;
+        };
+        origin: {
+            value: Array<number>;
+            units: string;
+        } & {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }, radius: number, startAngle?: number, endAngle?: number, res?: number): Vector3[];
+    protected PointToVector3(obj: {
+        value: Array<number>;
+        units: string;
+    } & {
+        x: number;
+        y: number;
+        z: number;
+    }, scale?: boolean): Vector3;
+    protected PointToFloatArray(obj: {
+        value: Array<number>;
+        units: string;
+    } & {
+        x: number;
+        y: number;
+        z: number;
+    }): number[];
+    protected FlattenVector3Array(input: Vector3[] | Vector2[]): number[];
+    protected unpackColors(int32Colors: number[], tolinear?: boolean): number[];
+    protected srgbToLinear(x: number): number;
+}

package/dist/modules/loaders/KingSy/KingSyLoader.d.ts

@@ -0,0 +1,18 @@
+import KingSyConverter from './KingSyConverter.js';
+import { Loader } from '../Loader.js';
+import { WorldTree } from '../../../index.js';
+import { ObjectLoader2 } from '@kingsy/objectloader2';
+export declare class KingSyLoader extends Loader {
+    protected loader: ObjectLoader2;
+    protected converter: KingSyConverter;
+    protected tree: WorldTree;
+    protected isCancelled: boolean;
+    protected isFinished: boolean;
+    get resource(): string;
+    get finished(): boolean;
+    constructor(targetTree: WorldTree, resource: string, authToken?: string, enableCaching?: boolean, resourceData?: unknown);
+    protected initObjectLoader(resource: string, authToken?: string, _enableCaching?: boolean, resourceData?: unknown): ObjectLoader2;
+    load(): Promise<boolean>;
+    cancel(): void;
+    dispose(): void;
+}

package/dist/modules/loaders/KingSy/KingSyOfflineLoader.d.ts

@@ -0,0 +1,8 @@
+import { KingSyLoader } from './KingSyLoader.js';
+import { WorldTree } from '../../tree/WorldTree.js';
+import { ObjectLoader2 } from '@kingsy/objectloader2';
+export declare class KingSyOfflineLoader extends KingSyLoader {
+    constructor(targetTree: WorldTree, resourceData: unknown, resourceId?: string);
+    protected initObjectLoader(_resource: string, _authToken?: string, _enableCaching?: boolean, resourceData?: unknown): ObjectLoader2;
+    load(): Promise<boolean>;
+}

package/dist/modules/loaders/Loader.d.ts

@@ -0,0 +1,35 @@
+import EventEmitter from '../EventEmitter.js';
+export declare enum LoaderEvent {
+    LoadProgress = "load-progress",
+    LoadCancelled = "load-cancelled",
+    LoadWarning = "load-warning",
+    Converted = "converted",
+    Traversed = "traversed"
+}
+export interface LoaderEventPayload {
+    [LoaderEvent.LoadProgress]: {
+        progress: number;
+        id: string;
+    };
+    [LoaderEvent.Converted]: {
+        count: number;
+    };
+    [LoaderEvent.Traversed]: {
+        count: number;
+    };
+    [LoaderEvent.LoadCancelled]: string;
+    [LoaderEvent.LoadWarning]: {
+        message: string;
+    };
+}
+export declare abstract class Loader extends EventEmitter {
+    protected _resource: string;
+    protected _resourceData: unknown;
+    abstract get resource(): string;
+    abstract get finished(): boolean;
+    protected constructor(resource: string, resourceData?: unknown);
+    on<T extends LoaderEvent>(eventType: T, listener: (arg: LoaderEventPayload[T]) => void): void;
+    abstract load(): Promise<boolean>;
+    abstract cancel(): void;
+    dispose(): void;
+}

package/dist/modules/loaders/OBJ/ObjConverter.d.ts

@@ -0,0 +1,18 @@
+import { Object3D } from 'three';
+import { type TreeNode, WorldTree } from '../../tree/WorldTree.js';
+import type { ConverterResultDelegate } from '../KingSy/KingSyConverter.js';
+export type ObjConverterNodeDelegate = ((object: Object3D, node: TreeNode) => Promise<void>) | null;
+export declare class ObjConverter {
+    protected lastAsyncPause: number;
+    protected tree: WorldTree;
+    protected readonly NodeConverterMapping: {
+        [name: string]: ObjConverterNodeDelegate;
+    };
+    constructor(tree: WorldTree);
+    asyncPause(): Promise<void>;
+    traverse(objectURL: string, object: Object3D, callback: ConverterResultDelegate, node?: TreeNode | null): Promise<void>;
+    private directNodeConverterExists;
+    private convertToNode;
+    private MeshToNode;
+    private groupToNode;
+}

package/dist/modules/loaders/OBJ/ObjGeometryConverter.d.ts

@@ -0,0 +1,14 @@
+import { type NodeData } from '../../../index.js';
+import { type GeometryData } from '../../converter/Geometry.js';
+import { GeometryConverter, KingSyType } from '../GeometryConverter.js';
+export declare class ObjGeometryConverter extends GeometryConverter {
+    getKingSyType(node: NodeData): KingSyType;
+    convertNodeToGeometryData(node: NodeData): GeometryData | null;
+    disposeNodeGeometryData(node: NodeData): void;
+    /** BLOCK INSTANCE */
+    protected BlockInstanceToGeometryData(node: NodeData): GeometryData;
+    /**
+     * MESH
+     */
+    protected MeshToGeometryData(node: NodeData): GeometryData | null;
+}

package/dist/modules/loaders/OBJ/ObjLoader.d.ts

@@ -0,0 +1,16 @@
+import { Loader } from '../Loader.js';
+import { OBJLoader } from 'three/examples/jsm/loaders/OBJLoader.js';
+import { ObjConverter } from './ObjConverter.js';
+import { WorldTree } from '../../../index.js';
+export declare class ObjLoader extends Loader {
+    protected baseLoader: OBJLoader;
+    protected converter: ObjConverter;
+    protected tree: WorldTree;
+    protected isFinished: boolean;
+    get resource(): string;
+    get finished(): boolean;
+    constructor(targetTree: WorldTree, resource: string, resourceData?: unknown);
+    load(): Promise<boolean>;
+    cancel(): void;
+    dispose(): void;
+}

package/dist/modules/materials/KingSyBasicMaterial.d.ts

@@ -0,0 +1,26 @@
+import { Material, type IUniform, Vector2, type MeshBasicMaterialParameters, Scene, Camera, BufferGeometry, Object3D } from 'three';
+import { Matrix4 } from 'three';
+import { ExtendedMeshBasicMaterial, type Uniforms } from './KingSyMaterial.js';
+import type { KingSyWebGLRenderer } from '../objects/KingSyWebGLRenderer.js';
+declare class KingSyBasicMaterial extends ExtendedMeshBasicMaterial {
+    protected static readonly matBuff: Matrix4;
+    protected static readonly vecBuff: Vector2;
+    private _billboardPixelHeight;
+    private _billboardOffset;
+    protected get vertexProgram(): string;
+    protected get fragmentProgram(): string;
+    protected get baseUniforms(): {
+        [uniform: string]: IUniform;
+    };
+    protected get uniformsDef(): Uniforms;
+    set billboardPixelHeight(value: number);
+    set billboardOffset(value: Vector2);
+    constructor(parameters: MeshBasicMaterialParameters, defines?: string[]);
+    /** We need a unique key per program */
+    customProgramCacheKey(): string;
+    copy(source: Material): this;
+    fastCopy(from: Material, to: Material): void;
+    /** Called by three.js render loop */
+    onBeforeRender(_this: KingSyWebGLRenderer, _scene: Scene, camera: Camera, _geometry: BufferGeometry, object: Object3D): void;
+}
+export default KingSyBasicMaterial;

package/dist/modules/materials/KingSyDepthMaterial.d.ts

@@ -0,0 +1,22 @@
+import { BufferGeometry, Camera, Object3D, Scene, type IUniform, type MeshDepthMaterialParameters } from 'three';
+import { Material } from 'three';
+import { ExtendedMeshDepthMaterial, type Uniforms } from './KingSyMaterial.js';
+import type { KingSyWebGLRenderer } from '../objects/KingSyWebGLRenderer.js';
+declare class KingSyDepthMaterial extends ExtendedMeshDepthMaterial {
+    protected get vertexProgram(): string;
+    protected get fragmentProgram(): string;
+    protected get baseUniforms(): {
+        [uniform: string]: IUniform;
+    };
+    protected get uniformsDef(): Uniforms;
+    constructor(parameters: MeshDepthMaterialParameters, defines?: string[]);
+    /** We need a unique key per program */
+    customProgramCacheKey(): string;
+    copy(source: Material): this;
+    fastCopy(from: Material, to: Material): void;
+    /** Another note here, this will NOT get called by three when rendering shadowmaps. We update the uniforms manually
+     * inside KingSyRenderer for shadowmaps
+     */
+    onBeforeRender(_this: KingSyWebGLRenderer, _scene: Scene, _camera: Camera, _geometry: BufferGeometry, object: Object3D): void;
+}
+export default KingSyDepthMaterial;

package/dist/modules/materials/KingSyDepthNormalIdMaterial.d.ts

@@ -0,0 +1,11 @@
+import { BufferGeometry, Camera, Object3D, Scene } from 'three';
+import { KingSyWebGLRenderer } from '../objects/KingSyWebGLRenderer.js';
+import KingSyDepthNormalMaterial from './KingSyDepthNormalMaterial.js';
+import { Uniforms } from './KingSyMaterial.js';
+declare class KingSyDepthNormalIdMaterial extends KingSyDepthNormalMaterial {
+    protected get vertexProgram(): string;
+    protected get fragmentProgram(): string;
+    protected get uniformsDef(): Uniforms;
+    onBeforeRender(_this: KingSyWebGLRenderer, _scene: Scene, _camera: Camera, _geometry: BufferGeometry, object: Object3D): void;
+}
+export default KingSyDepthNormalIdMaterial;

package/dist/modules/materials/KingSyDepthNormalMaterial.d.ts

@@ -0,0 +1,6 @@
+import KingSyDepthMaterial from './KingSyDepthMaterial.js';
+declare class KingSyDepthNormalMaterial extends KingSyDepthMaterial {
+    protected get vertexProgram(): string;
+    protected get fragmentProgram(): string;
+}
+export default KingSyDepthNormalMaterial;

package/dist/modules/materials/KingSyDisplaceMaterial.d.ts

@@ -0,0 +1,11 @@
+import { Material, type MeshBasicMaterialParameters } from 'three';
+import KingSyBasicMaterial from './KingSyBasicMaterial.js';
+import { type Uniforms } from './KingSyMaterial.js';
+declare class KingSyDisplaceMaterial extends KingSyBasicMaterial {
+    protected get vertexProgram(): string;
+    protected get fragmentProgram(): string;
+    protected get uniformsDef(): Uniforms;
+    constructor(parameters: MeshBasicMaterialParameters, defines?: string[]);
+    fastCopy(from: Material, to: Material): void;
+}
+export default KingSyDisplaceMaterial;

package/dist/modules/materials/KingSyGhostMaterial.d.ts

@@ -0,0 +1,8 @@
+import KingSyBasicMaterial from './KingSyBasicMaterial.js';
+import type { MeshBasicMaterialParameters } from 'three';
+declare class KingSyGhostMaterial extends KingSyBasicMaterial {
+    protected get vertexProgram(): string;
+    protected get fragmentProgram(): string;
+    constructor(parameters: MeshBasicMaterialParameters, defines?: string[]);
+}
+export default KingSyGhostMaterial;

package/dist/modules/materials/KingSyLineMaterial.d.ts

@@ -0,0 +1,20 @@
+import { type IUniform, Material, Scene, Camera, BufferGeometry, Object3D } from 'three';
+import { ExtendedLineMaterial, type Uniforms } from './KingSyMaterial.js';
+import { type LineMaterialParameters } from 'three/examples/jsm/lines/LineMaterial.js';
+import type { KingSyWebGLRenderer } from '../objects/KingSyWebGLRenderer.js';
+declare class KingSyLineMaterial extends ExtendedLineMaterial {
+    protected get vertexProgram(): string;
+    protected get fragmentProgram(): string;
+    protected get baseUniforms(): {
+        [uniform: string]: IUniform;
+    };
+    protected get uniformsDef(): Uniforms;
+    set pixelThreshold(value: number);
+    constructor(parameters: LineMaterialParameters, defines?: string[]);
+    /** We need a unique key per program */
+    customProgramCacheKey(): string;
+    copy(source: Material): this;
+    fastCopy(from: Material, to: Material): void;
+    onBeforeRender(_this: KingSyWebGLRenderer, _scene: Scene, _camera: Camera, _geometry: BufferGeometry, object: Object3D): void;
+}
+export default KingSyLineMaterial;

package/dist/modules/materials/KingSyMatcapMaterial.d.ts

@@ -0,0 +1,19 @@
+import { BufferGeometry, Camera, Material, MeshMatcapMaterialParameters, Object3D, Scene, type IUniform } from 'three';
+import { ExtendedMatcapMaterial, type Uniforms } from './KingSyMaterial.js';
+import type { KingSyWebGLRenderer } from '../objects/KingSyWebGLRenderer.js';
+declare class KingSyMatcapMaterial extends ExtendedMatcapMaterial {
+    protected get vertexProgram(): string;
+    protected get fragmentProgram(): string;
+    protected get baseUniforms(): {
+        [uniform: string]: IUniform;
+    };
+    protected get uniformsDef(): Uniforms;
+    constructor(parameters: MeshMatcapMaterialParameters, defines?: never[]);
+    /** We need a unique key per program */
+    customProgramCacheKey(): string;
+    copy(source: Material): this;
+    fastCopy(from: Material, to: Material): void;
+    /** Called by three.js render loop */
+    onBeforeRender(_this: KingSyWebGLRenderer, _scene: Scene, _camera: Camera, _geometry: BufferGeometry, object: Object3D): void;
+}
+export default KingSyMatcapMaterial;

package/dist/modules/materials/KingSyMaterial.d.ts

@@ -0,0 +1,65 @@
+import { type IUniform, Material, MeshBasicMaterial, MeshDepthMaterial, MeshNormalMaterial, MeshStandardMaterial, PointsMaterial, type Shader, MeshMatcapMaterial } from 'three';
+import { LineMaterial } from 'three/examples/jsm/lines/LineMaterial.js';
+import { StencilOutlineType } from '../../IViewer.js';
+import { type MaterialOptions } from './MaterialOptions.js';
+declare class KingSyUserData {
+    [k: string]: unknown;
+    toJSON(): {};
+}
+export type Uniforms = Record<string, any>;
+export declare class KingSyMaterial {
+    protected _internalUniforms: Shader;
+    protected _stencilOutline: StencilOutlineType;
+    needsCopy: boolean;
+    protected get kingsyUserData(): KingSyUserData;
+    protected set kingsyUserData(value: KingSyUserData);
+    protected get kingsyDefines(): Record<string, unknown> | undefined;
+    protected set kingsyDefines(value: Record<string, unknown> | undefined);
+    protected get vertexProgram(): string;
+    protected get fragmentProgram(): string;
+    protected get uniformsDef(): Uniforms;
+    protected get baseUniforms(): {
+        [uniform: string]: IUniform;
+    };
+    protected set stencilOutline(value: StencilOutlineType);
+    protected set pointSize(value: number);
+    protected init(defines?: Array<string>): void;
+    protected setUniforms(def: Uniforms): void;
+    protected setDefines(defines?: Array<string>): void;
+    protected copyUniforms(material: Material): void;
+    protected bindUniforms(): void;
+    protected copyFrom(source: Material): void;
+    protected onCompile(shader: Shader): void;
+    fastCopy(from: Material, to: Material): void;
+    setMaterialOptions(options: MaterialOptions): void;
+}
+export declare class ExtendedMeshStandardMaterial extends MeshStandardMaterial {
+}
+export declare class ExtendedMeshBasicMaterial extends MeshBasicMaterial {
+}
+export declare class ExtendedMeshDepthMaterial extends MeshDepthMaterial {
+}
+export declare class ExtendedMeshNormalMaterial extends MeshNormalMaterial {
+}
+export declare class ExtendedMatcapMaterial extends MeshMatcapMaterial {
+}
+export declare class ExtendedLineMaterial extends LineMaterial {
+}
+export declare class ExtendedPointsMaterial extends PointsMaterial {
+}
+export interface ExtendedMeshStandardMaterial extends KingSyMaterial {
+}
+export interface ExtendedMeshBasicMaterial extends KingSyMaterial {
+}
+export interface ExtendedMeshDepthMaterial extends KingSyMaterial {
+}
+export interface ExtendedMeshNormalMaterial extends KingSyMaterial {
+}
+export interface ExtendedMatcapMaterial extends KingSyMaterial {
+}
+export interface ExtendedLineMaterial extends KingSyMaterial {
+}
+export interface ExtendedPointsMaterial extends KingSyMaterial {
+}
+export declare function applyMixins(derivedCtor: any, constructors: any[]): void;
+export {};

package/dist/modules/materials/KingSyNormalMaterial.d.ts

@@ -0,0 +1,18 @@
+import { BufferGeometry, Camera, Material, Object3D, Scene, type IUniform, type MeshNormalMaterialParameters } from 'three';
+import { ExtendedMeshNormalMaterial, type Uniforms } from './KingSyMaterial.js';
+import type { KingSyWebGLRenderer } from '../objects/KingSyWebGLRenderer.js';
+declare class KingSyNormalMaterial extends ExtendedMeshNormalMaterial {
+    protected get vertexProgram(): string;
+    protected get fragmentProgram(): string;
+    protected get baseUniforms(): {
+        [uniform: string]: IUniform;
+    };
+    protected get uniformsDef(): Uniforms;
+    constructor(parameters: MeshNormalMaterialParameters, defines?: string[]);
+    /** We need a unique key per program */
+    customProgramCacheKey(): string;
+    copy(source: Material): this;
+    /** Called by three.js render loop */
+    onBeforeRender(_this: KingSyWebGLRenderer, _scene: Scene, _camera: Camera, _geometry: BufferGeometry, object: Object3D): void;
+}
+export default KingSyNormalMaterial;

package/dist/modules/materials/KingSyPointColouredMaterial.d.ts

@@ -0,0 +1,12 @@
+import { Material, Texture, type PointsMaterialParameters } from 'three';
+import type { Uniforms } from './KingSyMaterial.js';
+import KingSyPointMaterial from './KingSyPointMaterial.js';
+declare class KingSyPointColouredMaterial extends KingSyPointMaterial {
+    protected get vertexProgram(): string;
+    protected get fragmentProgram(): string;
+    protected get uniformsDef(): Uniforms;
+    constructor(parameters: PointsMaterialParameters, defines?: string[]);
+    setGradientTexture(texture: Texture): void;
+    fastCopy(from: Material, to: Material): void;
+}
+export default KingSyPointColouredMaterial;

package/dist/modules/materials/KingSyPointMaterial.d.ts

@@ -0,0 +1,18 @@
+import { type IUniform, Material, type PointsMaterialParameters, Scene, Camera, BufferGeometry, Object3D } from 'three';
+import { ExtendedPointsMaterial, type Uniforms } from './KingSyMaterial.js';
+import type { KingSyWebGLRenderer } from '../objects/KingSyWebGLRenderer.js';
+declare class KingSyPointMaterial extends ExtendedPointsMaterial {
+    protected get vertexProgram(): string;
+    protected get fragmentProgram(): string;
+    protected get baseUniforms(): {
+        [uniform: string]: IUniform;
+    };
+    protected get uniformsDef(): Uniforms;
+    constructor(parameters: PointsMaterialParameters, defines?: string[]);
+    /** We need a unique key per program */
+    customProgramCacheKey(): string;
+    copy(source: Material): this;
+    fastCopy(from: Material, to: Material): void;
+    onBeforeRender(_this: KingSyWebGLRenderer, _scene: Scene, _camera: Camera, _geometry: BufferGeometry, object: Object3D): void;
+}
+export default KingSyPointMaterial;

package/dist/modules/materials/KingSyShadowcatcherMaterial.d.ts

@@ -0,0 +1,10 @@
+import KingSyBasicMaterial from './KingSyBasicMaterial.js';
+import { type MeshBasicMaterialParameters } from 'three';
+import { type Uniforms } from './KingSyMaterial.js';
+declare class KingSyShadowcatcherMaterial extends KingSyBasicMaterial {
+    protected get vertexProgram(): string;
+    protected get fragmentProgram(): string;
+    protected get uniformsDef(): Uniforms;
+    constructor(parameters: MeshBasicMaterialParameters, defines?: never[]);
+}
+export default KingSyShadowcatcherMaterial;

package/dist/modules/materials/KingSyStandardColoredMaterial.d.ts

@@ -0,0 +1,11 @@
+import { Texture, type MeshStandardMaterialParameters } from 'three';
+import KingSyStandardMaterial from './KingSyStandardMaterial.js';
+import { type Uniforms } from './KingSyMaterial.js';
+declare class KingSyStandardColoredMaterial extends KingSyStandardMaterial {
+    protected get vertexProgram(): string;
+    protected get fragmentProgram(): string;
+    protected get uniformsDef(): Uniforms;
+    constructor(parameters: MeshStandardMaterialParameters, defines?: never[]);
+    setGradientTexture(texture: Texture): void;
+}
+export default KingSyStandardColoredMaterial;

package/dist/modules/materials/KingSyStandardMaterial.d.ts

@@ -0,0 +1,22 @@
+import { Material, type IUniform, type MeshStandardMaterialParameters, Scene, Camera, BufferGeometry, Object3D } from 'three';
+import { ExtendedMeshStandardMaterial, type Uniforms } from './KingSyMaterial.js';
+import { KingSyWebGLRenderer } from '../objects/KingSyWebGLRenderer.js';
+declare class KingSyStandardMaterial extends ExtendedMeshStandardMaterial {
+    protected originalRoughness: number | undefined;
+    protected artificialRoughness: number | undefined;
+    protected get vertexProgram(): string;
+    protected get fragmentProgram(): string;
+    protected get baseUniforms(): {
+        [uniform: string]: IUniform;
+    };
+    protected get uniformsDef(): Uniforms;
+    constructor(parameters: MeshStandardMaterialParameters, defines?: string[]);
+    /** We need a unique key per program */
+    customProgramCacheKey(): string;
+    copy(source: Material): this;
+    fastCopy(from: Material, to: Material): void;
+    updateArtificialRoughness(artificialRougness?: number): void;
+    /** Called by three.js render loop */
+    onBeforeRender(_this: KingSyWebGLRenderer, _scene: Scene, _camera: Camera, _geometry: BufferGeometry, object: Object3D): void;
+}
+export default KingSyStandardMaterial;