@luma.gl/engine 8.6.0-alpha.1 → 8.6.0-alpha.5

package/src/lib/model.ts

@@ -1,9 +1,9 @@
 // luma.gl, MIT license
+import {Device} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import {isWebGL} from '@luma.gl/gltools';
-import {ProgramProps} from '@luma.gl/webgl';
+import type {ProgramProps} from '@luma.gl/webgl';
 import {
-  Shader,
+  WebGLDevice,
   Program,
   VertexArray,
   clear,
@@ -31,9 +31,22 @@ const NOOP = () => {};
 const DRAW_PARAMS = {};
 
 export type ModelProps = ProgramProps & {
-  id?: string
+  id?: string;
+
+  // program props
+  // vs,
+  // fs,
+  varyings?: string[];
+  bufferMode?;
+
+  program?: Program;
+  modules?: any[];
+  defines?: Record<string, number | boolean>;
+  inject?: Record<string, any>;
+  transpileToGLSL100?: boolean;
+
   moduleSettings?: object; // UniformsOptions
-  attributes?: object,
+  attributes?: object;
   uniforms?: object; // Uniforms
   geometry?: object; // Geometry
   vertexCount?: number
@@ -50,8 +63,12 @@ export type ModelProps = ProgramProps & {
   indexType?;
   indexOffset?: number;
   vertexArrayInstanced?: boolean;
+
+  /** @deprecated Use isInstanced */
+  instanced?: boolean
 };
 
+
 export type ModelDrawOptions = {
   moduleSettings?;
   framebuffer?;
@@ -102,8 +119,10 @@ interface TransformOpts extends DrawOpts {
 */
 
 export default class Model {
-  readonly id: string;
+  readonly device: Device;
   readonly gl: WebGLRenderingContext;
+
+  readonly id: string;
   readonly animated: boolean = false;
   programManager: ProgramManager;
   vertexCount: number;
@@ -136,20 +155,24 @@ export default class Model {
   // TODO - just to unbreak deck.gl 7.0-beta, remove as soon as updated
   geometry = {};
 
-  constructor(gl, props: ModelProps = {}) {
+  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.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;
 
@@ -226,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) {
@@ -245,6 +268,11 @@ export default class Model {
     this._deleteGeometryBuffers();
   }
 
+  /** @deprecated Use .destroy() */
+  delete(): void {
+    this.destroy();
+  }
+
   // GETTERS
 
   getDrawMode() {
@@ -515,7 +543,9 @@ export default class Model {
       const {vs, fs, modules, inject, defines, varyings, bufferMode, transpileToGLSL100} =
         this.programProps;
       program = this.programManager.get({
+        // @ts-expect-error
         vs,
+        // @ts-expect-error
         fs,
         modules,
         inject,
@@ -542,7 +572,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});
@@ -618,7 +647,7 @@ export default class Model {
     const attributeTable = getDebugTableForVertexArray({
       vertexArray,
       header: `${this.id} attributes`,
-      // @ts-ignore
+      // @ts-expect-error
       attributes: this._attributes
     });
 
@@ -661,6 +690,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.ts

@@ -1,3 +1,4 @@
+import {Device} from '@luma.gl/api/';
 import {assembleShaders} from '@luma.gl/shadertools';
 import {Program} from '@luma.gl/webgl';
 
@@ -15,7 +16,7 @@ type GetProgramOptions = {
 };
 
 export default class ProgramManager {
-  readonly gl: WebGLRenderingContext;
+  readonly device: Device;
 
   stateHash = 0; // Used change hashing if hooks are modified
   private _hashCounter = 0;
@@ -28,17 +29,15 @@ export default class ProgramManager {
   private readonly _hookFunctions = [];
   private _defaultModules = [];
 
-  static getDefaultProgramManager(gl: WebGLRenderingContext): ProgramManager {
+  static getDefaultProgramManager(device: Device): ProgramManager {
     // @ts-expect-error
-    gl.luma = gl.luma || {};
+    device.defaultProgramManager = device.defaultProgramManager || new ProgramManager(device);
     // @ts-expect-error
-    gl.luma.defaultProgramManager = gl.luma.defaultProgramManager || new ProgramManager(gl);
-    // @ts-expect-error
-    return gl.luma.defaultProgramManager;
+    return device.defaultProgramManager;
   }
 
-  constructor(gl: WebGLRenderingContext) {
-    this.gl = gl;
+  constructor(device: Device) {
+    this.device = device;
   }
 
   addDefaultModule(module: Module): void {
@@ -56,17 +55,16 @@ export default class ProgramManager {
     this.stateHash++;
   }
 
-  addShaderHook(hook, opts) {
+  addShaderHook(hook, opts?): void {
     if (opts) {
       hook = Object.assign(opts, {hook});
     }
 
     this._hookFunctions.push(hook);
-
     this.stateHash++;
   }
 
-  get(props: GetProgramOptions = {}) {
+  get(props: GetProgramOptions = {}): Program {
     const {
       vs = '',
       fs = '',
@@ -107,7 +105,7 @@ export default class ProgramManager {
     }`;
 
     if (!this._programCache[hash]) {
-      const assembled = assembleShaders(this.gl, {
+      const assembled = assembleShaders(this.device, {
         vs,
         fs,
         modules,
@@ -117,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,

package/src/lib/render-loop.ts

@@ -0,0 +1,56 @@
+import {Stats} from '@probe.gl/stats';
+import type {AnimationProps} from './animation-loop';
+import AnimationLoop from './animation-loop';
+import {Timeline} from '../animation/timeline'
+
+/**
+ * Minimal animation loop that initializes models in constructor
+ * Simplifying type management
+ */
+export abstract class RenderLoop {
+  constructor(animationProps?: AnimationProps) {}
+  onRender(animationProps: AnimationProps) {}
+  onFinalize(animationProps: AnimationProps) {}
+
+  static getAnimationLoop(RenderLoopConstructor: typeof RenderLoop) {
+    return new WrappedAnimationLoop(RenderLoopConstructor);
+  }
+
+  /** Instantiates and runs the render loop */
+  static run(RenderLoopConstructor: typeof RenderLoop, options?: {start?: boolean}): WrappedAnimationLoop {
+    const animationLoop = RenderLoop.getAnimationLoop(RenderLoopConstructor);
+    if (options?.start !== false) {
+      animationLoop.start();
+    }
+    return animationLoop;
+  }
+}
+
+class WrappedAnimationLoop extends AnimationLoop {
+  RenderLoopConstructor: typeof RenderLoop;
+  renderLoop: RenderLoop;
+
+  getInfo() {
+    // @ts-ignore
+    return this.RenderLoopConstructor.info;
+  }
+
+  constructor(RenderLoopConstructor: typeof RenderLoop) {
+    super();
+    this.RenderLoopConstructor = RenderLoopConstructor;
+  }
+
+  onInitialize(animationProps: AnimationProps) {
+    // @ts-expect-error
+    this.renderLoop = new this.RenderLoopConstructor(animationProps);
+  }
+
+  onRender(animationProps: AnimationProps) {
+    this.renderLoop.onRender(animationProps);
+  }
+
+  onFinalize(animationProps: AnimationProps) {
+    this.renderLoop?.onFinalize?.(animationProps);
+  }
+}
+

package/src/transform/buffer-transform.ts

@@ -1,6 +1,5 @@
-import {isWebGL2} from '@luma.gl/gltools';
-import {Buffer, TransformFeedback} from '@luma.gl/webgl';
-import {assert} from '@luma.gl/webgl';
+import {assert} from '@luma.gl/api';
+import {Buffer, TransformFeedback, isWebGL2} from '@luma.gl/webgl';
 import type {TransformProps, TransformDrawOptions, TransformRunOptions, TransformBinding} from './transform-types';
 
 // import {TransformDrawOptions, TransformModelProps} from './resource-transform';

package/src/transform/texture-transform.ts

@@ -125,7 +125,7 @@ export default class TextureTransform {
     // readPixels returns 4 elements for each pixel, pack the elements when requested
     const ArrayType = pixels.constructor;
     const channelCount = typeToChannelCount(this.targetTextureType);
-    // @ts-ignore
+    // @ts-expect-error
     const packedPixels = new ArrayType((pixels.length * channelCount) / 4);
     let packCount = 0;
     for (let i = 0; i < pixels.length; i += 4) {
@@ -148,7 +148,6 @@ export default class TextureTransform {
       this.ownTexture.delete();
     }
     if (this.elementIDBuffer) {
-      // @ts-ignore
       this.elementIDBuffer.delete();
     }
   }
@@ -317,7 +316,7 @@ export default class TextureTransform {
   // build and return shader releated parameters
   _processVertexShader(props: TransformProps = {}) {
     const {sourceTextures, targetTexture} = this.bindings[this.currentIndex];
-    // @ts-ignore TODO - uniforms is not present
+    // @ts-expect-error TODO - uniforms is not present
     const {vs, uniforms, targetTextureType, inject, samplerTextureMap} = updateForTextures({
       vs: props.vs,
       sourceTextureMap: sourceTextures,

package/src/transform/transform-types.ts

@@ -12,6 +12,7 @@ export type TransformProps = {
   uniforms?: any;
   parameters?: any;
   discard?: boolean;
+  isIndexed?: boolean;
   _sourceTextures?: any;
   _targetTexture?: any;
   _targetTextureVarying?: string;

package/src/transform/transform.ts

@@ -1,21 +1,32 @@
+import {Device, assert} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
 import {getShaderInfo, getPassthroughFS} from '@luma.gl/shadertools';
-import {isWebGL2} from '@luma.gl/gltools';
 import type {Framebuffer, Buffer} from '@luma.gl/webgl';
-import {assert, isObjectEmpty} from '@luma.gl/webgl';
+import {WebGLDevice, isObjectEmpty} from '@luma.gl/webgl';
 
 import Model from '../lib/model';
 import BufferTransform from './buffer-transform';
 import TextureTransform from './texture-transform';
 import {TransformProps, TransformRunOptions, TransformDrawOptions} from './transform-types';
 
-// takes source and target buffers/textures and setsup the pipeline
+/** 
+ * Takes source and target buffers/textures and sets up the pipeline 
+ */
 export default class Transform {
-  static isSupported(gl: WebGLRenderingContext): boolean {
-    // TODO : differentiate writing to buffer vs not
-    return isWebGL2(gl);
+  /** 
+   * Check if Transforms are supported (they are not under WebGL1)
+   * @todo differentiate writing to buffer vs not
+   */
+  static isSupported(device: Device | WebGL2RenderingContext): boolean {
+    try {
+      const webglDevice = WebGLDevice.attach(device);
+      return webglDevice.isWebGL2;
+    } catch {
+      return false;
+    }
   }
 
+  readonly device: WebGLDevice;
   readonly gl: WebGL2RenderingContext;
   model: Model | null = null;
   elementCount = 0;
@@ -23,14 +34,16 @@ export default class Transform {
   textureTransform = null;
   elementIDBuffer = null;
 
-  constructor(gl: WebGL2RenderingContext, props: TransformProps = {}) {
-    this.gl = gl;
+  constructor(device: Device | WebGL2RenderingContext, props: TransformProps = {}) {
+    this.device = WebGLDevice.attach(device);
+    // TODO assert webgl2?
+    this.gl = this.device.gl2;
     this._initialize(props);
     Object.seal(this);
   }
 
-  // Delete owned resources.
-  delete(): void {
+  /** Delete owned resources. */
+  destroy(): void {
     const {model, bufferTransform, textureTransform} = this;
     if (model) {
       model.delete();
@@ -43,7 +56,12 @@ export default class Transform {
     }
   }
 
-  // Run one transform loop.
+  /** @deprecated Use destroy*() */
+  delete(): void {
+    this.destroy();
+  }
+
+  /** Run one transform loop. */
   run(options?: TransformRunOptions): void {
     const {clearRenderTarget = true} = options || {};
 
@@ -56,7 +74,7 @@ export default class Transform {
     this.model.transform(updatedOpts);
   }
 
-  // swap resources if a map is provided
+  /** swap resources if a map is provided */
   swap(): void {
     let swapped = false;
     const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean);
@@ -66,16 +84,15 @@ export default class Transform {
     assert(swapped, 'Nothing to swap');
   }
 
-  // Return Buffer object for given varying name.
+  /** Return Buffer object for given varying name. */
   getBuffer(varyingName: string = null): Buffer {
     return this.bufferTransform && this.bufferTransform.getBuffer(varyingName);
   }
 
-  // Return data either from Buffer or from Texture
+  /** Return data either from Buffer or from Texture */
   getData(options: {packed?: boolean; varyingName?: string} = {}) {
     const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean);
     for (const resourceTransform of resourceTransforms) {
-      // @ts-ignore
       const data = resourceTransform.getData(options);
       if (data) {
         return data;
@@ -84,15 +101,14 @@ export default class Transform {
     return null;
   }
 
-  // Return framebuffer object if rendering to textures
+  /** Return framebuffer object if rendering to textures */
   getFramebuffer(): Framebuffer | null {
     return this.textureTransform && this.textureTransform.getFramebuffer();
   }
 
-  // Update some or all buffer/texture bindings.
+  /** Update some or all buffer/texture bindings. */
   update(props: TransformProps): void {
     if ('elementCount' in props) {
-      // @ts-ignore TODO
       this.model.setVertexCount(props.elementCount);
     }
     const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean);
@@ -109,7 +125,7 @@ export default class Transform {
 
     props = this._updateModelProps(props);
     this.model = new Model(
-      gl,
+      this.device,
       Object.assign({}, props, {
         fs: props.fs || getPassthroughFS({version: getShaderInfo(props.vs).version}),
         id: props.id || 'transform-model',
@@ -118,9 +134,9 @@ export default class Transform {
       })
     );
 
-    /* eslint-disable no-unused-expressions */
-    this.bufferTransform && this.bufferTransform.setupResources({model: this.model});
-    /* eslint-enable no-unused-expressions */
+    if (this.bufferTransform) {
+      this.bufferTransform.setupResources({model: this.model});
+    }
   }
 
   _updateModelProps(props: TransformProps): TransformProps {