@sparkjsdev/spark 0.1.0

package/dist/types/dyno/util.d.ts

@@ -0,0 +1,139 @@
+import { Dyno, DynoBlock } from './base';
+import { ValueTypes } from './types';
+import { DynoVal, DynoValue, HasDynoOut } from './value';
+export declare const remapIndex: (index: DynoVal<"int">, from: DynoVal<"int">, to: DynoVal<"int">) => DynoVal<"int">;
+export declare const pcgMix: <T extends ValueTypes>(value: DynoVal<T>) => DynoVal<"uint">;
+export declare const pcgNext: (state: DynoVal<"uint">) => DynoVal<"uint">;
+export declare const pcgHash: (state: DynoVal<"uint">) => DynoVal<"uint">;
+export declare const hash: <T extends ValueTypes>(value: DynoVal<T>) => DynoVal<"uint">;
+export declare const hash2: <T extends ValueTypes>(value: DynoVal<T>) => DynoVal<"uvec2">;
+export declare const hash3: <T extends ValueTypes>(value: DynoVal<T>) => DynoVal<"uvec3">;
+export declare const hash4: <T extends ValueTypes>(value: DynoVal<T>) => DynoVal<"uvec4">;
+export declare const hashFloat: <T extends ValueTypes>(value: DynoVal<T>) => DynoVal<"float">;
+export declare const hashVec2: <T extends ValueTypes>(value: DynoVal<T>) => DynoVal<"vec2">;
+export declare const hashVec3: <T extends ValueTypes>(value: DynoVal<T>) => DynoVal<"vec3">;
+export declare const hashVec4: <T extends ValueTypes>(value: DynoVal<T>) => DynoVal<"vec4">;
+export declare class DynoRemapIndex extends Dyno<{
+    from: "int";
+    to: "int";
+    index: "int";
+}, {
+    index: "int";
+}> implements HasDynoOut<"int"> {
+    constructor({ from, to, index, }: {
+        from: DynoVal<"int">;
+        to: DynoVal<"int">;
+        index: DynoVal<"int">;
+    });
+    dynoOut(): DynoValue<"int">;
+}
+export declare class PcgNext<T extends "uint" | "int" | "float"> extends Dyno<{
+    state: T;
+}, {
+    state: "uint";
+}> implements HasDynoOut<"uint"> {
+    constructor({ state }: {
+        state: DynoVal<T>;
+    });
+    dynoOut(): DynoValue<"uint">;
+}
+export declare class PcgHash extends Dyno<{
+    state: "uint";
+}, {
+    hash: "uint";
+}> implements HasDynoOut<"uint"> {
+    constructor({ state }: {
+        state: DynoVal<"uint">;
+    });
+    dynoOut(): DynoValue<"uint">;
+}
+export declare class PcgMix<T extends ValueTypes> extends Dyno<{
+    value: T;
+}, {
+    state: "uint";
+}> implements HasDynoOut<"uint"> {
+    constructor({ value }: {
+        value: DynoVal<T>;
+    });
+    dynoOut(): DynoValue<"uint">;
+}
+export declare class Hash<T extends ValueTypes> extends DynoBlock<{
+    value: T;
+}, {
+    hash: "uint";
+}> implements HasDynoOut<"uint"> {
+    constructor({ value }: {
+        value: DynoVal<T>;
+    });
+    dynoOut(): DynoValue<"uint">;
+}
+export declare class Hash2<T extends ValueTypes> extends DynoBlock<{
+    value: T;
+}, {
+    hash: "uvec2";
+}> implements HasDynoOut<"uvec2"> {
+    constructor({ value }: {
+        value: DynoVal<T>;
+    });
+    dynoOut(): DynoValue<"uvec2">;
+}
+export declare class Hash3<T extends ValueTypes> extends DynoBlock<{
+    value: T;
+}, {
+    hash: "uvec3";
+}> implements HasDynoOut<"uvec3"> {
+    constructor({ value }: {
+        value: DynoVal<T>;
+    });
+    dynoOut(): DynoValue<"uvec3">;
+}
+export declare class Hash4<T extends ValueTypes> extends DynoBlock<{
+    value: T;
+}, {
+    hash: "uvec4";
+}> implements HasDynoOut<"uvec4"> {
+    constructor({ value }: {
+        value: DynoVal<T>;
+    });
+    dynoOut(): DynoValue<"uvec4">;
+}
+export declare class HashFloat<T extends ValueTypes> extends DynoBlock<{
+    value: T;
+}, {
+    hash: "float";
+}> implements HasDynoOut<"float"> {
+    constructor({ value }: {
+        value: DynoVal<T>;
+    });
+    dynoOut(): DynoValue<"float">;
+}
+export declare class HashVec2<T extends ValueTypes> extends DynoBlock<{
+    value: T;
+}, {
+    hash: "vec2";
+}> implements HasDynoOut<"vec2"> {
+    constructor({ value }: {
+        value: DynoVal<T>;
+    });
+    dynoOut(): DynoValue<"vec2">;
+}
+export declare class HashVec3<T extends ValueTypes> extends DynoBlock<{
+    value: T;
+}, {
+    hash: "vec3";
+}> implements HasDynoOut<"vec3"> {
+    constructor({ value }: {
+        value: DynoVal<T>;
+    });
+    dynoOut(): DynoValue<"vec3">;
+}
+export declare class HashVec4<T extends ValueTypes> extends DynoBlock<{
+    value: T;
+}, {
+    hash: "vec4";
+}> implements HasDynoOut<"vec4"> {
+    constructor({ value }: {
+        value: DynoVal<T>;
+    });
+    dynoOut(): DynoValue<"vec4">;
+}

package/dist/types/dyno/value.d.ts

@@ -0,0 +1,32 @@
+import { Dyno, IOTypes } from './base';
+import { DynoJsType, DynoType, SimpleTypes } from './types';
+export type DynoVal<T extends DynoType> = DynoValue<T> | HasDynoOut<T>;
+export declare function valType<T extends DynoType>(val: DynoVal<T>): T;
+export interface HasDynoOut<T extends DynoType> {
+    dynoOut(): DynoValue<T>;
+}
+export declare class DynoValue<T extends DynoType> {
+    type: T;
+    private __isDynoValue;
+    constructor(type: T);
+}
+export declare class DynoOutput<T extends DynoType, InTypes extends IOTypes, OutTypes extends IOTypes> extends DynoValue<T> {
+    dyno: Dyno<InTypes, OutTypes>;
+    key: string;
+    constructor(dyno: Dyno<InTypes, OutTypes>, key: string);
+}
+export declare class DynoLiteral<T extends DynoType> extends DynoValue<T> {
+    literal: string;
+    constructor(type: T, literal: string);
+    getLiteral(): string;
+}
+export declare function dynoLiteral<T extends DynoType>(type: T, literal: string): DynoLiteral<T>;
+export declare class DynoConst<T extends DynoType> extends DynoLiteral<T> {
+    value: DynoJsType<T>;
+    constructor(type: T, value: DynoJsType<T>);
+    getLiteral(): string;
+}
+export declare function dynoConst<T extends DynoType>(type: T, value: DynoJsType<T>): DynoConst<T>;
+export declare function literalZero(type: SimpleTypes): string;
+export declare function literalOne(type: SimpleTypes): string;
+export declare function literalNegOne(type: SimpleTypes): string;

package/dist/types/dyno/vecmat.d.ts

@@ -0,0 +1,226 @@
+import { BinaryOp, Dyno, TrinaryOp, UnaryOp } from './base';
+import { FloatTypes, IntTypes, MatFloatTypes, SquareMatTypes, UintTypes, VectorElementType, VectorTypes } from './types';
+import { DynoVal, DynoValue, HasDynoOut } from './value';
+export declare const length: <A extends "vec2" | "vec3" | "vec4">(a: DynoVal<A>) => DynoVal<"float">;
+export declare const distance: <A extends "vec2" | "vec3" | "vec4">(a: DynoVal<A>, b: DynoVal<A>) => DynoVal<"float">;
+export declare const dot: <A extends "vec2" | "vec3" | "vec4">(a: DynoVal<A>, b: DynoVal<A>) => DynoVal<"float">;
+export declare const cross: (a: DynoVal<"vec3">, b: DynoVal<"vec3">) => DynoVal<"vec3">;
+export declare const normalize: <A extends "vec2" | "vec3" | "vec4">(a: DynoVal<A>) => DynoVal<A>;
+export declare const faceforward: <A extends "vec2" | "vec3" | "vec4">(a: DynoVal<A>, b: DynoVal<A>, c: DynoVal<A>) => DynoVal<A>;
+export declare const reflectVec: <A extends "vec2" | "vec3" | "vec4">(incident: DynoVal<A>, normal: DynoVal<A>) => DynoVal<A>;
+export declare const refractVec: <A extends "vec2" | "vec3" | "vec4">(incident: DynoVal<A>, normal: DynoVal<A>, eta: DynoVal<"float">) => DynoVal<A>;
+export declare const split: <V extends VectorTypes>(vector: DynoVal<V>) => Split<V>;
+export declare const combine: <V extends VectorTypes, T extends VectorElementType<V>>({ vector, vectorType, x, y, z, w, r, g, b, a, }: {
+    vector?: DynoVal<V>;
+    vectorType?: V;
+    x?: DynoVal<T>;
+    y?: DynoVal<T>;
+    z?: DynoVal<T>;
+    w?: DynoVal<T>;
+    r?: DynoVal<T>;
+    g?: DynoVal<T>;
+    b?: DynoVal<T>;
+    a?: DynoVal<T>;
+}) => DynoVal<V>;
+export declare const projectH: <A extends "vec3" | "vec4">(a: DynoVal<A>) => DynoVal<ProjectHOutput<A>>;
+export declare const extendVec: <A extends "float" | "vec2" | "vec3">(a: DynoVal<A>, b: DynoVal<"float">) => DynoVal<ExtendVecOutput<A>>;
+export declare const swizzle: <A extends VectorTypes, S extends SwizzleSelect>(a: DynoVal<A>, select: S) => DynoVal<SwizzleOutput<A, SwizzleSelectLen<S>>>;
+export declare const compMult: <A extends MatFloatTypes>(a: DynoVal<A>, b: DynoVal<A>) => DynoVal<A>;
+export declare const outer: <A extends "vec2" | "vec3" | "vec4", B extends "vec2" | "vec3" | "vec4">(a: DynoVal<A>, b: DynoVal<B>) => DynoVal<OuterOutput<A, B>>;
+export declare const transpose: <A extends MatFloatTypes>(a: DynoVal<A>) => DynoVal<TransposeOutput<A>>;
+export declare const determinant: <A extends SquareMatTypes>(a: DynoVal<A>) => DynoVal<"float">;
+export declare const inverse: <A extends SquareMatTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare class Length<A extends "vec2" | "vec3" | "vec4"> extends UnaryOp<A, "float", "length"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Distance<A extends "vec2" | "vec3" | "vec4"> extends BinaryOp<A, A, "float", "distance"> {
+    constructor({ a, b }: {
+        a: DynoVal<A>;
+        b: DynoVal<A>;
+    });
+}
+export declare class Dot<A extends "vec2" | "vec3" | "vec4"> extends BinaryOp<A, A, "float", "dot"> {
+    constructor({ a, b }: {
+        a: DynoVal<A>;
+        b: DynoVal<A>;
+    });
+}
+export declare class Cross extends BinaryOp<"vec3", "vec3", "vec3", "cross"> {
+    constructor({ a, b }: {
+        a: DynoVal<"vec3">;
+        b: DynoVal<"vec3">;
+    });
+}
+export declare class Normalize<A extends "vec2" | "vec3" | "vec4"> extends UnaryOp<A, A, "normalize"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+type ProjectHOutput<A extends "vec3" | "vec4"> = A extends "vec3" ? "vec2" : A extends "vec4" ? "vec3" : never;
+export declare class ProjectH<A extends "vec3" | "vec4"> extends UnaryOp<A, ProjectHOutput<A>, "projected"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+type ExtendVecOutput<A extends "float" | "vec2" | "vec3"> = A extends "float" ? "vec2" : A extends "vec2" ? "vec3" : A extends "vec3" ? "vec4" : never;
+export declare class ExtendVec<A extends "float" | "vec2" | "vec3"> extends BinaryOp<A, "float", ExtendVecOutput<A>, "extend"> {
+    constructor({ a, b }: {
+        a: DynoVal<A>;
+        b: DynoVal<"float">;
+    });
+}
+export declare class FaceForward<A extends "vec2" | "vec3" | "vec4"> extends TrinaryOp<A, A, A, A, "forward"> {
+    constructor({ a, b, c }: {
+        a: DynoVal<A>;
+        b: DynoVal<A>;
+        c: DynoVal<A>;
+    });
+}
+export declare class ReflectVec<A extends "vec2" | "vec3" | "vec4"> extends BinaryOp<A, A, A, "reflection"> {
+    constructor({ incident, normal, }: {
+        incident: DynoVal<A>;
+        normal: DynoVal<A>;
+    });
+}
+export declare class RefractVec<A extends "vec2" | "vec3" | "vec4"> extends TrinaryOp<A, A, "float", A, "refraction"> {
+    constructor({ incident, normal, eta, }: {
+        incident: DynoVal<A>;
+        normal: DynoVal<A>;
+        eta: DynoVal<"float">;
+    });
+}
+export declare class CompMult<A extends MatFloatTypes> extends BinaryOp<A, A, A, "product"> {
+    constructor({ a, b }: {
+        a: DynoVal<A>;
+        b: DynoVal<A>;
+    });
+}
+type OuterOutput<A extends "vec2" | "vec3" | "vec4", B extends "vec2" | "vec3" | "vec4"> = A extends "vec2" ? B extends "vec2" ? "mat2" : B extends "vec3" ? "mat3x2" : B extends "vec4" ? "mat4x2" : never : A extends "vec3" ? B extends "vec2" ? "mat2x3" : B extends "vec3" ? "mat3" : B extends "vec4" ? "mat4x3" : never : A extends "vec4" ? B extends "vec2" ? "mat2x4" : B extends "vec3" ? "mat3x4" : B extends "vec4" ? "mat4" : never : never;
+export declare class Outer<A extends "vec2" | "vec3" | "vec4", B extends "vec2" | "vec3" | "vec4"> extends BinaryOp<A, B, OuterOutput<A, B>, "outer"> {
+    constructor({ a, b }: {
+        a: DynoVal<A>;
+        b: DynoVal<B>;
+    });
+}
+type TransposeOutput<A extends MatFloatTypes> = A extends SquareMatTypes ? A : A extends "mat2x3" ? "mat3x2" : A extends "mat2x4" ? "mat4x2" : A extends "mat3x2" ? "mat2x3" : A extends "mat3x4" ? "mat4x3" : A extends "mat4x2" ? "mat2x4" : A extends "mat4x3" ? "mat3x4" : never;
+export declare class Transpose<A extends MatFloatTypes> extends UnaryOp<A, TransposeOutput<A>, "transpose"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Determinant<A extends SquareMatTypes> extends UnaryOp<A, "float", "det"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Inverse<A extends SquareMatTypes> extends UnaryOp<A, A, "inverse"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+type SplitOutTypes<A extends VectorTypes> = A extends "vec2" ? {
+    x: "float";
+    y: "float";
+    r: "float";
+    g: "float";
+} : A extends "vec3" ? {
+    x: "float";
+    y: "float";
+    z: "float";
+    r: "float";
+    g: "float";
+    b: "float";
+} : A extends "vec4" ? {
+    x: "float";
+    y: "float";
+    z: "float";
+    w: "float";
+    r: "float";
+    g: "float";
+    b: "float";
+    a: "float";
+} : A extends "ivec2" ? {
+    x: "int";
+    y: "int";
+    r: "int";
+    g: "int";
+} : A extends "ivec3" ? {
+    x: "int";
+    y: "int";
+    z: "int";
+    r: "int";
+    g: "int";
+    b: "int";
+} : A extends "ivec4" ? {
+    x: "int";
+    y: "int";
+    z: "int";
+    w: "int";
+    r: "int";
+    g: "int";
+    b: "int";
+    a: "int";
+} : A extends "uvec2" ? {
+    x: "uint";
+    y: "uint";
+    r: "uint";
+    g: "uint";
+} : A extends "uvec3" ? {
+    x: "uint";
+    y: "uint";
+    z: "uint";
+    r: "uint";
+    g: "uint";
+    b: "uint";
+} : A extends "uvec4" ? {
+    x: "uint";
+    y: "uint";
+    z: "uint";
+    w: "uint";
+    r: "uint";
+    g: "uint";
+    b: "uint";
+    a: "uint";
+} : never;
+export declare class Split<V extends VectorTypes> extends Dyno<{
+    vector: V;
+}, SplitOutTypes<V>> {
+    constructor({ vector }: {
+        vector: DynoVal<V>;
+    });
+}
+export declare class Combine<V extends VectorTypes, T extends VectorElementType<V>> extends Dyno<SplitOutTypes<V> & {
+    vector: V;
+}, {
+    vector: V;
+}> implements HasDynoOut<V> {
+    constructor({ vector, vectorType, x, y, z, w, r, g, b, a, }: {
+        vector?: DynoVal<V>;
+        vectorType?: V;
+        x?: DynoVal<T>;
+        y?: DynoVal<T>;
+        z?: DynoVal<T>;
+        w?: DynoVal<T>;
+        r?: DynoVal<T>;
+        g?: DynoVal<T>;
+        b?: DynoVal<T>;
+        a?: DynoVal<T>;
+    });
+    dynoOut(): DynoValue<V>;
+}
+type SwizzleOutput<A extends VectorTypes, Len extends number> = A extends FloatTypes ? Len extends 1 ? "float" : Len extends 2 ? "vec2" : Len extends 3 ? "vec3" : Len extends 4 ? "vec4" : never : A extends IntTypes ? Len extends 1 ? "int" : Len extends 2 ? "ivec2" : Len extends 3 ? "ivec3" : Len extends 4 ? "ivec4" : never : A extends UintTypes ? Len extends 1 ? "uint" : Len extends 2 ? "uvec2" : Len extends 3 ? "uvec3" : Len extends 4 ? "uvec4" : never : never;
+type SwizzleSelectLen<S extends SwizzleSelect> = S extends Swizzle1Select ? 1 : S extends Swizzle2Select ? 2 : S extends Swizzle3Select ? 3 : S extends Swizzle4Select ? 4 : never;
+type Swizzle1Select = `${"x" | "y" | "z" | "w"}|${"r" | "g" | "b" | "a"}`;
+type Swizzle2Select = `${"x" | "y" | "z" | "w"}${"x" | "y" | "z" | "w"}` | `${"r" | "g" | "b" | "a"}${"r" | "g" | "b" | "a"}`;
+type Swizzle3Select = `${"x" | "y" | "z" | "w"}${"x" | "y" | "z" | "w"}${"x" | "y" | "z" | "w"}` | `${"r" | "g" | "b" | "a"}${"r" | "g" | "b" | "a"}${"r" | "g" | "b" | "a"}`;
+type Swizzle4Select = `${"x" | "y" | "z" | "w"}${"x" | "y" | "z" | "w"}${"x" | "y" | "z" | "w"}${"x" | "y" | "z" | "w"}` | `${"r" | "g" | "b" | "a"}${"r" | "g" | "b" | "a"}${"r" | "g" | "b" | "a"}${"r" | "g" | "b" | "a"}`;
+type SwizzleSelect = Swizzle1Select | Swizzle2Select | Swizzle3Select | Swizzle4Select;
+export declare class Swizzle<A extends VectorTypes, S extends SwizzleSelect> extends UnaryOp<A, SwizzleOutput<A, SwizzleSelectLen<S>>, "swizzle"> {
+    constructor({ vector, select }: {
+        vector: DynoVal<A>;
+        select: S;
+    });
+}
+export {};

package/dist/types/dyno.d.ts

@@ -0,0 +1,16 @@
+export * from './dyno/types';
+export * from './dyno/base';
+export * from './dyno/value';
+export * from './dyno/output';
+export * from './dyno/uniforms';
+export * from './dyno/program';
+export * from './dyno/math';
+export * from './dyno/logic';
+export * from './dyno/util';
+export * from './dyno/splats';
+export * from './dyno/transform';
+export * from './dyno/control';
+export * from './dyno/convert';
+export * from './dyno/texture';
+export * from './dyno/trig';
+export * from './dyno/vecmat';

package/dist/types/generators/snow.d.ts

@@ -0,0 +1,65 @@
+import { SplatGenerator } from '../SplatGenerator';
+import * as THREE from "three";
+export declare const DEFAULT_SNOW: {
+    box: THREE.Box3;
+    density: number;
+    fallDirection: THREE.Vector3;
+    fallVelocity: number;
+    wanderScale: number;
+    wanderVariance: number;
+    color1: THREE.Color;
+    color2: THREE.Color;
+    minScale: number;
+    maxScale: number;
+    anisoScale: THREE.Vector3;
+};
+export declare const DEFAULT_RAIN: {
+    box: THREE.Box3;
+    density: number;
+    fallDirection: THREE.Vector3;
+    fallVelocity: number;
+    wanderScale: number;
+    wanderVariance: number;
+    color1: THREE.Color;
+    color2: THREE.Color;
+    minScale: number;
+    maxScale: number;
+    anisoScale: THREE.Vector3;
+};
+export declare function snowBox({ box, minY, numSplats, density, anisoScale, minScale, maxScale, fallDirection, fallVelocity, wanderScale, wanderVariance, color1, color2, opacity, onFrame, }: {
+    box?: THREE.Box3;
+    minY?: number;
+    numSplats?: number;
+    density?: number;
+    anisoScale?: THREE.Vector3;
+    minScale?: number;
+    maxScale?: number;
+    fallDirection?: THREE.Vector3;
+    fallVelocity?: number;
+    wanderScale?: number;
+    wanderVariance?: number;
+    color1?: THREE.Color;
+    color2?: THREE.Color;
+    opacity?: number;
+    onFrame?: ({ object, time, deltaTime, }: {
+        object: SplatGenerator;
+        time: number;
+        deltaTime: number;
+    }) => void;
+}): {
+    snow: SplatGenerator;
+    min: import('../dyno').DynoVec3<THREE.Vector3, string>;
+    max: import('../dyno').DynoVec3<THREE.Vector3, string>;
+    minY: import('../dyno').DynoFloat<string>;
+    color1: import('../dyno').DynoVec3<THREE.Color, string>;
+    color2: import('../dyno').DynoVec3<THREE.Color, string>;
+    opacity: import('../dyno').DynoFloat<string>;
+    fallVelocity: import('../dyno').DynoFloat<string>;
+    wanderVariance: import('../dyno').DynoFloat<string>;
+    wanderScale: import('../dyno').DynoFloat<string>;
+    fallDirection: import('../dyno').DynoVec3<THREE.Vector3, string>;
+    minScale: import('../dyno').DynoFloat<string>;
+    maxScale: import('../dyno').DynoFloat<string>;
+    anisoScale: import('../dyno').DynoVec3<THREE.Vector3, string>;
+};
+export type SNOW_RESULT_TYPE = ReturnType<typeof snowBox>;

package/dist/types/generators/static.d.ts

@@ -0,0 +1,9 @@
+import { SplatGenerator } from '../SplatGenerator';
+import * as THREE from "three";
+export declare function staticBox({ box, cells, dotScale, color, opacity, }: {
+    box: THREE.Box3;
+    cells: THREE.Vector3;
+    dotScale: number;
+    color?: THREE.Color;
+    opacity?: number;
+}): SplatGenerator;

package/dist/types/generators.d.ts

@@ -0,0 +1,2 @@
+export * from './generators/static';
+export * from './generators/snow';

package/dist/types/hands.d.ts

@@ -0,0 +1,95 @@
+import { Object3D, Quaternion, Vector3, WebXRManager } from 'three';
+import { SplatMesh } from './SplatMesh';
+export declare enum JointEnum {
+    w = "wrist",
+    t0 = "thumb-metacarpal",
+    t1 = "thumb-phalanx-proximal",
+    t2 = "thumb-phalanx-distal",
+    t3 = "thumb-tip",
+    i0 = "index-finger-metacarpal",
+    i1 = "index-finger-phalanx-proximal",
+    i2 = "index-finger-phalanx-intermediate",
+    i3 = "index-finger-phalanx-distal",
+    i4 = "index-finger-tip",
+    m0 = "middle-finger-metacarpal",
+    m1 = "middle-finger-phalanx-proximal",
+    m2 = "middle-finger-phalanx-intermediate",
+    m3 = "middle-finger-phalanx-distal",
+    m4 = "middle-finger-tip",
+    r0 = "ring-finger-metacarpal",
+    r1 = "ring-finger-phalanx-proximal",
+    r2 = "ring-finger-phalanx-intermediate",
+    r3 = "ring-finger-phalanx-distal",
+    r4 = "ring-finger-tip",
+    p0 = "pinky-finger-metacarpal",
+    p1 = "pinky-finger-phalanx-proximal",
+    p2 = "pinky-finger-phalanx-intermediate",
+    p3 = "pinky-finger-phalanx-distal",
+    p4 = "pinky-finger-tip"
+}
+export type JointId = keyof typeof JointEnum;
+export declare const JOINT_IDS: JointId[];
+export declare const NUM_JOINTS: number;
+export declare const JOINT_INDEX: {
+    [key in JointId]: number;
+};
+export declare const JOINT_RADIUS: {
+    [key in JointId]: number;
+};
+export declare const JOINT_SEGMENTS: JointId[][];
+export declare const JOINT_SEGMENT_STEPS: number[][];
+export declare const JOINT_TIPS: JointId[];
+export declare const FINGER_TIPS: JointId[];
+export declare enum Hand {
+    left = "left",
+    right = "right"
+}
+export declare const HANDS: Hand[];
+export type Joint = {
+    position: Vector3;
+    quaternion: Quaternion;
+    radius: number;
+};
+export type HandJoints = {
+    [key in JointId]?: Joint;
+};
+export type HandsJoints = {
+    [key in Hand]?: HandJoints;
+};
+export declare class XrHands {
+    hands: HandsJoints;
+    last: HandsJoints;
+    values: Record<string, number>;
+    tests: Record<string, boolean>;
+    lastTests: Record<string, boolean>;
+    updated: boolean;
+    update({ xr, xrFrame }: {
+        xr: WebXRManager;
+        xrFrame: XRFrame;
+    }): void;
+    makeGhostMesh(): SplatMesh;
+    distance(handA: Hand, jointA: JointId, handB: Hand, jointB: JointId, last?: boolean): number;
+    separation(handA: Hand, jointA: JointId, handB: Hand, jointB: JointId, last?: boolean): number;
+    touching(handA: Hand, jointA: JointId, handB: Hand, jointB: JointId, last?: boolean): number;
+    allTipsTouching(hand: Hand, last?: boolean): number;
+    triTipsTouching(hand: Hand, last?: boolean): number;
+}
+export declare class HandMovement {
+    xrHands: XrHands;
+    control: Object3D;
+    moveInertia: number;
+    rotateInertia: number;
+    lastGrip: {
+        [key in Hand]?: Vector3;
+    };
+    lastPivot: Vector3;
+    rotateVelocity: number;
+    velocity: Vector3;
+    constructor({ xrHands, control, moveInertia, rotateInertia, }: {
+        xrHands: XrHands;
+        control: Object3D;
+        moveInertia?: number;
+        rotateInertia?: number;
+    });
+    update(deltaTime: number): void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,20 @@
+export { ForgeRenderer, type ForgeRendererOptions } from './ForgeRenderer';
+export { ForgeViewpoint, type ForgeViewpointOptions } from './ForgeViewpoint';
+export * as dyno from './dyno';
+export { SplatLoader, unpackSplats, SplatFileType, getSplatFileType, } from './SplatLoader';
+export { PlyReader } from './ply';
+export { SpzReader, SpzWriter, transcodeSpz } from './spz';
+export { PackedSplats, type PackedSplatsOptions } from './PackedSplats';
+export { SplatGenerator, type GsplatGenerator, SplatModifier, type GsplatModifier, SplatTransformer, } from './SplatGenerator';
+export { SplatAccumulator, type GeneratorMapping } from './SplatAccumulator';
+export { Readback, type Rgba8Readback, type ReadbackBuffer } from './Readback';
+export { SplatMesh, type SplatMeshOptions, type SplatMeshContext, } from './SplatMesh';
+export { SplatSkinning, type SplatSkinningOptions } from './SplatSkinning';
+export { SplatEdit, type SplatEditOptions, SplatEditSdf, type SplatEditSdfOptions, SplatEditSdfType, SplatEditRgbaBlendMode, SplatEdits, } from './SplatEdit';
+export { constructGrid, constructAxes, constructSpherePoints, imageSplats, textSplats, } from './splatConstructors';
+export * as generators from './generators';
+export { VRButton } from './vrButton';
+export { type JointId, JointEnum, JOINT_IDS, NUM_JOINTS, JOINT_INDEX, JOINT_RADIUS, JOINT_SEGMENTS, JOINT_SEGMENT_STEPS, JOINT_TIPS, FINGER_TIPS, Hand, HANDS, type Joint, type HandJoints, type HandsJoints, XrHands, HandMovement, } from './hands';
+export { ForgeControls, FpsMovement, PointerControls } from './controls';
+export { isMobile, isAndroid, isOculus, flipPixels, pixelsToPngUrl, toHalf, fromHalf, floatToUint8, floatToSint8, Uint8ToFloat, Sint8ToFloat, setPackedSplat, unpackSplat, } from './utils';
+export * as utils from './utils';

package/dist/types/ksplat.d.ts

@@ -0,0 +1,6 @@
+export declare function decodeKsplat(fileBytes: Uint8Array, initNumSplats: (numSplats: number) => void, splatCallback: (index: number, x: number, y: number, z: number, scaleX: number, scaleY: number, scaleZ: number, quatX: number, quatY: number, quatZ: number, quatW: number, opacity: number, r: number, g: number, b: number) => void, shCallback?: (index: number, sh1: Float32Array, sh2?: Float32Array, sh3?: Float32Array) => void): void;
+export declare function unpackKsplat(fileBytes: Uint8Array): {
+    packedArray: Uint32Array;
+    numSplats: number;
+    extra: Record<string, unknown>;
+};

package/dist/types/ply.d.ts

@@ -0,0 +1,31 @@
+export type PlyPropertyType = "char" | "uchar" | "short" | "ushort" | "int" | "uint" | "float" | "double";
+export type PlyElement = {
+    name: string;
+    count: number;
+    properties: Record<string, PlyProperty>;
+};
+export type PlyProperty = {
+    isList: boolean;
+    type: PlyPropertyType;
+    countType?: PlyPropertyType;
+};
+export type SplatCallback = (index: number, x: number, y: number, z: number, scaleX: number, scaleY: number, scaleZ: number, quatX: number, quatY: number, quatZ: number, quatW: number, opacity: number, r: number, g: number, b: number) => void;
+export type SplatShCallback = (index: number, sh1: Float32Array, sh2?: Float32Array, sh3?: Float32Array) => void;
+export declare class PlyReader {
+    fileBytes: Uint8Array;
+    header: string;
+    littleEndian: boolean;
+    elements: Record<string, PlyElement>;
+    comments: string[];
+    data: DataView | null;
+    static defaultPointScale: number;
+    numSplats: number;
+    constructor({ fileBytes }: {
+        fileBytes: Uint8Array | ArrayBuffer;
+    });
+    parseHeader(): Promise<void>;
+    parseData(elementCallback: (element: PlyElement) => null | ((index: number, item: Record<string, number | number[]>) => void)): void;
+    parseSplats(splatCallback: SplatCallback, shCallback?: SplatShCallback): void;
+    injectRgba(rgba: Uint8Array): void;
+}
+export declare const SH_C0 = 0.28209479177387814;

package/dist/types/shaders.d.ts

@@ -0,0 +1 @@
+export declare function getShaders(): Record<string, string>;