@sparkjsdev/spark 0.1.0

package/dist/types/SplatMesh.d.ts

@@ -0,0 +1,85 @@
+import { PackedSplats } from './PackedSplats';
+import { RgbaArray } from './RgbaArray';
+import { SplatEdit } from './SplatEdit';
+import { GsplatModifier, SplatGenerator, SplatTransformer } from './SplatGenerator';
+import { SplatFileType } from './SplatLoader';
+import { SplatSkinning } from './SplatSkinning';
+import { DynoFloat, DynoUsampler2DArray, DynoVal, DynoVec4, Gsplat } from './dyno';
+import * as THREE from "three";
+export type SplatMeshOptions = {
+    url?: string;
+    fileBytes?: Uint8Array | ArrayBuffer;
+    fileType?: SplatFileType;
+    fileName?: string;
+    packedSplats?: PackedSplats;
+    maxSplats?: number;
+    constructSplats?: (splats: PackedSplats) => Promise<void> | void;
+    onLoad?: (mesh: SplatMesh) => Promise<void> | void;
+    editable?: boolean;
+    onFrame?: ({ mesh, time, deltaTime, }: {
+        mesh: SplatMesh;
+        time: number;
+        deltaTime: number;
+    }) => void;
+    objectModifier?: GsplatModifier;
+    worldModifier?: GsplatModifier;
+};
+export type SplatMeshContext = {
+    transform: SplatTransformer;
+    viewToWorld: SplatTransformer;
+    worldToView: SplatTransformer;
+    viewToObject: SplatTransformer;
+    recolor: DynoVec4<THREE.Vector4>;
+    time: DynoFloat;
+    deltaTime: DynoFloat;
+};
+export declare class SplatMesh extends SplatGenerator {
+    initialized: Promise<SplatMesh>;
+    isInitialized: boolean;
+    packedSplats: PackedSplats;
+    recolor: THREE.Color;
+    opacity: number;
+    context: SplatMeshContext;
+    onFrame?: ({ mesh, time, deltaTime, }: {
+        mesh: SplatMesh;
+        time: number;
+        deltaTime: number;
+    }) => void;
+    objectModifier?: GsplatModifier;
+    worldModifier?: GsplatModifier;
+    enableViewToObject: boolean;
+    enableViewToWorld: boolean;
+    enableWorldToView: boolean;
+    skinning: SplatSkinning | null;
+    edits: SplatEdit[] | null;
+    editable: boolean;
+    private rgbaDisplaceEdits;
+    splatRgba: RgbaArray | null;
+    maxSh: number;
+    constructor(options?: SplatMeshOptions);
+    asyncInitialize(options: SplatMeshOptions): Promise<void>;
+    static staticInitialized: Promise<void>;
+    static isStaticInitialized: boolean;
+    static dynoTime: DynoFloat<"value">;
+    static staticInitialize(): Promise<void>;
+    pushSplat(center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color): void;
+    forEachSplat(callback: (index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color) => void): void;
+    dispose(): void;
+    constructGenerator(context: SplatMeshContext): void;
+    updateGenerator(): void;
+    update({ time, viewToWorld, deltaTime, globalEdits, }: {
+        time: number;
+        viewToWorld: THREE.Matrix4;
+        deltaTime: number;
+        globalEdits: SplatEdit[];
+    }): void;
+    raycast(raycaster: THREE.Raycaster, intersects: {
+        distance: number;
+        point: THREE.Vector3;
+        object: THREE.Object3D;
+    }[]): void;
+    private ensureShTextures;
+}
+export declare function evaluateSH1(gsplat: DynoVal<typeof Gsplat>, sh1: DynoUsampler2DArray<"sh1", THREE.DataArrayTexture>, viewDir: DynoVal<"vec3">): DynoVal<"vec3">;
+export declare function evaluateSH2(gsplat: DynoVal<typeof Gsplat>, sh2: DynoVal<"usampler2DArray">, viewDir: DynoVal<"vec3">): DynoVal<"vec3">;
+export declare function evaluateSH3(gsplat: DynoVal<typeof Gsplat>, sh3: DynoVal<"usampler2DArray">, viewDir: DynoVal<"vec3">): DynoVal<"vec3">;

package/dist/types/SplatSkinning.d.ts

@@ -0,0 +1,29 @@
+import { SplatMesh } from './SplatMesh';
+import { DynoUniform, DynoVal, Gsplat } from './dyno';
+import * as THREE from "three";
+export type SplatSkinningOptions = {
+    mesh: SplatMesh;
+    numSplats?: number;
+    numBones?: number;
+};
+export declare class SplatSkinning {
+    mesh: SplatMesh;
+    numSplats: number;
+    skinData: Uint16Array;
+    skinTexture: THREE.DataArrayTexture;
+    numBones: number;
+    boneData: Float32Array;
+    boneTexture: THREE.DataTexture;
+    uniform: DynoUniform<typeof GsplatSkinning, "skinning">;
+    constructor(options: SplatSkinningOptions);
+    modify(gsplat: DynoVal<typeof Gsplat>): DynoVal<typeof Gsplat>;
+    setRestQuatPos(boneIndex: number, quat: THREE.Quaternion, pos: THREE.Vector3): void;
+    setBoneQuatPos(boneIndex: number, quat: THREE.Quaternion, pos: THREE.Vector3): void;
+    setSplatBones(splatIndex: number, boneIndices: THREE.Vector4, weights: THREE.Vector4): void;
+    updateBones(): void;
+}
+export declare const GsplatSkinning: {
+    type: "GsplatSkinning";
+};
+export declare const defineGsplatSkinning: string;
+export declare const defineApplyGsplatSkinning: string;

package/dist/types/antisplat.d.ts

@@ -0,0 +1,5 @@
+export declare function decodeAntiSplat(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): void;
+export declare function unpackAntiSplat(fileBytes: Uint8Array): {
+    packedArray: Uint32Array;
+    numSplats: number;
+};

package/dist/types/controls.d.ts

@@ -0,0 +1,114 @@
+import * as THREE from "three";
+export declare class ForgeControls {
+    fpsMovement: FpsMovement;
+    pointerControls: PointerControls;
+    lastTime: number;
+    constructor({ canvas }: {
+        canvas: HTMLCanvasElement;
+    });
+    update(control: THREE.Object3D): void;
+}
+export declare class FpsMovement {
+    moveSpeed: number;
+    rollSpeed: number;
+    stickThreshold: number;
+    rotateSpeed: number;
+    keycodeMoveMapping: {
+        [key: string]: THREE.Vector3;
+    };
+    keycodeRotateMapping: {
+        [key: string]: THREE.Vector3;
+    };
+    gamepadMapping: {
+        [button: number]: "shift" | "ctrl" | "rollLeft" | "rollRight";
+    };
+    capsMultiplier: number;
+    shiftMultiplier: number;
+    ctrlMultiplier: number;
+    xr?: THREE.WebXRManager;
+    enable: boolean;
+    keydown: {
+        [key: string]: boolean;
+    };
+    keycode: {
+        [key: string]: boolean;
+    };
+    constructor({ moveSpeed, rollSpeed, stickThreshold, rotateSpeed, keycodeMoveMapping, keycodeRotateMapping, gamepadMapping, capsMultiplier, shiftMultiplier, ctrlMultiplier, xr, }?: {
+        moveSpeed?: number;
+        rollSpeed?: number;
+        stickThreshold?: number;
+        rotateSpeed?: number;
+        keycodeMoveMapping?: {
+            [key: string]: THREE.Vector3;
+        };
+        keycodeRotateMapping?: {
+            [key: string]: THREE.Vector3;
+        };
+        gamepadMapping?: {
+            [button: number]: "shift" | "ctrl" | "rollLeft" | "rollRight";
+        };
+        capsMultiplier?: number;
+        shiftMultiplier?: number;
+        ctrlMultiplier?: number;
+        xr?: THREE.WebXRManager;
+    });
+    update(deltaTime: number, control: THREE.Object3D): void;
+}
+type PointerState = {
+    initial: THREE.Vector2;
+    last: THREE.Vector2;
+    position: THREE.Vector2;
+    pointerId: number;
+    button?: number;
+    timeStamp: DOMHighResTimeStamp;
+};
+export declare class PointerControls {
+    canvas: HTMLCanvasElement;
+    rotateSpeed: number;
+    slideSpeed: number;
+    scrollSpeed: number;
+    swapRotateSlide: boolean;
+    reverseRotate: boolean;
+    reverseSlide: boolean;
+    reverseSwipe: boolean;
+    reverseScroll: boolean;
+    moveInertia: number;
+    rotateInertia: number;
+    enable: boolean;
+    doublePress: ({ position, intervalMs, }: {
+        position: THREE.Vector2;
+        intervalMs: number;
+    }) => void;
+    doublePressLimitMs: number;
+    doublePressDistance: number;
+    lastUp: {
+        position: THREE.Vector2;
+        time: number;
+    } | null;
+    rotating: PointerState | null;
+    sliding: PointerState | null;
+    dualPress: boolean;
+    scroll: THREE.Vector3;
+    rotateVelocity: THREE.Vector3;
+    moveVelocity: THREE.Vector3;
+    constructor({ canvas, rotateSpeed, slideSpeed, scrollSpeed, swapRotateSlide, reverseRotate, reverseSlide, reverseSwipe, reverseScroll, moveInertia, rotateInertia, doublePress, }: {
+        canvas: HTMLCanvasElement;
+        rotateSpeed?: number;
+        slideSpeed?: number;
+        scrollSpeed?: number;
+        swapRotateSlide?: boolean;
+        reverseRotate?: boolean;
+        reverseSlide?: boolean;
+        reverseSwipe?: boolean;
+        reverseScroll?: boolean;
+        moveInertia?: number;
+        rotateInertia?: number;
+        doublePress?: ({ position, intervalMs, }: {
+            position: THREE.Vector2;
+            intervalMs: number;
+        }) => void;
+    });
+    getPointerPosition(event: PointerEvent): THREE.Vector2;
+    update(deltaTime: number, control: THREE.Object3D): void;
+}
+export {};

package/dist/types/defines.d.ts

@@ -0,0 +1,17 @@
+export declare const LN_SCALE_MIN = -9;
+export declare const LN_SCALE_MAX = 9;
+export declare const LN_RESCALE: number;
+export declare const SCALE_MIN: number;
+export declare const SCALE_MAX: number;
+export declare const SPLAT_TEX_WIDTH_BITS = 11;
+export declare const SPLAT_TEX_HEIGHT_BITS = 11;
+export declare const SPLAT_TEX_DEPTH_BITS = 11;
+export declare const SPLAT_TEX_LAYER_BITS: number;
+export declare const SPLAT_TEX_WIDTH: number;
+export declare const SPLAT_TEX_HEIGHT: number;
+export declare const SPLAT_TEX_DEPTH: number;
+export declare const SPLAT_TEX_MIN_HEIGHT = 1;
+export declare const SPLAT_TEX_WIDTH_MASK: number;
+export declare const SPLAT_TEX_HEIGHT_MASK: number;
+export declare const SPLAT_TEX_DEPTH_MASK: number;
+export declare const WASM_SPLAT_SORT = true;

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

@@ -0,0 +1,174 @@
+import { IUniform } from 'three';
+import { DynoType } from './types';
+import { DynoVal, DynoValue, HasDynoOut } from './value';
+export declare class Compilation {
+    globals: Set<string>;
+    statements: string[];
+    uniforms: Record<string, IUniform>;
+    declares: Set<string>;
+    updaters: (() => void)[];
+    sequence: number;
+    indent: string;
+    constructor({ indent }?: {
+        indent?: string;
+    });
+    nextSequence(): number;
+}
+export type IOTypes = Record<string, DynoType>;
+type GenerateContext<InTypes extends IOTypes, OutTypes extends IOTypes> = {
+    inputs: {
+        [K in keyof InTypes]?: string;
+    };
+    outputs: {
+        [K in keyof OutTypes]?: string;
+    };
+    compile: Compilation;
+};
+export declare class Dyno<InTypes extends IOTypes, OutTypes extends IOTypes> {
+    inTypes: InTypes;
+    outTypes: OutTypes;
+    inputs: {
+        [K in keyof InTypes]?: DynoVal<InTypes[K]>;
+    };
+    update?: () => void;
+    globals?: ({ inputs, outputs, compile, }: GenerateContext<InTypes, OutTypes>) => string[];
+    statements?: ({ inputs, outputs, compile, }: GenerateContext<InTypes, OutTypes>) => string[];
+    generate: ({ inputs, outputs, compile, }: GenerateContext<InTypes, OutTypes>) => {
+        globals?: string[];
+        statements?: string[];
+        uniforms?: Record<string, IUniform>;
+    };
+    constructor({ inTypes, outTypes, inputs, update, globals, statements, generate, }: {
+        inTypes?: InTypes;
+        outTypes?: OutTypes;
+        inputs?: {
+            [K in keyof InTypes]?: DynoVal<InTypes[K]>;
+        };
+        update?: () => void;
+        globals?: ({ inputs, outputs, compile, }: GenerateContext<InTypes, OutTypes>) => string[];
+        statements?: ({ inputs, outputs, compile, }: GenerateContext<InTypes, OutTypes>) => string[];
+        generate?: ({ inputs, outputs, compile, }: GenerateContext<InTypes, OutTypes>) => {
+            globals?: string[];
+            statements?: string[];
+            uniforms?: Record<string, IUniform>;
+        };
+    });
+    get outputs(): {
+        [K in keyof OutTypes]: DynoVal<OutTypes[K]>;
+    };
+    apply(inputs: {
+        [K in keyof InTypes]?: DynoVal<InTypes[K]>;
+    }): {
+        [K in keyof OutTypes]: DynoVal<OutTypes[K]>;
+    };
+    compile({ inputs, outputs, compile, }: {
+        inputs: {
+            [K in keyof InTypes]?: string;
+        };
+        outputs: {
+            [K in keyof OutTypes]?: string;
+        };
+        compile: Compilation;
+    }): string[];
+}
+export type DynoBlockType<InTypes extends IOTypes, OutTypes extends IOTypes> = (inputs: {
+    [K in keyof InTypes]?: DynoVal<InTypes[K]>;
+}, outputs: {
+    [K in keyof OutTypes]?: DynoVal<OutTypes[K]>;
+}, { roots }: {
+    roots: Dyno<InTypes, OutTypes>[];
+}) => {
+    [K in keyof OutTypes]?: DynoVal<OutTypes[K]>;
+} | undefined;
+export declare class DynoBlock<InTypes extends IOTypes, OutTypes extends IOTypes> extends Dyno<InTypes, OutTypes> {
+    construct: DynoBlockType<InTypes, OutTypes>;
+    constructor({ inTypes, outTypes, inputs, update, globals, construct, }: {
+        inTypes?: InTypes;
+        outTypes?: OutTypes;
+        inputs?: {
+            [K in keyof InTypes]?: DynoVal<InTypes[K]>;
+        };
+        update?: () => void;
+        globals?: ({ inputs, outputs, compile, }: GenerateContext<InTypes, OutTypes>) => string[];
+        construct: DynoBlockType<InTypes, OutTypes>;
+    });
+    generateBlock({ inputs, outputs, compile, }: {
+        inputs: {
+            [K in keyof InTypes]?: string;
+        };
+        outputs: {
+            [K in keyof OutTypes]?: string;
+        };
+        compile: Compilation;
+    }): {
+        statements: string[];
+    };
+}
+export declare function dynoBlock<InTypes extends Record<string, DynoType>, OutTypes extends Record<string, DynoType>>(inTypes: InTypes, outTypes: OutTypes, construct: DynoBlockType<InTypes, OutTypes>, { update, globals }?: {
+    update?: () => void;
+    globals?: () => string[];
+}): DynoBlock<InTypes, OutTypes>;
+export declare function dyno<InTypes extends Record<string, DynoType>, OutTypes extends Record<string, DynoType>>({ inTypes, outTypes, inputs, update, globals, statements, generate, }: {
+    inTypes: InTypes;
+    outTypes: OutTypes;
+    inputs?: {
+        [K in keyof InTypes]?: DynoVal<InTypes[K]>;
+    };
+    update?: () => void;
+    globals?: ({ inputs, outputs, compile, }: GenerateContext<InTypes, OutTypes>) => string[];
+    statements?: ({ inputs, outputs, compile, }: GenerateContext<InTypes, OutTypes>) => string[];
+    generate?: ({ inputs, outputs, compile, }: GenerateContext<InTypes, OutTypes>) => {
+        globals?: string[];
+        statements?: string[];
+        uniforms?: Record<string, IUniform>;
+    };
+}): Dyno<InTypes, OutTypes>;
+export declare function dynoDeclare(name: string, type: DynoType, count?: number): string;
+export declare function unindentLines(s: string): string[];
+export declare function unindent(s: string): string;
+export declare class UnaryOp<A extends DynoType, OutType extends DynoType, OutKey extends string> extends Dyno<{
+    a: A;
+}, {
+    [key in OutKey]: OutType;
+}> implements HasDynoOut<OutType> {
+    constructor({ a, outKey, outTypeFunc, }: {
+        a: DynoVal<A>;
+        outKey: OutKey;
+        outTypeFunc: (aType: A) => OutType;
+    });
+    outKey: OutKey;
+    dynoOut(): DynoValue<OutType>;
+}
+export declare class BinaryOp<A extends DynoType, B extends DynoType, OutType extends DynoType, OutKey extends string> extends Dyno<{
+    a: A;
+    b: B;
+}, {
+    [key in OutKey]: OutType;
+}> implements HasDynoOut<OutType> {
+    constructor({ a, b, outKey, outTypeFunc, }: {
+        a: DynoVal<A>;
+        b: DynoVal<B>;
+        outKey: OutKey;
+        outTypeFunc: (aType: A, bType: B) => OutType;
+    });
+    outKey: OutKey;
+    dynoOut(): DynoValue<OutType>;
+}
+export declare class TrinaryOp<A extends DynoType, B extends DynoType, C extends DynoType, OutType extends DynoType, OutKey extends string> extends Dyno<{
+    a: A;
+    b: B;
+    c: C;
+}, {
+    [key in OutKey]: OutType;
+}> implements HasDynoOut<OutType> {
+    constructor({ a, b, c, outKey, outTypeFunc, }: {
+        a: DynoVal<A>;
+        b: DynoVal<B>;
+        c: DynoVal<C>;
+        outKey: OutKey;
+        outTypeFunc: (aType: A, bType: B, cType: C) => OutType;
+    });
+    outKey: OutKey;
+    dynoOut(): DynoValue<OutType>;
+}
+export {};

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

@@ -0,0 +1,6 @@
+export declare const dynoIf: () => never;
+export declare const dynoSwitch: () => never;
+export declare const dynoFor: () => never;
+export declare const comment: () => never;
+export declare const arrayIndex: () => never;
+export declare const arrayLength: () => never;

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

@@ -0,0 +1,190 @@
+import { UnaryOp } from './base';
+import { SimpleTypes } from './types';
+import { DynoVal } from './value';
+export declare const bool: <T extends "bool" | "int" | "uint" | "float">(value: DynoVal<T>) => DynoVal<"bool">;
+export declare const int: <T extends "bool" | "int" | "uint" | "float">(value: DynoVal<T>) => DynoVal<"int">;
+export declare const uint: <T extends "bool" | "int" | "uint" | "float">(value: DynoVal<T>) => DynoVal<"uint">;
+export declare const float: <T extends "bool" | "int" | "uint" | "float">(value: DynoVal<T>) => DynoVal<"float">;
+export declare const bvec2: <T extends "bool" | "bvec2" | "ivec2" | "uvec2" | "vec2">(value: DynoVal<T>) => DynoVal<"bvec2">;
+export declare const bvec3: <T extends "bool" | "bvec3" | "ivec3" | "uvec3" | "vec3">(value: DynoVal<T>) => DynoVal<"bvec3">;
+export declare const bvec4: <T extends "bool" | "bvec4" | "ivec4" | "uvec4" | "vec4">(value: DynoVal<T>) => DynoVal<"bvec4">;
+export declare const ivec2: <T extends "int" | "bvec2" | "ivec2" | "uvec2" | "vec2">(value: DynoVal<T>) => DynoVal<"ivec2">;
+export declare const ivec3: <T extends "int" | "bvec3" | "ivec3" | "uvec3" | "vec3">(value: DynoVal<T>) => DynoVal<"ivec3">;
+export declare const ivec4: <T extends "int" | "bvec4" | "ivec4" | "uvec4" | "vec4">(value: DynoVal<T>) => DynoVal<"ivec4">;
+export declare const uvec2: <T extends "uint" | "bvec2" | "ivec2" | "uvec2" | "vec2">(value: DynoVal<T>) => DynoVal<"uvec2">;
+export declare const uvec3: <T extends "uint" | "bvec3" | "ivec3" | "uvec3" | "vec3">(value: DynoVal<T>) => DynoVal<"uvec3">;
+export declare const uvec4: <T extends "uint" | "bvec4" | "ivec4" | "uvec4" | "vec4">(value: DynoVal<T>) => DynoVal<"uvec4">;
+export declare const vec2: <T extends "float" | "bvec2" | "ivec2" | "uvec2" | "vec2" | "vec3" | "vec4">(value: DynoVal<T>) => DynoVal<"vec2">;
+export declare const vec3: <T extends "float" | "bvec3" | "ivec3" | "uvec3" | "vec3" | "vec4">(value: DynoVal<T>) => DynoVal<"vec3">;
+export declare const vec4: <T extends "float" | "bvec4" | "ivec4" | "uvec4" | "vec4">(value: DynoVal<T>) => DynoVal<"vec4">;
+export declare const mat2: <T extends "float" | "mat2" | "mat3" | "mat4">(value: DynoVal<T>) => DynoVal<"mat2">;
+export declare const mat3: <T extends "float" | "mat2" | "mat3" | "mat4">(value: DynoVal<T>) => DynoVal<"mat3">;
+export declare const mat4: <T extends "float" | "mat2" | "mat3" | "mat4">(value: DynoVal<T>) => DynoVal<"mat4">;
+export declare const floatBitsToInt: (value: DynoVal<"float">) => DynoVal<"int">;
+export declare const floatBitsToUint: (value: DynoVal<"float">) => DynoVal<"uint">;
+export declare const intBitsToFloat: (value: DynoVal<"int">) => DynoVal<"float">;
+export declare const uintBitsToFloat: (value: DynoVal<"uint">) => DynoVal<"float">;
+export declare const packSnorm2x16: (value: DynoVal<"vec2">) => DynoVal<"uint">;
+export declare const unpackSnorm2x16: (value: DynoVal<"uint">) => DynoVal<"vec2">;
+export declare const packUnorm2x16: (value: DynoVal<"vec2">) => DynoVal<"uint">;
+export declare const unpackUnorm2x16: (value: DynoVal<"uint">) => DynoVal<"vec2">;
+export declare const packHalf2x16: (value: DynoVal<"vec2">) => DynoVal<"uint">;
+export declare const unpackHalf2x16: (value: DynoVal<"uint">) => DynoVal<"vec2">;
+export declare const uintToRgba8: (value: DynoVal<"uint">) => DynoVal<"vec4">;
+export declare class SimpleCast<Allowed extends SimpleTypes, OutType extends SimpleTypes, OutKey extends string> extends UnaryOp<Allowed, OutType, OutKey> {
+    constructor({ value, outType, outKey, }: {
+        value: DynoVal<Allowed>;
+        outType: OutType;
+        outKey: OutKey;
+    });
+}
+export declare class Bool extends SimpleCast<"bool" | "int" | "uint" | "float", "bool", "bool"> {
+    constructor({ value, }: {
+        value: DynoVal<"bool" | "int" | "uint" | "float">;
+    });
+}
+export declare class Int extends SimpleCast<"bool" | "int" | "uint" | "float", "int", "int"> {
+    constructor({ value, }: {
+        value: DynoVal<"bool" | "int" | "uint" | "float">;
+    });
+}
+export declare class Uint extends SimpleCast<"bool" | "int" | "uint" | "float", "uint", "uint"> {
+    constructor({ value, }: {
+        value: DynoVal<"bool" | "int" | "uint" | "float">;
+    });
+}
+export declare class Float extends SimpleCast<"bool" | "int" | "uint" | "float", "float", "float"> {
+    constructor({ value, }: {
+        value: DynoVal<"bool" | "int" | "uint" | "float">;
+    });
+}
+export declare class BVec2 extends SimpleCast<"bool" | "bvec2" | "ivec2" | "uvec2" | "vec2", "bvec2", "bvec2"> {
+    constructor({ value, }: {
+        value: DynoVal<"bool" | "bvec2" | "ivec2" | "uvec2" | "vec2">;
+    });
+}
+export declare class BVec3 extends SimpleCast<"bool" | "bvec3" | "ivec3" | "uvec3" | "vec3", "bvec3", "bvec3"> {
+    constructor({ value, }: {
+        value: DynoVal<"bool" | "bvec3" | "ivec3" | "uvec3" | "vec3">;
+    });
+}
+export declare class BVec4 extends SimpleCast<"bool" | "bvec4" | "ivec4" | "uvec4" | "vec4", "bvec4", "bvec4"> {
+    constructor({ value, }: {
+        value: DynoVal<"bool" | "bvec4" | "ivec4" | "uvec4" | "vec4">;
+    });
+}
+export declare class IVec2 extends SimpleCast<"int" | "bvec2" | "ivec2" | "uvec2" | "vec2", "ivec2", "ivec2"> {
+    constructor({ value, }: {
+        value: DynoVal<"int" | "bvec2" | "ivec2" | "uvec2" | "vec2">;
+    });
+}
+export declare class IVec3 extends SimpleCast<"int" | "bvec3" | "ivec3" | "uvec3" | "vec3", "ivec3", "ivec3"> {
+    constructor({ value, }: {
+        value: DynoVal<"int" | "bvec3" | "ivec3" | "uvec3" | "vec3">;
+    });
+}
+export declare class IVec4 extends SimpleCast<"int" | "bvec4" | "ivec4" | "uvec4" | "vec4", "ivec4", "ivec4"> {
+    constructor({ value, }: {
+        value: DynoVal<"int" | "bvec4" | "ivec4" | "uvec4" | "vec4">;
+    });
+}
+export declare class UVec2 extends SimpleCast<"uint" | "ivec2" | "bvec2" | "uvec2" | "vec2", "uvec2", "uvec2"> {
+    constructor({ value, }: {
+        value: DynoVal<"uint" | "ivec2" | "bvec2" | "uvec2" | "vec2">;
+    });
+}
+export declare class UVec3 extends SimpleCast<"uint" | "ivec3" | "bvec3" | "uvec3" | "vec3", "uvec3", "uvec3"> {
+    constructor({ value, }: {
+        value: DynoVal<"uint" | "ivec3" | "bvec3" | "uvec3" | "vec3">;
+    });
+}
+export declare class UVec4 extends SimpleCast<"uint" | "ivec4" | "bvec4" | "uvec4" | "vec4", "uvec4", "uvec4"> {
+    constructor({ value, }: {
+        value: DynoVal<"uint" | "ivec4" | "bvec4" | "uvec4" | "vec4">;
+    });
+}
+export declare class Vec2 extends SimpleCast<"float" | "bvec2" | "ivec2" | "uvec2" | "vec2" | "vec3" | "vec4", "vec2", "vec2"> {
+    constructor({ value, }: {
+        value: DynoVal<"float" | "bvec2" | "ivec2" | "uvec2" | "vec2" | "vec3" | "vec4">;
+    });
+}
+export declare class Vec3 extends SimpleCast<"float" | "bvec3" | "ivec3" | "uvec3" | "vec3" | "vec2" | "vec4", "vec3", "vec3"> {
+    constructor({ value, }: {
+        value: DynoVal<"float" | "bvec3" | "ivec3" | "uvec3" | "vec3" | "vec2" | "vec4">;
+    });
+}
+export declare class Vec4 extends SimpleCast<"float" | "bvec4" | "ivec4" | "uvec4" | "vec4", "vec4", "vec4"> {
+    constructor({ value, }: {
+        value: DynoVal<"float" | "bvec4" | "ivec4" | "uvec4" | "vec4">;
+    });
+}
+export declare class Mat2 extends SimpleCast<"float" | "mat2" | "mat3" | "mat4", "mat2", "mat2"> {
+    constructor({ value, }: {
+        value: DynoVal<"float" | "mat2" | "mat3" | "mat4">;
+    });
+}
+export declare class Mat3 extends SimpleCast<"float" | "mat2" | "mat3" | "mat4", "mat3", "mat3"> {
+    constructor({ value, }: {
+        value: DynoVal<"float" | "mat2" | "mat3" | "mat4">;
+    });
+}
+export declare class Mat4 extends SimpleCast<"float" | "mat2" | "mat3" | "mat4", "mat4", "mat4"> {
+    constructor({ value, }: {
+        value: DynoVal<"float" | "mat2" | "mat3" | "mat4">;
+    });
+}
+export declare class FloatBitsToInt extends UnaryOp<"float", "int", "int"> {
+    constructor({ value }: {
+        value: DynoVal<"float">;
+    });
+}
+export declare class FloatBitsToUint extends UnaryOp<"float", "uint", "uint"> {
+    constructor({ value }: {
+        value: DynoVal<"float">;
+    });
+}
+export declare class IntBitsToFloat extends UnaryOp<"int", "float", "float"> {
+    constructor({ value }: {
+        value: DynoVal<"int">;
+    });
+}
+export declare class UintBitsToFloat extends UnaryOp<"uint", "float", "float"> {
+    constructor({ value }: {
+        value: DynoVal<"uint">;
+    });
+}
+export declare class PackSnorm2x16 extends UnaryOp<"vec2", "uint", "uint"> {
+    constructor({ value }: {
+        value: DynoVal<"vec2">;
+    });
+}
+export declare class UnpackSnorm2x16 extends UnaryOp<"uint", "vec2", "vec2"> {
+    constructor({ value }: {
+        value: DynoVal<"uint">;
+    });
+}
+export declare class PackUnorm2x16 extends UnaryOp<"vec2", "uint", "uint"> {
+    constructor({ value }: {
+        value: DynoVal<"vec2">;
+    });
+}
+export declare class UnpackUnorm2x16 extends UnaryOp<"uint", "vec2", "vec2"> {
+    constructor({ value }: {
+        value: DynoVal<"uint">;
+    });
+}
+export declare class PackHalf2x16 extends UnaryOp<"vec2", "uint", "uint"> {
+    constructor({ value }: {
+        value: DynoVal<"vec2">;
+    });
+}
+export declare class UnpackHalf2x16 extends UnaryOp<"uint", "vec2", "vec2"> {
+    constructor({ value }: {
+        value: DynoVal<"uint">;
+    });
+}
+export declare class UintToRgba8 extends UnaryOp<"uint", "vec4", "rgba8"> {
+    constructor({ value }: {
+        value: DynoVal<"uint">;
+    });
+}