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

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 {