Class WasmGPU

Properties

`Readonly`animation

animation: {
    createClip: (descriptor: AnimationClipDescriptor) => AnimationClip;
    createPlayer: (
        clip: AnimationClip,
        options?: Partial<Pick<AnimationPlayer, "speed" | "loop" | "playing">>,
    ) => AnimationPlayer;
    createSkin: (
        name: string,
        joints: Transform[],
        inverseBindMatrices: Float32Array<ArrayBufferLike> | null,
    ) => Skin;
} = ...

`Readonly`colormap

colormap: {
    builtin: (name: BuiltinColormapName) => Colormap;
    fromPalette: (
        colors: readonly [number, number, number, number][],
        desc?: ColormapDescriptor,
    ) => Colormap;
    fromStops: (
        stops: readonly ColormapStop[],
        desc?: ColormapDescriptor,
    ) => Colormap;
    grayscale: () => Colormap;
    inferno: () => Colormap;
    magma: () => Colormap;
    plasma: () => Colormap;
    turbo: () => Colormap;
    viridis: () => Colormap;
} = ...

`Readonly`compute

compute: Compute

`Readonly`createCamera

createCamera: {
    orthographic: (
        options?: {
            bottom?: number;
            far?: number;
            left?: number;
            near?: number;
            right?: number;
            top?: number;
        },
    ) => OrthographicCamera;
    perspective: (
        options?: {
            aspect?: number;
            far?: number;
            fov?: number;
            near?: number;
        },
    ) => PerspectiveCamera;
} = ...

`Readonly`createControls

createControls: {
    orbit: (
        camera: Camera,
        domElement: HTMLCanvasElement,
        options?: OrbitControlsDescriptor,
    ) => OrbitControls;
    trackball: (
        camera: Camera,
        domElement: HTMLCanvasElement,
        options?: TrackballControlsDescriptor,
    ) => TrackballControls;
} = ...

`Readonly`createLight

createLight: {
    ambient: (
        options?: { color?: Color; intensity?: number },
    ) => AmbientLight;
    directional: (
        options?: {
            color?: Color;
            direction?: [number, number, number];
            intensity?: number;
        },
    ) => DirectionalLight;
    point: (
        options?: {
            color?: Color;
            intensity?: number;
            position?: [number, number, number];
            range?: number;
        },
    ) => PointLight;
} = ...

`Readonly`geometry

geometry: {
    box: (width?: number, height?: number, depth?: number) => Geometry;
    custom: (
        descriptor: {
            indices?: Uint32Array<ArrayBufferLike>;
            normals?: Float32Array<ArrayBufferLike>;
            positions: Float32Array;
            uvs?: Float32Array<ArrayBufferLike>;
        },
    ) => Geometry;
    cylinder: (
        radiusTop?: number,
        radiusBottom?: number,
        height?: number,
        radialSegments?: number,
        heightSegments?: number,
        openEnded?: boolean,
    ) => Geometry;
    plane: (
        width?: number,
        height?: number,
        widthSegments?: number,
        heightSegments?: number,
    ) => Geometry;
    prism: (radius?: number, height?: number, sides?: number) => Geometry;
    pyramid: (
        baseWidth?: number,
        baseDepth?: number,
        height?: number,
    ) => Geometry;
    sphere: (
        radius?: number,
        widthSegments?: number,
        heightSegments?: number,
    ) => Geometry;
    torus: (
        radius?: number,
        tube?: number,
        radialSegments?: number,
        tubularSegments?: number,
    ) => Geometry;
} = ...

`Readonly`gltf

gltf: {
    import: (
        doc: GltfDocument,
        options?: ImportGltfOptions,
    ) => Promise<GltfImportResult>;
    load: (
        source: string | ArrayBuffer,
        options?: LoadGltfOptions,
    ) => Promise<GltfDocument>;
    loadAndImport: (
        source: string | ArrayBuffer,
        options?: GltfOptions,
    ) => Promise<GltfImportResult>;
    parseGLB: (glb: ArrayBuffer) => ParsedGLB;
    readAccessor: (doc: GltfDocument, accessorIndex: number) => AccessorView;
    readAccessorAsFloat32: (
        doc: GltfDocument,
        accessorIndex: number,
    ) => Float32Array;
    readAccessorAsUint16: (
        doc: GltfDocument,
        accessorIndex: number,
    ) => Uint16Array;
    readIndicesAsUint32: (
        doc: GltfDocument,
        accessorIndex: number,
    ) => Uint32Array;
} = ...

`Readonly`material

material: {
    custom: (options: CustomMaterialDescriptor) => CustomMaterial;
    data: (options?: DataMaterialDescriptor) => DataMaterial;
    standard: (options?: StandardMaterialDescriptor) => StandardMaterial;
    unlit: (options?: UnlitMaterialDescriptor) => UnlitMaterial;
} = ...

`Readonly`texture

texture: { create2D: (descriptor: Texture2DDescriptor) => Texture2D } = ...

Accessors

cullingStats

get cullingStats(): { tested: number; visible: number }
Returns { tested: number; visible: number }
- Defined in core/engine.ts:98

frameArena

get frameArena(): {
    alloc: (bytes: number, align?: number) => number;
    allocF32: (len: number) => number;
    capBytes: () => number;
    epoch: () => number;
    init: (capBytes?: number) => number;
    reset: () => void;
    usedBytes: () => number;
}
Returns {
    alloc: (bytes: number, align?: number) => number;
    allocF32: (len: number) => number;
    capBytes: () => number;
    epoch: () => number;
    init: (capBytes?: number) => number;
    reset: () => void;
    usedBytes: () => number;
}
- Defined in core/engine.ts:138

gpu

get gpu(): { device: GPUDevice; format: GPUTextureFormat; queue: GPUQueue }
Returns { device: GPUDevice; format: GPUTextureFormat; queue: GPUQueue }
- Defined in core/engine.ts:90

interop

get interop(): {
    buffer: () => ArrayBufferLike;
    bytes: () => Uint8Array<ArrayBuffer>;
    createHeapArena: (capBytes: number, align?: number) => WasmHeapArena;
    frame: {
        allocF32: (len: number) => WasmSlice<Float32Array<ArrayBufferLike>>;
        allocI32: (len: number) => WasmSlice<Int32Array<ArrayBufferLike>>;
        allocU32: (len: number) => WasmSlice<Uint32Array<ArrayBufferLike>>;
        allocU8: (
            len: number,
            align?: number,
        ) => WasmSlice<Uint8Array<ArrayBufferLike>>;
    };
    heap: {
        allocF32: (len: number) => WasmSlice<Float32Array<ArrayBufferLike>>;
        allocI32: (len: number) => WasmSlice<Int32Array<ArrayBufferLike>>;
        allocU32: (len: number) => WasmSlice<Uint32Array<ArrayBufferLike>>;
        allocU8: (
            len: number,
            align?: number,
        ) => WasmSlice<Uint8Array<ArrayBufferLike>>;
    };
    isSharedMemory: () => boolean;
    requireSharedMemory: () => SharedArrayBuffer;
    view: <T extends WasmTypedArray>(
        ctor: WasmTypedArrayConstructor<T>,
        ptr: number,
        len: number,
    ) => T;
    viewFromHandle: (
        buffer: ArrayBufferLike,
        handle: WasmSliceHandle,
    ) => ArrayBufferView;
    viewOn: <T extends WasmTypedArray>(
        ctor: WasmTypedArrayConstructor<T>,
        buffer: ArrayBufferLike,
        ptr: number,
        len: number,
    ) => T;
}
Returns {
    buffer: () => ArrayBufferLike;
    bytes: () => Uint8Array<ArrayBuffer>;
    createHeapArena: (capBytes: number, align?: number) => WasmHeapArena;
    frame: {
        allocF32: (len: number) => WasmSlice<Float32Array<ArrayBufferLike>>;
        allocI32: (len: number) => WasmSlice<Int32Array<ArrayBufferLike>>;
        allocU32: (len: number) => WasmSlice<Uint32Array<ArrayBufferLike>>;
        allocU8: (
            len: number,
            align?: number,
        ) => WasmSlice<Uint8Array<ArrayBufferLike>>;
    };
    heap: {
        allocF32: (len: number) => WasmSlice<Float32Array<ArrayBufferLike>>;
        allocI32: (len: number) => WasmSlice<Int32Array<ArrayBufferLike>>;
        allocU32: (len: number) => WasmSlice<Uint32Array<ArrayBufferLike>>;
        allocU8: (
            len: number,
            align?: number,
        ) => WasmSlice<Uint8Array<ArrayBufferLike>>;
    };
    isSharedMemory: () => boolean;
    requireSharedMemory: () => SharedArrayBuffer;
    view: <T extends WasmTypedArray>(
        ctor: WasmTypedArrayConstructor<T>,
        ptr: number,
        len: number,
    ) => T;
    viewFromHandle: (
        buffer: ArrayBufferLike,
        handle: WasmSliceHandle,
    ) => ArrayBufferView;
    viewOn: <T extends WasmTypedArray>(
        ctor: WasmTypedArrayConstructor<T>,
        buffer: ArrayBufferLike,
        ptr: number,
        len: number,
    ) => T;
}
- Defined in core/engine.ts:106

isRunning

get isRunning(): boolean
Returns boolean
- Defined in core/engine.ts:94

math

get math(): {
    mat4: {
        abs: (matr: number[]) => number[];
        add: (matr1: number[], matr2: number[]) => number[];
        copy: (matr: number[]) => number[];
        det: (matr: number[]) => number;
        identity: () => number[];
        init: (
            m0: number,
            m1: number,
            m2: number,
            m3: number,
            m4: number,
            m5: number,
            m6: number,
            m7: number,
            m8: number,
            m9: number,
            m10: number,
            m11: number,
            m12: number,
            m13: number,
            m14: number,
            m15: number,
        ) => number[];
        invert: (matr: number[]) => number[];
        isEqual: (matr1: number[], matr2: number[]) => boolean;
        isIdentity: (matr: number[]) => boolean;
        isInverse: (matr1: number[], matr2: number[]) => boolean;
        isZero: (matr: number[]) => boolean;
        lookAt: (eye: number[], center: number[], up: number[]) => number[];
        mul: (matr1: number[], matr2ORvect: number[]) => number[];
        neg: (matr: number[]) => number[];
        norm: (matr: number[]) => number;
        normalize: (matr: number[]) => number[];
        normsq: (matr: number[]) => number;
        perspective: (
            fovY: number,
            aspect: number,
            near: number,
            far: number,
        ) => number[];
        print: (matr: number[]) => void;
        random: (min: number, max: number) => number[];
        rotateX: (matr: number[], angle: number) => number[];
        rotateY: (matr: number[], angle: number) => number[];
        rotateZ: (matr: number[], angle: number) => number[];
        round: (matr: number[]) => number[];
        scl: (matr: number[], scalar: number) => number[];
        sub: (matr1: number[], matr2: number[]) => number[];
        trace: (matr: number[]) => number;
        translate: (matr: number[], vect: number[]) => number[];
        transpose: (matr: number[]) => number[];
    };
    quat: {
        abs: (q: number[]) => number[];
        add: (q1: number[], q2: number[]) => number[];
        copy: (q: number[]) => number[];
        dist: (q1: number[], q2: number[]) => number;
        distsq: (q1: number[], q2: number[]) => number;
        fromAxisAngle: (axis: number[], angle: number) => number[];
        init: (a: number, b: number, c: number, d: number) => number[];
        invert: (q: number[]) => number[];
        isEqual: (q1: number[], q2: number[]) => boolean;
        isNormalized: (q: number[]) => boolean;
        isZero: (q: number[]) => boolean;
        mul: (q1: number[], q2: number[]) => number[];
        neg: (q: number[]) => number[];
        norm: (q: number[]) => number;
        normalize: (q: number[]) => number[];
        normscl: (q: number[], scalar: number) => number[];
        normsq: (q: number[]) => number;
        print: (q: number[]) => void;
        random: (min: number, max: number) => number[];
        round: (q: number[]) => number[];
        scl: (q: number[], scalar: number) => number[];
        slerp: (q1: number[], q2: number[], t: number) => number[];
        sub: (q1: number[], q2: number[]) => number[];
        toRotation: (q: number[], v: number[]) => number[];
    };
    vec3: {
        abs: (v: number[]) => number[];
        add: (v1: number[], v2: number[]) => number[];
        ang: (v: number[]) => number[];
        angBetween: (v1: number[], v2: number[]) => number;
        copy: (v: number[]) => number[];
        cross: (v1: number[], v2: number[]) => number[];
        dist: (v1: number[], v2: number[]) => number;
        distsq: (v1: number[], v2: number[]) => number;
        dot: (v1: number[], v2: number[]) => number;
        init: (x: number, y: number, z: number) => number[];
        interp: (v: number[], a: number, b: number, c: number) => number[];
        isEqual: (v1: number[], v2: number[]) => boolean;
        isNormalized: (v: number[]) => boolean;
        isOrthogonal: (v1: number[], v2: number[]) => boolean;
        isParallel: (v1: number[], v2: number[]) => boolean;
        isZero: (v: number[]) => boolean;
        neg: (v: number[]) => number[];
        norm: (v: number[]) => number;
        normalize: (v: number[]) => number[];
        normscl: (v: number[], scalar: number) => number[];
        normsq: (v: number[]) => number;
        oproj: (v1: number[], v2: number[]) => number[];
        print: (v: number[]) => void;
        proj: (v1: number[], v2: number[]) => number[];
        random: (min: number, max: number) => number[];
        reflect: (v1: number[], v2: number[]) => number[];
        refract: (v1: number[], v2: number[], refractiveIndex: number) => number[];
        round: (v: number[]) => number[];
        scl: (v: number[], scalar: number) => number[];
        sub: (v1: number[], v2: number[]) => number[];
    };
}
Returns {
    mat4: {
        abs: (matr: number[]) => number[];
        add: (matr1: number[], matr2: number[]) => number[];
        copy: (matr: number[]) => number[];
        det: (matr: number[]) => number;
        identity: () => number[];
        init: (
            m0: number,
            m1: number,
            m2: number,
            m3: number,
            m4: number,
            m5: number,
            m6: number,
            m7: number,
            m8: number,
            m9: number,
            m10: number,
            m11: number,
            m12: number,
            m13: number,
            m14: number,
            m15: number,
        ) => number[];
        invert: (matr: number[]) => number[];
        isEqual: (matr1: number[], matr2: number[]) => boolean;
        isIdentity: (matr: number[]) => boolean;
        isInverse: (matr1: number[], matr2: number[]) => boolean;
        isZero: (matr: number[]) => boolean;
        lookAt: (eye: number[], center: number[], up: number[]) => number[];
        mul: (matr1: number[], matr2ORvect: number[]) => number[];
        neg: (matr: number[]) => number[];
        norm: (matr: number[]) => number;
        normalize: (matr: number[]) => number[];
        normsq: (matr: number[]) => number;
        perspective: (
            fovY: number,
            aspect: number,
            near: number,
            far: number,
        ) => number[];
        print: (matr: number[]) => void;
        random: (min: number, max: number) => number[];
        rotateX: (matr: number[], angle: number) => number[];
        rotateY: (matr: number[], angle: number) => number[];
        rotateZ: (matr: number[], angle: number) => number[];
        round: (matr: number[]) => number[];
        scl: (matr: number[], scalar: number) => number[];
        sub: (matr1: number[], matr2: number[]) => number[];
        trace: (matr: number[]) => number;
        translate: (matr: number[], vect: number[]) => number[];
        transpose: (matr: number[]) => number[];
    };
    quat: {
        abs: (q: number[]) => number[];
        add: (q1: number[], q2: number[]) => number[];
        copy: (q: number[]) => number[];
        dist: (q1: number[], q2: number[]) => number;
        distsq: (q1: number[], q2: number[]) => number;
        fromAxisAngle: (axis: number[], angle: number) => number[];
        init: (a: number, b: number, c: number, d: number) => number[];
        invert: (q: number[]) => number[];
        isEqual: (q1: number[], q2: number[]) => boolean;
        isNormalized: (q: number[]) => boolean;
        isZero: (q: number[]) => boolean;
        mul: (q1: number[], q2: number[]) => number[];
        neg: (q: number[]) => number[];
        norm: (q: number[]) => number;
        normalize: (q: number[]) => number[];
        normscl: (q: number[], scalar: number) => number[];
        normsq: (q: number[]) => number;
        print: (q: number[]) => void;
        random: (min: number, max: number) => number[];
        round: (q: number[]) => number[];
        scl: (q: number[], scalar: number) => number[];
        slerp: (q1: number[], q2: number[], t: number) => number[];
        sub: (q1: number[], q2: number[]) => number[];
        toRotation: (q: number[], v: number[]) => number[];
    };
    vec3: {
        abs: (v: number[]) => number[];
        add: (v1: number[], v2: number[]) => number[];
        ang: (v: number[]) => number[];
        angBetween: (v1: number[], v2: number[]) => number;
        copy: (v: number[]) => number[];
        cross: (v1: number[], v2: number[]) => number[];
        dist: (v1: number[], v2: number[]) => number;
        distsq: (v1: number[], v2: number[]) => number;
        dot: (v1: number[], v2: number[]) => number;
        init: (x: number, y: number, z: number) => number[];
        interp: (v: number[], a: number, b: number, c: number) => number[];
        isEqual: (v1: number[], v2: number[]) => boolean;
        isNormalized: (v: number[]) => boolean;
        isOrthogonal: (v1: number[], v2: number[]) => boolean;
        isParallel: (v1: number[], v2: number[]) => boolean;
        isZero: (v: number[]) => boolean;
        neg: (v: number[]) => number[];
        norm: (v: number[]) => number;
        normalize: (v: number[]) => number[];
        normscl: (v: number[], scalar: number) => number[];
        normsq: (v: number[]) => number;
        oproj: (v1: number[], v2: number[]) => number[];
        print: (v: number[]) => void;
        proj: (v1: number[], v2: number[]) => number[];
        random: (min: number, max: number) => number[];
        reflect: (v1: number[], v2: number[]) => number[];
        refract: (v1: number[], v2: number[], refractiveIndex: number) => number[];
        round: (v: number[]) => number[];
        scl: (v: number[], scalar: number) => number[];
        sub: (v1: number[], v2: number[]) => number[];
    };
}
- Defined in core/engine.ts:122

performanceStats

get performanceStats(): PerformanceStats | null
Returns PerformanceStats | null
- Defined in core/engine.ts:156

python

get python(): {
    bytes: (handle: WasmNdarrayHandle) => Uint8Array;
    copyInto: (
        handle: WasmNdarrayHandle,
        src: PythonArraySource,
        options?: Omit<SendNdarrayOptions, "allocator" | "shape">,
    ) => void;
    free: (handle: WasmNdarrayHandle) => void;
    receiveNdarray: (
        handle: WasmNdarrayHandle,
        options?: ReceiveNdarrayOptions,
    ) => NdarrayTransfer;
    sendNdarray: (
        src: PythonArraySource,
        options?: SendNdarrayOptions,
    ) => WasmNdarrayHandle;
    view: (handle: WasmNdarrayHandle) => NumberTypedArray;
}
Returns {
    bytes: (handle: WasmNdarrayHandle) => Uint8Array;
    copyInto: (
        handle: WasmNdarrayHandle,
        src: PythonArraySource,
        options?: Omit<SendNdarrayOptions, "allocator" | "shape">,
    ) => void;
    free: (handle: WasmNdarrayHandle) => void;
    receiveNdarray: (
        handle: WasmNdarrayHandle,
        options?: ReceiveNdarrayOptions,
    ) => NdarrayTransfer;
    sendNdarray: (
        src: PythonArraySource,
        options?: SendNdarrayOptions,
    ) => WasmNdarrayHandle;
    view: (handle: WasmNdarrayHandle) => NumberTypedArray;
}
- Defined in core/engine.ts:114

`Static`frameArena

get frameArena(): {
    alloc: (bytes: number, align?: number) => number;
    allocF32: (len: number) => number;
    capBytes: () => number;
    epoch: () => number;
    init: (capBytes?: number) => number;
    reset: () => void;
    usedBytes: () => number;
}
Returns {
    alloc: (bytes: number, align?: number) => number;
    allocF32: (len: number) => number;
    capBytes: () => number;
    epoch: () => number;
    init: (capBytes?: number) => number;
    reset: () => void;
    usedBytes: () => number;
}
- Defined in core/engine.ts:134

`Static`interop

get interop(): {
    buffer: () => ArrayBufferLike;
    bytes: () => Uint8Array<ArrayBuffer>;
    createHeapArena: (capBytes: number, align?: number) => WasmHeapArena;
    frame: {
        allocF32: (len: number) => WasmSlice<Float32Array<ArrayBufferLike>>;
        allocI32: (len: number) => WasmSlice<Int32Array<ArrayBufferLike>>;
        allocU32: (len: number) => WasmSlice<Uint32Array<ArrayBufferLike>>;
        allocU8: (
            len: number,
            align?: number,
        ) => WasmSlice<Uint8Array<ArrayBufferLike>>;
    };
    heap: {
        allocF32: (len: number) => WasmSlice<Float32Array<ArrayBufferLike>>;
        allocI32: (len: number) => WasmSlice<Int32Array<ArrayBufferLike>>;
        allocU32: (len: number) => WasmSlice<Uint32Array<ArrayBufferLike>>;
        allocU8: (
            len: number,
            align?: number,
        ) => WasmSlice<Uint8Array<ArrayBufferLike>>;
    };
    isSharedMemory: () => boolean;
    requireSharedMemory: () => SharedArrayBuffer;
    view: <T extends WasmTypedArray>(
        ctor: WasmTypedArrayConstructor<T>,
        ptr: number,
        len: number,
    ) => T;
    viewFromHandle: (
        buffer: ArrayBufferLike,
        handle: WasmSliceHandle,
    ) => ArrayBufferView;
    viewOn: <T extends WasmTypedArray>(
        ctor: WasmTypedArrayConstructor<T>,
        buffer: ArrayBufferLike,
        ptr: number,
        len: number,
    ) => T;
}
Returns {
    buffer: () => ArrayBufferLike;
    bytes: () => Uint8Array<ArrayBuffer>;
    createHeapArena: (capBytes: number, align?: number) => WasmHeapArena;
    frame: {
        allocF32: (len: number) => WasmSlice<Float32Array<ArrayBufferLike>>;
        allocI32: (len: number) => WasmSlice<Int32Array<ArrayBufferLike>>;
        allocU32: (len: number) => WasmSlice<Uint32Array<ArrayBufferLike>>;
        allocU8: (
            len: number,
            align?: number,
        ) => WasmSlice<Uint8Array<ArrayBufferLike>>;
    };
    heap: {
        allocF32: (len: number) => WasmSlice<Float32Array<ArrayBufferLike>>;
        allocI32: (len: number) => WasmSlice<Int32Array<ArrayBufferLike>>;
        allocU32: (len: number) => WasmSlice<Uint32Array<ArrayBufferLike>>;
        allocU8: (
            len: number,
            align?: number,
        ) => WasmSlice<Uint8Array<ArrayBufferLike>>;
    };
    isSharedMemory: () => boolean;
    requireSharedMemory: () => SharedArrayBuffer;
    view: <T extends WasmTypedArray>(
        ctor: WasmTypedArrayConstructor<T>,
        ptr: number,
        len: number,
    ) => T;
    viewFromHandle: (
        buffer: ArrayBufferLike,
        handle: WasmSliceHandle,
    ) => ArrayBufferView;
    viewOn: <T extends WasmTypedArray>(
        ctor: WasmTypedArrayConstructor<T>,
        buffer: ArrayBufferLike,
        ptr: number,
        len: number,
    ) => T;
}
- Defined in core/engine.ts:102

`Static`math

get math(): {
    mat4: {
        abs: (matr: number[]) => number[];
        add: (matr1: number[], matr2: number[]) => number[];
        copy: (matr: number[]) => number[];
        det: (matr: number[]) => number;
        identity: () => number[];
        init: (
            m0: number,
            m1: number,
            m2: number,
            m3: number,
            m4: number,
            m5: number,
            m6: number,
            m7: number,
            m8: number,
            m9: number,
            m10: number,
            m11: number,
            m12: number,
            m13: number,
            m14: number,
            m15: number,
        ) => number[];
        invert: (matr: number[]) => number[];
        isEqual: (matr1: number[], matr2: number[]) => boolean;
        isIdentity: (matr: number[]) => boolean;
        isInverse: (matr1: number[], matr2: number[]) => boolean;
        isZero: (matr: number[]) => boolean;
        lookAt: (eye: number[], center: number[], up: number[]) => number[];
        mul: (matr1: number[], matr2ORvect: number[]) => number[];
        neg: (matr: number[]) => number[];
        norm: (matr: number[]) => number;
        normalize: (matr: number[]) => number[];
        normsq: (matr: number[]) => number;
        perspective: (
            fovY: number,
            aspect: number,
            near: number,
            far: number,
        ) => number[];
        print: (matr: number[]) => void;
        random: (min: number, max: number) => number[];
        rotateX: (matr: number[], angle: number) => number[];
        rotateY: (matr: number[], angle: number) => number[];
        rotateZ: (matr: number[], angle: number) => number[];
        round: (matr: number[]) => number[];
        scl: (matr: number[], scalar: number) => number[];
        sub: (matr1: number[], matr2: number[]) => number[];
        trace: (matr: number[]) => number;
        translate: (matr: number[], vect: number[]) => number[];
        transpose: (matr: number[]) => number[];
    };
    quat: {
        abs: (q: number[]) => number[];
        add: (q1: number[], q2: number[]) => number[];
        copy: (q: number[]) => number[];
        dist: (q1: number[], q2: number[]) => number;
        distsq: (q1: number[], q2: number[]) => number;
        fromAxisAngle: (axis: number[], angle: number) => number[];
        init: (a: number, b: number, c: number, d: number) => number[];
        invert: (q: number[]) => number[];
        isEqual: (q1: number[], q2: number[]) => boolean;
        isNormalized: (q: number[]) => boolean;
        isZero: (q: number[]) => boolean;
        mul: (q1: number[], q2: number[]) => number[];
        neg: (q: number[]) => number[];
        norm: (q: number[]) => number;
        normalize: (q: number[]) => number[];
        normscl: (q: number[], scalar: number) => number[];
        normsq: (q: number[]) => number;
        print: (q: number[]) => void;
        random: (min: number, max: number) => number[];
        round: (q: number[]) => number[];
        scl: (q: number[], scalar: number) => number[];
        slerp: (q1: number[], q2: number[], t: number) => number[];
        sub: (q1: number[], q2: number[]) => number[];
        toRotation: (q: number[], v: number[]) => number[];
    };
    vec3: {
        abs: (v: number[]) => number[];
        add: (v1: number[], v2: number[]) => number[];
        ang: (v: number[]) => number[];
        angBetween: (v1: number[], v2: number[]) => number;
        copy: (v: number[]) => number[];
        cross: (v1: number[], v2: number[]) => number[];
        dist: (v1: number[], v2: number[]) => number;
        distsq: (v1: number[], v2: number[]) => number;
        dot: (v1: number[], v2: number[]) => number;
        init: (x: number, y: number, z: number) => number[];
        interp: (v: number[], a: number, b: number, c: number) => number[];
        isEqual: (v1: number[], v2: number[]) => boolean;
        isNormalized: (v: number[]) => boolean;
        isOrthogonal: (v1: number[], v2: number[]) => boolean;
        isParallel: (v1: number[], v2: number[]) => boolean;
        isZero: (v: number[]) => boolean;
        neg: (v: number[]) => number[];
        norm: (v: number[]) => number;
        normalize: (v: number[]) => number[];
        normscl: (v: number[], scalar: number) => number[];
        normsq: (v: number[]) => number;
        oproj: (v1: number[], v2: number[]) => number[];
        print: (v: number[]) => void;
        proj: (v1: number[], v2: number[]) => number[];
        random: (min: number, max: number) => number[];
        reflect: (v1: number[], v2: number[]) => number[];
        refract: (v1: number[], v2: number[], refractiveIndex: number) => number[];
        round: (v: number[]) => number[];
        scl: (v: number[], scalar: number) => number[];
        sub: (v1: number[], v2: number[]) => number[];
    };
}
Returns {
    mat4: {
        abs: (matr: number[]) => number[];
        add: (matr1: number[], matr2: number[]) => number[];
        copy: (matr: number[]) => number[];
        det: (matr: number[]) => number;
        identity: () => number[];
        init: (
            m0: number,
            m1: number,
            m2: number,
            m3: number,
            m4: number,
            m5: number,
            m6: number,
            m7: number,
            m8: number,
            m9: number,
            m10: number,
            m11: number,
            m12: number,
            m13: number,
            m14: number,
            m15: number,
        ) => number[];
        invert: (matr: number[]) => number[];
        isEqual: (matr1: number[], matr2: number[]) => boolean;
        isIdentity: (matr: number[]) => boolean;
        isInverse: (matr1: number[], matr2: number[]) => boolean;
        isZero: (matr: number[]) => boolean;
        lookAt: (eye: number[], center: number[], up: number[]) => number[];
        mul: (matr1: number[], matr2ORvect: number[]) => number[];
        neg: (matr: number[]) => number[];
        norm: (matr: number[]) => number;
        normalize: (matr: number[]) => number[];
        normsq: (matr: number[]) => number;
        perspective: (
            fovY: number,
            aspect: number,
            near: number,
            far: number,
        ) => number[];
        print: (matr: number[]) => void;
        random: (min: number, max: number) => number[];
        rotateX: (matr: number[], angle: number) => number[];
        rotateY: (matr: number[], angle: number) => number[];
        rotateZ: (matr: number[], angle: number) => number[];
        round: (matr: number[]) => number[];
        scl: (matr: number[], scalar: number) => number[];
        sub: (matr1: number[], matr2: number[]) => number[];
        trace: (matr: number[]) => number;
        translate: (matr: number[], vect: number[]) => number[];
        transpose: (matr: number[]) => number[];
    };
    quat: {
        abs: (q: number[]) => number[];
        add: (q1: number[], q2: number[]) => number[];
        copy: (q: number[]) => number[];
        dist: (q1: number[], q2: number[]) => number;
        distsq: (q1: number[], q2: number[]) => number;
        fromAxisAngle: (axis: number[], angle: number) => number[];
        init: (a: number, b: number, c: number, d: number) => number[];
        invert: (q: number[]) => number[];
        isEqual: (q1: number[], q2: number[]) => boolean;
        isNormalized: (q: number[]) => boolean;
        isZero: (q: number[]) => boolean;
        mul: (q1: number[], q2: number[]) => number[];
        neg: (q: number[]) => number[];
        norm: (q: number[]) => number;
        normalize: (q: number[]) => number[];
        normscl: (q: number[], scalar: number) => number[];
        normsq: (q: number[]) => number;
        print: (q: number[]) => void;
        random: (min: number, max: number) => number[];
        round: (q: number[]) => number[];
        scl: (q: number[], scalar: number) => number[];
        slerp: (q1: number[], q2: number[], t: number) => number[];
        sub: (q1: number[], q2: number[]) => number[];
        toRotation: (q: number[], v: number[]) => number[];
    };
    vec3: {
        abs: (v: number[]) => number[];
        add: (v1: number[], v2: number[]) => number[];
        ang: (v: number[]) => number[];
        angBetween: (v1: number[], v2: number[]) => number;
        copy: (v: number[]) => number[];
        cross: (v1: number[], v2: number[]) => number[];
        dist: (v1: number[], v2: number[]) => number;
        distsq: (v1: number[], v2: number[]) => number;
        dot: (v1: number[], v2: number[]) => number;
        init: (x: number, y: number, z: number) => number[];
        interp: (v: number[], a: number, b: number, c: number) => number[];
        isEqual: (v1: number[], v2: number[]) => boolean;
        isNormalized: (v: number[]) => boolean;
        isOrthogonal: (v1: number[], v2: number[]) => boolean;
        isParallel: (v1: number[], v2: number[]) => boolean;
        isZero: (v: number[]) => boolean;
        neg: (v: number[]) => number[];
        norm: (v: number[]) => number;
        normalize: (v: number[]) => number[];
        normscl: (v: number[], scalar: number) => number[];
        normsq: (v: number[]) => number;
        oproj: (v1: number[], v2: number[]) => number[];
        print: (v: number[]) => void;
        proj: (v1: number[], v2: number[]) => number[];
        random: (min: number, max: number) => number[];
        reflect: (v1: number[], v2: number[]) => number[];
        refract: (v1: number[], v2: number[], refractiveIndex: number) => number[];
        round: (v: number[]) => number[];
        scl: (v: number[], scalar: number) => number[];
        sub: (v1: number[], v2: number[]) => number[];
    };
}
- Defined in core/engine.ts:118

`Static`python

get python(): {
    bytes: (handle: WasmNdarrayHandle) => Uint8Array;
    copyInto: (
        handle: WasmNdarrayHandle,
        src: PythonArraySource,
        options?: Omit<SendNdarrayOptions, "allocator" | "shape">,
    ) => void;
    free: (handle: WasmNdarrayHandle) => void;
    receiveNdarray: (
        handle: WasmNdarrayHandle,
        options?: ReceiveNdarrayOptions,
    ) => NdarrayTransfer;
    sendNdarray: (
        src: PythonArraySource,
        options?: SendNdarrayOptions,
    ) => WasmNdarrayHandle;
    view: (handle: WasmNdarrayHandle) => NumberTypedArray;
}
Returns {
    bytes: (handle: WasmNdarrayHandle) => Uint8Array;
    copyInto: (
        handle: WasmNdarrayHandle,
        src: PythonArraySource,
        options?: Omit<SendNdarrayOptions, "allocator" | "shape">,
    ) => void;
    free: (handle: WasmNdarrayHandle) => void;
    receiveNdarray: (
        handle: WasmNdarrayHandle,
        options?: ReceiveNdarrayOptions,
    ) => NdarrayTransfer;
    sendNdarray: (
        src: PythonArraySource,
        options?: SendNdarrayOptions,
    ) => WasmNdarrayHandle;
    view: (handle: WasmNdarrayHandle) => NumberTypedArray;
}
- Defined in core/engine.ts:110

Methods

createGlyphField

createGlyphField(descriptor?: GlyphFieldDescriptor): GlyphField
Parameters
- descriptor: GlyphFieldDescriptor = {}
Returns GlyphField
- Defined in core/engine.ts:253

createHeapArena

createHeapArena(capBytes: number, align?: number): WasmHeapArena
Parameters
- capBytes: number
- align: number = 16
Returns WasmHeapArena
- Defined in core/engine.ts:130

createMesh

createMesh(geometry: Geometry, material: Material): Mesh
Parameters
- geometry: Geometry
- material: Material
Returns Mesh
- Defined in core/engine.ts:245

createPerformanceStats

createPerformanceStats(desc?: PerformanceStatsDescriptor): PerformanceStats
Parameters
- desc: PerformanceStatsDescriptor = {}
Returns PerformanceStats
- Defined in core/engine.ts:142

createPointCloud

createPointCloud(descriptor?: PointCloudDescriptor): PointCloud
Parameters
- descriptor: PointCloudDescriptor = {}
Returns PointCloud
- Defined in core/engine.ts:249

createScene

createScene(background?: Color): Scene
Parameters
- Optionalbackground: Color
Returns Scene
- Defined in core/engine.ts:171

createTransform

createTransform(): Transform
Returns Transform
- Defined in core/engine.ts:241

destroy

destroy(): void
Returns void
- Defined in core/engine.ts:339

destroyPerformanceStats

destroyPerformanceStats(): void
Returns void
- Defined in core/engine.ts:160

render

render(scene: Scene, camera: Camera): void
Parameters
- scene: Scene
- camera: Camera
Returns void
- Defined in core/engine.ts:166

run

run(callback: FrameCallback): void
Parameters
- callback: FrameCallback
Returns void
- Defined in core/engine.ts:63

stop

stop(): void
Returns void
- Defined in core/engine.ts:82

`Static`create

create(
canvas: HTMLCanvasElement,
descriptor?: RendererDescriptor,
): Promise<WasmGPU>
Parameters
- canvas: HTMLCanvasElement
- descriptor: RendererDescriptor = {}
Returns Promise<WasmGPU>
- Defined in core/engine.ts:57

`Static`createHeapArena

createHeapArena(capBytes: number, align?: number): WasmHeapArena
Parameters
- capBytes: number
- align: number = 16
Returns WasmHeapArena
- Defined in core/engine.ts:126

Class WasmGPU

Index

Properties

Accessors

Methods

Properties

Readonlyanimation

Readonlycolormap

Readonlycompute

ReadonlycreateCamera

ReadonlycreateControls

ReadonlycreateLight

Readonlygeometry

Readonlygltf

Readonlymaterial

Readonlytexture

Accessors

cullingStats

Returns { tested: number; visible: number }

frameArena

Returns { alloc: (bytes: number, align?: number) => number; allocF32: (len: number) => number; capBytes: () => number; epoch: () => number; init: (capBytes?: number) => number; reset: () => void; usedBytes: () => number;}

gpu

Returns { device: GPUDevice; format: GPUTextureFormat; queue: GPUQueue }

interop

isRunning

Returns boolean

math

performanceStats

Returns PerformanceStats | null

python

StaticframeArena

Returns { alloc: (bytes: number, align?: number) => number; allocF32: (len: number) => number; capBytes: () => number; epoch: () => number; init: (capBytes?: number) => number; reset: () => void; usedBytes: () => number;}

Staticinterop

Staticmath

Staticpython

Methods

createGlyphField

Parameters

Returns GlyphField

createHeapArena

Parameters

Returns WasmHeapArena

createMesh

Parameters

Returns Mesh

createPerformanceStats

Parameters

Returns PerformanceStats

createPointCloud

Parameters

Returns PointCloud

createScene

Parameters

Returns Scene

createTransform

Returns Transform

destroy

Returns void

destroyPerformanceStats

Returns void

render

Parameters

Returns void

run

Parameters

Returns void

stop

Returns void

Staticcreate

Parameters

Returns Promise<WasmGPU>

StaticcreateHeapArena

Parameters

Returns WasmHeapArena

Settings

On This Page

`Readonly`animation

`Readonly`colormap

`Readonly`compute

`Readonly`createCamera

`Readonly`createControls

`Readonly`createLight

`Readonly`geometry

`Readonly`gltf

`Readonly`material

`Readonly`texture

Returns {
alloc: (bytes: number, align?: number) => number;
allocF32: (len: number) => number;
capBytes: () => number;
epoch: () => number;
init: (capBytes?: number) => number;
reset: () => void;
usedBytes: () => number;
}

`Static`frameArena

Returns {
alloc: (bytes: number, align?: number) => number;
allocF32: (len: number) => number;
capBytes: () => number;
epoch: () => number;
init: (capBytes?: number) => number;
reset: () => void;
usedBytes: () => number;
}

`Static`interop

`Static`math

`Static`python

`Static`create

`Static`createHeapArena