@luma.gl/engine 8.5.8 → 8.6.0-alpha.2

package/src/lib/{model-utils.js → model-utils.ts}

@@ -11,8 +11,8 @@ const GLTF_TO_LUMA_ATTRIBUTE_MAP = {
   TEXCOORD_2: 'texCoords2'
 };
 
-export function getBuffersFromGeometry(gl, geometry, options) {
-  const buffers = {};
+export function getBuffersFromGeometry(gl: WebGLRenderingContext, geometry, options?) {
+  const buffers: Record<string, Buffer | [Buffer, {}]> = {};
   let indices = geometry.indices;
 
   for (const name in geometry.attributes) {

package/src/lib/{model.js → model.ts}

@@ -1,9 +1,9 @@
-/* eslint-disable complexity */
-
+// luma.gl, MIT license
+import {Device} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import {isWebGL} from '@luma.gl/gltools';
-import ProgramManager from './program-manager';
+import type {ProgramProps} from '@luma.gl/webgl';
 import {
+  WebGLDevice,
   Program,
   VertexArray,
   clear,
@@ -19,6 +19,7 @@ import {
   getDebugTableForVertexArray,
   getDebugTableForProgramConfiguration
 } from '@luma.gl/webgl';
+import ProgramManager from './program-manager';
 import {getBuffersFromGeometry} from './model-utils';
 
 const LOG_DRAW_PRIORITY = 2;
@@ -29,23 +30,149 @@ const ERR_MODEL_PARAMS = 'Model needs drawMode and vertexCount';
 const NOOP = () => {};
 const DRAW_PARAMS = {};
 
+export type ModelProps = ProgramProps & {
+  id?: string;
+
+  // program props
+  // vs,
+  // fs,
+  // varyings,
+  // bufferMode,
+
+  program?: Program;
+  modules?: any[];
+  defines?: Record<string, number | boolean>;
+  inject?: Record<string, any>;
+  transpileToGLSL100?: boolean;
+
+  moduleSettings?: object; // UniformsOptions
+  attributes?: object;
+  uniforms?: object; // Uniforms
+  geometry?: object; // Geometry
+  vertexCount?: number
+  drawMode?: number
+  isInstanced?: boolean
+  instanceCount?: number
+  programManager?: ProgramManager
+  onBeforeRender?: () => void
+  onAfterRender?: () => void
+  _feedbackBuffers?: object; // FeedbackBuffers
+
+  // Deprecated?
+  isIndexed?: boolean;
+  indexType?;
+  indexOffset?: number;
+  vertexArrayInstanced?: boolean;
+
+  /** @deprecated Use isInstanced */
+  instanced?: boolean
+};
+
+
+export type ModelDrawOptions = {
+  moduleSettings?;
+  framebuffer?;
+  uniforms?;
+  attributes?;
+  transformFeedback?;
+  parameters?;
+  vertexArray?;
+};
+
+/* TODO - from autogenerated declarations, copy types and delete
+interface ModelProps extends ProgramProps {
+  id?: string
+  moduleSettings?: UniformsOptions
+  uniforms?: Uniforms
+  geometry?: Geometry
+  vertexCount?: number
+  drawMode?: number
+  programManager?: ProgramManager
+  onBeforeRender?: () => void
+  onAfterRender?: () => void
+  _feedbackBuffers?: FeedbackBuffers
+}
+
+interface DrawOpts {
+  moduleSettings?: UniformsOptions
+  framebuffer: Framebuffer
+  uniforms?: Uniforms
+  attributes?: Attributes
+  parameters?: Parameters
+  transformFeedback?: TransformFeedback
+  vertexArray?: VertexArray
+}
+
+interface ClearOpts {
+  framebuffer?: Framebuffer
+  color?: boolean
+  depth?: boolean
+  stencil?: boolean
+}
+
+interface TransformOpts extends DrawOpts {
+  discard: boolean
+  feedbackBuffers: FeedbackBuffers
+  unbindModels: Array<Model>
+  parameters: Parameters
+}
+*/
+
 export default class Model {
-  constructor(gl, props = {}) {
+  readonly device: Device;
+  readonly gl: WebGLRenderingContext;
+
+  readonly id: string;
+  readonly animated: boolean = false;
+  programManager: ProgramManager;
+  vertexCount: number;
+
+  lastLogTime: number = 0; // TODO - move to probe.gl
+
+  props: ModelProps;
+  userData: Record<string, any> = {};
+  needsRedraw: boolean = true;
+  attributes: Record<string, any> = {};
+  _attributes: Record<string, any> = {};
+  uniforms: Record<string, any> = {};
+
+  drawMode;
+  instanceCount: number;
+  pickable: boolean = true;
+
+  programProps: ProgramProps & {program?: Program; modules; inject; defines; varyings; bufferMode; transpileToGLSL100;};
+  vertexArray: VertexArray;
+  program: Program;
+  transformFeedback: TransformFeedback | undefined;
+  _programDirty = true;
+  _programManagerState;
+  _managedProgram;
+
+  // Track buffers created by setGeometry
+  geometryBuffers = {};
+  // geometry might have set drawMode and vertexCount
+  isInstanced: boolean;
+  // TODO - just to unbreak deck.gl 7.0-beta, remove as soon as updated
+  geometry = {};
+
+  constructor(device: Device, props?: ModelProps);
+  /* @deprecated */
+  constructor(gl: WebGLRenderingContext, props?: ModelProps);
+  constructor(device, props: ModelProps = {}) {
     // Deduce a helpful id
     const {id = uid('model')} = props;
-    assert(isWebGL(gl));
     this.id = id;
-    this.gl = gl;
+    const webglDevice = WebGLDevice.attach(device);
+    this.device = webglDevice;
+    this.gl = webglDevice.gl;
     this.id = props.id || uid('Model');
-    this.lastLogTime = 0; // TODO - move to probe.gl
-    this.animated = false;
     this.initialize(props);
   }
 
-  initialize(props) {
+  initialize(props: ModelProps) {
     this.props = {};
 
-    this.programManager = props.programManager || ProgramManager.getDefaultProgramManager(this.gl);
+    this.programManager = props.programManager || ProgramManager.getDefaultProgramManager(this.device);
     this._programManagerState = -1;
     this._managedProgram = false;
 
@@ -63,9 +190,9 @@ export default class Model {
 
     this.programProps = {
       program,
+      modules,
       vs,
       fs,
-      modules,
       defines,
       inject,
       varyings,
@@ -122,7 +249,7 @@ export default class Model {
     this._setModelProps(props);
   }
 
-  delete() {
+  destroy(): void {
     // delete all attributes created by this model
     // TODO - should buffer deletes be handled by vertex array?
     for (const key in this._attributes) {
@@ -141,17 +268,22 @@ export default class Model {
     this._deleteGeometryBuffers();
   }
 
+  /** @deprecated Use .destroy() */
+  delete(): void {
+    this.destroy();
+  }
+
   // GETTERS
 
   getDrawMode() {
     return this.drawMode;
   }
 
-  getVertexCount() {
+  getVertexCount(): number {
     return this.vertexCount;
   }
 
-  getInstanceCount() {
+  getInstanceCount(): number {
     return this.instanceCount;
   }
 
@@ -159,22 +291,13 @@ export default class Model {
     return this.attributes;
   }
 
-  getProgram() {
+  getProgram(): Program {
     return this.program;
   }
 
-  setProgram(props) {
-    const {
-      program,
-      vs,
-      fs,
-      modules,
-      defines,
-      inject,
-      varyings,
-      bufferMode,
-      transpileToGLSL100
-    } = props;
+  setProgram(props): void {
+    const {program, vs, fs, modules, defines, inject, varyings, bufferMode, transpileToGLSL100} =
+      props;
     this.programProps = {
       program,
       vs,
@@ -195,24 +318,24 @@ export default class Model {
 
   // SETTERS
 
-  setDrawMode(drawMode) {
+  setDrawMode(drawMode): this {
     this.drawMode = drawMode;
     return this;
   }
 
-  setVertexCount(vertexCount) {
+  setVertexCount(vertexCount): this {
     assert(Number.isFinite(vertexCount));
     this.vertexCount = vertexCount;
     return this;
   }
 
-  setInstanceCount(instanceCount) {
+  setInstanceCount(instanceCount): this {
     assert(Number.isFinite(instanceCount));
     this.instanceCount = instanceCount;
     return this;
   }
 
-  setGeometry(geometry) {
+  setGeometry(geometry): this {
     this.drawMode = geometry.drawMode;
     this.vertexCount = geometry.getVertexCount();
 
@@ -223,7 +346,7 @@ export default class Model {
     return this;
   }
 
-  setAttributes(attributes = {}) {
+  setAttributes(attributes = {}): this {
     // Avoid setting needsRedraw if no attributes
     if (isObjectEmpty(attributes)) {
       return this;
@@ -242,13 +365,12 @@ export default class Model {
   }
 
   // TODO - should actually set the uniforms
-  setUniforms(uniforms = {}) {
+  setUniforms(uniforms = {}): this {
     Object.assign(this.uniforms, uniforms);
-
     return this;
   }
 
-  getModuleUniforms(opts) {
+  getModuleUniforms(opts?) {
     this._checkProgram();
 
     const getUniforms = this.programManager.getUniforms(this.program);
@@ -260,19 +382,19 @@ export default class Model {
     return {};
   }
 
-  updateModuleSettings(opts) {
+  updateModuleSettings(opts?): this {
     const uniforms = this.getModuleUniforms(opts || {});
     return this.setUniforms(uniforms);
   }
 
   // DRAW CALLS
 
-  clear(opts) {
+  clear(opts): this {
     clear(this.program.gl, opts);
     return this;
   }
 
-  draw(opts = {}) {
+  draw(opts: ModelDrawOptions = {}): boolean {
     // Lazy update program and vertex array
     this._checkProgram();
 
@@ -344,8 +466,9 @@ export default class Model {
     return didDraw;
   }
 
-  // Draw call for transform feedback
-  transform(opts = {}) {
+  // Draw call for transform feedback, TBD...
+  transform(opts: ModelDrawOptions = {}): this {
+    // @ts-expect-error
     const {discard = true, feedbackBuffers, unbindModels = []} = opts;
 
     let {parameters} = opts;
@@ -358,11 +481,11 @@ export default class Model {
       parameters = Object.assign({}, parameters, {[GL.RASTERIZER_DISCARD]: discard});
     }
 
-    unbindModels.forEach(model => model.vertexArray.unbindBuffers());
+    unbindModels.forEach((model) => model.vertexArray.unbindBuffers());
     try {
       this.draw(Object.assign({}, opts, {parameters}));
     } finally {
-      unbindModels.forEach(model => model.vertexArray.bindBuffers());
+      unbindModels.forEach((model) => model.vertexArray.bindBuffers());
     }
 
     return this;
@@ -370,14 +493,14 @@ export default class Model {
 
   // DEPRECATED METHODS
 
-  render(uniforms = {}) {
+  render(uniforms = {}): boolean {
     log.warn('Model.render() is deprecated. Use Model.setUniforms() and Model.draw()')();
     return this.setUniforms(uniforms).draw();
   }
 
   // PRIVATE METHODS
 
-  _setModelProps(props) {
+  _setModelProps(props): void {
     Object.assign(this.props, props);
 
     if ('uniforms' in props) {
@@ -404,7 +527,7 @@ export default class Model {
     }
   }
 
-  _checkProgram() {
+  _checkProgram(): void {
     const needsUpdate =
       this._programDirty || this.programManager.stateHash !== this._programManagerState;
 
@@ -417,16 +540,8 @@ export default class Model {
     if (program) {
       this._managedProgram = false;
     } else {
-      const {
-        vs,
-        fs,
-        modules,
-        inject,
-        defines,
-        varyings,
-        bufferMode,
-        transpileToGLSL100
-      } = this.programProps;
+      const {vs, fs, modules, inject, defines, varyings, bufferMode, transpileToGLSL100} =
+        this.programProps;
       program = this.programManager.get({
         vs,
         fs,
@@ -455,7 +570,6 @@ export default class Model {
     this.program = program;
 
     if (this.vertexArray) {
-      // @ts-ignore TODO
       this.vertexArray.setProps({program: this.program, attributes: this.vertexArray.attributes});
     } else {
       this.vertexArray = new VertexArray(this.gl, {program: this.program});
@@ -470,19 +584,19 @@ export default class Model {
     );
   }
 
-  _deleteGeometryBuffers() {
+  _deleteGeometryBuffers(): void {
     for (const name in this.geometryBuffers) {
       // Buffer is raw value (for indices) or first element of [buffer, accessor] pair
       const buffer = this.geometryBuffers[name][0] || this.geometryBuffers[name];
       if (buffer instanceof Buffer) {
-        buffer.delete();
+        buffer.destroy();
       }
     }
   }
 
   // Updates (evaluates) all function valued uniforms based on a new set of animationProps
   // experimental
-  _setAnimationProps(animationProps) {
+  _setAnimationProps(animationProps): void {
     if (this.animated) {
       assert(animationProps, 'Model.draw(): animated uniforms but no animationProps');
       // const animatedUniforms = this._evaluateAnimateUniforms(animationProps);
@@ -492,7 +606,7 @@ export default class Model {
 
   // Transform Feedback
 
-  _setFeedbackBuffers(feedbackBuffers = {}) {
+  _setFeedbackBuffers(feedbackBuffers = {}): this {
     // Avoid setting needsRedraw if no feedbackBuffers
     if (isObjectEmpty(feedbackBuffers)) {
       return this;
@@ -509,7 +623,7 @@ export default class Model {
     return this;
   }
 
-  _logDrawCallStart(logLevel) {
+  _logDrawCallStart(logLevel: number): number {
     const logDrawTimeout = logLevel > 3 ? 0 : LOG_DRAW_TIMEOUT;
     if (Date.now() - this.lastLogTime < logDrawTimeout) {
       return undefined;
@@ -522,7 +636,7 @@ export default class Model {
     return logLevel;
   }
 
-  _logDrawCallEnd(logLevel, vertexArray, uniforms, framebuffer) {
+  _logDrawCallEnd(logLevel, vertexArray, uniforms, framebuffer?): void {
     // HACK: logLevel === undefined means logDrawCallStart didn't run
     if (logLevel === undefined) {
       return;
@@ -531,11 +645,15 @@ export default class Model {
     const attributeTable = getDebugTableForVertexArray({
       vertexArray,
       header: `${this.id} attributes`,
-      // @ts-ignore
+      // @ts-expect-error
       attributes: this._attributes
     });
 
-    const {table: uniformTable, unusedTable, unusedCount} = getDebugTableForUniforms({
+    const {
+      table: uniformTable,
+      unusedTable,
+      unusedCount
+    } = getDebugTableForUniforms({
       header: `${this.id} uniforms`,
       program: this.program,
       uniforms: Object.assign({}, this.program.uniforms, uniforms)
@@ -570,6 +688,6 @@ export default class Model {
       framebuffer.log({logLevel: LOG_DRAW_PRIORITY, message: `Rendered to ${framebuffer.id}`});
     }
 
-    log.groupEnd(LOG_DRAW_PRIORITY, `>>> DRAWING MODEL ${this.id}`)();
+    log.groupEnd(LOG_DRAW_PRIORITY)();
   }
 }

package/src/lib/{program-manager.js → program-manager.ts}

@@ -1,54 +1,70 @@
+import {Device} from '@luma.gl/api/';
 import {assembleShaders} from '@luma.gl/shadertools';
 import {Program} from '@luma.gl/webgl';
 
-export default class ProgramManager {
-  static getDefaultProgramManager(gl) {
-    gl.luma = gl.luma || {};
-    gl.luma.defaultProgramManager = gl.luma.defaultProgramManager || new ProgramManager(gl);
-
-    return gl.luma.defaultProgramManager;
-  }
+type Module = 'string' | {name: string}; // TODO
 
-  constructor(gl) {
-    this.gl = gl;
+type GetProgramOptions = {
+  vs?: string,
+  fs?: string,
+  defines?: {},
+  inject?: {},
+  varyings?: string[],
+  bufferMode?: number,
+  modules?: Module[];
+  transpileToGLSL100?: boolean
+};
 
-    this._programCache = {};
-    this._getUniforms = {};
-    this._registeredModules = {}; // TODO: Remove? This isn't used anywhere in luma.gl
-    this._hookFunctions = [];
-    this._defaultModules = [];
+export default class ProgramManager {
+  readonly device: Device;
+
+  stateHash = 0; // Used change hashing if hooks are modified
+  private _hashCounter = 0;
+  private readonly _hashes = {};
+  private readonly _useCounts = {};
+
+  private readonly _programCache = {};
+  private readonly _getUniforms = {};
+  private readonly _registeredModules = {}; // TODO: Remove? This isn't used anywhere in luma.gl
+  private readonly _hookFunctions = [];
+  private _defaultModules = [];
+
+  static getDefaultProgramManager(device: Device): ProgramManager {
+    // @ts-expect-error
+    device.defaultProgramManager = device.defaultProgramManager || new ProgramManager(device);
+    // @ts-expect-error
+    return device.defaultProgramManager;
+  }
 
-    this._hashes = {};
-    this._hashCounter = 0;
-    this.stateHash = 0; // Used change hashing if hooks are modified
-    this._useCounts = {};
+  constructor(device: Device) {
+    this.device = device;
   }
 
-  addDefaultModule(module) {
-    if (!this._defaultModules.find(m => m.name === module.name)) {
+  addDefaultModule(module: Module): void {
+    // @ts-expect-error
+    if (!this._defaultModules.find((m) => m.name === module.name)) {
       this._defaultModules.push(module);
     }
 
     this.stateHash++;
   }
 
-  removeDefaultModule(module) {
+  removeDefaultModule(module: Module): void {
     const moduleName = typeof module === 'string' ? module : module.name;
-    this._defaultModules = this._defaultModules.filter(m => m.name !== moduleName);
+    this._defaultModules = this._defaultModules.filter((m) => m.name !== moduleName);
     this.stateHash++;
   }
 
-  addShaderHook(hook, opts) {
+  addShaderHook(hook, opts?): void {
     if (opts) {
       hook = Object.assign(opts, {hook});
     }
 
     this._hookFunctions.push(hook);
-
     this.stateHash++;
   }
 
-  get(props = {}) {
+  get(props: GetProgramOptions = {}): Program {
     const {
       vs = '',
       fs = '',
@@ -63,8 +79,9 @@ export default class ProgramManager {
 
     const vsHash = this._getHash(vs);
     const fsHash = this._getHash(fs);
-    const moduleHashes = modules.map(m => this._getHash(m.name)).sort();
-    const varyingHashes = varyings.map(v => this._getHash(v));
+    // @ts-expect-error
+    const moduleHashes = modules.map((m) => this._getHash(m.name)).sort();
+    const varyingHashes = varyings.map((v) => this._getHash(v));
 
     const defineKeys = Object.keys(defines).sort();
     const injectKeys = Object.keys(inject).sort();
@@ -88,7 +105,7 @@ export default class ProgramManager {
     }`;
 
     if (!this._programCache[hash]) {
-      const assembled = assembleShaders(this.gl, {
+      const assembled = assembleShaders(this.device, {
         vs,
         fs,
         modules,
@@ -98,7 +115,8 @@ export default class ProgramManager {
         transpileToGLSL100
       });
 
-      this._programCache[hash] = new Program(this.gl, {
+      // @ts-expect-error TODO - program should be created from device
+      this._programCache[hash] = new Program(this.device.gl, {
         hash,
         vs: assembled.vs,
         fs: assembled.fs,
@@ -106,7 +124,7 @@ export default class ProgramManager {
         bufferMode
       });
 
-      this._getUniforms[hash] = assembled.getUniforms || (x => {});
+      this._getUniforms[hash] = assembled.getUniforms || ((x) => {});
       this._useCounts[hash] = 0;
     }
 
@@ -115,11 +133,11 @@ export default class ProgramManager {
     return this._programCache[hash];
   }
 
-  getUniforms(program) {
+  getUniforms(program: Program) {
     return this._getUniforms[program.hash] || null;
   }
 
-  release(program) {
+  release(program: Program): void {
     const hash = program.hash;
     this._useCounts[hash]--;
 
@@ -131,7 +149,7 @@ export default class ProgramManager {
     }
   }
 
-  _getHash(key) {
+  _getHash(key: string): string {
     if (this._hashes[key] === undefined) {
       this._hashes[key] = this._hashCounter++;
     }
@@ -140,7 +158,7 @@ export default class ProgramManager {
   }
 
   // Dedup and combine with default modules
-  _getModuleList(appModules = []) {
+  _getModuleList(appModules: Module[] = []): Module[] {
     const modules = new Array(this._defaultModules.length + appModules.length);
     const seen = {};
     let count = 0;
@@ -154,6 +172,7 @@ export default class ProgramManager {
 
     for (let i = 0, len = appModules.length; i < len; ++i) {
       const module = appModules[i];
+      // @ts-expect-error
       const name = module.name;
       if (!seen[name]) {
         modules[count++] = module;