@luma.gl/engine 8.6.0-alpha.5 → 9.0.0-alpha.10

package/dist/lib/model.js

@@ -1,573 +1,182 @@
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import GL from '@luma.gl/constants';
-import { WebGLDevice, Program, VertexArray, clear, TransformFeedback, Buffer, log, isObjectEmpty, uid, assert } from '@luma.gl/webgl';
-import { getDebugTableForUniforms, getDebugTableForVertexArray, getDebugTableForProgramConfiguration } from '@luma.gl/webgl';
-import ProgramManager from './program-manager';
-import { getBuffersFromGeometry } from './model-utils';
-const LOG_DRAW_PRIORITY = 2;
-const LOG_DRAW_TIMEOUT = 10000;
-const ERR_MODEL_PARAMS = 'Model needs drawMode and vertexCount';
-
-const NOOP = () => {};
-
-const DRAW_PARAMS = {};
+import { RenderPipeline } from '@luma.gl/api';
+import { getAttributeBuffersFromGeometry, getIndexBufferFromGeometry } from './model-utils';
+import { PipelineFactory } from './pipeline-factory';
+const DEFAULT_MODEL_PROPS = { ...RenderPipeline._DEFAULT_PROPS,
+  vs: null,
+  fs: null,
+  id: 'unnamed',
+  handle: undefined,
+  userData: {},
+  modules: [],
+  moduleSettings: {},
+  geometry: null
+};
 export default class Model {
-  constructor(device, props = {}) {
+  constructor(device, props) {
     _defineProperty(this, "device", void 0);
 
-    _defineProperty(this, "gl", void 0);
+    _defineProperty(this, "pipeline", void 0);
 
     _defineProperty(this, "id", void 0);
 
-    _defineProperty(this, "animated", false);
+    _defineProperty(this, "vs", void 0);
 
-    _defineProperty(this, "programManager", void 0);
+    _defineProperty(this, "fs", null);
 
-    _defineProperty(this, "vertexCount", void 0);
+    _defineProperty(this, "topology", void 0);
 
-    _defineProperty(this, "lastLogTime", 0);
+    _defineProperty(this, "vertexCount", void 0);
 
     _defineProperty(this, "props", void 0);
 
-    _defineProperty(this, "userData", {});
-
-    _defineProperty(this, "needsRedraw", true);
-
-    _defineProperty(this, "attributes", {});
-
-    _defineProperty(this, "_attributes", {});
-
-    _defineProperty(this, "uniforms", {});
-
-    _defineProperty(this, "drawMode", void 0);
-
-    _defineProperty(this, "instanceCount", void 0);
-
-    _defineProperty(this, "pickable", true);
-
-    _defineProperty(this, "programProps", void 0);
-
-    _defineProperty(this, "vertexArray", void 0);
-
-    _defineProperty(this, "program", void 0);
-
-    _defineProperty(this, "transformFeedback", void 0);
-
-    _defineProperty(this, "_programDirty", true);
-
-    _defineProperty(this, "_programManagerState", void 0);
-
-    _defineProperty(this, "_managedProgram", void 0);
-
-    _defineProperty(this, "geometryBuffers", {});
-
-    _defineProperty(this, "isInstanced", void 0);
-
-    _defineProperty(this, "geometry", {});
+    _defineProperty(this, "_getModuleUniforms", void 0);
 
-    const {
-      id = uid('model')
-    } = props;
-    this.id = id;
-    const webglDevice = WebGLDevice.attach(device);
-    this.device = webglDevice;
-    this.gl = webglDevice.gl;
-    this.id = props.id || uid('Model');
-    this.initialize(props);
-  }
-
-  initialize(props) {
-    this.props = {};
-    this.programManager = props.programManager || ProgramManager.getDefaultProgramManager(this.device);
-    this._programManagerState = -1;
-    this._managedProgram = false;
-    const {
-      program = null,
-      vs,
-      fs,
-      modules,
-      defines,
-      inject,
-      varyings,
-      bufferMode,
-      transpileToGLSL100
-    } = props;
-    this.programProps = {
-      program,
-      modules,
-      vs,
-      fs,
-      defines,
-      inject,
-      varyings,
-      bufferMode,
-      transpileToGLSL100
+    this.props = { ...DEFAULT_MODEL_PROPS,
+      ...props
     };
-    this.program = null;
-    this.vertexArray = null;
-    this._programDirty = true;
-    this.userData = {};
-    this.needsRedraw = true;
-    this._attributes = {};
-    this.attributes = {};
-    this.uniforms = {};
-    this.pickable = true;
-
-    this._checkProgram();
-
-    this.setUniforms(Object.assign({}, this.getModuleUniforms(props.moduleSettings)));
-    this.drawMode = props.drawMode !== undefined ? props.drawMode : GL.TRIANGLES;
-    this.vertexCount = props.vertexCount || 0;
-    this.geometryBuffers = {};
-    this.isInstanced = props.isInstanced || props.instanced || props.instanceCount > 0;
-
-    this._setModelProps(props);
-
-    this.geometry = {};
-    assert(this.drawMode !== undefined && Number.isFinite(this.vertexCount), ERR_MODEL_PARAMS);
-  }
-
-  setProps(props) {
-    this._setModelProps(props);
-  }
-
-  destroy() {
-    for (const key in this._attributes) {
-      if (this._attributes[key] !== this.attributes[key]) {
-        this._attributes[key].delete();
-      }
-    }
+    props = this.props;
+    this.id = this.props.id;
+    this.device = device;
 
-    if (this._managedProgram) {
-      this.programManager.release(this.program);
-      this._managedProgram = false;
+    if (!props.vs) {
+      throw new Error('no vertex shader');
     }
 
-    this.vertexArray.delete();
-
-    this._deleteGeometryBuffers();
-  }
-
-  delete() {
-    this.destroy();
-  }
-
-  getDrawMode() {
-    return this.drawMode;
-  }
-
-  getVertexCount() {
-    return this.vertexCount;
-  }
-
-  getInstanceCount() {
-    return this.instanceCount;
-  }
-
-  getAttributes() {
-    return this.attributes;
-  }
-
-  getProgram() {
-    return this.program;
-  }
+    this.vs = getShaderSource(this.device, props.vs);
 
-  setProgram(props) {
-    const {
-      program,
-      vs,
-      fs,
-      modules,
-      defines,
-      inject,
-      varyings,
-      bufferMode,
-      transpileToGLSL100
-    } = props;
-    this.programProps = {
-      program,
-      vs,
-      fs,
-      modules,
-      defines,
-      inject,
-      varyings,
-      bufferMode,
-      transpileToGLSL100
-    };
-    this._programDirty = true;
-  }
-
-  getUniforms() {
-    return this.uniforms;
-  }
-
-  setDrawMode(drawMode) {
-    this.drawMode = drawMode;
-    return this;
-  }
-
-  setVertexCount(vertexCount) {
-    assert(Number.isFinite(vertexCount));
-    this.vertexCount = vertexCount;
-    return this;
-  }
-
-  setInstanceCount(instanceCount) {
-    assert(Number.isFinite(instanceCount));
-    this.instanceCount = instanceCount;
-    return this;
-  }
-
-  setGeometry(geometry) {
-    this.drawMode = geometry.drawMode;
-    this.vertexCount = geometry.getVertexCount();
-
-    this._deleteGeometryBuffers();
-
-    this.geometryBuffers = getBuffersFromGeometry(this.gl, geometry);
-    this.vertexArray.setAttributes(this.geometryBuffers);
-    return this;
-  }
-
-  setAttributes(attributes = {}) {
-    if (isObjectEmpty(attributes)) {
-      return this;
+    if (props.fs) {
+      this.fs = getShaderSource(this.device, props.fs);
     }
 
-    const normalizedAttributes = {};
+    this.vertexCount = this.props.vertexCount;
+    this.topology = this.props.topology;
 
-    for (const name in attributes) {
-      const attribute = attributes[name];
-      normalizedAttributes[name] = attribute.getValue ? attribute.getValue() : attribute;
+    if (this.props.geometry) {
+      this.vertexCount = this.props.geometry.vertexCount;
+      this.topology = this.props.geometry.topology || 'triangle-list';
     }
 
-    this.vertexArray.setAttributes(normalizedAttributes);
-    return this;
-  }
-
-  setUniforms(uniforms = {}) {
-    Object.assign(this.uniforms, uniforms);
-    return this;
-  }
-
-  getModuleUniforms(opts) {
-    this._checkProgram();
-
-    const getUniforms = this.programManager.getUniforms(this.program);
+    const pipelineFactory = PipelineFactory.getDefaultPipelineFactory(this.device);
+    const {
+      pipeline,
+      getUniforms
+    } = pipelineFactory.createRenderPipeline({ ...this.props,
+      vs: this.vs,
+      fs: this.fs,
+      topology: this.topology,
+      parameters: props.parameters,
+      layout: props.layout
+    });
+    this.pipeline = pipeline;
+    this._getModuleUniforms = getUniforms;
 
-    if (getUniforms) {
-      return getUniforms(opts);
+    if (this.props.geometry) {
+      this._setGeometry(this.props.geometry);
     }
 
-    return {};
+    this.setUniforms(this._getModuleUniforms());
+    this.setProps(this.props);
   }
 
-  updateModuleSettings(opts) {
-    const uniforms = this.getModuleUniforms(opts || {});
-    return this.setUniforms(uniforms);
+  destroy() {
+    this.pipeline.destroy();
   }
 
-  clear(opts) {
-    clear(this.program.gl, opts);
+  draw(renderPass) {
+    this.pipeline.draw({
+      renderPass,
+      vertexCount: this.vertexCount,
+      instanceCount: this.props.instanceCount
+    });
     return this;
   }
 
-  draw(opts = {}) {
-    this._checkProgram();
-
-    const {
-      moduleSettings = null,
-      framebuffer,
-      uniforms = {},
-      attributes = {},
-      transformFeedback = this.transformFeedback,
-      parameters = {},
-      vertexArray = this.vertexArray
-    } = opts;
-    this.setAttributes(attributes);
-    this.updateModuleSettings(moduleSettings);
-    this.setUniforms(uniforms);
-    let logPriority;
-
-    if (log.priority >= LOG_DRAW_PRIORITY) {
-      logPriority = this._logDrawCallStart(LOG_DRAW_PRIORITY);
-    }
-
-    const drawParams = this.vertexArray.getDrawParams();
-    const {
-      isIndexed = drawParams.isIndexed,
-      indexType = drawParams.indexType,
-      indexOffset = drawParams.indexOffset,
-      vertexArrayInstanced = drawParams.isInstanced
-    } = this.props;
-
-    if (vertexArrayInstanced && !this.isInstanced) {
-      log.warn('Found instanced attributes on non-instanced model', this.id)();
+  setProps(props) {
+    if (props.indices) {
+      this.setIndexBuffer(props.indices);
     }
 
-    const {
-      isInstanced,
-      instanceCount
-    } = this;
-    const {
-      onBeforeRender = NOOP,
-      onAfterRender = NOOP
-    } = this.props;
-    onBeforeRender();
-    this.program.setUniforms(this.uniforms);
-    const didDraw = this.program.draw(Object.assign(DRAW_PARAMS, opts, {
-      logPriority,
-      uniforms: null,
-      framebuffer,
-      parameters,
-      drawMode: this.getDrawMode(),
-      vertexCount: this.getVertexCount(),
-      vertexArray,
-      transformFeedback,
-      isIndexed,
-      indexType,
-      isInstanced,
-      instanceCount,
-      offset: isIndexed ? indexOffset : 0
-    }));
-    onAfterRender();
-
-    if (log.priority >= LOG_DRAW_PRIORITY) {
-      this._logDrawCallEnd(logPriority, vertexArray, framebuffer);
+    if (props.attributes) {
+      this.setAttributes(props.attributes);
     }
 
-    return didDraw;
-  }
-
-  transform(opts = {}) {
-    const {
-      discard = true,
-      feedbackBuffers,
-      unbindModels = []
-    } = opts;
-    let {
-      parameters
-    } = opts;
-
-    if (feedbackBuffers) {
-      this._setFeedbackBuffers(feedbackBuffers);
+    if (props.bindings) {
+      this.setBindings(props.bindings);
     }
 
-    if (discard) {
-      parameters = Object.assign({}, parameters, {
-        [GL.RASTERIZER_DISCARD]: discard
-      });
+    if (props.uniforms) {
+      this.setUniforms(props.uniforms);
     }
 
-    unbindModels.forEach(model => model.vertexArray.unbindBuffers());
-
-    try {
-      this.draw(Object.assign({}, opts, {
-        parameters
-      }));
-    } finally {
-      unbindModels.forEach(model => model.vertexArray.bindBuffers());
+    if (props.moduleSettings) {
+      this.updateModuleSettings(props.moduleSettings);
     }
 
     return this;
   }
 
-  render(uniforms = {}) {
-    log.warn('Model.render() is deprecated. Use Model.setUniforms() and Model.draw()')();
-    return this.setUniforms(uniforms).draw();
-  }
+  updateModuleSettings(props) {
+    const uniforms = this._getModuleUniforms(props);
 
-  _setModelProps(props) {
-    Object.assign(this.props, props);
-
-    if ('uniforms' in props) {
-      this.setUniforms(props.uniforms);
-    }
-
-    if ('pickable' in props) {
-      this.pickable = props.pickable;
-    }
-
-    if ('instanceCount' in props) {
-      this.instanceCount = props.instanceCount;
-    }
-
-    if ('geometry' in props) {
-      this.setGeometry(props.geometry);
-    }
-
-    if ('attributes' in props) {
-      this.setAttributes(props.attributes);
-    }
-
-    if ('_feedbackBuffers' in props) {
-      this._setFeedbackBuffers(props._feedbackBuffers);
-    }
+    this.setUniforms(uniforms);
+    return this;
   }
 
-  _checkProgram() {
-    const needsUpdate = this._programDirty || this.programManager.stateHash !== this._programManagerState;
-
-    if (!needsUpdate) {
-      return;
-    }
-
-    let {
-      program
-    } = this.programProps;
-
-    if (program) {
-      this._managedProgram = false;
-    } else {
-      const {
-        vs,
-        fs,
-        modules,
-        inject,
-        defines,
-        varyings,
-        bufferMode,
-        transpileToGLSL100
-      } = this.programProps;
-      program = this.programManager.get({
-        vs,
-        fs,
-        modules,
-        inject,
-        defines,
-        varyings,
-        bufferMode,
-        transpileToGLSL100
-      });
-
-      if (this.program && this._managedProgram) {
-        this.programManager.release(this.program);
-      }
-
-      this._programManagerState = this.programManager.stateHash;
-      this._managedProgram = true;
-    }
-
-    assert(program instanceof Program, 'Model needs a program');
-    this._programDirty = false;
-
-    if (program === this.program) {
-      return;
-    }
-
-    this.program = program;
-
-    if (this.vertexArray) {
-      this.vertexArray.setProps({
-        program: this.program,
-        attributes: this.vertexArray.attributes
-      });
-    } else {
-      this.vertexArray = new VertexArray(this.gl, {
-        program: this.program
-      });
-    }
-
-    this.setUniforms(Object.assign({}, this.getModuleUniforms()));
+  setIndexBuffer(indices) {
+    this.pipeline.setIndexBuffer(indices);
+    return this;
   }
 
-  _deleteGeometryBuffers() {
-    for (const name in this.geometryBuffers) {
-      const buffer = this.geometryBuffers[name][0] || this.geometryBuffers[name];
-
-      if (buffer instanceof Buffer) {
-        buffer.destroy();
-      }
-    }
+  setAttributes(attributes) {
+    this.pipeline.setAttributes(attributes);
+    Object.assign(this.props.attributes, attributes);
+    return this;
   }
 
-  _setAnimationProps(animationProps) {
-    if (this.animated) {
-      assert(animationProps, 'Model.draw(): animated uniforms but no animationProps');
-    }
+  setBindings(bindings) {
+    this.pipeline.setBindings(bindings);
+    Object.assign(this.props.bindings, bindings);
+    return this;
   }
 
-  _setFeedbackBuffers(feedbackBuffers = {}) {
-    if (isObjectEmpty(feedbackBuffers)) {
-      return this;
-    }
-
-    const {
-      gl
-    } = this.program;
-    this.transformFeedback = this.transformFeedback || new TransformFeedback(gl, {
-      program: this.program
-    });
-    this.transformFeedback.setBuffers(feedbackBuffers);
+  setUniforms(uniforms) {
+    this.pipeline.setUniforms(uniforms);
+    Object.assign(this.props.uniforms, uniforms);
     return this;
   }
 
-  _logDrawCallStart(logLevel) {
-    const logDrawTimeout = logLevel > 3 ? 0 : LOG_DRAW_TIMEOUT;
+  _setGeometry(geometry) {
+    const geometryBuffers = getAttributeBuffersFromGeometry(this.device, geometry);
+    this.setAttributes(geometryBuffers);
+    const indexBuffer = getIndexBufferFromGeometry(this.device, geometry);
 
-    if (Date.now() - this.lastLogTime < logDrawTimeout) {
-      return undefined;
+    if (indexBuffer) {
+      this.setIndexBuffer(indexBuffer);
     }
-
-    this.lastLogTime = Date.now();
-    log.group(LOG_DRAW_PRIORITY, ">>> DRAWING MODEL ".concat(this.id), {
-      collapsed: log.level <= 2
-    })();
-    return logLevel;
   }
 
-  _logDrawCallEnd(logLevel, vertexArray, uniforms, framebuffer) {
-    if (logLevel === undefined) {
-      return;
-    }
-
-    const attributeTable = getDebugTableForVertexArray({
-      vertexArray,
-      header: "".concat(this.id, " attributes"),
-      attributes: this._attributes
-    });
-    const {
-      table: uniformTable,
-      unusedTable,
-      unusedCount
-    } = getDebugTableForUniforms({
-      header: "".concat(this.id, " uniforms"),
-      program: this.program,
-      uniforms: Object.assign({}, this.program.uniforms, uniforms)
-    });
-    const {
-      table: missingTable,
-      count: missingCount
-    } = getDebugTableForUniforms({
-      header: "".concat(this.id, " uniforms"),
-      program: this.program,
-      uniforms: Object.assign({}, this.program.uniforms, uniforms),
-      undefinedOnly: true
-    });
+}
 
-    if (missingCount > 0) {
-      log.log('MISSING UNIFORMS', Object.keys(missingTable))();
-    }
+function getShaderSource(device, shader) {
+  if (typeof shader === 'string') {
+    return shader;
+  }
 
-    if (unusedCount > 0) {
-      log.log('UNUSED UNIFORMS', Object.keys(unusedTable))();
-    }
+  switch (device.info.type) {
+    case 'webgpu':
+      if (shader !== null && shader !== void 0 && shader.wgsl) {
+        return shader.wgsl;
+      }
 
-    const configTable = getDebugTableForProgramConfiguration(this.vertexArray.configuration);
-    log.table(logLevel, attributeTable)();
-    log.table(logLevel, uniformTable)();
-    log.table(logLevel + 1, configTable)();
+      throw new Error('WebGPU does not support GLSL shaders');
 
-    if (framebuffer) {
-      framebuffer.log({
-        logLevel: LOG_DRAW_PRIORITY,
-        message: "Rendered to ".concat(framebuffer.id)
-      });
-    }
+    default:
+      if (shader !== null && shader !== void 0 && shader.glsl) {
+        return shader.glsl;
+      }
 
-    log.groupEnd(LOG_DRAW_PRIORITY)();
+      throw new Error('WebGL does not support WGSL shaders');
   }
-
 }
 //# sourceMappingURL=model.js.map