@luma.gl/engine 8.6.0-alpha.5 → 9.0.0-alpha.3

package/src/lib/model.ts

@@ -1,695 +1,179 @@
-// luma.gl, MIT license
-import {Device} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import type {ProgramProps} from '@luma.gl/webgl';
-import {
-  WebGLDevice,
-  Program,
-  VertexArray,
-  clear,
-  TransformFeedback,
-  Buffer,
-  log,
-  isObjectEmpty,
-  uid,
-  assert
-} from '@luma.gl/webgl';
-import {
-  getDebugTableForUniforms,
-  getDebugTableForVertexArray,
-  getDebugTableForProgramConfiguration
-} from '@luma.gl/webgl';
-import ProgramManager from './program-manager';
-import {getBuffersFromGeometry} from './model-utils';
-
-const LOG_DRAW_PRIORITY = 2;
-const LOG_DRAW_TIMEOUT = 10000;
-
-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?: string[];
-  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
+import type {Device, Buffer, RenderPipelineProps, RenderPass, Binding} from '@luma.gl/api';
+import {RenderPipeline, Shader, cast} from '@luma.gl/api';
+import type { ShaderModule } from '@luma.gl/shadertools';
+import type Geometry from '../geometry/geometry';
+import {getAttributeBuffersFromGeometry, getIndexBufferFromGeometry} from './model-utils';
+import PipelineFactory from './pipeline-factory';
+
+export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs'> & {
+  // Model also accepts a string
+  vs?: {glsl?: string; wgsl?: string} | string;
+  fs?: {glsl?: string; wgsl?: string} | string;
+  modules?: ShaderModule[];
+  moduleSettings?: Record<string, Record<string, any>>;
+  geometry?: Geometry;
 };
 
-
-export type ModelDrawOptions = {
-  moduleSettings?;
-  framebuffer?;
-  uniforms?;
-  attributes?;
-  transformFeedback?;
-  parameters?;
-  vertexArray?;
+const DEFAULT_MODEL_PROPS: Required<ModelProps> = {
+  ...RenderPipeline._DEFAULT_PROPS,
+  vs: undefined,
+  fs: undefined,
+  id: 'unnamed',
+  handle: undefined,
+  userData: {},
+  modules: [],
+  moduleSettings: {},
+  geometry: undefined
 };
 
-/* 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
-}
-*/
-
+/** v9 API */
 export default class Model {
   readonly device: Device;
-  readonly gl: WebGLRenderingContext;
-
+  readonly pipeline: RenderPipeline;
   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;
+  readonly vs: string;
+  readonly fs: string | undefined;
+  readonly topology: string;
+  readonly vertexCount;
+  props: Required<ModelProps>;
 
-  // 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 = {};
+  private _getModuleUniforms: (props?: Record<string, Record<string, any>>) => Record<string, any>;
 
-  constructor(device: Device, props?: ModelProps);
-  /* @deprecated */
-  constructor(gl: WebGLRenderingContext, props?: ModelProps);
-  constructor(device, props: ModelProps = {}) {
-    // Deduce a helpful id
-    const {id = uid('model')} = props;
-    this.id = id;
-    const webglDevice = WebGLDevice.attach(device);
-    this.device = webglDevice;
-    this.gl = webglDevice.gl;
-    this.id = props.id || uid('Model');
-    this.initialize(props);
-  }
-
-  initialize(props: ModelProps) {
-    this.props = {};
-
-    this.programManager = props.programManager || ProgramManager.getDefaultProgramManager(this.device);
-    this._programManagerState = -1;
-    this._managedProgram = false;
-
-    const {
-      program = null,
-      vs,
-      fs,
-      modules,
-      defines,
-      inject,
-      varyings,
-      bufferMode,
-      transpileToGLSL100
-    } = props;
-
-    this.programProps = {
-      program,
-      modules,
-      vs,
-      fs,
-      defines,
-      inject,
-      varyings,
-      bufferMode,
-      transpileToGLSL100
-    };
-    this.program = null;
-    this.vertexArray = null;
-    this._programDirty = true;
-
-    // Initialize state
-    this.userData = {};
-    this.needsRedraw = true;
-
-    // Attributes and buffers
-    // Model manages auto Buffer creation from typed arrays
-    this._attributes = {}; // All attributes
-    this.attributes = {}; // User defined attributes
-
-    // Model manages uniform animation
-    this.uniforms = {};
-
-    // picking options
-    this.pickable = true;
-
-    this._checkProgram();
-
-    this.setUniforms(
-      Object.assign(
-        {},
-        this.getModuleUniforms(props.moduleSettings) // Get unforms for supplied parameters
-      )
-    );
-
-    this.drawMode = props.drawMode !== undefined ? props.drawMode : GL.TRIANGLES;
-    this.vertexCount = props.vertexCount || 0;
-
-    // Track buffers created by setGeometry
-    this.geometryBuffers = {};
-
-    // geometry might have set drawMode and vertexCount
-    this.isInstanced = props.isInstanced || props.instanced || props.instanceCount > 0;
-
-    this._setModelProps(props);
-
-    // TODO - just to unbreak deck.gl 7.0-beta, remove as soon as updated
-    this.geometry = {};
-
-    // assert(program || program instanceof Program);
-    assert(this.drawMode !== undefined && Number.isFinite(this.vertexCount), ERR_MODEL_PARAMS);
-  }
-
-  setProps(props) {
-    this._setModelProps(props);
-  }
-
-  destroy(): void {
-    // delete all attributes created by this model
-    // TODO - should buffer deletes be handled by vertex array?
-    for (const key in this._attributes) {
-      if (this._attributes[key] !== this.attributes[key]) {
-        this._attributes[key].delete();
-      }
-    }
+  constructor(device: Device, props: ModelProps) {
+    this.props = {...DEFAULT_MODEL_PROPS, ...props};
+    props = this.props;
+    this.id = props.id;
+    this.device = device;
 
-    if (this._managedProgram) {
-      this.programManager.release(this.program);
-      this._managedProgram = false;
+    // Create the pipeline
+    this.vs = getShaderSource(this.device, props.vs);
+    if (props.fs) {
+      this.fs = getShaderSource(this.device, props.fs);
     }
 
-    this.vertexArray.delete();
-
-    this._deleteGeometryBuffers();
-  }
-
-  /** @deprecated Use .destroy() */
-  delete(): void {
-    this.destroy();
-  }
-
-  // GETTERS
+    this.vertexCount = this.props.vertexCount;
+    this.topology = this.props.topology;
 
-  getDrawMode() {
-    return this.drawMode;
-  }
-
-  getVertexCount(): number {
-    return this.vertexCount;
-  }
-
-  getInstanceCount(): number {
-    return this.instanceCount;
-  }
+    if (this.props.geometry) {
+      this.vertexCount = this.props.geometry.vertexCount;
+      this.topology = this.props.geometry.topology;
+    }
 
-  getAttributes() {
-    return this.attributes;
-  }
+    const {renderPipeline, getUniforms} = PipelineFactory.getDefaultPipelineFactory(this.device).createRenderPipeline({
+      ...this.props,
+      vs: this.vs,
+      fs: this.fs,
+      topology: this.topology,
+      parameters: props.parameters,
+      // Geometry in the vertex shader!
+      // @ts-expect-error
+      layout: props.layout
+    });
 
-  getProgram(): Program {
-    return this.program;
-  }
+    this.pipeline = renderPipeline;
+    this._getModuleUniforms = getUniforms;
 
-  setProgram(props): void {
-    const {program, vs, fs, modules, defines, inject, varyings, bufferMode, transpileToGLSL100} =
-      props;
-    this.programProps = {
-      program,
-      vs,
-      fs,
-      modules,
-      defines,
-      inject,
-      varyings,
-      bufferMode,
-      transpileToGLSL100
-    };
-    this._programDirty = true;
+    if (this.props.geometry) {
+      this._setGeometry(this.props.geometry);
+    }
+    this.setUniforms(this._getModuleUniforms()) // Get all default module uniforms
+    this.setProps(this.props);
   }
 
-  getUniforms() {
-    return this.uniforms;
+  destroy(): void {
+    this.pipeline.destroy();
   }
 
-  // SETTERS
-
-  setDrawMode(drawMode): this {
-    this.drawMode = drawMode;
+  draw(renderPass?: RenderPass): this {
+    this.pipeline.draw({
+      renderPass,
+      vertexCount: this.vertexCount,
+      instanceCount: this.props.instanceCount
+    });
     return this;
   }
 
-  setVertexCount(vertexCount): this {
-    assert(Number.isFinite(vertexCount));
-    this.vertexCount = vertexCount;
+  setProps(props: ModelProps): this {
+    if (props.indices) {
+      this.setIndexBuffer(props.indices);
+    }
+    if (props.attributes) {
+      this.setAttributes(props.attributes);
+    }
+    if (props.bindings) {
+      this.setBindings(props.bindings);
+    }
+    if (props.uniforms) {
+      this.setUniforms(props.uniforms);
+    }
+    if (props.moduleSettings) {
+      this.updateModuleSettings(props.moduleSettings);
+    }
     return this;
   }
 
-  setInstanceCount(instanceCount): this {
-    assert(Number.isFinite(instanceCount));
-    this.instanceCount = instanceCount;
+  updateModuleSettings(props: Record<string, any>): this {
+    const uniforms = this._getModuleUniforms(props);
+    this.setUniforms(uniforms);
     return this;
   }
 
-  setGeometry(geometry): this {
-    this.drawMode = geometry.drawMode;
-    this.vertexCount = geometry.getVertexCount();
-
-    this._deleteGeometryBuffers();
-
-    this.geometryBuffers = getBuffersFromGeometry(this.gl, geometry);
-    this.vertexArray.setAttributes(this.geometryBuffers);
+  setIndexBuffer(indices: Buffer): this {
+    this.pipeline.setIndexBuffer(indices);
+    // this._indices = indices;
     return this;
   }
 
-  setAttributes(attributes = {}): this {
-    // Avoid setting needsRedraw if no attributes
-    if (isObjectEmpty(attributes)) {
-      return this;
-    }
-
-    const normalizedAttributes = {};
-    for (const name in attributes) {
-      const attribute = attributes[name];
-      // The `getValue` call provides support for deck.gl `Attribute` class
-      // TODO - remove once deck refactoring completes
-      normalizedAttributes[name] = attribute.getValue ? attribute.getValue() : attribute;
-    }
-
-    this.vertexArray.setAttributes(normalizedAttributes);
+  setAttributes(attributes: Record<string, Buffer>): this {
+    this.pipeline.setAttributes(attributes);
+    Object.assign(this.props.attributes, attributes);
     return this;
   }
 
-  // TODO - should actually set the uniforms
-  setUniforms(uniforms = {}): this {
-    Object.assign(this.uniforms, uniforms);
+  /** Set the bindings */
+  setBindings(bindings: Record<string, Binding>): this {
+    this.pipeline.setBindings(bindings);
+    Object.assign(this.props.bindings, bindings);
     return this;
   }
 
-  getModuleUniforms(opts?) {
-    this._checkProgram();
-
-    const getUniforms = this.programManager.getUniforms(this.program);
-
-    if (getUniforms) {
-      return getUniforms(opts);
-    }
-
-    return {};
-  }
-
-  updateModuleSettings(opts?): this {
-    const uniforms = this.getModuleUniforms(opts || {});
-    return this.setUniforms(uniforms);
-  }
-
-  // DRAW CALLS
-
-  clear(opts): this {
-    clear(this.program.gl, opts);
+  setUniforms(uniforms: Record<string, any>): this {
+    this.pipeline.setUniforms(uniforms);
+    Object.assign(this.props.uniforms, uniforms);
     return this;
   }
 
-  draw(opts: ModelDrawOptions = {}): boolean {
-    // Lazy update program and vertex array
-    this._checkProgram();
-
-    const {
-      moduleSettings = null,
-      framebuffer,
-      uniforms = {},
-      attributes = {},
-      transformFeedback = this.transformFeedback,
-      parameters = {},
-      vertexArray = this.vertexArray
-    } = opts;
-
-    // Update model with any just provided attributes, settings or uniforms
-    this.setAttributes(attributes);
-    this.updateModuleSettings(moduleSettings);
-    this.setUniforms(uniforms);
+  _setGeometry(geometry: Geometry): void {
+    // this._deleteGeometryBuffers();
 
-    let logPriority;
+    const geometryBuffers = getAttributeBuffersFromGeometry(this.device, geometry);
+    this.setAttributes(geometryBuffers);
 
-    if (log.priority >= LOG_DRAW_PRIORITY) {
-      logPriority = this._logDrawCallStart(LOG_DRAW_PRIORITY);
+    const indexBuffer = getIndexBufferFromGeometry(this.device, geometry);
+    if (indexBuffer) {
+      this.setIndexBuffer(indexBuffer);
     }
-
-    const drawParams = this.vertexArray.getDrawParams();
-    const {
-      isIndexed = drawParams.isIndexed,
-      indexType = drawParams.indexType,
-      indexOffset = drawParams.indexOffset,
-      vertexArrayInstanced = drawParams.isInstanced
-    } = this.props;
-
-    if (vertexArrayInstanced && !this.isInstanced) {
-      log.warn('Found instanced attributes on non-instanced model', this.id)();
-    }
-
-    const {isInstanced, instanceCount} = this;
-
-    const {onBeforeRender = NOOP, onAfterRender = NOOP} = this.props;
-
-    onBeforeRender();
-
-    this.program.setUniforms(this.uniforms);
-
-    const didDraw = this.program.draw(
-      Object.assign(DRAW_PARAMS, opts, {
-        logPriority,
-        uniforms: null, // Already set (may contain "function values" not understood by Program)
-        framebuffer,
-        parameters,
-        drawMode: this.getDrawMode(),
-        vertexCount: this.getVertexCount(),
-        vertexArray,
-        transformFeedback,
-        isIndexed,
-        indexType,
-        isInstanced,
-        instanceCount,
-        offset: isIndexed ? indexOffset : 0
-      })
-    );
-
-    onAfterRender();
-
-    if (log.priority >= LOG_DRAW_PRIORITY) {
-      this._logDrawCallEnd(logPriority, vertexArray, framebuffer);
-    }
-
-    return didDraw;
-  }
-
-  // Draw call for transform feedback, TBD...
-  transform(opts: ModelDrawOptions = {}): this {
-    // @ts-expect-error
-    const {discard = true, feedbackBuffers, unbindModels = []} = opts;
-
-    let {parameters} = opts;
-
-    if (feedbackBuffers) {
-      this._setFeedbackBuffers(feedbackBuffers);
-    }
-
-    if (discard) {
-      parameters = Object.assign({}, parameters, {[GL.RASTERIZER_DISCARD]: discard});
-    }
-
-    unbindModels.forEach((model) => model.vertexArray.unbindBuffers());
-    try {
-      this.draw(Object.assign({}, opts, {parameters}));
-    } finally {
-      unbindModels.forEach((model) => model.vertexArray.bindBuffers());
-    }
-
-    return this;
   }
+}
 
-  // DEPRECATED METHODS
-
-  render(uniforms = {}): boolean {
-    log.warn('Model.render() is deprecated. Use Model.setUniforms() and Model.draw()')();
-    return this.setUniforms(uniforms).draw();
-  }
-
-  // PRIVATE METHODS
-
-  _setModelProps(props): void {
-    Object.assign(this.props, props);
-
-    if ('uniforms' in props) {
-      this.setUniforms(props.uniforms);
-    }
-
-    if ('pickable' in props) {
-      this.pickable = props.pickable;
-    }
-
-    if ('instanceCount' in props) {
-      this.instanceCount = props.instanceCount;
-    }
-    if ('geometry' in props) {
-      this.setGeometry(props.geometry);
-    }
-
-    // webgl settings
-    if ('attributes' in props) {
-      this.setAttributes(props.attributes);
-    }
-    if ('_feedbackBuffers' in props) {
-      this._setFeedbackBuffers(props._feedbackBuffers);
-    }
+/** Create a shader from the different overloads */
+function getShaderSource(device: Device, shader: string | {glsl?: string; wgsl?: string}): string {
+  // TODO - detect WGSL/GLSL and throw an error if not supported
+  if (typeof shader === 'string') {
+    return shader;
   }
 
-  _checkProgram(): void {
-    const needsUpdate =
-      this._programDirty || this.programManager.stateHash !== this._programManagerState;
-
-    if (!needsUpdate) {
-      return;
-    }
-
-    let {program} = this.programProps;
-
-    if (program) {
-      this._managedProgram = false;
-    } else {
-      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,
-        defines,
-        varyings,
-        bufferMode,
-        transpileToGLSL100
-      });
-      if (this.program && this._managedProgram) {
-        this.programManager.release(this.program);
+  switch (device.info.type) {
+    case 'webgpu':
+      if (shader?.wgsl) {
+        return shader.wgsl;
       }
-      this._programManagerState = this.programManager.stateHash;
-      this._managedProgram = true;
-    }
-
-    assert(program instanceof Program, 'Model needs a program');
+      throw new Error('WebGPU does not support GLSL shaders');
 
-    this._programDirty = false;
-
-    if (program === this.program) {
-      return;
-    }
-
-    this.program = program;
-
-    if (this.vertexArray) {
-      this.vertexArray.setProps({program: this.program, attributes: this.vertexArray.attributes});
-    } else {
-      this.vertexArray = new VertexArray(this.gl, {program: this.program});
-    }
-
-    // Make sure we have some reasonable default uniforms in place
-    this.setUniforms(
-      Object.assign(
-        {},
-        this.getModuleUniforms() // Get all default uniforms,
-      )
-    );
-  }
-
-  _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.destroy();
+    default:
+      if (shader?.glsl) {
+        return shader.glsl;
       }
-    }
-  }
-
-  // Updates (evaluates) all function valued uniforms based on a new set of animationProps
-  // experimental
-  _setAnimationProps(animationProps): void {
-    if (this.animated) {
-      assert(animationProps, 'Model.draw(): animated uniforms but no animationProps');
-      // const animatedUniforms = this._evaluateAnimateUniforms(animationProps);
-      // Object.assign(this.uniforms, animatedUniforms);
-    }
-  }
-
-  // Transform Feedback
-
-  _setFeedbackBuffers(feedbackBuffers = {}): this {
-    // Avoid setting needsRedraw if no feedbackBuffers
-    if (isObjectEmpty(feedbackBuffers)) {
-      return this;
-    }
-
-    const {gl} = this.program;
-    this.transformFeedback =
-      this.transformFeedback ||
-      new TransformFeedback(gl, {
-        program: this.program
-      });
-
-    this.transformFeedback.setBuffers(feedbackBuffers);
-    return this;
-  }
-
-  _logDrawCallStart(logLevel: number): number {
-    const logDrawTimeout = logLevel > 3 ? 0 : LOG_DRAW_TIMEOUT;
-    if (Date.now() - this.lastLogTime < logDrawTimeout) {
-      return undefined;
-    }
-
-    this.lastLogTime = Date.now();
-
-    log.group(LOG_DRAW_PRIORITY, `>>> DRAWING MODEL ${this.id}`, {collapsed: log.level <= 2})();
-
-    return logLevel;
-  }
-
-  _logDrawCallEnd(logLevel, vertexArray, uniforms, framebuffer?): void {
-    // HACK: logLevel === undefined means logDrawCallStart didn't run
-    if (logLevel === undefined) {
-      return;
-    }
-
-    const attributeTable = getDebugTableForVertexArray({
-      vertexArray,
-      header: `${this.id} attributes`,
-      // @ts-expect-error
-      attributes: this._attributes
-    });
-
-    const {
-      table: uniformTable,
-      unusedTable,
-      unusedCount
-    } = getDebugTableForUniforms({
-      header: `${this.id} uniforms`,
-      program: this.program,
-      uniforms: Object.assign({}, this.program.uniforms, uniforms)
-    });
-
-    // log missing uniforms
-    const {table: missingTable, count: missingCount} = getDebugTableForUniforms({
-      header: `${this.id} uniforms`,
-      program: this.program,
-      uniforms: Object.assign({}, this.program.uniforms, uniforms),
-      undefinedOnly: true
-    });
-
-    if (missingCount > 0) {
-      log.log('MISSING UNIFORMS', Object.keys(missingTable))();
-      // log.table(logLevel, missingTable)();
-    }
-    if (unusedCount > 0) {
-      log.log('UNUSED UNIFORMS', Object.keys(unusedTable))();
-      // log.log(logLevel, 'Unused uniforms ', unusedTable)();
-    }
-
-    const configTable = getDebugTableForProgramConfiguration(this.vertexArray.configuration);
-
-    log.table(logLevel, attributeTable)();
-
-    log.table(logLevel, uniformTable)();
-
-    log.table(logLevel + 1, configTable)();
-
-    if (framebuffer) {
-      framebuffer.log({logLevel: LOG_DRAW_PRIORITY, message: `Rendered to ${framebuffer.id}`});
-    }
-
-    log.groupEnd(LOG_DRAW_PRIORITY)();
+      throw new Error('WebGL does not support WGSL shaders');
   }
 }