@luma.gl/engine 9.0.0-alpha.9 → 9.0.0-beta.10

package/dist/animation-loop/animation-loop.js

@@ -0,0 +1,442 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { luma } from '@luma.gl/core';
+import { requestAnimationFrame, cancelAnimationFrame } from '@luma.gl/core';
+import { Stats } from '@probe.gl/stats';
+let statIdCounter = 0;
+const DEFAULT_ANIMATION_LOOP_PROPS = {
+    device: null,
+    onAddHTML: () => '',
+    onInitialize: async () => {
+        return null;
+    },
+    onRender: () => { },
+    onFinalize: () => { },
+    onError: error => console.error(error), // eslint-disable-line no-console
+    stats: luma.stats.get(`animation-loop-${statIdCounter++}`),
+    // view parameters
+    useDevicePixels: true,
+    autoResizeViewport: false,
+    autoResizeDrawingBuffer: false
+};
+/** Convenient animation loop */
+export class AnimationLoop {
+    device = null;
+    canvas = null;
+    props;
+    animationProps = null;
+    timeline = null;
+    stats;
+    cpuTime;
+    gpuTime;
+    frameRate;
+    display;
+    needsRedraw = 'initialized';
+    _initialized = false;
+    _running = false;
+    _animationFrameId = null;
+    _nextFramePromise = null;
+    _resolveNextFrame = null;
+    _cpuStartTime = 0;
+    // _gpuTimeQuery: Query | null = null;
+    /*
+     * @param {HTMLCanvasElement} canvas - if provided, width and height will be passed to context
+     */
+    constructor(props) {
+        this.props = { ...DEFAULT_ANIMATION_LOOP_PROPS, ...props };
+        props = this.props;
+        if (!props.device) {
+            throw new Error('No device provided');
+        }
+        const { useDevicePixels = true } = this.props;
+        // state
+        this.stats = props.stats || new Stats({ id: 'animation-loop-stats' });
+        this.cpuTime = this.stats.get('CPU Time');
+        this.gpuTime = this.stats.get('GPU Time');
+        this.frameRate = this.stats.get('Frame Rate');
+        this.setProps({
+            autoResizeViewport: props.autoResizeViewport,
+            autoResizeDrawingBuffer: props.autoResizeDrawingBuffer,
+            useDevicePixels
+        });
+        // Bind methods
+        this.start = this.start.bind(this);
+        this.stop = this.stop.bind(this);
+        this._onMousemove = this._onMousemove.bind(this);
+        this._onMouseleave = this._onMouseleave.bind(this);
+    }
+    destroy() {
+        this.stop();
+        this._setDisplay(null);
+    }
+    /** @deprecated Use .destroy() */
+    delete() {
+        this.destroy();
+    }
+    /** Flags this animation loop as needing redraw */
+    setNeedsRedraw(reason) {
+        this.needsRedraw = this.needsRedraw || reason;
+        return this;
+    }
+    /** TODO - move these props to CanvasContext? */
+    setProps(props) {
+        if ('autoResizeViewport' in props) {
+            this.props.autoResizeViewport = props.autoResizeViewport || false;
+        }
+        if ('autoResizeDrawingBuffer' in props) {
+            this.props.autoResizeDrawingBuffer = props.autoResizeDrawingBuffer || false;
+        }
+        if ('useDevicePixels' in props) {
+            this.props.useDevicePixels = props.useDevicePixels || false;
+        }
+        return this;
+    }
+    /** Starts a render loop if not already running */
+    async start() {
+        if (this._running) {
+            return this;
+        }
+        this._running = true;
+        try {
+            let appContext;
+            if (!this._initialized) {
+                this._initialized = true;
+                // Create the WebGL context
+                await this._initDevice();
+                this._initialize();
+                // Note: onIntialize can return a promise (e.g. in case app needs to load resources)
+                await this.props.onInitialize(this._getAnimationProps());
+            }
+            // check that we haven't been stopped
+            if (!this._running) {
+                return null;
+            }
+            // Start the loop
+            if (appContext !== false) {
+                // cancel any pending renders to ensure only one loop can ever run
+                this._cancelAnimationFrame();
+                this._requestAnimationFrame();
+            }
+            return this;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Unknown error');
+            this.props.onError(error);
+            // this._running = false; // TODO
+            throw error;
+        }
+    }
+    /** Stops a render loop if already running, finalizing */
+    stop() {
+        // console.debug(`Stopping ${this.constructor.name}`);
+        if (this._running) {
+            // call callback
+            // If stop is called immediately, we can end up in a state where props haven't been initialized...
+            if (this.animationProps) {
+                this.props.onFinalize(this.animationProps);
+            }
+            this._cancelAnimationFrame();
+            this._nextFramePromise = null;
+            this._resolveNextFrame = null;
+            this._running = false;
+        }
+        return this;
+    }
+    /** Explicitly draw a frame */
+    redraw() {
+        if (this.device?.isLost) {
+            return this;
+        }
+        this._beginFrameTimers();
+        this._setupFrame();
+        this._updateAnimationProps();
+        this._renderFrame(this._getAnimationProps());
+        // clear needsRedraw flag
+        this._clearNeedsRedraw();
+        if (this._resolveNextFrame) {
+            this._resolveNextFrame(this);
+            this._nextFramePromise = null;
+            this._resolveNextFrame = null;
+        }
+        this._endFrameTimers();
+        return this;
+    }
+    /** Add a timeline, it will be automatically updated by the animation loop. */
+    attachTimeline(timeline) {
+        this.timeline = timeline;
+        return this.timeline;
+    }
+    /** Remove a timeline */
+    detachTimeline() {
+        this.timeline = null;
+    }
+    /** Wait until a render completes */
+    waitForRender() {
+        this.setNeedsRedraw('waitForRender');
+        if (!this._nextFramePromise) {
+            this._nextFramePromise = new Promise(resolve => {
+                this._resolveNextFrame = resolve;
+            });
+        }
+        return this._nextFramePromise;
+    }
+    /** TODO - should use device.deviceContext */
+    async toDataURL() {
+        this.setNeedsRedraw('toDataURL');
+        await this.waitForRender();
+        if (this.canvas instanceof HTMLCanvasElement) {
+            return this.canvas.toDataURL();
+        }
+        throw new Error('OffscreenCanvas');
+    }
+    // PRIVATE METHODS
+    _initialize() {
+        this._startEventHandling();
+        // Initialize the callback data
+        this._initializeAnimationProps();
+        this._updateAnimationProps();
+        // Default viewport setup, in case onInitialize wants to render
+        this._resizeCanvasDrawingBuffer();
+        this._resizeViewport();
+        // this._gpuTimeQuery = Query.isSupported(this.gl, ['timers']) ? new Query(this.gl) : null;
+    }
+    _setDisplay(display) {
+        if (this.display) {
+            this.display.destroy();
+            this.display.animationLoop = null;
+        }
+        // store animation loop on the display
+        if (display) {
+            display.animationLoop = this;
+        }
+        this.display = display;
+    }
+    _requestAnimationFrame() {
+        if (!this._running) {
+            return;
+        }
+        // VR display has a separate animation frame to sync with headset
+        // TODO WebVR API discontinued, replaced by WebXR: https://immersive-web.github.io/webxr/
+        // See https://developer.mozilla.org/en-US/docs/Web/API/VRDisplay/requestAnimationFrame
+        // if (this.display && this.display.requestAnimationFrame) {
+        //   this._animationFrameId = this.display.requestAnimationFrame(this._animationFrame.bind(this));
+        // }
+        this._animationFrameId = requestAnimationFrame(this._animationFrame.bind(this));
+    }
+    _cancelAnimationFrame() {
+        if (this._animationFrameId === null) {
+            return;
+        }
+        // VR display has a separate animation frame to sync with headset
+        // TODO WebVR API discontinued, replaced by WebXR: https://immersive-web.github.io/webxr/
+        // See https://developer.mozilla.org/en-US/docs/Web/API/VRDisplay/requestAnimationFrame
+        // if (this.display && this.display.cancelAnimationFrame) {
+        //   this.display.cancelAnimationFrame(this._animationFrameId);
+        // }
+        cancelAnimationFrame(this._animationFrameId);
+        this._animationFrameId = null;
+    }
+    _animationFrame() {
+        if (!this._running) {
+            return;
+        }
+        this.redraw();
+        this._requestAnimationFrame();
+    }
+    // Called on each frame, can be overridden to call onRender multiple times
+    // to support e.g. stereoscopic rendering
+    _renderFrame(animationProps) {
+        // Allow e.g. VR display to render multiple frames.
+        if (this.display) {
+            this.display._renderFrame(animationProps);
+            return;
+        }
+        // call callback
+        this.props.onRender(this._getAnimationProps());
+        // end callback
+        // Submit commands (necessary on WebGPU)
+        this.device.submit();
+    }
+    _clearNeedsRedraw() {
+        this.needsRedraw = false;
+    }
+    _setupFrame() {
+        this._resizeCanvasDrawingBuffer();
+        this._resizeViewport();
+    }
+    // Initialize the  object that will be passed to app callbacks
+    _initializeAnimationProps() {
+        if (!this.device) {
+            throw new Error('loop');
+        }
+        this.animationProps = {
+            animationLoop: this,
+            device: this.device,
+            canvas: this.device?.canvasContext?.canvas,
+            timeline: this.timeline,
+            // Initial values
+            useDevicePixels: this.props.useDevicePixels,
+            needsRedraw: false,
+            // Placeholders
+            width: 1,
+            height: 1,
+            aspect: 1,
+            // Animation props
+            time: 0,
+            startTime: Date.now(),
+            engineTime: 0,
+            tick: 0,
+            tock: 0,
+            // Experimental
+            _mousePosition: null // Event props
+        };
+    }
+    _getAnimationProps() {
+        if (!this.animationProps) {
+            throw new Error('animationProps');
+        }
+        return this.animationProps;
+    }
+    // Update the context object that will be passed to app callbacks
+    _updateAnimationProps() {
+        if (!this.animationProps) {
+            return;
+        }
+        // Can this be replaced with canvas context?
+        const { width, height, aspect } = this._getSizeAndAspect();
+        if (width !== this.animationProps.width || height !== this.animationProps.height) {
+            this.setNeedsRedraw('drawing buffer resized');
+        }
+        if (aspect !== this.animationProps.aspect) {
+            this.setNeedsRedraw('drawing buffer aspect changed');
+        }
+        this.animationProps.width = width;
+        this.animationProps.height = height;
+        this.animationProps.aspect = aspect;
+        this.animationProps.needsRedraw = this.needsRedraw;
+        // Update time properties
+        this.animationProps.engineTime = Date.now() - this.animationProps.startTime;
+        if (this.timeline) {
+            this.timeline.update(this.animationProps.engineTime);
+        }
+        this.animationProps.tick = Math.floor((this.animationProps.time / 1000) * 60);
+        this.animationProps.tock++;
+        // For back compatibility
+        this.animationProps.time = this.timeline
+            ? this.timeline.getTime()
+            : this.animationProps.engineTime;
+    }
+    /** Wait for supplied device */
+    async _initDevice() {
+        this.device = await this.props.device;
+        if (!this.device) {
+            throw new Error('No device provided');
+        }
+        this.canvas = this.device.canvasContext?.canvas || null;
+        // this._createInfoDiv();
+    }
+    _createInfoDiv() {
+        if (this.canvas && this.props.onAddHTML) {
+            const wrapperDiv = document.createElement('div');
+            document.body.appendChild(wrapperDiv);
+            wrapperDiv.style.position = 'relative';
+            const div = document.createElement('div');
+            div.style.position = 'absolute';
+            div.style.left = '10px';
+            div.style.bottom = '10px';
+            div.style.width = '300px';
+            div.style.background = 'white';
+            if (this.canvas instanceof HTMLCanvasElement) {
+                wrapperDiv.appendChild(this.canvas);
+            }
+            wrapperDiv.appendChild(div);
+            const html = this.props.onAddHTML(div);
+            if (html) {
+                div.innerHTML = html;
+            }
+        }
+    }
+    _getSizeAndAspect() {
+        if (!this.device) {
+            return { width: 1, height: 1, aspect: 1 };
+        }
+        // https://webglfundamentals.org/webgl/lessons/webgl-resizing-the-canvas.html
+        const [width, height] = this.device?.canvasContext?.getPixelSize() || [1, 1];
+        // https://webglfundamentals.org/webgl/lessons/webgl-anti-patterns.html
+        let aspect = 1;
+        const canvas = this.device?.canvasContext?.canvas;
+        // @ts-expect-error
+        if (canvas && canvas.clientHeight) {
+            // @ts-expect-error
+            aspect = canvas.clientWidth / canvas.clientHeight;
+        }
+        else if (width > 0 && height > 0) {
+            aspect = width / height;
+        }
+        return { width, height, aspect };
+    }
+    /** Default viewport setup */
+    _resizeViewport() {
+        // TODO can we use canvas context to code this in a portable way?
+        // @ts-expect-error Expose on canvasContext
+        if (this.props.autoResizeViewport && this.device.gl) {
+            // @ts-expect-error Expose canvasContext
+            this.device.gl.viewport(0, 0, 
+            // @ts-expect-error Expose canvasContext
+            this.device.gl.drawingBufferWidth, 
+            // @ts-expect-error Expose canvasContext
+            this.device.gl.drawingBufferHeight);
+        }
+    }
+    /**
+     * Resize the render buffer of the canvas to match canvas client size
+     * Optionally multiplying with devicePixel ratio
+     */
+    _resizeCanvasDrawingBuffer() {
+        if (this.props.autoResizeDrawingBuffer) {
+            this.device?.canvasContext?.resize({ useDevicePixels: this.props.useDevicePixels });
+        }
+    }
+    _beginFrameTimers() {
+        this.frameRate.timeEnd();
+        this.frameRate.timeStart();
+        // Check if timer for last frame has completed.
+        // GPU timer results are never available in the same
+        // frame they are captured.
+        // if (
+        //   this._gpuTimeQuery &&
+        //   this._gpuTimeQuery.isResultAvailable() &&
+        //   !this._gpuTimeQuery.isTimerDisjoint()
+        // ) {
+        //   this.stats.get('GPU Time').addTime(this._gpuTimeQuery.getTimerMilliseconds());
+        // }
+        // if (this._gpuTimeQuery) {
+        //   // GPU time query start
+        //   this._gpuTimeQuery.beginTimeElapsedQuery();
+        // }
+        this.cpuTime.timeStart();
+    }
+    _endFrameTimers() {
+        this.cpuTime.timeEnd();
+        // if (this._gpuTimeQuery) {
+        //   // GPU time query end. Results will be available on next frame.
+        //   this._gpuTimeQuery.end();
+        // }
+    }
+    // Event handling
+    _startEventHandling() {
+        if (this.canvas) {
+            this.canvas.addEventListener('mousemove', this._onMousemove.bind(this));
+            this.canvas.addEventListener('mouseleave', this._onMouseleave.bind(this));
+        }
+    }
+    _onMousemove(event) {
+        if (event instanceof MouseEvent) {
+            this._getAnimationProps()._mousePosition = [event.offsetX, event.offsetY];
+        }
+    }
+    _onMouseleave(event) {
+        this._getAnimationProps()._mousePosition = null;
+    }
+}

package/dist/{lib → animation-loop}/animation-props.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="offscreencanvas" />
-import { Device } from '@luma.gl/api';
-import { Timeline } from '../animation/timeline';
-import type { AnimationLoop } from './animation-loop';
+import { Device } from '@luma.gl/core';
+import { Timeline } from "../animation/timeline.js";
+import type { AnimationLoop } from "./animation-loop.js";
 /** Properties passed to every render frame  */
-export declare type AnimationProps = {
+export type AnimationProps = {
     device: Device;
     animationLoop: AnimationLoop;
     /** @todo Should be canvasContext */

package/dist/animation-loop/animation-props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-props.d.ts","sourceRoot":"","sources":["../../src/animation-loop/animation-props.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AACrC,OAAO,EAAC,QAAQ,EAAC,iCAA8B;AAC/C,OAAO,KAAK,EAAC,aAAa,EAAC,4BAAyB;AAEpD,+CAA+C;AAC/C,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,aAAa,CAAC;IAE7B,oCAAoC;IACpC,MAAM,EAAE,iBAAiB,GAAG,eAAe,CAAC;IAC5C,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IAGf,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IAGb,WAAW,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAE7B,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAG1B,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;CAC1C,CAAC"}

package/dist/animation-loop/animation-props.js

@@ -0,0 +1 @@
+export {};

package/dist/animation-loop/make-animation-loop.d.ts

@@ -0,0 +1,6 @@
+import { AnimationLoopTemplate } from "./animation-loop-template.js";
+import { AnimationLoop, AnimationLoopProps } from "./animation-loop.js";
+export type MakeAnimationLoopProps = Omit<AnimationLoopProps, 'onCreateDevice' | 'onInitialize' | 'onRedraw' | 'onFinalize'>;
+/** Instantiates and runs the render loop */
+export declare function makeAnimationLoop(AnimationLoopTemplateCtor: typeof AnimationLoopTemplate, props?: MakeAnimationLoopProps): AnimationLoop;
+//# sourceMappingURL=make-animation-loop.d.ts.map

package/dist/animation-loop/make-animation-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-animation-loop.d.ts","sourceRoot":"","sources":["../../src/animation-loop/make-animation-loop.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,qBAAqB,EAAC,qCAAkC;AAChE,OAAO,EAAC,aAAa,EAAE,kBAAkB,EAAC,4BAAyB;AAGnE,MAAM,MAAM,sBAAsB,GAAG,IAAI,CACvC,kBAAkB,EAClB,gBAAgB,GAAG,cAAc,GAAG,UAAU,GAAG,YAAY,CAC9D,CAAC;AAEF,4CAA4C;AAC5C,wBAAgB,iBAAiB,CAC/B,yBAAyB,EAAE,OAAO,qBAAqB,EACvD,KAAK,CAAC,EAAE,sBAAsB,GAC7B,aAAa,CAkCf"}

package/dist/animation-loop/make-animation-loop.js

@@ -0,0 +1,32 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { luma } from '@luma.gl/core';
+import { AnimationLoop } from "./animation-loop.js";
+/** Instantiates and runs the render loop */
+export function makeAnimationLoop(AnimationLoopTemplateCtor, props) {
+    let renderLoop = null;
+    const device = props?.device || luma.createDevice();
+    // Create an animation loop;
+    const animationLoop = new AnimationLoop({
+        ...props,
+        device,
+        async onInitialize(animationProps) {
+            // @ts-expect-error abstract to prevent instantiation
+            renderLoop = new AnimationLoopTemplateCtor(animationProps);
+            // Any async loading can be handled here
+            return await renderLoop?.onInitialize(animationProps);
+        },
+        onRender: (animationProps) => renderLoop?.onRender(animationProps),
+        onFinalize: (animationProps) => renderLoop?.onFinalize(animationProps)
+    });
+    // @ts-expect-error Hack: adds info for the website to find
+    animationLoop.getInfo = () => {
+        // @ts-ignore
+        // eslint-disable-next-line no-invalid-this
+        return this.AnimationLoopTemplateCtor.info;
+    };
+    // Start the loop automatically
+    // animationLoop.start();
+    return animationLoop;
+}

package/dist/computation.d.ts

@@ -0,0 +1,95 @@
+import type { TypedArray } from '@luma.gl/core';
+import type { ComputePipelineProps, Shader, Binding } from '@luma.gl/core';
+import { Device, Buffer, ComputePipeline, ComputePass, UniformStore } from '@luma.gl/core';
+import type { ShaderModule, PlatformInfo } from '@luma.gl/shadertools';
+import { ShaderAssembler } from '@luma.gl/shadertools';
+import { ShaderInputs } from "./shader-inputs.js";
+import { PipelineFactory } from "./lib/pipeline-factory.js";
+import { ShaderFactory } from "./lib/shader-factory.js";
+export type ComputationProps = Omit<ComputePipelineProps, 'shader'> & {
+    source?: string;
+    /** shadertool shader modules (added to shader code) */
+    modules?: ShaderModule[];
+    /** Shadertool module defines (configures shader code)*/
+    defines?: Record<string, string | number | boolean>;
+    /** Shader inputs, used to generated uniform buffers and bindings */
+    shaderInputs?: ShaderInputs;
+    /** Bindings */
+    bindings?: Record<string, Binding>;
+    /** Show shader source in browser? */
+    debugShaders?: 'never' | 'errors' | 'warnings' | 'always';
+    /** Factory used to create a {@link ComputePipeline}. Defaults to {@link Device} default factory. */
+    pipelineFactory?: PipelineFactory;
+    /** Factory used to create a {@link Shader}. Defaults to {@link Device} default factory. */
+    shaderFactory?: ShaderFactory;
+    /** Shader assembler. Defaults to the ShaderAssembler.getShaderAssembler() */
+    shaderAssembler?: ShaderAssembler;
+};
+/**
+ * v9 Model API
+ * A model
+ * - automatically reuses pipelines (programs) when possible
+ * - automatically rebuilds pipelines if necessary to accommodate changed settings
+ * shadertools integration
+ * - accepts modules and performs shader transpilation
+ */
+export declare class Computation {
+    static defaultProps: Required<ComputationProps>;
+    readonly device: Device;
+    readonly id: string;
+    readonly pipelineFactory: PipelineFactory;
+    readonly shaderFactory: ShaderFactory;
+    userData: {
+        [key: string]: any;
+    };
+    /** Bindings (textures, samplers, uniform buffers) */
+    bindings: Record<string, Binding>;
+    /** The underlying GPU "program". @note May be recreated if parameters change */
+    pipeline: ComputePipeline;
+    /** the underlying compiled compute shader */
+    shader: Shader;
+    source: string;
+    /** ShaderInputs instance */
+    shaderInputs: ShaderInputs;
+    _uniformStore: UniformStore;
+    _pipelineNeedsUpdate: string | false;
+    private _getModuleUniforms;
+    private props;
+    private _destroyed;
+    constructor(device: Device, props: ComputationProps);
+    destroy(): void;
+    predraw(): void;
+    dispatch(computePass: ComputePass, x: number, y?: number, z?: number): void;
+    /**
+     * Updates the vertex count (used in draw calls)
+     * @note Any attributes with stepMode=vertex need to be at least this big
+     */
+    setVertexCount(vertexCount: number): void;
+    /**
+     * Updates the instance count (used in draw calls)
+     * @note Any attributes with stepMode=instance need to be at least this big
+     */
+    setInstanceCount(instanceCount: number): void;
+    setShaderInputs(shaderInputs: ShaderInputs): void;
+    /**
+     * Updates shader module settings (which results in uniforms being set)
+     */
+    setShaderModuleProps(props: Record<string, any>): void;
+    updateShaderInputs(): void;
+    /**
+     * Sets bindings (textures, samplers, uniform buffers)
+     */
+    setBindings(bindings: Record<string, Binding>): void;
+    _setPipelineNeedsUpdate(reason: string): void;
+    _updatePipeline(): ComputePipeline;
+    /** Throttle draw call logging */
+    _lastLogTime: number;
+    _logOpen: boolean;
+    _logDrawCallStart(): void;
+    _logDrawCallEnd(): void;
+    protected _drawCount: number;
+    _getBufferOrConstantValues(attribute: Buffer | TypedArray, dataType: any): string;
+}
+/** Create a shadertools platform info from the Device */
+export declare function getPlatformInfo(device: Device): PlatformInfo;
+//# sourceMappingURL=computation.d.ts.map

package/dist/computation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computation.d.ts","sourceRoot":"","sources":["../src/computation.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAgB,oBAAoB,EAAE,MAAM,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AACxF,OAAO,EAAC,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,WAAW,EAAE,YAAY,EAAC,MAAM,eAAe,CAAC;AAGzF,OAAO,KAAK,EAAC,YAAY,EAAE,YAAY,EAAC,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAC,eAAe,EAA0B,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAC,YAAY,EAAC,2BAAwB;AAC7C,OAAO,EAAC,eAAe,EAAC,kCAA+B;AACvD,OAAO,EAAC,aAAa,EAAC,gCAA6B;AAMnD,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,oBAAoB,EAAE,QAAQ,CAAC,GAAG;IACpE,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,uDAAuD;IACvD,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;IACzB,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;IAGpD,oEAAoE;IACpE,YAAY,CAAC,EAAE,YAAY,CAAC;IAE5B,eAAe;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEnC,qCAAqC;IACrC,YAAY,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;IAE1D,oGAAoG;IACpG,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,2FAA2F;IAC3F,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,6EAA6E;IAC7E,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AAEF;;;;;;;GAOG;AACH,qBAAa,WAAW;IACtB,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,gBAAgB,CAAC,CAkB7C;IAEF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAC1C,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IAEtC,QAAQ,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAAM;IAEpC,qDAAqD;IACrD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAM;IAEvC,gFAAgF;IAChF,QAAQ,EAAE,eAAe,CAAC;IAC1B,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IAEf,4BAA4B;IAC5B,YAAY,EAAE,YAAY,CAAC;IAE3B,aAAa,EAAE,YAAY,CAAC;IAE5B,oBAAoB,EAAE,MAAM,GAAG,KAAK,CAAmB;IAEvD,OAAO,CAAC,kBAAkB,CAAuE;IACjG,OAAO,CAAC,KAAK,CAA6B;IAE1C,OAAO,CAAC,UAAU,CAAS;gBAEf,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB;IAwDnD,OAAO,IAAI,IAAI;IAUf,OAAO;IAKP,QAAQ,CAAC,WAAW,EAAE,WAAW,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAyB3E;;;OAGG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAIzC;;;OAGG;IACH,gBAAgB,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;IAI7C,eAAe,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI;IAUjD;;OAEG;IACH,oBAAoB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IAgBtD,kBAAkB,IAAI,IAAI;IAI1B;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAIpD,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI7C,eAAe,IAAI,eAAe;IAgClC,iCAAiC;IACjC,YAAY,SAAK;IACjB,QAAQ,UAAS;IAEjB,iBAAiB,IAAI,IAAI;IAazB,eAAe,IAAI,IAAI;IAgBvB,SAAS,CAAC,UAAU,SAAK;IAGzB,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,EAAE,QAAQ,EAAE,GAAG,GAAG,MAAM;CAMlF;AAED,yDAAyD;AACzD,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAS5D"}