7173933498

Committed 11 Dec 2023 10:05PM UTC coverage: 72.416% (-0.2%) from 72.575%

Build # 7173933498

Build Type

Pull #1858

github

Committed by

web-flow

Commit Message

Merge 794cb4f5a into caff0a0a5

Pull Request Pull Request #1858: feat(webgl): New TransformFeedback resource

Run Details

1235 of 1671 branches covered (0.0%)

Branch coverage included in aggregate %.

158 of 341 new or added lines in 13 files covered. (46.33%)

1 existing line in 1 file now uncovered.

20867 of 28850 relevant lines covered (72.33%)

16.4 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.8

/modules/engine/src/model/model.ts

// luma.gl, MIT license
// Copyright (c) vis.gl contributors

import type {
  TypedArray,
  RenderPipelineProps,
  RenderPipelineParameters,
  BufferLayout,
  VertexArray,
  AttributeInfo,
  TransformFeedback
} from '@luma.gl/core';
import type {Binding, UniformValue, PrimitiveTopology} from '@luma.gl/core';
import {
  Device,
  Buffer,
  RenderPipeline,
  RenderPass,
  log,
  uid,
  deepEqual,
  splitUniformsAndBindings
} from '@luma.gl/core';
import {getAttributeInfosFromLayouts} from '@luma.gl/core';
import type {ShaderModule, PlatformInfo} from '@luma.gl/shadertools';
import {ShaderAssembler} from '@luma.gl/shadertools';
import type {Geometry} from '../geometry/geometry';
import {GPUGeometry, makeGPUGeometry} from '../geometry/gpu-geometry';
import {PipelineFactory} from '../lib/pipeline-factory';

export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs'> & {
  // Model also accepts a string shaders
  vs: {glsl?: string; wgsl?: string} | string | null;
  fs: {glsl?: string; wgsl?: string} | string | null;
  /** shadertool shader modules (added to shader code) */
  modules?: ShaderModule[];
  /** Shadertool module defines (configures shader code)*/
  defines?: Record<string, string | number | boolean>;
  // TODO - injections, hooks etc?

  /** pipeline factory to use to create render pipelines. Defaults to default factory for the device */
  pipelineFactory?: PipelineFactory;
  /** Shader assembler. Defaults to the ShaderAssembler.getShaderAssembler() */
  shaderAssembler?: ShaderAssembler;

  /** Parameters that are built into the pipeline */
  parameters?: RenderPipelineParameters;

  /** Geometry */
  geometry?: GPUGeometry | Geometry | null;

  /** Vertex count */
  vertexCount?: number;
  /** instance count */
  instanceCount?: number;

  indexBuffer?: Buffer | null;
  /** @note this is really a map of buffers, not a map of attributes */
  attributes?: Record<string, Buffer>;
  /**   */
  constantAttributes?: Record<string, TypedArray>;

  transformFeedback?: TransformFeedback;

  /** Mapped uniforms for shadertool modules */
  moduleSettings?: Record<string, Record<string, any>>;
};

/**
 * v9 Model API
 * A model
 * - automatically reuses pipelines (programs) when possible
 * - automatically rebuilds pipelines if necessary to accommodate changed settings
 * shadertools integration
 * - accepts modules and performs shader transpilation
 */
export class Model {
  static defaultProps: Required<ModelProps> = {
    ...RenderPipeline.defaultProps,
    vs: null,
    fs: null,
    id: 'unnamed',
    handle: undefined,
    userData: {},
    defines: {},
    modules: [],
    moduleSettings: {},
    geometry: null,
    indexBuffer: null,
    attributes: {},
    constantAttributes: {},

    pipelineFactory: undefined!,
    transformFeedback: undefined,
    shaderAssembler: ShaderAssembler.getDefaultShaderAssembler()
  };

  readonly device: Device;
  readonly id: string;
  readonly vs: string;
  readonly fs: string;
  readonly pipelineFactory: PipelineFactory;
  userData: {[key: string]: any} = {};

  // Fixed properties (change can trigger pipeline rebuild)

  /** The render pipeline GPU parameters, depth testing etc */
  parameters: RenderPipelineParameters;

  /** The primitive topology */
  topology: PrimitiveTopology;
  /** Buffer layout */
  bufferLayout: BufferLayout[];

  // Dynamic properties

  /** Vertex count */
  vertexCount: number;
  /** instance count */
  instanceCount: number = 0;

  /** Index buffer */
  indexBuffer: Buffer | null = null;
  /** Buffer-valued attributes */
  bufferAttributes: Record<string, Buffer> = {};
  /** Constant-valued attributes */
  constantAttributes: Record<string, TypedArray> = {};
  /** Bindings (textures, samplers, uniform buffers) */
  bindings: Record<string, Binding> = {};
  /** Sets uniforms @deprecated Use uniform buffers and setBindings() for portability*/
  uniforms: Record<string, UniformValue> = {};

  /** The underlying GPU "program". @note May be recreated if parameters change */
  pipeline: RenderPipeline;

  /**
   * VertexArray
   * @note not implemented: if bufferLayout is updated, vertex array has to be rebuilt!
   * @todo - allow application to define multiple vertex arrays?
   * */
  vertexArray: VertexArray;

  /** TransformFeedback, WebGL 2 only. */
  transformFeedback: TransformFeedback | null = null;

  _pipelineNeedsUpdate: string | false = 'newly created';
  _attributeInfos: Record<string, AttributeInfo> = {};
  _gpuGeometry: GPUGeometry | null = null;
  private _getModuleUniforms: (props?: Record<string, Record<string, any>>) => Record<string, any>;
  private props: Required<ModelProps>;

  constructor(device: Device, props: ModelProps) {
    this.props = {...Model.defaultProps, ...props};
    props = this.props;
    this.id = props.id || uid('model');
    this.device = device;

    Object.assign(this.userData, props.userData);

    /** Create a shadertools platform info from the Device */
    const platformInfo: PlatformInfo = {
      type: device.info.type,
      shaderLanguage: device.info.shadingLanguages[0],
      gpu: device.info.gpu,
      features: device.features
    };

    const {vs, fs, getUniforms} = this.props.shaderAssembler.assembleShaders(
      platformInfo,
      this.props
    );
    this.vs = vs;
    this.fs = fs;
    this._getModuleUniforms = getUniforms;

    this.vertexCount = this.props.vertexCount;
    this.instanceCount = this.props.instanceCount;

    this.topology = this.props.topology;
    this.bufferLayout = this.props.bufferLayout;
    this.parameters = this.props.parameters;

    // Geometry, if provided, sets topology and vertex cound
    if (props.geometry) {
      this._gpuGeometry = this.setGeometry(props.geometry);
    }

    this.pipelineFactory =
      props.pipelineFactory || PipelineFactory.getDefaultPipelineFactory(this.device);

    // Create the pipeline
    // @note order is important
    this.pipeline = this._updatePipeline();

    this.vertexArray = device.createVertexArray({
      renderPipeline: this.pipeline
    });

    // Now we can apply geometry attributes
    if (this._gpuGeometry) {
      this._setGeometryAttributes(this._gpuGeometry);
    }

    // Apply any dynamic settings that will not trigger pipeline change
    if (props.vertexCount) {
      this.setVertexCount(props.vertexCount);
    }
    if (props.instanceCount) {
      this.setInstanceCount(props.instanceCount);
    }
    // @ts-expect-error
    if (props.indices) {
      throw new Error('Model.props.indices removed. Use props.indexBuffer');
    }
    if (props.indexBuffer) {
      this.setIndexBuffer(props.indexBuffer);
    }
    if (props.attributes) {
      this.setAttributes(props.attributes);
    }
    if (props.constantAttributes) {
      this.setConstantAttributes(props.constantAttributes);
    }
    if (props.bindings) {
      this.setBindings(props.bindings);
    }
    if (props.uniforms) {
      this.setUniforms(props.uniforms);
    }
    if (props.moduleSettings) {
      this.updateModuleSettings(props.moduleSettings);
    }
    if (props.transformFeedback) {
      this.transformFeedback = props.transformFeedback;
    }

    this.setUniforms(this._getModuleUniforms()); // Get all default module uniforms

    // Catch any access to non-standard props
    Object.seal(this);
  }

  destroy(): void {
    this.pipelineFactory.release(this.pipeline);
  }

  // Draw call

  draw(renderPass: RenderPass): void {
    // Check if the pipeline is invalidated
    // TODO - this is likely the worst place to do this from performance perspective. Perhaps add a predraw()?
    this.pipeline = this._updatePipeline();

    // Set pipeline state, we may be sharing a pipeline so we need to set all state on every draw
    // Any caching needs to be done inside the pipeline functions
    this.pipeline.setBindings(this.bindings);
    this.pipeline.setUniforms(this.uniforms);

    this.pipeline.draw({
      renderPass,
      vertexArray: this.vertexArray,
      vertexCount: this.vertexCount,
      instanceCount: this.instanceCount,
      transformFeedback: this.transformFeedback
    });
  }

  // Update fixed fields (can trigger pipeline rebuild)

  /**
   * Updates the optional geometry
   * Geometry, set topology and bufferLayout
   * @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU
   */
  setGeometry(geometry: GPUGeometry | Geometry): GPUGeometry {
    const gpuGeometry = geometry && makeGPUGeometry(this.device, geometry);
    this.setTopology(gpuGeometry.topology || 'triangle-list');
    this.bufferLayout = mergeBufferLayouts(this.bufferLayout, gpuGeometry.bufferLayout);
    if (this.vertexArray) {
      this._setGeometryAttributes(gpuGeometry);
    }
    return gpuGeometry;
  }

  /**
   * Updates the optional geometry attributes
   * Geometry, sets several attributes, indexBuffer, and also vertex count
   * @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU
   */
  _setGeometryAttributes(gpuGeometry: GPUGeometry): void {
    // TODO - delete previous geometry?
    this.vertexCount = gpuGeometry.vertexCount;
    this.setAttributes(gpuGeometry.attributes);
    this.setIndexBuffer(gpuGeometry.indices);
  }

  /**
   * Updates the primitive topology ('triangle-list', 'triangle-strip' etc).
   * @note Triggers a pipeline rebuild / pipeline cache fetch on WebGPU
   */
  setTopology(topology: PrimitiveTopology): void {
    if (topology !== this.topology) {
      this.topology = topology;
      this._setPipelineNeedsUpdate('topology');
    }
  }

  /**
   * Updates the buffer layout.
   * @note Triggers a pipeline rebuild / pipeline cache fetch on WebGPU
   */
  setBufferLayout(bufferLayout: BufferLayout[]): void {
    this.bufferLayout = this._gpuGeometry
      ? mergeBufferLayouts(bufferLayout, this._gpuGeometry.bufferLayout)
      : bufferLayout;
    this._setPipelineNeedsUpdate('bufferLayout');

    // Recreate the pipeline
    this.pipeline = this._updatePipeline();

    // vertex array needs to be updated if we update buffer layout,
    // but not if we update parameters
    this.vertexArray = this.device.createVertexArray({
      renderPipeline: this.pipeline
    });

    // Reapply geometry attributes to the new vertex array
    if (this._gpuGeometry) {
      this._setGeometryAttributes(this._gpuGeometry);
    }
  }

  /**
   * Set GPU parameters.
   * @note Can trigger a pipeline rebuild / pipeline cache fetch.
   * @param parameters
   */
  setParameters(parameters: RenderPipelineParameters) {
    if (!deepEqual(parameters, this.parameters, 2)) {
      this.parameters = parameters;
      this._setPipelineNeedsUpdate('parameters');
    }
  }

  // Update dynamic fields

  /**
   * Updates the vertex count (used in draw calls)
   * @note Any attributes with stepMode=vertex need to be at least this big
   */
  setVertexCount(vertexCount: number): void {
    this.vertexCount = vertexCount;
  }

  /**
   * Updates the instance count (used in draw calls)
   * @note Any attributes with stepMode=instance need to be at least this big
   */
  setInstanceCount(instanceCount: number): void {
    this.instanceCount = instanceCount;
  }

  /**
   * Updates shader module settings (which results in bindings & uniforms being set)
   */
  setShaderModuleProps(props: Record<string, any>): void {
    const {bindings, uniforms} = splitUniformsAndBindings(this._getModuleUniforms(props));
    Object.assign(this.bindings, bindings);
    Object.assign(this.uniforms, uniforms);
  }

  /**
   * Updates optional transform feedback. WebGL 2 only.
   */
  setTransformFeedback(transformFeedback: TransformFeedback | null): void {
    this.transformFeedback = transformFeedback;
  }

  /**
   * @deprecated Updates shader module settings (which results in uniforms being set)
   */
  updateModuleSettings(props: Record<string, any>): void {
    this.setShaderModuleProps(props);
  }

  /**
   * Sets bindings (textures, samplers, uniform buffers)
   */
  setBindings(bindings: Record<string, Binding>): void {
    Object.assign(this.bindings, bindings);
  }

  /**
   * Sets individual uniforms
   * @deprecated WebGL only, use uniform buffers for portability
   * @param uniforms
   * @returns self for chaining
   */
  setUniforms(uniforms: Record<string, UniformValue>): void {
    this.pipeline.setUniforms(uniforms);
    Object.assign(this.uniforms, uniforms);
  }

  /**
   * Sets the index buffer
   * @todo - how to unset it if we change geometry?
   */
  setIndexBuffer(indexBuffer: Buffer | null): void {
    this.vertexArray.setIndexBuffer(indexBuffer);
  }

  /**
   * Sets attributes (buffers)
   * @note Overrides any attributes previously set with the same name
   */
  setAttributes(buffers: Record<string, Buffer>): void {
    if (buffers.indices) {
      log.warn(
        `Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`
      );
    }
    for (const [bufferName, buffer] of Object.entries(buffers)) {
      const bufferLayout = this.bufferLayout.find(layout => layout.name === bufferName);
      if (!bufferLayout) {
        log.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)();
        continue; // eslint-disable-line no-continue
      }

      // For an interleaved attribute we may need to set multiple attributes
      const attributeNames = bufferLayout.attributes
        ? bufferLayout.attributes?.map(layout => layout.attribute)
        : [bufferLayout.name];
      let set = false;
      for (const attributeName of attributeNames) {
        const attributeInfo = this._attributeInfos[attributeName];
        if (attributeInfo) {
          this.vertexArray.setBuffer(attributeInfo.location, buffer);
          set = true;
        }
      }
      if (!set) {
        log.warn(
          `Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`
        )();
      }
    }
  }

  /**
   * Sets constant attributes
   * @note Overrides any attributes previously set with the same name
   * Constant attributes are only supported in WebGL, not in WebGPU
   * Any attribute that is disabled in the current vertex array object
   * is read from the context's global constant value for that attribute location.
   * @param constantAttributes
   */
  setConstantAttributes(attributes: Record<string, TypedArray>): void {
    for (const [attributeName, value] of Object.entries(attributes)) {
      const attributeInfo = this._attributeInfos[attributeName];
      if (attributeInfo) {
        this.vertexArray.setConstant(attributeInfo.location, value);
      } else {
        log.warn(
          `Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`
        )();
      }
    }
  }

  _setPipelineNeedsUpdate(reason: string): void {
    this._pipelineNeedsUpdate = this._pipelineNeedsUpdate || reason;
  }

  _updatePipeline(): RenderPipeline {
    if (this._pipelineNeedsUpdate) {
      if (this.pipeline) {
        log.log(
          1,
          `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`
        )();
      }
      this._pipelineNeedsUpdate = false;
      this.pipeline = this.device.createRenderPipeline({
        ...this.props,
        bufferLayout: this.bufferLayout,
        topology: this.topology,
        parameters: this.parameters,
        vs: this.device.createShader({id: '{$this.id}-vertex', stage: 'vertex', source: this.vs}),
        fs: this.fs
          ? this.device.createShader({
              id: '{$this.id}-fragment',
              stage: 'fragment',
              source: this.fs
            })
          : null
      });
      this._attributeInfos = getAttributeInfosFromLayouts(
        this.pipeline.shaderLayout,
        this.bufferLayout
      );
    }
    return this.pipeline;
  }
}

/** TODO - move to core, document add tests */
function mergeBufferLayouts(layouts1: BufferLayout[], layouts2: BufferLayout[]): BufferLayout[] {
  const layouts = [...layouts1];
  for (const attribute of layouts2) {
    const index = layouts.findIndex(attribute2 => attribute2.name === attribute.name);
    if (index < 0) {
      layouts.push(attribute);
    } else {
      layouts[index] = attribute;
    }
  }
  return layouts;
}

1	// luma.gl, MIT license	1✔
2	// Copyright (c) vis.gl contributors	1✔
3		1✔
4	import type {	1✔
5	TypedArray,	1✔
6	RenderPipelineProps,	1✔
7	RenderPipelineParameters,	1✔
8	BufferLayout,	1✔
9	VertexArray,	1✔
10	AttributeInfo,	1✔
11	TransformFeedback	1✔
12	} from '@luma.gl/core';	1✔
13	import type {Binding, UniformValue, PrimitiveTopology} from '@luma.gl/core';	1✔
14	import {	1✔
15	Device,	1✔
16	Buffer,	1✔
17	RenderPipeline,	1✔
18	RenderPass,	1✔
19	log,	1✔
20	uid,	1✔
21	deepEqual,	1✔
22	splitUniformsAndBindings	1✔
23	} from '@luma.gl/core';	1✔
24	import {getAttributeInfosFromLayouts} from '@luma.gl/core';	1✔
25	import type {ShaderModule, PlatformInfo} from '@luma.gl/shadertools';	1✔
26	import {ShaderAssembler} from '@luma.gl/shadertools';	1✔
27	import type {Geometry} from '../geometry/geometry';	1✔
28	import {GPUGeometry, makeGPUGeometry} from '../geometry/gpu-geometry';	1✔
29	import {PipelineFactory} from '../lib/pipeline-factory';	1✔
30		1✔
31	export type ModelProps = Omit<RenderPipelineProps, 'vs' \| 'fs'> & {	1✔
32	// Model also accepts a string shaders	1✔
33	vs: {glsl?: string; wgsl?: string} \| string \| null;	1✔
34	fs: {glsl?: string; wgsl?: string} \| string \| null;	1✔
35	/** shadertool shader modules (added to shader code) */	1✔
36	modules?: ShaderModule[];	1✔
37	/** Shadertool module defines (configures shader code)*/	1✔
38	defines?: Record<string, string \| number \| boolean>;	1✔
39	// TODO - injections, hooks etc?	1✔
40		1✔
41	/** pipeline factory to use to create render pipelines. Defaults to default factory for the device */	1✔
42	pipelineFactory?: PipelineFactory;	1✔
43	/** Shader assembler. Defaults to the ShaderAssembler.getShaderAssembler() */	1✔
44	shaderAssembler?: ShaderAssembler;	1✔
45		1✔
46	/** Parameters that are built into the pipeline */	1✔
47	parameters?: RenderPipelineParameters;	1✔
48		1✔
49	/** Geometry */	1✔
50	geometry?: GPUGeometry \| Geometry \| null;	1✔
51		1✔
52	/** Vertex count */	1✔
53	vertexCount?: number;	1✔
54	/** instance count */	1✔
55	instanceCount?: number;	1✔
56		1✔
57	indexBuffer?: Buffer \| null;	1✔
58	/** @note this is really a map of buffers, not a map of attributes */	1✔
59	attributes?: Record<string, Buffer>;	1✔
60	/** */	1✔
61	constantAttributes?: Record<string, TypedArray>;	1✔
62		1✔
63	transformFeedback?: TransformFeedback;	1✔
64		1✔
65	/** Mapped uniforms for shadertool modules */	1✔
66	moduleSettings?: Record<string, Record<string, any>>;	1✔
67	};	1✔
68		1✔
69	/**	1✔
70	* v9 Model API	1✔
71	* A model	1✔
72	* - automatically reuses pipelines (programs) when possible	1✔
73	* - automatically rebuilds pipelines if necessary to accommodate changed settings	1✔
74	* shadertools integration	1✔
75	* - accepts modules and performs shader transpilation	1✔
76	*/	1✔
77	export class Model {	1✔
78	static defaultProps: Required<ModelProps> = {	1✔
79	...RenderPipeline.defaultProps,	1✔
80	vs: null,	1✔
81	fs: null,	1✔
82	id: 'unnamed',	1✔
83	handle: undefined,	1✔
84	userData: {},	1✔
85	defines: {},	1✔
86	modules: [],	1✔
87	moduleSettings: {},	1✔
88	geometry: null,	1✔
89	indexBuffer: null,	1✔
90	attributes: {},	1✔
91	constantAttributes: {},	1✔
92		1✔
93	pipelineFactory: undefined!,	1✔
94	transformFeedback: undefined,	1✔
95	shaderAssembler: ShaderAssembler.getDefaultShaderAssembler()	1✔
96	};	1✔
97		1✔
98	readonly device: Device;	1✔
99	readonly id: string;	1✔
100	readonly vs: string;	1✔
101	readonly fs: string;	1✔
102	readonly pipelineFactory: PipelineFactory;	1✔
103	userData: {[key: string]: any} = {};	1✔
104		1✔
105	// Fixed properties (change can trigger pipeline rebuild)	1✔
106		1✔
107	/** The render pipeline GPU parameters, depth testing etc */	1✔
108	parameters: RenderPipelineParameters;	1✔
109		1✔
110	/** The primitive topology */	1✔
111	topology: PrimitiveTopology;	1✔
112	/** Buffer layout */	1✔
113	bufferLayout: BufferLayout[];	1✔
114		1✔
115	// Dynamic properties	1✔
116		1✔
117	/** Vertex count */	1✔
118	vertexCount: number;	1✔
119	/** instance count */	1✔
120	instanceCount: number = 0;	1✔
121		1✔
122	/** Index buffer */	1✔
123	indexBuffer: Buffer \| null = null;	1✔
124	/** Buffer-valued attributes */	1✔
125	bufferAttributes: Record<string, Buffer> = {};	1✔
126	/** Constant-valued attributes */	1✔
127	constantAttributes: Record<string, TypedArray> = {};	1✔
128	/** Bindings (textures, samplers, uniform buffers) */	1✔
129	bindings: Record<string, Binding> = {};	1✔
130	/** Sets uniforms @deprecated Use uniform buffers and setBindings() for portability*/	1✔
131	uniforms: Record<string, UniformValue> = {};	1✔
132		1✔
133	/** The underlying GPU "program". @note May be recreated if parameters change */	1✔
134	pipeline: RenderPipeline;	1✔
135		1✔
136	/**	1✔
137	* VertexArray	1✔
138	* @note not implemented: if bufferLayout is updated, vertex array has to be rebuilt!	1✔
139	* @todo - allow application to define multiple vertex arrays?	1✔
140	* */	1✔
141	vertexArray: VertexArray;	1✔
142		1✔
143	/** TransformFeedback, WebGL 2 only. */	1✔
144	transformFeedback: TransformFeedback \| null = null;	1✔
145		1✔
146	_pipelineNeedsUpdate: string \| false = 'newly created';	1✔
147	_attributeInfos: Record<string, AttributeInfo> = {};	1✔
148	_gpuGeometry: GPUGeometry \| null = null;	1✔
149	private _getModuleUniforms: (props?: Record<string, Record<string, any>>) => Record<string, any>;	1✔
150	private props: Required<ModelProps>;	1✔
151		1✔
152	constructor(device: Device, props: ModelProps) {	1✔
153	this.props = {...Model.defaultProps, ...props};	3✔
154	props = this.props;	3✔
155	this.id = props.id \|\| uid('model');	3!
156	this.device = device;	3✔
157		3✔
158	Object.assign(this.userData, props.userData);	3✔
159		3✔
160	/** Create a shadertools platform info from the Device */	3✔
161	const platformInfo: PlatformInfo = {	3✔
162	type: device.info.type,	3✔
163	shaderLanguage: device.info.shadingLanguages[0],	3✔
164	gpu: device.info.gpu,	3✔
165	features: device.features	3✔
166	};	3✔
167		3✔
168	const {vs, fs, getUniforms} = this.props.shaderAssembler.assembleShaders(	3✔
169	platformInfo,	3✔
170	this.props	3✔
171	);	3✔
172	this.vs = vs;	3✔
173	this.fs = fs;	3✔
174	this._getModuleUniforms = getUniforms;	3✔
175		3✔
176	this.vertexCount = this.props.vertexCount;	3✔
177	this.instanceCount = this.props.instanceCount;	3✔
178		3✔
179	this.topology = this.props.topology;	3✔
180	this.bufferLayout = this.props.bufferLayout;	3✔
181	this.parameters = this.props.parameters;	3✔
182		3✔
183	// Geometry, if provided, sets topology and vertex cound	3✔
184	if (props.geometry) {	3!
185	this._gpuGeometry = this.setGeometry(props.geometry);	×
186	}	×
187		3✔
188	this.pipelineFactory =	3✔
189	props.pipelineFactory \|\| PipelineFactory.getDefaultPipelineFactory(this.device);	3✔
190		3✔
191	// Create the pipeline	3✔
192	// @note order is important	3✔
193	this.pipeline = this._updatePipeline();	3✔
194		3✔
195	this.vertexArray = device.createVertexArray({	3✔
196	renderPipeline: this.pipeline	3✔
197	});	3✔
198		3✔
199	// Now we can apply geometry attributes	3✔
200	if (this._gpuGeometry) {	3!
201	this._setGeometryAttributes(this._gpuGeometry);	×
202	}	×
203		3✔
204	// Apply any dynamic settings that will not trigger pipeline change	3✔
205	if (props.vertexCount) {	3!
206	this.setVertexCount(props.vertexCount);	×
207	}	×
208	if (props.instanceCount) {	3!
209	this.setInstanceCount(props.instanceCount);	×
210	}	×
211	// @ts-expect-error	3✔
212	if (props.indices) {	3!
213	throw new Error('Model.props.indices removed. Use props.indexBuffer');	×
214	}	×
215	if (props.indexBuffer) {	3!
216	this.setIndexBuffer(props.indexBuffer);	×
217	}	×
218	if (props.attributes) {	3✔
219	this.setAttributes(props.attributes);	3✔
220	}	3✔
221	if (props.constantAttributes) {	3✔
222	this.setConstantAttributes(props.constantAttributes);	3✔
223	}	3✔
224	if (props.bindings) {	3✔
225	this.setBindings(props.bindings);	3✔
226	}	3✔
227	if (props.uniforms) {	3✔
228	this.setUniforms(props.uniforms);	3✔
229	}	3✔
230	if (props.moduleSettings) {	3✔
231	this.updateModuleSettings(props.moduleSettings);	3✔
232	}	3✔
233	if (props.transformFeedback) {	3!
NEW 234	this.transformFeedback = props.transformFeedback;	×
NEW 235	}	×
236		3✔
237	this.setUniforms(this._getModuleUniforms()); // Get all default module uniforms	3✔
238		3✔
239	// Catch any access to non-standard props	3✔
240	Object.seal(this);	3✔
241	}	3✔
242		1✔
243	destroy(): void {	1✔
244	this.pipelineFactory.release(this.pipeline);	×
245	}	×
246		1✔
247	// Draw call	1✔
248		1✔
249	draw(renderPass: RenderPass): void {	1✔
250	// Check if the pipeline is invalidated	×
251	// TODO - this is likely the worst place to do this from performance perspective. Perhaps add a predraw()?	×
252	this.pipeline = this._updatePipeline();	×
253		×
254	// Set pipeline state, we may be sharing a pipeline so we need to set all state on every draw	×
255	// Any caching needs to be done inside the pipeline functions	×
256	this.pipeline.setBindings(this.bindings);	×
257	this.pipeline.setUniforms(this.uniforms);	×
258		×
259	this.pipeline.draw({	×
260	renderPass,	×
261	vertexArray: this.vertexArray,	×
262	vertexCount: this.vertexCount,	×
NEW 263	instanceCount: this.instanceCount,	×
NEW 264	transformFeedback: this.transformFeedback	×
265	});	×
266	}	×
267		1✔
268	// Update fixed fields (can trigger pipeline rebuild)	1✔
269		1✔
270	/**	1✔
271	* Updates the optional geometry	1✔
272	* Geometry, set topology and bufferLayout	1✔
273	* @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU	1✔
274	*/	1✔
275	setGeometry(geometry: GPUGeometry \| Geometry): GPUGeometry {	1✔
276	const gpuGeometry = geometry && makeGPUGeometry(this.device, geometry);	×
277	this.setTopology(gpuGeometry.topology \|\| 'triangle-list');	×
278	this.bufferLayout = mergeBufferLayouts(this.bufferLayout, gpuGeometry.bufferLayout);	×
279	if (this.vertexArray) {	×
280	this._setGeometryAttributes(gpuGeometry);	×
281	}	×
282	return gpuGeometry;	×
283	}	×
284		1✔
285	/**	1✔
286	* Updates the optional geometry attributes	1✔
287	* Geometry, sets several attributes, indexBuffer, and also vertex count	1✔
288	* @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU	1✔
289	*/	1✔
290	_setGeometryAttributes(gpuGeometry: GPUGeometry): void {	1✔
291	// TODO - delete previous geometry?	×
292	this.vertexCount = gpuGeometry.vertexCount;	×
293	this.setAttributes(gpuGeometry.attributes);	×
294	this.setIndexBuffer(gpuGeometry.indices);	×
295	}	×
296		1✔
297	/**	1✔
298	* Updates the primitive topology ('triangle-list', 'triangle-strip' etc).	1✔
299	* @note Triggers a pipeline rebuild / pipeline cache fetch on WebGPU	1✔
300	*/	1✔
301	setTopology(topology: PrimitiveTopology): void {	1✔
302	if (topology !== this.topology) {	×
303	this.topology = topology;	×
304	this._setPipelineNeedsUpdate('topology');	×
305	}	×
306	}	×
307		1✔
308	/**	1✔
309	* Updates the buffer layout.	1✔
310	* @note Triggers a pipeline rebuild / pipeline cache fetch on WebGPU	1✔
311	*/	1✔
312	setBufferLayout(bufferLayout: BufferLayout[]): void {	1✔
313	this.bufferLayout = this._gpuGeometry	×
314	? mergeBufferLayouts(bufferLayout, this._gpuGeometry.bufferLayout)	×
315	: bufferLayout;	×
316	this._setPipelineNeedsUpdate('bufferLayout');	×
317		×
318	// Recreate the pipeline	×
319	this.pipeline = this._updatePipeline();	×
320		×
321	// vertex array needs to be updated if we update buffer layout,	×
322	// but not if we update parameters	×
323	this.vertexArray = this.device.createVertexArray({	×
324	renderPipeline: this.pipeline	×
325	});	×
326		×
327	// Reapply geometry attributes to the new vertex array	×
328	if (this._gpuGeometry) {	×
329	this._setGeometryAttributes(this._gpuGeometry);	×
330	}	×
331	}	×
332		1✔
333	/**	1✔
334	* Set GPU parameters.	1✔
335	* @note Can trigger a pipeline rebuild / pipeline cache fetch.	1✔
336	* @param parameters	1✔
337	*/	1✔
338	setParameters(parameters: RenderPipelineParameters) {	1✔
339	if (!deepEqual(parameters, this.parameters, 2)) {	×
340	this.parameters = parameters;	×
341	this._setPipelineNeedsUpdate('parameters');	×
342	}	×
343	}	×
344		1✔
345	// Update dynamic fields	1✔
346		1✔
347	/**	1✔
348	* Updates the vertex count (used in draw calls)	1✔
349	* @note Any attributes with stepMode=vertex need to be at least this big	1✔
350	*/	1✔
351	setVertexCount(vertexCount: number): void {	1✔
352	this.vertexCount = vertexCount;	×
353	}	×
354		1✔
355	/**	1✔
356	* Updates the instance count (used in draw calls)	1✔
357	* @note Any attributes with stepMode=instance need to be at least this big	1✔
358	*/	1✔
359	setInstanceCount(instanceCount: number): void {	1✔
360	this.instanceCount = instanceCount;	×
361	}	×
362		1✔
363	/**	1✔
364	* Updates shader module settings (which results in bindings & uniforms being set)	1✔
365	*/	1✔
366	setShaderModuleProps(props: Record<string, any>): void {	1✔
367	const {bindings, uniforms} = splitUniformsAndBindings(this._getModuleUniforms(props));	3✔
368	Object.assign(this.bindings, bindings);	3✔
369	Object.assign(this.uniforms, uniforms);	3✔
370	}	3✔
371		1✔
372	/**	1✔
373	* Updates optional transform feedback. WebGL 2 only.	1✔
374	*/	1✔
375	setTransformFeedback(transformFeedback: TransformFeedback \| null): void {	1✔
NEW 376	this.transformFeedback = transformFeedback;	×
NEW 377	}	×
378		1✔
379	/**	1✔
380	* @deprecated Updates shader module settings (which results in uniforms being set)	1✔
381	*/	1✔
382	updateModuleSettings(props: Record<string, any>): void {	1✔
383	this.setShaderModuleProps(props);	3✔
384	}	3✔
385		1✔
386	/**	1✔
387	* Sets bindings (textures, samplers, uniform buffers)	1✔
388	*/	1✔
389	setBindings(bindings: Record<string, Binding>): void {	1✔
390	Object.assign(this.bindings, bindings);	3✔
391	}	3✔
392		1✔
393	/**	1✔
394	* Sets individual uniforms	1✔
395	* @deprecated WebGL only, use uniform buffers for portability	1✔
396	* @param uniforms	1✔
397	* @returns self for chaining	1✔
398	*/	1✔
399	setUniforms(uniforms: Record<string, UniformValue>): void {	1✔
400	this.pipeline.setUniforms(uniforms);	6✔
401	Object.assign(this.uniforms, uniforms);	6✔
402	}	6✔
403		1✔
404	/**	1✔
405	* Sets the index buffer	1✔
406	* @todo - how to unset it if we change geometry?	1✔
407	*/	1✔
408	setIndexBuffer(indexBuffer: Buffer \| null): void {	1✔
409	this.vertexArray.setIndexBuffer(indexBuffer);	×
410	}	×
411		1✔
412	/**	1✔
413	* Sets attributes (buffers)	1✔
414	* @note Overrides any attributes previously set with the same name	1✔
415	*/	1✔
416	setAttributes(buffers: Record<string, Buffer>): void {	1✔
417	if (buffers.indices) {	3!
418	log.warn(	×
419	`Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`	×
420	);	×
421	}	×
422	for (const [bufferName, buffer] of Object.entries(buffers)) {	3!
423	const bufferLayout = this.bufferLayout.find(layout => layout.name === bufferName);	×
424	if (!bufferLayout) {	×
NEW 425	log.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)();	×
426	continue; // eslint-disable-line no-continue	×
427	}	×
428		×
429	// For an interleaved attribute we may need to set multiple attributes	×
430	const attributeNames = bufferLayout.attributes	×
431	? bufferLayout.attributes?.map(layout => layout.attribute)	×
432	: [bufferLayout.name];	×
433	let set = false;	×
434	for (const attributeName of attributeNames) {	×
435	const attributeInfo = this._attributeInfos[attributeName];	×
436	if (attributeInfo) {	×
437	this.vertexArray.setBuffer(attributeInfo.location, buffer);	×
438	set = true;	×
439	}	×
440	}	×
441	if (!set) {	×
442	log.warn(	×
443	`Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`	×
444	)();	×
445	}	×
446	}	×
447	}	3✔
448		1✔
449	/**	1✔
450	* Sets constant attributes	1✔
451	* @note Overrides any attributes previously set with the same name	1✔
452	* Constant attributes are only supported in WebGL, not in WebGPU	1✔
453	* Any attribute that is disabled in the current vertex array object	1✔
454	* is read from the context's global constant value for that attribute location.	1✔
455	* @param constantAttributes	1✔
456	*/	1✔
457	setConstantAttributes(attributes: Record<string, TypedArray>): void {	1✔
458	for (const [attributeName, value] of Object.entries(attributes)) {	3!
459	const attributeInfo = this._attributeInfos[attributeName];	×
460	if (attributeInfo) {	×
461	this.vertexArray.setConstant(attributeInfo.location, value);	×
462	} else {	×
463	log.warn(	×
464	`Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`	×
465	)();	×
466	}	×
467	}	×
468	}	3✔
469		1✔
470	_setPipelineNeedsUpdate(reason: string): void {	1✔
471	this._pipelineNeedsUpdate = this._pipelineNeedsUpdate \|\| reason;	×
472	}	×
473		1✔
474	_updatePipeline(): RenderPipeline {	1✔
475	if (this._pipelineNeedsUpdate) {	3✔
476	if (this.pipeline) {	3!
477	log.log(	×
478	1,	×
479	`Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`	×
480	)();	×
481	}	×
482	this._pipelineNeedsUpdate = false;	3✔
483	this.pipeline = this.device.createRenderPipeline({	3✔
484	...this.props,	3✔
485	bufferLayout: this.bufferLayout,	3✔
486	topology: this.topology,	3✔
487	parameters: this.parameters,	3✔
488	vs: this.device.createShader({id: '{$this.id}-vertex', stage: 'vertex', source: this.vs}),	3✔
489	fs: this.fs	3✔
490	? this.device.createShader({	3✔
491	id: '{$this.id}-fragment',	3✔
492	stage: 'fragment',	3✔
493	source: this.fs	3✔
494	})	3✔
495	: null	3!
496	});	3✔
497	this._attributeInfos = getAttributeInfosFromLayouts(	3✔
498	this.pipeline.shaderLayout,	3✔
499	this.bufferLayout	3✔
500	);	3✔
501	}	3✔
502	return this.pipeline;	3✔
503	}	3✔
504	}	1✔
505		1✔
506	/** TODO - move to core, document add tests */	1✔
507	function mergeBufferLayouts(layouts1: BufferLayout[], layouts2: BufferLayout[]): BufferLayout[] {	×
508	const layouts = [...layouts1];	×
509	for (const attribute of layouts2) {	×
510	const index = layouts.findIndex(attribute2 => attribute2.name === attribute.name);	×
511	if (index < 0) {	×
512	layouts.push(attribute);	×
513	} else {	×
514	layouts[index] = attribute;	×
515	}	×
516	}	×
517	return layouts;	×
518	}	×

visgl / luma.gl / 7173933498

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous