@luma.gl/engine 9.0.0-alpha.8 → 9.0.0-beta.1

package/dist/model/model.d.ts

@@ -0,0 +1,206 @@
+import type { TypedArray, RenderPipelineProps, RenderPipelineParameters } from '@luma.gl/core';
+import type { BufferLayout, VertexArray, TransformFeedback } from '@luma.gl/core';
+import type { AttributeInfo, Binding, UniformValue, PrimitiveTopology } from '@luma.gl/core';
+import { Device, Buffer, RenderPipeline, RenderPass, UniformStore } from '@luma.gl/core';
+import type { ShaderModule, PlatformInfo } from '@luma.gl/shadertools';
+import { ShaderAssembler } from '@luma.gl/shadertools';
+import { ShaderInputs } from '../shader-inputs';
+import type { Geometry } from '../geometry/geometry';
+import { GPUGeometry } from '../geometry/gpu-geometry';
+import { PipelineFactory } from '../lib/pipeline-factory';
+export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs'> & {
+    source?: string;
+    vs: {
+        glsl?: string;
+        wgsl?: string;
+    } | string | null;
+    fs: {
+        glsl?: string;
+        wgsl?: string;
+    } | string | null;
+    /** 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;
+    /** pipeline factory to use to create render pipelines. Defaults to default factory for the device */
+    pipelineFactory?: PipelineFactory;
+    /** Shader assembler. Defaults to the ShaderAssembler.getShaderAssembler() */
+    shaderAssembler?: ShaderAssembler;
+    /** Parameters that are built into the pipeline */
+    parameters?: RenderPipelineParameters;
+    /** Geometry */
+    geometry?: GPUGeometry | Geometry | null;
+    /** Vertex count */
+    vertexCount?: number;
+    /** instance count */
+    instanceCount?: number;
+    indexBuffer?: Buffer | null;
+    /** @note this is really a map of buffers, not a map of attributes */
+    attributes?: Record<string, Buffer>;
+    /**   */
+    constantAttributes?: Record<string, TypedArray>;
+    /** @internal For use with {@link TransformFeedback}, WebGL 2 only. */
+    varyings?: string[];
+    transformFeedback?: TransformFeedback;
+    /** Mapped uniforms for shadertool modules */
+    moduleSettings?: Record<string, Record<string, any>>;
+};
+/**
+ * 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 Model {
+    static defaultProps: Required<ModelProps>;
+    readonly device: Device;
+    readonly id: string;
+    readonly vs: string;
+    readonly fs: string;
+    readonly pipelineFactory: PipelineFactory;
+    userData: {
+        [key: string]: any;
+    };
+    /** The render pipeline GPU parameters, depth testing etc */
+    parameters: RenderPipelineParameters;
+    /** The primitive topology */
+    topology: PrimitiveTopology;
+    /** Buffer layout */
+    bufferLayout: BufferLayout[];
+    /** Vertex count */
+    vertexCount: number;
+    /** instance count */
+    instanceCount: number;
+    /** Index buffer */
+    indexBuffer: Buffer | null;
+    /** Buffer-valued attributes */
+    bufferAttributes: Record<string, Buffer>;
+    /** Constant-valued attributes */
+    constantAttributes: Record<string, TypedArray>;
+    /** Bindings (textures, samplers, uniform buffers) */
+    bindings: Record<string, Binding>;
+    /** Sets uniforms @deprecated Use uniform buffers and setBindings() for portability*/
+    uniforms: Record<string, UniformValue>;
+    /**
+     * VertexArray
+     * @note not implemented: if bufferLayout is updated, vertex array has to be rebuilt!
+     * @todo - allow application to define multiple vertex arrays?
+     * */
+    vertexArray: VertexArray;
+    /** TransformFeedback, WebGL 2 only. */
+    transformFeedback: TransformFeedback | null;
+    /** The underlying GPU "program". @note May be recreated if parameters change */
+    pipeline: RenderPipeline;
+    /** ShaderInputs instance */
+    shaderInputs: ShaderInputs;
+    _uniformStore: UniformStore;
+    _pipelineNeedsUpdate: string | false;
+    _attributeInfos: Record<string, AttributeInfo>;
+    _gpuGeometry: GPUGeometry | null;
+    private _getModuleUniforms;
+    private props;
+    constructor(device: Device, props: ModelProps);
+    destroy(): void;
+    predraw(): void;
+    draw(renderPass: RenderPass): void;
+    /**
+     * Updates the optional geometry
+     * Geometry, set topology and bufferLayout
+     * @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU
+     */
+    setGeometry(geometry: GPUGeometry | Geometry): GPUGeometry;
+    /**
+     * Updates the optional geometry attributes
+     * Geometry, sets several attributes, indexBuffer, and also vertex count
+     * @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU
+     */
+    _setGeometryAttributes(gpuGeometry: GPUGeometry): void;
+    /**
+     * Updates the primitive topology ('triangle-list', 'triangle-strip' etc).
+     * @note Triggers a pipeline rebuild / pipeline cache fetch on WebGPU
+     */
+    setTopology(topology: PrimitiveTopology): void;
+    /**
+     * Updates the buffer layout.
+     * @note Triggers a pipeline rebuild / pipeline cache fetch on WebGPU
+     */
+    setBufferLayout(bufferLayout: BufferLayout[]): void;
+    /**
+     * Set GPU parameters.
+     * @note Can trigger a pipeline rebuild / pipeline cache fetch.
+     * @param parameters
+     */
+    setParameters(parameters: RenderPipelineParameters): 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;
+    /**
+     * @deprecated Updates shader module settings (which results in uniforms being set)
+     */
+    updateModuleSettings(props: Record<string, any>): void;
+    /**
+     * Sets bindings (textures, samplers, uniform buffers)
+     */
+    setBindings(bindings: Record<string, Binding>): void;
+    /**
+     * Sets individual uniforms
+     * @deprecated WebGL only, use uniform buffers for portability
+     * @param uniforms
+     * @returns self for chaining
+     */
+    setUniforms(uniforms: Record<string, UniformValue>): void;
+    /**
+     * Sets the index buffer
+     * @todo - how to unset it if we change geometry?
+     */
+    setIndexBuffer(indexBuffer: Buffer | null): void;
+    /**
+     * Updates optional transform feedback. WebGL 2 only.
+     */
+    setTransformFeedback(transformFeedback: TransformFeedback | null): void;
+    /**
+     * Sets attributes (buffers)
+     * @note Overrides any attributes previously set with the same name
+     */
+    setAttributes(buffers: Record<string, Buffer>, _option?: 'ignore-unknown'): void;
+    /**
+     * Sets constant attributes
+     * @note Overrides any attributes previously set with the same name
+     * Constant attributes are only supported in WebGL, not in WebGPU
+     * Any attribute that is disabled in the current vertex array object
+     * is read from the context's global constant value for that attribute location.
+     * @param constantAttributes
+     */
+    setConstantAttributes(attributes: Record<string, TypedArray>): void;
+    _setPipelineNeedsUpdate(reason: string): void;
+    _updatePipeline(): RenderPipeline;
+    /** Throttle draw call logging */
+    _lastLogTime: number;
+    _logOpen: boolean;
+    _logDrawCallStart(): void;
+    _logDrawCallEnd(): void;
+    protected _drawCount: number;
+    _logFramebuffer(renderPass: RenderPass): void;
+    _getAttributeDebugTable(): Record<string, Record<string, unknown>>;
+    _getBufferOrConstantValues(attribute: Buffer | TypedArray, dataType: any): string;
+}
+/** Create a shadertools platform info from the Device */
+export declare function getPlatformInfo(device: Device): PlatformInfo;
+//# sourceMappingURL=model.d.ts.map

package/dist/model/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/model/model.ts"],"names":[],"mappings":"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"}

package/dist/model/model.js

@@ -0,0 +1,435 @@
+import { Buffer, RenderPipeline, UniformStore, getTypedArrayFromDataType } from '@luma.gl/core';
+import { log, uid, deepEqual, splitUniformsAndBindings, isNumberArray } from '@luma.gl/core';
+import { getAttributeInfosFromLayouts } from '@luma.gl/core';
+import { ShaderAssembler, getShaderLayoutFromWGSL } from '@luma.gl/shadertools';
+import { ShaderInputs } from "../shader-inputs.js";
+import { makeGPUGeometry } from "../geometry/gpu-geometry.js";
+import { PipelineFactory } from "../lib/pipeline-factory.js";
+import { getDebugTableForShaderLayout } from "../debug/debug-shader-layout.js";
+import { debugFramebuffer } from "../debug/debug-framebuffer.js";
+const LOG_DRAW_PRIORITY = 2;
+const LOG_DRAW_TIMEOUT = 10000;
+export class Model {
+  constructor(device, props) {
+    var _this$props$modules, _this$props$modules2, _this$shaderInputs;
+    this.device = void 0;
+    this.id = void 0;
+    this.vs = void 0;
+    this.fs = void 0;
+    this.pipelineFactory = void 0;
+    this.userData = {};
+    this.parameters = void 0;
+    this.topology = void 0;
+    this.bufferLayout = void 0;
+    this.vertexCount = void 0;
+    this.instanceCount = 0;
+    this.indexBuffer = null;
+    this.bufferAttributes = {};
+    this.constantAttributes = {};
+    this.bindings = {};
+    this.uniforms = {};
+    this.vertexArray = void 0;
+    this.transformFeedback = null;
+    this.pipeline = void 0;
+    this.shaderInputs = void 0;
+    this._uniformStore = void 0;
+    this._pipelineNeedsUpdate = 'newly created';
+    this._attributeInfos = {};
+    this._gpuGeometry = null;
+    this._getModuleUniforms = void 0;
+    this.props = void 0;
+    this._lastLogTime = 0;
+    this._logOpen = false;
+    this._drawCount = 0;
+    this.props = {
+      ...Model.defaultProps,
+      ...props
+    };
+    props = this.props;
+    this.id = props.id || uid('model');
+    this.device = device;
+    Object.assign(this.userData, props.userData);
+    const moduleMap = Object.fromEntries(((_this$props$modules = this.props.modules) === null || _this$props$modules === void 0 ? void 0 : _this$props$modules.map(module => [module.name, module])) || []);
+    this.setShaderInputs(props.shaderInputs || new ShaderInputs(moduleMap));
+    const isWebGPU = this.device.info.type === 'webgpu';
+    if (this.props.source) {
+      if (isWebGPU) {
+        var _this$props;
+        (_this$props = this.props).shaderLayout || (_this$props.shaderLayout = getShaderLayoutFromWGSL(this.props.source));
+      }
+      this.props.fs = this.props.source;
+      this.props.vs = this.props.source;
+    }
+    if (isWebGPU && typeof this.props.vs !== 'string') {
+      var _this$props2;
+      (_this$props2 = this.props).shaderLayout || (_this$props2.shaderLayout = getShaderLayoutFromWGSL(this.props.vs.wgsl));
+    }
+    const platformInfo = getPlatformInfo(device);
+    const modules = (((_this$props$modules2 = this.props.modules) === null || _this$props$modules2 === void 0 ? void 0 : _this$props$modules2.length) > 0 ? this.props.modules : (_this$shaderInputs = this.shaderInputs) === null || _this$shaderInputs === void 0 ? void 0 : _this$shaderInputs.getModules()) || [];
+    const {
+      vs,
+      fs,
+      getUniforms
+    } = this.props.shaderAssembler.assembleShaders({
+      platformInfo,
+      ...this.props,
+      modules
+    });
+    this.vs = vs;
+    this.fs = fs;
+    this._getModuleUniforms = getUniforms;
+    this.vertexCount = this.props.vertexCount;
+    this.instanceCount = this.props.instanceCount;
+    this.topology = this.props.topology;
+    this.bufferLayout = this.props.bufferLayout;
+    this.parameters = this.props.parameters;
+    if (props.geometry) {
+      this._gpuGeometry = this.setGeometry(props.geometry);
+    }
+    this.pipelineFactory = props.pipelineFactory || PipelineFactory.getDefaultPipelineFactory(this.device);
+    this.pipeline = this._updatePipeline();
+    this.vertexArray = device.createVertexArray({
+      renderPipeline: this.pipeline
+    });
+    if (this._gpuGeometry) {
+      this._setGeometryAttributes(this._gpuGeometry);
+    }
+    if (props.vertexCount) {
+      this.setVertexCount(props.vertexCount);
+    }
+    if (props.instanceCount) {
+      this.setInstanceCount(props.instanceCount);
+    }
+    if (props.indices) {
+      throw new Error('Model.props.indices removed. Use props.indexBuffer');
+    }
+    if (props.indexBuffer) {
+      this.setIndexBuffer(props.indexBuffer);
+    }
+    if (props.attributes) {
+      this.setAttributes(props.attributes);
+    }
+    if (props.constantAttributes) {
+      this.setConstantAttributes(props.constantAttributes);
+    }
+    if (props.bindings) {
+      this.setBindings(props.bindings);
+    }
+    if (props.uniforms) {
+      this.setUniforms(props.uniforms);
+    }
+    if (props.moduleSettings) {
+      log.warn('Model.props.moduleSettings is deprecated. Use Model.shaderInputs.setProps()')();
+      this.updateModuleSettings(props.moduleSettings);
+    }
+    if (props.transformFeedback) {
+      this.transformFeedback = props.transformFeedback;
+    }
+    Object.seal(this);
+  }
+  destroy() {
+    this.pipelineFactory.release(this.pipeline);
+    this._uniformStore.destroy();
+  }
+  predraw() {
+    this.updateShaderInputs();
+  }
+  draw(renderPass) {
+    this.predraw();
+    try {
+      this._logDrawCallStart();
+      this.pipeline = this._updatePipeline();
+      this.pipeline.setBindings(this.bindings);
+      this.pipeline.setUniforms(this.uniforms);
+      this.pipeline.draw({
+        renderPass,
+        vertexArray: this.vertexArray,
+        vertexCount: this.vertexCount,
+        instanceCount: this.instanceCount,
+        transformFeedback: this.transformFeedback
+      });
+    } finally {
+      this._logDrawCallEnd();
+    }
+    this._logFramebuffer(renderPass);
+  }
+  setGeometry(geometry) {
+    const gpuGeometry = geometry && makeGPUGeometry(this.device, geometry);
+    this.setTopology(gpuGeometry.topology || 'triangle-list');
+    this.bufferLayout = mergeBufferLayouts(this.bufferLayout, gpuGeometry.bufferLayout);
+    if (this.vertexArray) {
+      this._setGeometryAttributes(gpuGeometry);
+    }
+    return gpuGeometry;
+  }
+  _setGeometryAttributes(gpuGeometry) {
+    const attributes = {
+      ...gpuGeometry.attributes
+    };
+    for (const [attributeName] of Object.entries(attributes)) {
+      if (!this.pipeline.shaderLayout.attributes.find(layout => layout.name === attributeName) && attributeName !== 'positions') {
+        delete attributes[attributeName];
+      }
+    }
+    this.vertexCount = gpuGeometry.vertexCount;
+    this.setIndexBuffer(gpuGeometry.indices);
+    this.setAttributes(gpuGeometry.attributes, 'ignore-unknown');
+    this.setAttributes(attributes);
+  }
+  setTopology(topology) {
+    if (topology !== this.topology) {
+      this.topology = topology;
+      this._setPipelineNeedsUpdate('topology');
+    }
+  }
+  setBufferLayout(bufferLayout) {
+    this.bufferLayout = this._gpuGeometry ? mergeBufferLayouts(bufferLayout, this._gpuGeometry.bufferLayout) : bufferLayout;
+    this._setPipelineNeedsUpdate('bufferLayout');
+    this.pipeline = this._updatePipeline();
+    this.vertexArray = this.device.createVertexArray({
+      renderPipeline: this.pipeline
+    });
+    if (this._gpuGeometry) {
+      this._setGeometryAttributes(this._gpuGeometry);
+    }
+  }
+  setParameters(parameters) {
+    if (!deepEqual(parameters, this.parameters, 2)) {
+      this.parameters = parameters;
+      this._setPipelineNeedsUpdate('parameters');
+    }
+  }
+  setVertexCount(vertexCount) {
+    this.vertexCount = vertexCount;
+  }
+  setInstanceCount(instanceCount) {
+    this.instanceCount = instanceCount;
+  }
+  setShaderInputs(shaderInputs) {
+    this.shaderInputs = shaderInputs;
+    this._uniformStore = new UniformStore(this.shaderInputs.modules);
+    for (const moduleName of Object.keys(this.shaderInputs.modules)) {
+      const uniformBuffer = this._uniformStore.getManagedUniformBuffer(this.device, moduleName);
+      this.bindings[`${moduleName}Uniforms`] = uniformBuffer;
+    }
+  }
+  setShaderModuleProps(props) {
+    const uniforms = this._getModuleUniforms(props);
+    const keys = Object.keys(uniforms).filter(k => {
+      const uniform = uniforms[k];
+      return !isNumberArray(uniform) && typeof uniform !== 'number' && typeof uniform !== 'boolean';
+    });
+    const bindings = {};
+    for (const k of keys) {
+      bindings[k] = uniforms[k];
+      delete uniforms[k];
+    }
+  }
+  updateShaderInputs() {
+    this._uniformStore.setUniforms(this.shaderInputs.getUniformValues());
+  }
+  updateModuleSettings(props) {
+    log.warn('Model.updateModuleSettings is deprecated. Use Model.shaderInputs.setProps()')();
+    const {
+      bindings,
+      uniforms
+    } = splitUniformsAndBindings(this._getModuleUniforms(props));
+    Object.assign(this.bindings, bindings);
+    Object.assign(this.uniforms, uniforms);
+  }
+  setBindings(bindings) {
+    Object.assign(this.bindings, bindings);
+  }
+  setUniforms(uniforms) {
+    this.pipeline.setUniforms(uniforms);
+    Object.assign(this.uniforms, uniforms);
+  }
+  setIndexBuffer(indexBuffer) {
+    this.vertexArray.setIndexBuffer(indexBuffer);
+  }
+  setTransformFeedback(transformFeedback) {
+    this.transformFeedback = transformFeedback;
+  }
+  setAttributes(buffers, _option) {
+    if (buffers.indices) {
+      log.warn(`Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`)();
+    }
+    for (const [bufferName, buffer] of Object.entries(buffers)) {
+      const bufferLayout = this.bufferLayout.find(layout => getAttributeNames(layout).includes(bufferName));
+      if (!bufferLayout) {
+        log.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)();
+        continue;
+      }
+      const attributeNames = getAttributeNames(bufferLayout);
+      let set = false;
+      for (const attributeName of attributeNames) {
+        const attributeInfo = this._attributeInfos[attributeName];
+        if (attributeInfo) {
+          this.vertexArray.setBuffer(attributeInfo.location, buffer);
+          set = true;
+        }
+      }
+      if (!set && _option !== 'ignore-unknown') {
+        log.warn(`Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`)();
+      }
+    }
+  }
+  setConstantAttributes(attributes) {
+    for (const [attributeName, value] of Object.entries(attributes)) {
+      const attributeInfo = this._attributeInfos[attributeName];
+      if (attributeInfo) {
+        this.vertexArray.setConstant(attributeInfo.location, value);
+      } else {
+        log.warn(`Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`)();
+      }
+    }
+  }
+  _setPipelineNeedsUpdate(reason) {
+    this._pipelineNeedsUpdate = this._pipelineNeedsUpdate || reason;
+  }
+  _updatePipeline() {
+    if (this._pipelineNeedsUpdate) {
+      if (this.pipeline) {
+        log.log(1, `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)();
+      }
+      this._pipelineNeedsUpdate = false;
+      const vs = this.device.createShader({
+        id: `${this.id}-vertex`,
+        stage: 'vertex',
+        source: this.vs
+      });
+      const fs = this.fs ? this.device.createShader({
+        id: `${this.id}-fragment`,
+        stage: 'fragment',
+        source: this.fs
+      }) : null;
+      this.pipeline = this.device.createRenderPipeline({
+        ...this.props,
+        bufferLayout: this.bufferLayout,
+        topology: this.topology,
+        parameters: this.parameters,
+        vs,
+        fs
+      });
+      this._attributeInfos = getAttributeInfosFromLayouts(this.pipeline.shaderLayout, this.bufferLayout);
+    }
+    return this.pipeline;
+  }
+  _logDrawCallStart() {
+    const logDrawTimeout = log.level > 3 ? 0 : LOG_DRAW_TIMEOUT;
+    if (log.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) {
+      return;
+    }
+    this._lastLogTime = Date.now();
+    this._logOpen = true;
+    log.group(LOG_DRAW_PRIORITY, `>>> DRAWING MODEL ${this.id}`, {
+      collapsed: log.level <= 2
+    })();
+  }
+  _logDrawCallEnd() {
+    if (this._logOpen) {
+      const shaderLayoutTable = getDebugTableForShaderLayout(this.pipeline.shaderLayout, this.id);
+      log.table(LOG_DRAW_PRIORITY, shaderLayoutTable)();
+      const uniformTable = this.shaderInputs.getDebugTable();
+      for (const [name, value] of Object.entries(this.uniforms)) {
+        uniformTable[name] = {
+          value
+        };
+      }
+      log.table(LOG_DRAW_PRIORITY, uniformTable)();
+      const attributeTable = this._getAttributeDebugTable();
+      log.table(LOG_DRAW_PRIORITY, this._attributeInfos)();
+      log.table(LOG_DRAW_PRIORITY, attributeTable)();
+      log.groupEnd(LOG_DRAW_PRIORITY)();
+      this._logOpen = false;
+    }
+  }
+  _logFramebuffer(renderPass) {
+    const debugFramebuffers = log.get('framebuffer');
+    this._drawCount++;
+    if (!debugFramebuffers || this._drawCount++ > 3 && this._drawCount % 60) {
+      return;
+    }
+    const framebuffer = renderPass.props.framebuffer;
+    if (framebuffer) {
+      debugFramebuffer(framebuffer, {
+        id: framebuffer.id,
+        minimap: true
+      });
+    }
+  }
+  _getAttributeDebugTable() {
+    const table = {};
+    for (const [name, attributeInfo] of Object.entries(this._attributeInfos)) {
+      table[attributeInfo.location] = {
+        name,
+        type: attributeInfo.shaderType,
+        values: this._getBufferOrConstantValues(this.vertexArray.attributes[attributeInfo.location], attributeInfo.bufferDataType)
+      };
+    }
+    if (this.vertexArray.indexBuffer) {
+      const {
+        indexBuffer
+      } = this.vertexArray;
+      const values = indexBuffer.indexType === 'uint32' ? new Uint32Array(indexBuffer.debugData) : new Uint16Array(indexBuffer.debugData);
+      table.indices = {
+        name: 'indices',
+        type: indexBuffer.indexType,
+        values: values.toString()
+      };
+    }
+    return table;
+  }
+  _getBufferOrConstantValues(attribute, dataType) {
+    const TypedArrayConstructor = getTypedArrayFromDataType(dataType);
+    const typedArray = attribute instanceof Buffer ? new TypedArrayConstructor(attribute.debugData) : attribute;
+    return typedArray.toString();
+  }
+}
+Model.defaultProps = {
+  ...RenderPipeline.defaultProps,
+  source: null,
+  vs: null,
+  fs: null,
+  id: 'unnamed',
+  handle: undefined,
+  userData: {},
+  defines: {},
+  modules: [],
+  moduleSettings: undefined,
+  geometry: null,
+  indexBuffer: null,
+  attributes: {},
+  constantAttributes: {},
+  varyings: [],
+  shaderInputs: undefined,
+  pipelineFactory: undefined,
+  transformFeedback: undefined,
+  shaderAssembler: ShaderAssembler.getDefaultShaderAssembler()
+};
+function mergeBufferLayouts(layouts1, layouts2) {
+  const layouts = [...layouts1];
+  for (const attribute of layouts2) {
+    const index = layouts.findIndex(attribute2 => attribute2.name === attribute.name);
+    if (index < 0) {
+      layouts.push(attribute);
+    } else {
+      layouts[index] = attribute;
+    }
+  }
+  return layouts;
+}
+export function getPlatformInfo(device) {
+  return {
+    type: device.info.type,
+    shaderLanguage: device.info.shadingLanguage,
+    shaderLanguageVersion: device.info.shadingLanguageVersion,
+    gpu: device.info.gpu,
+    features: device.features
+  };
+}
+function getAttributeNames(bufferLayout) {
+  var _bufferLayout$attribu;
+  return bufferLayout.attributes ? (_bufferLayout$attribu = bufferLayout.attributes) === null || _bufferLayout$attribu === void 0 ? void 0 : _bufferLayout$attribu.map(layout => layout.attribute) : [bufferLayout.name];
+}
+//# sourceMappingURL=model.js.map