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

package/src/lib/model.d.ts

@@ -1,214 +0,0 @@
-import ProgramManager from './program-manager';
-import {Program, Shader} from '@luma.gl/webgl';
-
-type DefineMap = object;
-type InjectionMap = object;
-
-type ProgramProps = {
-  program?: Program
-  vs?: Shader | string
-  fs?: Shader | string
-  modules?: (object | string)[]; // Array<ShaderModule | ShaderModuleObject | string>
-  defines?: DefineMap
-  inject?: InjectionMap
-  varyings?: string[]
-  bufferMode?: number
-  transpileToGLSL100?: boolean
-}
-
-type ModelProps = ProgramProps & {
-  id?: string
-  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
-}
-
-/*
-export type ModelProps = {
-  id?: string;
-  program?: Program;
-  vs?: Shader | string;
-  fs?: Shader | string;
-  geometry?: object;
-  drawMode?: number;
-  vertexCount?: number;
-  isInstanced?: boolean;
-  modules?: object;
-  defines?: object;
-  inject?: object;
-  varyings?: object;
-  bufferMode?: number;
-  transpileToGLSL100?: boolean;
-};
-*/
-
-export default class Model {
-  readonly id: string;
-  readonly gl: WebGLRenderingContext;
-  readonly animated: boolean;
-  readonly programManager: ProgramManager;
-  readonly vertexCount: number;
-
-  constructor(gl: WebGLRenderingContext, props?: ModelProps);
-  initialize(props: any): void;
-  setProps(props: any): void;
-  delete(): void;
-  getDrawMode(): any;
-  getVertexCount(): any;
-  getInstanceCount(): any;
-  getAttributes(): any;
-  getProgram(): any;
-  setProgram(props: any): void;
-  getUniforms(): any;
-  setDrawMode(drawMode: any): this;
-  setVertexCount(vertexCount: number): this;
-  setInstanceCount(instanceCount: number): this;
-  setGeometry(geometry: any): this;
-  setAttributes(attributes?: object): this;
-  setUniforms(uniforms?: object): this;
-  getModuleUniforms(opts?: object): any;
-  updateModuleSettings(opts?: object): this;
-  clear(opts: any): this;
-  draw(opts?: {}): boolean;
-  transform(opts?: {}): this;
-  render(uniforms?: {}): any;
-}
-
-/*
-import Geometry from '../geometry/geometry';
-import { AnimationProps } from './animation-loop';
-import {
-  Buffer,
-  Program,
-  VertexArray,
-  Framebuffer,
-  TransformFeedback,
-  Accessor,
-  VertexShader,
-  FragmentShader
-} from '@luma.gl/webgl';
-
-import {
-  AccessorObject
-} from '@luma.gl/webgl/src/classes/accessor'
-
-import {
-  Uniforms,
-  UniformsOptions
-} from '@luma.gl/webgl/src/classes/uniforms'
-
-import {
-  ShaderModule,
-  ShaderModuleObject,
-  InjectionMap
-} from '@luma.gl/shadertools/src/lib/shader-module'
-
-import {
-  DefineMap
-} from '@luma.gl/shadertools/src/lib/assemble-shaders'
-
-type Attribute = Buffer | AccessorObject | Accessor |
-  [Buffer, Accessor] | [Buffer, AccessorObject]
-
-interface Attributes {
-  [attributeName: string]: Attribute
-}
-
-interface Parameters {
-  [parameterConstant: number]: boolean
-  [settingName: string]: boolean
-}
-
-interface FeedbackBuffers {
-  [name: string]: string | Buffer
-}
-
-interface ProgramProps {
-  program: Program
-  vs: VertexShader | string
-  fs: FragmentShader | string
-  modules: Array<ShaderModule | ShaderModuleObject | string>
-  defines: DefineMap
-  inject: InjectionMap
-  varyings: Array<string>
-  bufferMode: number
-  transpileToGLSL100: boolean
-}
-
-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 {
-  readonly id: string;
-  readonly gl: WebGLRenderingContext;
-  readonly animated: boolean;
-  readonly programManager: ProgramManager;
-
-  constructor(gl: WebGLRenderingContext, props?: ModelProps);
-  initialize(props: any): void;
-  setProps(props: any): void;
-  delete(): void;
-  getDrawMode(): any;
-  getVertexCount(): any;
-  getInstanceCount(): any;
-  getAttributes(): any;
-  getProgram(): any;
-  setProgram(props: any): void;
-  getUniforms(): any;
-  setDrawMode(drawMode: any): this;
-  setVertexCount(vertexCount: number): this;
-  setInstanceCount(instanceCount: number): this;
-  setGeometry(geometry: any): this;
-  setAttributes(attributes?: object): this;
-  setUniforms(uniforms?: object): this;
-  getModuleUniforms(opts?: object): any;
-  updateModuleSettings(opts?: object): this;
-  clear(opts: any): this;
-  draw(opts?: {}): any;
-  transform(opts?: {}): this;
-  render(uniforms?: {}): any;
-}
-*/

package/src/lib/program-manager.d.ts

@@ -1,79 +0,0 @@
-export default class ProgramManager {
-  static getDefaultProgramManager(gl: WebGLRenderingContext): any;
-  constructor(gl: WebGLRenderingContext);
-  addDefaultModule(module: any): void;
-  removeDefaultModule(module: any): void;
-  addShaderHook(hook: any, opts: any): void;
-  get(props?: {}): any;
-  getUniforms(program: any): any;
-  release(program: any): void;
-}
-
-/*
-import {
-  VertexShader,
-  FragmentShader,
-  Program
-} from '@luma.gl/webgl';
-
-import {
-  Uniforms,
-  UniformsOptions
-} from '@luma.gl/webgl/src/classes/uniforms'
-
-import {
-  ShaderModule,
-  ShaderModuleObject,
-  InjectionMap
-} from '@luma.gl/shadertools/src/lib/shader-module'
-
-import {
-  DefineMap
-} from '@luma.gl/shadertools/src/lib/assemble-shaders'
-
-interface ProgramManagerProps {
-  vs?: VertexShader | string
-  fs?: FragmentShader | string
-  modules?: Array<ShaderModuleObject | string>
-  defines?: DefineMap
-  inject?: InjectionMap
-  varyings?: Array<string>
-  bufferMode?: number
-  transpileToGLSL100?: boolean
-}
-
-export default class ProgramManager {
-  stateHash: number
-  gl: WebGLRenderingContext
-  _programCache: {
-    [programHash: string]: Program
-  }
-  _getUniforms: {
-    [programHash: string]: (opts: UniformsOptions, context: Uniforms) => Uniforms
-  }
-  _registeredModules: {} // TODO: Remove? This isn't used anywhere in luma.gl
-  _hookFunctions: Array<{
-    hook: string
-    header?: string
-    footer?: string
-  }>
-  _defaultModules: Array<ShaderModuleObject | ShaderModule>
-  _hashes: {
-    [key: string]: number
-  }
-  _hashCounter: number
-  _useCounts: {
-    [programHash: string]: number
-  }
-  static getDefaultProgramManager(gl: WebGLRenderingContext): ProgramManager;
-  constructor(gl: WebGLRenderingContext);
-  addDefaultModule(module: ShaderModuleObject | ShaderModule): void;
-  removeDefaultModule(module: ShaderModuleObject | ShaderModule | string): void;
-  addShaderHook(hook: string, opts?: {header?: string, footer?: string}): void;
-  get(props?: ProgramManagerProps): Program;
-  getUniforms(program: Program): ((opts: UniformsOptions, context: Uniforms) => Uniforms) | null;
-  release(program: Program): void;
-  _getHash(key: string): number;
-  _getModuleList(appModules?: Array<ShaderModuleObject | ShaderModule>): Array<ShaderModuleObject | ShaderModule>;
-}
-*/

package/src/transform/buffer-transform.d.ts

@@ -1,13 +0,0 @@
-import {TransformDrawOptions, TransformModelProps} from './resource-transform';
-
-export default class BufferTransform {
-  constructor(gl: WebGLRenderingContext, props?: {});
-  setupResources(opts: any): void;
-  updateModelProps(props?: {}): TransformModelProps;
-  getDrawOptions(opts?: {}): TransformDrawOptions;
-  swap(): boolean;
-  update(opts?: {}): void;
-  getBuffer(varyingName: any): any;
-  getData(options?: {varyingName: string}): any;
-  delete(): void;
-}

package/src/transform/resource-transform.d.ts

@@ -1,16 +0,0 @@
-export type TransformDrawOptions = {
-  attributes?: object;
-  framebuffer?: any;
-  uniforms?: object;
-  discard?: boolean;
-  parameters?: object;
-  transformFeedback?: any;
-};
-
-export type TransformModelProps = {
-  vs: any;
-  fs: any;
-  modules: any;
-  uniforms: any;
-  inject: any;
-};

package/src/transform/texture-transform.d.ts

@@ -1,16 +0,0 @@
-import {TransformDrawOptions, TransformModelProps} from './resource-transform';
-
-export default class TextureTransform {
-  constructor(gl: WebGLRenderingContext, props?: {});
-
-  updateModelProps(props?: {}): TransformModelProps;
-
-  getDrawOptions(opts?: {}): TransformDrawOptions;
-
-  swap(): boolean;
-  update(opts?: {}): void;
-  getTargetTexture(): any;
-  getData(opts: {packed?: boolean}): any;
-  getFramebuffer(): any;
-  delete(): void;
-}

package/src/transform/transform-shader-utils.d.ts

@@ -1,31 +0,0 @@
-export function updateForTextures(options: {
-  vs: any;
-  sourceTextureMap: any;
-  targetTextureVarying: any;
-  targetTexture: any;
-}): {
-  vs: any;
-  targetTextureType: any;
-  inject: {};
-  samplerTextureMap: {};
-};
-
-export function getSizeUniforms(options: {
-  sourceTextureMap: any;
-  targetTextureVarying: any;
-  targetTexture: any;
-}): {};
-
-export function getVaryingType(line: any, varying: any): any;
-
-export function processAttributeDefinition(
-  line: any,
-  textureMap: any
-): {
-  updatedLine: string;
-  inject: {
-    'vs:#decl': string;
-    'vs:#main-start': string;
-  };
-  samplerTextureMap: {};
-};

package/src/transform/transform.d.ts

@@ -1,33 +0,0 @@
-import Model from '../lib/model';
-
-export type TransformProps = {
-  vs?: string;
-  elementCount?: number;
-  sourceBuffers?: object;
-  feedbackBuffers?: object;
-  varyings?: string[];
-  feedbackMap?: object;
-  modules?: object[]; // TODO use ShaderModule type
-  _sourceTextures?: any;
-  _targetTexture?: any;
-  _targetTextureVarying?: string;
-  _swapTexture?: string;
-  _fs?: string;
-  inject?: any;
-  drawMode?: number;
-};
-
-export default class Transform {
-  readonly model: Model;
-
-  static isSupported(gl: WebGLRenderingContext): any;
-  constructor(gl: WebGLRenderingContext, props?: TransformProps);
-  delete(): void;
-  run(opts?: {}): void;
-  swap(): void;
-  getBuffer(varyingName?: any): any;
-  // TODO - mix of options for buffers and textures
-  getData(opts?: {packed?: boolean; varyingName?: string}): any;
-  getFramebuffer(): any;
-  update(opts?: TransformProps): void;
-}

package/src/transform/transform.js

@@ -1,177 +0,0 @@
-import GL from '@luma.gl/constants';
-import {getPassthroughFS} from '@luma.gl/shadertools';
-import BufferTransform from './buffer-transform';
-import TextureTransform from './texture-transform';
-
-import {isWebGL2} from '@luma.gl/gltools';
-import {assert, isObjectEmpty, getShaderVersion} from '@luma.gl/webgl';
-import Model from '../lib/model';
-
-// takes source and target buffers/textures and setsup the pipeline
-export default class Transform {
-  static isSupported(gl) {
-    // TODO : differentiate writting to buffer vs not
-    return isWebGL2(gl);
-  }
-
-  constructor(gl, props = {}) {
-    this.gl = gl;
-    this.model = null;
-    this.elementCount = 0;
-    this.bufferTransform = null;
-    this.textureTransform = null;
-    this.elementIDBuffer = null;
-    this._initialize(props);
-    Object.seal(this);
-  }
-
-  // Delete owned resources.
-  delete() {
-    const {model, bufferTransform, textureTransform} = this;
-    if (model) {
-      model.delete();
-    }
-    if (bufferTransform) {
-      bufferTransform.delete();
-    }
-    if (textureTransform) {
-      textureTransform.delete();
-    }
-  }
-
-  // Run one transform loop.
-  run(opts = {}) {
-    const {clearRenderTarget = true} = opts;
-
-    const updatedOpts = this._updateDrawOptions(opts);
-
-    if (clearRenderTarget && updatedOpts.framebuffer) {
-      updatedOpts.framebuffer.clear({color: true});
-    }
-
-    this.model.transform(updatedOpts);
-  }
-
-  // swap resources if a map is provided
-  swap() {
-    let swapped = false;
-    const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean);
-    for (const resourceTransform of resourceTransforms) {
-      swapped = swapped || resourceTransform.swap();
-    }
-    assert(swapped, 'Nothing to swap');
-  }
-
-  // Return Buffer object for given varying name.
-  getBuffer(varyingName = null) {
-    return this.bufferTransform && this.bufferTransform.getBuffer(varyingName);
-  }
-
-  // Return data either from Buffer or from Texture
-  getData(opts = {}) {
-    const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean);
-    for (const resourceTransform of resourceTransforms) {
-      // @ts-ignore
-      const data = resourceTransform.getData(opts);
-      if (data) {
-        return data;
-      }
-    }
-    return null;
-  }
-
-  // Return framebuffer object if rendering to textures
-  getFramebuffer() {
-    return this.textureTransform && this.textureTransform.getFramebuffer();
-  }
-
-  // Update some or all buffer/texture bindings.
-  update(opts = {}) {
-    if ('elementCount' in opts) {
-      // @ts-ignore TODO
-      this.model.setVertexCount(opts.elementCount);
-    }
-    const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean);
-    for (const resourceTransform of resourceTransforms) {
-      resourceTransform.update(opts);
-    }
-  }
-
-  // Private
-
-  _initialize(props = {}) {
-    const {gl} = this;
-    this._buildResourceTransforms(gl, props);
-
-    props = this._updateModelProps(props);
-    this.model = new Model(
-      gl,
-      Object.assign({}, props, {
-        fs: props.fs || getPassthroughFS({version: getShaderVersion(props.vs)}),
-        id: props.id || 'transform-model',
-        drawMode: props.drawMode || GL.POINTS,
-        vertexCount: props.elementCount
-      })
-    );
-
-    /* eslint-disable no-unused-expressions */
-    this.bufferTransform && this.bufferTransform.setupResources({model: this.model});
-    /* eslint-enable no-unused-expressions */
-  }
-
-  _updateModelProps(props) {
-    let updatedProps = Object.assign({}, props);
-    const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean);
-    for (const resourceTransform of resourceTransforms) {
-      updatedProps = resourceTransform.updateModelProps(updatedProps);
-    }
-    return updatedProps;
-  }
-
-  _buildResourceTransforms(gl, props) {
-    if (canCreateBufferTransform(props)) {
-      this.bufferTransform = new BufferTransform(gl, props);
-    }
-    if (canCreateTextureTransform(props)) {
-      this.textureTransform = new TextureTransform(gl, props);
-    }
-    assert(
-      this.bufferTransform || this.textureTransform,
-      'must provide source/feedback buffers or source/target textures'
-    );
-  }
-
-  _updateDrawOptions(opts) {
-    let updatedOpts = Object.assign({}, opts);
-    const resourceTransforms = [this.bufferTransform, this.textureTransform].filter(Boolean);
-    for (const resourceTransform of resourceTransforms) {
-      updatedOpts = Object.assign(updatedOpts, resourceTransform.getDrawOptions(updatedOpts));
-    }
-    return updatedOpts;
-  }
-}
-
-// Helper Methods
-
-function canCreateBufferTransform(props) {
-  if (
-    !isObjectEmpty(props.feedbackBuffers) ||
-    !isObjectEmpty(props.feedbackMap) ||
-    (props.varyings && props.varyings.length > 0)
-  ) {
-    return true;
-  }
-  return false;
-}
-
-function canCreateTextureTransform(props) {
-  if (
-    !isObjectEmpty(props._sourceTextures) ||
-    props._targetTexture ||
-    props._targetTextureVarying
-  ) {
-    return true;
-  }
-
-  return false;
-}

package/src/utils/clip-space.d.ts

@@ -1,5 +0,0 @@
-import Model, {ModelProps} from '../lib/model';
-
-export default class ClipSpace extends Model {
-  constructor(gl: WebGLRenderingContext, opts?: ModelProps);
-}