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

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.js → buffer-transform.ts}

@@ -1,28 +1,40 @@
-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';
+// export interface BufferTransform2 {
+//   setupResources(opts: any): void;
+//   updateModelProps(props?: {}): TransformProps;
+//   getDrawOptions(opts?: {}): TransformDrawOptions;
+//   swap(): boolean;
+//   update(opts?: {}): void;
+//   getBuffer(varyingName: any): any;
+//   getData(options?: {varyingName: string}): any;
+//   delete(): void;
+// }
 
 export default class BufferTransform {
-  constructor(gl, props = {}) {
+  gl: WebGL2RenderingContext;
+  currentIndex = 0;
+  feedbackMap = {};
+  varyings: string[] | null = null; // varyings array
+  bindings: TransformBinding[] = [];
+  resources = {}; // resources to be deleted
+
+  constructor(gl: WebGL2RenderingContext, props: TransformProps = {}) {
     this.gl = gl;
-    this.currentIndex = 0;
-    this.feedbackMap = {};
-    this.varyings = null; // varyings array
-    this.bindings = []; // each element is an object : {sourceBuffers, feedbackBuffers, transformFeedback}
-
-    this.resources = {}; // resources to be deleted
-
     this._initialize(props);
     Object.seal(this);
   }
 
-  setupResources(opts) {
+  setupResources(opts): void {
     for (const binding of this.bindings) {
       this._setupTransformFeedback(binding, opts);
     }
   }
 
-  updateModelProps(props = {}) {
+  updateModelProps(props: TransformProps = {}): TransformProps {
     const {varyings} = this;
     if (varyings.length > 0) {
       props = Object.assign({}, props, {varyings});
@@ -30,15 +42,16 @@ export default class BufferTransform {
     return props;
   }
 
-  getDrawOptions(opts = {}) {
+  // @ts-expect-error
+  getDrawOptions(opts: TransformRunOptions = {}): TransformDrawOptions {
     const binding = this.bindings[this.currentIndex];
     const {sourceBuffers, transformFeedback} = binding;
+    // @ts-expect-error
     const attributes = Object.assign({}, sourceBuffers, opts.attributes);
-
     return {attributes, transformFeedback};
   }
 
-  swap() {
+  swap(): boolean {
     if (this.feedbackMap) {
       this.currentIndex = this._getNextIndex();
       return true;
@@ -52,7 +65,7 @@ export default class BufferTransform {
   }
 
   // returns current feedbackBuffer of given name
-  getBuffer(varyingName) {
+  getBuffer(varyingName: string | null): Buffer | null {
     const {feedbackBuffers} = this.bindings[this.currentIndex];
     const bufferOrParams = varyingName ? feedbackBuffers[varyingName] : null;
     if (!bufferOrParams) {
@@ -61,7 +74,7 @@ export default class BufferTransform {
     return bufferOrParams instanceof Buffer ? bufferOrParams : bufferOrParams.buffer;
   }
 
-  getData(options = {}) {
+  getData(options: {varyingName?: string} = {}) {
     const {varyingName} = options;
     const buffer = this.getBuffer(varyingName);
     if (buffer) {
@@ -71,7 +84,7 @@ export default class BufferTransform {
   }
 
   // Delete owned resources.
-  delete() {
+  delete(): void {
     for (const name in this.resources) {
       this.resources[name].delete();
     }
@@ -79,7 +92,7 @@ export default class BufferTransform {
 
   // Private
 
-  _initialize(props = {}) {
+  _initialize(props: TransformProps = {}): void {
     this._setupBuffers(props);
     this.varyings = props.varyings || Object.keys(this.bindings[this.currentIndex].feedbackBuffers);
     if (this.varyings.length > 0) {
@@ -125,13 +138,15 @@ export default class BufferTransform {
   }
 
   _setupBuffers(props = {}) {
-    const {sourceBuffers = null} = props;
-    Object.assign(this.feedbackMap, props.feedbackMap);
+  // @ts-expect-error
+  const {sourceBuffers = null} = props;
+  // @ts-expect-error
+  Object.assign(this.feedbackMap, props.feedbackMap);
     const feedbackBuffers = this._getFeedbackBuffers(props);
     this._updateBindings({sourceBuffers, feedbackBuffers});
   }
 
-  _setupTransformFeedback(binding, {model}) {
+  _setupTransformFeedback(binding, {model}): void {
     const {program} = model;
     binding.transformFeedback = new TransformFeedback(this.gl, {
       program,
@@ -139,7 +154,7 @@ export default class BufferTransform {
     });
   }
 
-  _updateBindings(opts) {
+  _updateBindings(opts): void {
     this.bindings[this.currentIndex] = this._updateBinding(this.bindings[this.currentIndex], opts);
     if (this.feedbackMap) {
       const {sourceBuffers, feedbackBuffers} = this._swapBuffers(this.bindings[this.currentIndex]);
@@ -166,7 +181,7 @@ export default class BufferTransform {
     return binding;
   }
 
-  _swapBuffers(opts) {
+  _swapBuffers(opts): {sourceBuffers: any; feedbackBuffers: any} {
     if (!this.feedbackMap) {
       return null;
     }
@@ -184,7 +199,7 @@ export default class BufferTransform {
   }
 
   // Create a buffer and add to list of buffers to be deleted.
-  _createNewBuffer(name, opts) {
+  _createNewBuffer(name, opts): Buffer {
     const buffer = new Buffer(this.gl, opts);
     if (this.resources[name]) {
       this.resources[name].delete();
@@ -193,7 +208,7 @@ export default class BufferTransform {
     return buffer;
   }
 
-  _getNextIndex() {
+  _getNextIndex(): number {
     return (this.currentIndex + 1) % 2;
   }
 }

package/src/transform/{texture-transform.js → texture-transform.ts}

@@ -1,17 +1,10 @@
-/** @typedef {import('./transform').TransformProps} TransformProps */
 import GL from '@luma.gl/constants';
 
-import {
-  cloneTextureFrom,
-  readPixelsToArray,
-  getShaderVersion,
-  Buffer,
-  Texture2D,
-  Framebuffer
-} from '@luma.gl/webgl';
+import {cloneTextureFrom, readPixelsToArray, Buffer, Texture2D, Framebuffer} from '@luma.gl/webgl';
 
 import {
   _transform as transformModule,
+  getShaderInfo,
   getPassthroughFS,
   typeToChannelCount,
   combineInjects
@@ -19,6 +12,8 @@ import {
 
 import {updateForTextures, getSizeUniforms} from './transform-shader-utils';
 
+import type {TransformProps, TransformDrawOptions} from './transform-types';
+
 // TODO: move these constants to transform-shader-utils
 // Texture parameters needed so sample can precisely pick pixel for given element id.
 const SRC_TEX_PARAMETER_OVERRIDES = {
@@ -30,7 +25,24 @@ const SRC_TEX_PARAMETER_OVERRIDES = {
 const FS_OUTPUT_VARIABLE = 'transform_output';
 
 export default class TextureTransform {
-  constructor(gl, props = {}) {
+  gl: WebGL2RenderingContext;
+  id = 0;
+  currentIndex = 0;
+  _swapTexture = null;
+  targetTextureVarying = null;
+  targetTextureType = null;
+  samplerTextureMap = null;
+  bindings = []; // each element is an object : {sourceTextures, targetTexture, framebuffer}
+  resources = {}; // resources to be deleted
+
+  hasTargetTexture: boolean = false;
+  hasSourceTextures: boolean = false;
+  ownTexture: Texture2D | null = null;
+  elementIDBuffer: Buffer | null = null;
+  _targetRefTexName: string;
+  elementCount: number;
+
+  constructor(gl: WebGL2RenderingContext, props: TransformProps = {}) {
     this.gl = gl;
     this.id = this.currentIndex = 0;
     this._swapTexture = null;
@@ -45,15 +57,14 @@ export default class TextureTransform {
     Object.seal(this);
   }
 
-  updateModelProps(props = {}) {
+  updateModelProps(props: TransformProps = {}) {
     const updatedModelProps = this._processVertexShader(props);
     return Object.assign({}, props, updatedModelProps);
   }
 
-  getDrawOptions(opts = {}) {
-    const {sourceBuffers, sourceTextures, framebuffer, targetTexture} = this.bindings[
-      this.currentIndex
-    ];
+  getDrawOptions(opts: TransformProps = {}): TransformDrawOptions {
+    const {sourceBuffers, sourceTextures, framebuffer, targetTexture} =
+      this.bindings[this.currentIndex];
 
     const attributes = Object.assign({}, sourceBuffers, opts.attributes);
     const uniforms = Object.assign({}, opts.uniforms);
@@ -76,7 +87,6 @@ export default class TextureTransform {
       });
       Object.assign(uniforms, sizeUniforms);
     }
-
     if (this.hasTargetTexture) {
       discard = false;
       parameters.viewport = [0, 0, framebuffer.width, framebuffer.height];
@@ -115,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) {
@@ -144,11 +154,11 @@ export default class TextureTransform {
 
   // Private
 
-  _initialize(props = {}) {
+  _initialize(props: TransformProps = {}) {
     const {_targetTextureVarying, _swapTexture} = props;
     this._swapTexture = _swapTexture;
     this.targetTextureVarying = _targetTextureVarying;
-    this.hasTargetTexture = _targetTextureVarying;
+    this.hasTargetTexture = Boolean(_targetTextureVarying);
     this._setupTextures(props);
   }
 
@@ -171,8 +181,7 @@ export default class TextureTransform {
     return this._createNewTexture(refTexture);
   }
 
-  /** @param {TransformProps} props */
-  _setupTextures(props = {}) {
+  _setupTextures(props: TransformProps = {}) {
     const {sourceBuffers, _sourceTextures = {}, _targetTexture} = props;
     const targetTexture = this._createTargetTexture({
       sourceTextures: _sourceTextures,
@@ -186,7 +195,7 @@ export default class TextureTransform {
     }
   }
 
-  _updateElementIDBuffer(elementCount) {
+  _updateElementIDBuffer(elementCount: number): void {
     if (typeof elementCount !== 'number' || this.elementCount >= elementCount) {
       return;
     }
@@ -305,9 +314,9 @@ export default class TextureTransform {
   }
 
   // build and return shader releated parameters
-  _processVertexShader(props = {}) {
+  _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,
@@ -320,13 +329,14 @@ export default class TextureTransform {
     const fs =
       props._fs ||
       getPassthroughFS({
-        version: getShaderVersion(vs),
+        version: getShaderInfo(vs).version,
         input: this.targetTextureVarying,
         inputType: targetTextureType,
         output: FS_OUTPUT_VARIABLE
       });
     const modules =
       this.hasSourceTextures || this.targetTextureVarying
+        // @ts-expect-error
         ? [transformModule].concat(props.modules || [])
         : props.modules;
     return {vs, fs, modules, uniforms, inject: combinedInject};

package/src/transform/{transform-shader-utils.js → transform-shader-utils.ts}

@@ -8,7 +8,18 @@ const VS_POS_VARIABLE = 'transform_position';
 // Scan provided vertex shader
 // for each texture attribute, inject sampler instructions and build uniforms for sampler
 // for texture target, get varying type and inject position instruction
-export function updateForTextures({vs, sourceTextureMap, targetTextureVarying, targetTexture}) {
+export function updateForTextures(options: {
+  vs: any;
+  sourceTextureMap: any;
+  targetTextureVarying: any;
+  targetTexture: any;
+}): {
+  vs: any;
+  targetTextureType: any;
+  inject: {};
+  samplerTextureMap: {};
+} {
+  const {vs, sourceTextureMap, targetTextureVarying, targetTexture} = options;
   const texAttributeNames = Object.keys(sourceTextureMap);
   let sourceCount = texAttributeNames.length;
   let targetTextureType = null;
@@ -67,46 +78,47 @@ export function updateForTextures({vs, sourceTextureMap, targetTextureVarying, t
 }
 
 // builds and returns an object contaning size uniform for each texture
-export function getSizeUniforms({sourceTextureMap, targetTextureVarying, targetTexture}) {
+export function getSizeUniforms(options: {
+  sourceTextureMap: any;
+  targetTextureVarying: any;
+  targetTexture: any;
+}): {} {
   const uniforms = {};
   let width;
   let height;
-  if (targetTextureVarying) {
-    ({width, height} = targetTexture);
-    uniforms[`${SIZE_UNIFORM_PREFIX}${targetTextureVarying}`] = [width, height];
+  if (options.targetTextureVarying) {
+    ({width, height} = options.targetTexture);
+    uniforms[`${SIZE_UNIFORM_PREFIX}${options.targetTextureVarying}`] = [width, height];
   }
-  for (const textureName in sourceTextureMap) {
-    ({width, height} = sourceTextureMap[textureName]);
+  for (const textureName in options.sourceTextureMap) {
+    ({width, height} = options.sourceTextureMap[textureName]);
     uniforms[`${SIZE_UNIFORM_PREFIX}${textureName}`] = [width, height];
   }
   return uniforms;
 }
 
-// Checks if provided line is defining an attribute, if so returns details otherwise null
-function getAttributeDefinition(line) {
-  return getQualifierDetails(line, ['attribute', 'in']);
-}
-
-function getSamplerDeclerations(textureName) {
-  const samplerName = `${SAMPLER_UNIFORM_PREFIX}${textureName}`;
-  const sizeName = `${SIZE_UNIFORM_PREFIX}${textureName}`;
-  const uniformDeclerations = `\
-  uniform sampler2D ${samplerName};
-  uniform vec2 ${sizeName};`;
-  return {samplerName, sizeName, uniformDeclerations};
-}
-
 // Return size (float, vec2 etc) of a given varying, null if doens't exist.
-export function getVaryingType(line, varying) {
-  const qualaiferDetails = getQualifierDetails(line, ['varying', 'out']);
-  if (!qualaiferDetails) {
+
+export function getVaryingType(line: any, varying: any): any {
+  const qualiferDetails = getQualifierDetails(line, ['varying', 'out']);
+  if (!qualiferDetails) {
     return null;
   }
-  return qualaiferDetails.name === varying ? qualaiferDetails.type : null;
+  return qualiferDetails.name === varying ? qualiferDetails.type : null;
 }
 
 // build required definitions, sample instructions for each texture attribute
-export function processAttributeDefinition(line, textureMap) {
+export function processAttributeDefinition(
+  line: any,
+  textureMap: any
+): {
+  updatedLine: string;
+  inject: {
+    'vs:#decl': string;
+    'vs:#main-start': string;
+  };
+  samplerTextureMap: {};
+} {
   const samplerTextureMap = {};
   const attributeData = getAttributeDefinition(line);
   if (!attributeData) {
@@ -116,7 +128,7 @@ export function processAttributeDefinition(line, textureMap) {
   if (name && textureMap[name]) {
     // eslint-disable-next-line no-useless-escape
     const updatedLine = `\// ${line} => Replaced by Transform with a sampler`;
-    const {samplerName, sizeName, uniformDeclerations} = getSamplerDeclerations(name);
+    const {samplerName, sizeName, uniformDeclerations} = getSamplerDeclarations(name);
 
     const channels = typeToChannelSuffix(type);
     const sampleInstruction = `  ${type} ${name} = transform_getInput(${samplerName}, ${sizeName}).${channels};\n`;
@@ -139,3 +151,19 @@ export function processAttributeDefinition(line, textureMap) {
   }
   return null;
 }
+
+// HELPERS
+
+// Checks if provided line is defining an attribute, if so returns details otherwise null
+function getAttributeDefinition(line) {
+  return getQualifierDetails(line, ['attribute', 'in']);
+}
+
+function getSamplerDeclarations(textureName) {
+  const samplerName = `${SAMPLER_UNIFORM_PREFIX}${textureName}`;
+  const sizeName = `${SIZE_UNIFORM_PREFIX}${textureName}`;
+  const uniformDeclerations = `\
+  uniform sampler2D ${samplerName};
+  uniform vec2 ${sizeName};`;
+  return {samplerName, sizeName, uniformDeclerations};
+}

package/src/transform/transform-types.ts

@@ -0,0 +1,42 @@
+/** Properties for creating Transforms */
+export type TransformProps = {
+  id?: string;
+  vs?: string;
+  elementCount?: number;
+  sourceBuffers?: object;
+  feedbackBuffers?: object;
+  varyings?: string[];
+  feedbackMap?: object;
+  modules?: object[]; // TODO use ShaderModule type
+  attributes?: any;
+  uniforms?: any;
+  parameters?: any;
+  discard?: boolean;
+  isIndexed?: boolean;
+  _sourceTextures?: any;
+  _targetTexture?: any;
+  _targetTextureVarying?: string;
+  _swapTexture?: string;
+  _fs?: string;
+  fs?: string;
+  inject?: any;
+  drawMode?: number;
+};
+
+/** Options that can be provided when running a Transform */
+export type TransformRunOptions = {
+  clearRenderTarget?: boolean;
+  uniforms: Record<string, any>;
+};
+
+/** Options that control drawing a Transform. Used by subclasses to return draw parameters */
+export type TransformDrawOptions = {
+  attributes?: object;
+  framebuffer?: any;
+  uniforms?: object;
+  discard?: boolean;
+  parameters?: object;
+  transformFeedback?: any;
+};
+
+export type TransformBinding = {sourceBuffers, feedbackBuffers, transformFeedback};