6744610589

Committed 03 Nov 2023 11:28AM UTC coverage: 77.543% (-0.02%) from 77.558%

Build # 6744610589

Build Type

Pull #1828

github

Committed by

web-flow

Commit Message

Merge 572af652a into 83478bba8

Pull Request Pull Request #1828: Bind framebuffer color attachment in render pipeline

Run Details

1548 of 2033 branches covered (0.0%)

Branch coverage included in aggregate %.

1 of 12 new or added lines in 1 file covered. (8.33%)

3 existing lines in 1 file now uncovered.

30662 of 39505 relevant lines covered (77.62%)

12.74 hits per line

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

41.8

/modules/webgl/src/adapter/resources/webgl-render-pipeline.ts

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

import type {UniformValue, RenderPipelineProps, Binding} from '@luma.gl/core';
import type {ShaderLayout, PrimitiveTopology} from '@luma.gl/core';
import type {RenderPass, VertexArray} from '@luma.gl/core';
import {RenderPipeline, cast, log} from '@luma.gl/core';
import {mergeShaderLayout} from '@luma.gl/core';
// import {mergeShaderLayout, getAttributeInfosFromLayouts} from '@luma.gl/core';
import {GL} from '@luma.gl/constants';

import {getShaderLayout} from '../helpers/get-shader-layout';
import {withDeviceAndGLParameters} from '../converters/device-parameters';
import {setUniform} from '../helpers/set-uniform';
// import {copyUniform, checkUniformValues} from '../../classes/uniforms';

import {WebGLDevice} from '../webgl-device';
import {WEBGLBuffer} from './webgl-buffer';
import {WEBGLShader} from './webgl-shader';
import {WEBGLFramebuffer} from './webgl-framebuffer';
import {WEBGLTexture} from './webgl-texture';
// import {WEBGLVertexArray} from './webgl-vertex-array';
import {WEBGLRenderPass} from './webgl-render-pass';

const LOG_PROGRAM_PERF_PRIORITY = 4;

/** Creates a new render pipeline */
export class WEBGLRenderPipeline extends RenderPipeline {
  /** The WebGL device that created this render pipeline */
  device: WebGLDevice;
  /** Handle to underlying WebGL program */
  handle: WebGLProgram;
  /** vertex shader */
  vs: WEBGLShader;
  /** fragment shader */
  fs: WEBGLShader;
  /** The layout extracted from shader by WebGL introspection APIs */
  introspectedLayout: ShaderLayout;

  /** Uniforms set on this model */
  uniforms: Record<string, UniformValue> = {};
  /** Bindings set on this model */
  bindings: Record<string, Binding> = {};
  /** WebGL varyings */
  varyings: string[] | null = null;

  _textureUniforms: Record<string, any> = {};
  _textureIndexCounter: number = 0;
  _uniformCount: number = 0;
  _uniformSetters: Record<string, Function> = {}; // TODO are these used?

  constructor(device: WebGLDevice, props: RenderPipelineProps) {
    super(device, props);
    this.device = device;
    this.handle = this.props.handle || this.device.gl.createProgram();
    this.device.setSpectorMetadata(this.handle, {id: this.props.id});

    // Create shaders if needed
    this.vs = cast<WEBGLShader>(props.vs);
    this.fs = cast<WEBGLShader>(props.fs);
    // assert(this.vs.stage === 'vertex');
    // assert(this.fs.stage === 'fragment');

    // Setup varyings if supplied
    // @ts-expect-error WebGL only
    const {varyings, bufferMode = GL.SEPARATE_ATTRIBS} = props;
    if (varyings && varyings.length > 0) {
      this.device.assertWebGL2();
      this.varyings = varyings;
      this.device.gl2?.transformFeedbackVaryings(this.handle, varyings, bufferMode);
    }

    this._compileAndLink();

    this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
    // Merge provided layout with introspected layout
    this.shaderLayout = mergeShaderLayout(this.introspectedLayout, props.shaderLayout);
    // Merge layout with any buffer map overrides
    // this.bufferLayout = props.bufferLayout || [];
    // this.shaderLayout = mergeBufferMap(this.shaderLayout, this.bufferLayout);
  }

  override destroy(): void {
    if (this.handle) {
      this.device.gl.deleteProgram(this.handle);
      // this.handle = null;
      this.destroyed = true;
    }
  }

  // setIndexBuffer(indexBuffer: Buffer): void {
  //   const webglBuffer = cast<WEBGLBuffer>(indexBuffer);
  //   this.vertexArrayObject.setElementBuffer(webglBuffer);
  //   this._indexBuffer = indexBuffer;
  // }

  // /** @todo needed for portable model */
  // setAttributes(attributes: Record<string, Buffer>): void {
  //   for (const [name, buffer] of Object.entries(attributes)) {
  //     const webglBuffer = cast<WEBGLBuffer>(buffer);
  //     const attribute = getAttributeLayout(this.layout, name);
  //     if (!attribute) {
  //       log.warn(
  //         `Ignoring buffer supplied for unknown attribute "${name}" in pipeline "${this.id}" (buffer "${buffer.id}")`
  //       )();
  //       continue;
  //     }
  //     const decoded = decodeVertexFormat(attribute.format);
  //     const {type: typeString, components: size, byteLength: stride, normalized, integer} = decoded;
  //     const divisor = attribute.stepMode === 'instance' ? 1 : 0;
  //     const type = getWebGLDataType(typeString);
  //     this.vertexArrayObject.setBuffer(attribute.location, webglBuffer, {
  //       size,
  //       type,
  //       stride,
  //       offset: 0,
  //       normalized,
  //       integer,
  //       divisor
  //     });
  //   }
  // }

  /**
   * Bindings include: textures, samplers and uniform buffers
   * @todo needed for portable model
   */
  setBindings(bindings: Record<string, Binding>): void {
    // if (log.priority >= 2) {
    //   checkUniformValues(uniforms, this.id, this._uniformSetters);
    // }

    for (const [name, value] of Object.entries(bindings)) {
      const binding = this.shaderLayout.bindings.find(binding => binding.name === name);
      if (!binding) {
        log.warn(`Unknown binding ${name} in render pipeline ${this.id}`)();
        continue; // eslint-disable-line no-continue
      }
      if (!value) {
        log.warn(`Unsetting binding ${name} in render pipeline ${this.id}`)();
      }
      switch (binding.type) {
        case 'uniform':
          // @ts-expect-error
          if (!(value instanceof WEBGLBuffer) && !(value.buffer instanceof WEBGLBuffer)) {
            throw new Error('buffer value');
          }
          break;
        case 'texture':
          if (!(value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
            throw new Error('texture value');
          }
          break;
        case 'sampler':
          log.warn(`Ignoring sampler ${name}`)();
          break;
        default:
          throw new Error(binding.type);
      }

      this.bindings[name] = value;
    }
  }

  setUniforms(uniforms: Record<string, UniformValue>) {
    // TODO - check against layout
    Object.assign(this.uniforms, uniforms);
  }

  /** @todo needed for portable model
   * @note The WebGL API is offers many ways to draw things
   * This function unifies those ways into a single call using common parameters with sane defaults
   */
  draw(options: {
    renderPass: RenderPass;
    /** vertex attributes */
    vertexArray: VertexArray;
    vertexCount?: number;
    indexCount?: number;
    instanceCount?: number;
    firstVertex?: number;
    firstIndex?: number;
    firstInstance?: number;
    baseVertex?: number;
  }): boolean {
    const {
      renderPass,
      vertexArray,
      vertexCount,
      // indexCount,
      instanceCount,
      firstVertex = 0
      // firstIndex,
      // firstInstance,
      // baseVertex
    } = options;

    const glDrawMode = getGLDrawMode(this.props.topology);
    const isIndexed: boolean = Boolean(vertexArray.indexBuffer);
    const glIndexType = (vertexArray.indexBuffer as WEBGLBuffer)?.glIndexType;
    const isInstanced: boolean = Number(instanceCount) > 0;

    // Avoid WebGL draw call when not rendering any data or values are incomplete
    // Note: async textures set as uniforms might still be loading.
    // Now that all uniforms have been updated, check if any texture
    // in the uniforms is not yet initialized, then we don't draw
    if (!this._areTexturesRenderable() || vertexCount === 0) {
      // (isInstanced && instanceCount === 0)
      return false;
    }

    this.device.gl.useProgram(this.handle);

    // Note: Rebinds constant attributes before each draw call
    vertexArray.bindBeforeRender(renderPass);

    const primitiveMode = getGLPrimitive(this.props.topology);
    const transformFeedback: any = null;
    if (transformFeedback) {
      transformFeedback.begin(primitiveMode);
    }

    // We have to apply bindings before every draw call since other draw calls will overwrite
    this._applyBindings();
    this._applyUniforms();

    const webglRenderPass = renderPass as WEBGLRenderPass;
    //     // TODO - Use polyfilled WebGL2RenderingContext instead of ANGLE extension
    //     if (isIndexed && isInstanced) {
    //       // ANGLE_instanced_arrays extension
    //       this.device.gl2?.drawElementsInstanced(
    //         drawMode,
    //         vertexCount || 0, // indexCount?
    //         indexType,
    //         firstVertex,
    //         instanceCount || 0
    //       );
    //       // } else if (isIndexed && this.device.isWebGL2 && !isNaN(start) && !isNaN(end)) {
    //       //   this.device.gl2.drawRangeElements(drawMode, start, end, vertexCount, indexType, offset);
    //     } else if (isIndexed) {
    //       this.device.gl.drawElements(drawMode, vertexCount || 0, indexType, firstVertex); // indexCount?
    //     } else if (isInstanced) {
    //       this.device.gl2?.drawArraysInstanced(
    //         drawMode,
    //         firstVertex,
    //         vertexCount || 0,
    //         instanceCount || 0
    //       );
    //     } else {
    //       this.device.gl.drawArrays(drawMode, firstVertex, vertexCount || 0);
    //     }
    //   });

    withDeviceAndGLParameters(this.device, this.props.parameters, webglRenderPass.glParameters, () => {
      if (isIndexed && isInstanced) {
        // ANGLE_instanced_arrays extension
        this.device.gl2?.drawElementsInstanced(
          glDrawMode,
          vertexCount || 0, // indexCount?
          glIndexType,
          firstVertex,
          instanceCount || 0
        );
        // } else if (isIndexed && this.device.isWebGL2 && !isNaN(start) && !isNaN(end)) {
        //   this.device.gl2.drawRangeElements(glDrawMode, start, end, vertexCount, glIndexType, offset);
      } else if (isIndexed) {
        this.device.gl.drawElements(glDrawMode, vertexCount || 0, glIndexType, firstVertex); // indexCount?
      } else if (isInstanced) {
        this.device.gl2?.drawArraysInstanced(
          glDrawMode,
          firstVertex,
          vertexCount || 0,
          instanceCount || 0
        );
      } else {
        this.device.gl.drawArrays(glDrawMode, firstVertex, vertexCount || 0);
      }

      if (transformFeedback) {
        transformFeedback.end();
      }
    });

    vertexArray.unbindAfterRender(renderPass);

    return true;
  }

  // setAttributes(attributes: Record<string, Buffer>): void {}
  // setBindings(bindings: Record<string, Binding>): void {}

  protected _compileAndLink() {
    const {gl} = this.device;
    gl.attachShader(this.handle, this.vs.handle);
    gl.attachShader(this.handle, this.fs.handle);
    log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
    gl.linkProgram(this.handle);
    log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();

    // Avoid checking program linking error in production
    // @ts-expect-error
    if (!gl.debug && log.level === 0) {
      // return;
    }

    const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);
    if (!linked) {
      throw new Error(`Error linking: ${gl.getProgramInfoLog(this.handle)}`);
    }

    gl.validateProgram(this.handle);
    const validated = gl.getProgramParameter(this.handle, gl.VALIDATE_STATUS);
    if (!validated) {
      throw new Error(`Error validating: ${gl.getProgramInfoLog(this.handle)}`);
    }
  }

  // PRIVATE METHODS

  /**
   * Checks if all texture-values uniforms are renderable (i.e. loaded)
   * Update a texture if needed (e.g. from video)
   * Note: This is currently done before every draw call
   */
  _areTexturesRenderable() {
    let texturesRenderable = true;

    for (const [, texture] of Object.entries(this._textureUniforms)) {
      texture.update();
      texturesRenderable = texturesRenderable && texture.loaded;
    }

    for (const [, texture] of Object.entries(this.bindings)) {
      // texture.update();
      // @ts-expect-error
      if (texture.loaded !== undefined) {
        // @ts-expect-error
        texturesRenderable = texturesRenderable && texture.loaded;
      }
    }

    return texturesRenderable;
  }

  /**
   * Constant attributes need to be reset before every draw call
   * Any attribute that is disabled in the current vertex array object
   * is read from the context's global constant value for that attribute location.
   * @note Constant attributes are only supported in WebGL, not in WebGPU
   *
  _applyConstantAttributes(vertexArray: WEBGLVertexArray): void {
    const attributeInfos = getAttributeInfosFromLayouts(this.shaderLayout, this.bufferLayout);
    for (const [name, value] of Object.entries(this.)) {
      const attributeInfo = attributeInfos[name];
      if (!attributeInfo) {
        log.warn(
          `Ignoring constant value supplied for unknown attribute "${name}" in pipeline "${this.id}"`
        )();
        continue; // eslint-disable-line no-continue
      }
      vertexArray.setConstant(attributeInfo.location, value);
      vertexArray.enable(attributeInfo.location, false);
    }
  }
  */

  /** Apply any bindings (before each draw call) */
  _applyBindings() {
    this.device.gl.useProgram(this.handle);

    const {gl2} = this.device;
    if (!gl2) {
      throw new Error('bindings');
    }

    let textureUnit = 0;
    let uniformBufferIndex = 0;
    for (const binding of this.shaderLayout.bindings) {
      const value = this.bindings[binding.name];
      if (!value) {
        throw new Error(`No value for binding ${binding.name} in ${this.id}`);
      }
      switch (binding.type) {
        case 'uniform':
          // Set buffer
          const {name} = binding;
          const location = gl2.getUniformBlockIndex(this.handle, name);
          if (location === GL.INVALID_INDEX) {
            throw new Error(`Invalid uniform block name ${name}`);
          }
          gl2.uniformBlockBinding(this.handle, uniformBufferIndex, location);
          // console.debug(binding, location);
          if (value instanceof WEBGLBuffer) {
            gl2.bindBufferBase(GL.UNIFORM_BUFFER, uniformBufferIndex, value.handle);
          } else {
            gl2.bindBufferRange(
              GL.UNIFORM_BUFFER,
              uniformBufferIndex,
              // @ts-expect-error
              value.buffer.handle,
              // @ts-expect-error
              value.offset || 0,
              // @ts-expect-error
              value.size || value.buffer.byteLength - value.offset
            );
          }
          uniformBufferIndex += 1;
          break;

        case 'texture':
          if (!(value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
            throw new Error('texture');
          }
          let texture: WEBGLTexture;
          if (value instanceof WEBGLTexture) {
            texture = value;
          } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTexture) {
            texture = value.colorAttachments[0];
          } else {
            throw new Error('No texture');
          }

          gl2.activeTexture(GL.TEXTURE0 + textureUnit);
          gl2.bindTexture(texture.target, texture.handle);
          // gl2.bindSampler(textureUnit, sampler.handle);
          textureUnit += 1;
          break;

        case 'sampler':
          // ignore
          break;

        case 'storage':
        case 'read-only-storage':
          throw new Error(`binding type '${binding.type}' not supported in WebGL`);
      }
    }
  }

  /**
   * Due to program sharing, uniforms need to be reset before every draw call
   * (though caching will avoid redundant WebGL calls)
   */
  _applyUniforms() {
    for (const uniformLayout of this.shaderLayout.uniforms || []) {
      const {name, location, type, textureUnit} = uniformLayout;
      const value = this.uniforms[name] ?? textureUnit;
      if (value !== undefined) {
        setUniform(this.device.gl, location, type, value);
      }
    }
  }
}

/** Get the primitive type for draw */
function getGLDrawMode(
  topology: PrimitiveTopology
):
  | GL.POINTS
  | GL.LINES
  | GL.LINE_STRIP
  | GL.LINE_LOOP
  | GL.TRIANGLES
  | GL.TRIANGLE_STRIP
  | GL.TRIANGLE_FAN {
  // prettier-ignore
  switch (topology) {
    case 'point-list': return GL.POINTS;
    case 'line-list': return GL.LINES;
    case 'line-strip': return GL.LINE_STRIP;
    case 'line-loop-webgl': return GL.LINE_LOOP;
    case 'triangle-list': return GL.TRIANGLES;
    case 'triangle-strip': return GL.TRIANGLE_STRIP;
    case 'triangle-fan-webgl': return GL.TRIANGLE_FAN;
    default: throw new Error(topology);
  }
}

/** Get the primitive type for transform feedback */
function getGLPrimitive(topology: PrimitiveTopology): GL.POINTS | GL.LINES | GL.TRIANGLES {
  // prettier-ignore
  switch (topology) {
    case 'point-list': return GL.POINTS;
    case 'line-list': return GL.LINES;
    case 'line-strip': return GL.LINES;
    case 'line-loop-webgl': return GL.LINES;
    case 'triangle-list': return GL.TRIANGLES;
    case 'triangle-strip': return GL.TRIANGLES;
    case 'triangle-fan-webgl': return GL.TRIANGLES;
    default: throw new Error(topology);
  }
}

1	// luma.gl, MIT license	1✔
2	// Copyright (c) vis.gl contributors	1✔
3		1✔
4	import type {UniformValue, RenderPipelineProps, Binding} from '@luma.gl/core';	1✔
5	import type {ShaderLayout, PrimitiveTopology} from '@luma.gl/core';	1✔
6	import type {RenderPass, VertexArray} from '@luma.gl/core';	1✔
7	import {RenderPipeline, cast, log} from '@luma.gl/core';	1✔
8	import {mergeShaderLayout} from '@luma.gl/core';	1✔
9	// import {mergeShaderLayout, getAttributeInfosFromLayouts} from '@luma.gl/core';	1✔
10	import {GL} from '@luma.gl/constants';	1✔
11		1✔
12	import {getShaderLayout} from '../helpers/get-shader-layout';	1✔
13	import {withDeviceAndGLParameters} from '../converters/device-parameters';	1✔
14	import {setUniform} from '../helpers/set-uniform';	1✔
15	// import {copyUniform, checkUniformValues} from '../../classes/uniforms';	1✔
16		1✔
17	import {WebGLDevice} from '../webgl-device';	1✔
18	import {WEBGLBuffer} from './webgl-buffer';	1✔
19	import {WEBGLShader} from './webgl-shader';	1✔
20	import {WEBGLFramebuffer} from './webgl-framebuffer';	1✔
21	import {WEBGLTexture} from './webgl-texture';	1✔
22	// import {WEBGLVertexArray} from './webgl-vertex-array';	1✔
23	import {WEBGLRenderPass} from './webgl-render-pass';	1✔
24		1✔
25	const LOG_PROGRAM_PERF_PRIORITY = 4;	1✔
26		1✔
27	/** Creates a new render pipeline */	1✔
28	export class WEBGLRenderPipeline extends RenderPipeline {	1✔
29	/** The WebGL device that created this render pipeline */	1✔
30	device: WebGLDevice;	1✔
31	/** Handle to underlying WebGL program */	1✔
32	handle: WebGLProgram;	1✔
33	/** vertex shader */	1✔
34	vs: WEBGLShader;	1✔
35	/** fragment shader */	1✔
36	fs: WEBGLShader;	1✔
37	/** The layout extracted from shader by WebGL introspection APIs */	1✔
38	introspectedLayout: ShaderLayout;	1✔
39		1✔
40	/** Uniforms set on this model */	1✔
41	uniforms: Record<string, UniformValue> = {};	1✔
42	/** Bindings set on this model */	1✔
43	bindings: Record<string, Binding> = {};	1✔
44	/** WebGL varyings */	1✔
45	varyings: string[] \| null = null;	1✔
46		1✔
47	_textureUniforms: Record<string, any> = {};	1✔
48	_textureIndexCounter: number = 0;	1✔
49	_uniformCount: number = 0;	1✔
50	_uniformSetters: Record<string, Function> = {}; // TODO are these used?	1✔
51		1✔
52	constructor(device: WebGLDevice, props: RenderPipelineProps) {	1✔
53	super(device, props);	4✔
54	this.device = device;	4✔
55	this.handle = this.props.handle \|\| this.device.gl.createProgram();	4✔
56	this.device.setSpectorMetadata(this.handle, {id: this.props.id});	4✔
57		4✔
58	// Create shaders if needed	4✔
59	this.vs = cast<WEBGLShader>(props.vs);	4✔
60	this.fs = cast<WEBGLShader>(props.fs);	4✔
61	// assert(this.vs.stage === 'vertex');	4✔
62	// assert(this.fs.stage === 'fragment');	4✔
63		4✔
64	// Setup varyings if supplied	4✔
65	// @ts-expect-error WebGL only	4✔
66	const {varyings, bufferMode = GL.SEPARATE_ATTRIBS} = props;	4✔
67	if (varyings && varyings.length > 0) {	4!
68	this.device.assertWebGL2();	×
69	this.varyings = varyings;	×
70	this.device.gl2?.transformFeedbackVaryings(this.handle, varyings, bufferMode);	×
71	}	×
72		4✔
73	this._compileAndLink();	4✔
74		4✔
75	this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);	4✔
76	// Merge provided layout with introspected layout	4✔
77	this.shaderLayout = mergeShaderLayout(this.introspectedLayout, props.shaderLayout);	4✔
78	// Merge layout with any buffer map overrides	4✔
79	// this.bufferLayout = props.bufferLayout \|\| [];	4✔
80	// this.shaderLayout = mergeBufferMap(this.shaderLayout, this.bufferLayout);	4✔
81	}	4✔
82		1✔
83	override destroy(): void {	1✔
84	if (this.handle) {	1✔
85	this.device.gl.deleteProgram(this.handle);	1✔
86	// this.handle = null;	1✔
87	this.destroyed = true;	1✔
88	}	1✔
89	}	1✔
90		1✔
91	// setIndexBuffer(indexBuffer: Buffer): void {	1✔
92	// const webglBuffer = cast<WEBGLBuffer>(indexBuffer);	1✔
93	// this.vertexArrayObject.setElementBuffer(webglBuffer);	1✔
94	// this._indexBuffer = indexBuffer;	1✔
95	// }	1✔
96		1✔
97	// /** @todo needed for portable model */	1✔
98	// setAttributes(attributes: Record<string, Buffer>): void {	1✔
99	// for (const [name, buffer] of Object.entries(attributes)) {	1✔
100	// const webglBuffer = cast<WEBGLBuffer>(buffer);	1✔
101	// const attribute = getAttributeLayout(this.layout, name);	1✔
102	// if (!attribute) {	1✔
103	// log.warn(	1✔
104	// `Ignoring buffer supplied for unknown attribute "${name}" in pipeline "${this.id}" (buffer "${buffer.id}")`	1✔
105	// )();	1✔
106	// continue;	1✔
107	// }	1✔
108	// const decoded = decodeVertexFormat(attribute.format);	1✔
109	// const {type: typeString, components: size, byteLength: stride, normalized, integer} = decoded;	1✔
110	// const divisor = attribute.stepMode === 'instance' ? 1 : 0;	1✔
111	// const type = getWebGLDataType(typeString);	1✔
112	// this.vertexArrayObject.setBuffer(attribute.location, webglBuffer, {	1✔
113	// size,	1✔
114	// type,	1✔
115	// stride,	1✔
116	// offset: 0,	1✔
117	// normalized,	1✔
118	// integer,	1✔
119	// divisor	1✔
120	// });	1✔
121	// }	1✔
122	// }	1✔
123		1✔
124	/**	1✔
125	* Bindings include: textures, samplers and uniform buffers	1✔
126	* @todo needed for portable model	1✔
127	*/	1✔
128	setBindings(bindings: Record<string, Binding>): void {	1✔
129	// if (log.priority >= 2) {	×
130	// checkUniformValues(uniforms, this.id, this._uniformSetters);	×
131	// }	×
132		×
133	for (const [name, value] of Object.entries(bindings)) {	×
134	const binding = this.shaderLayout.bindings.find(binding => binding.name === name);	×
135	if (!binding) {	×
136	log.warn(`Unknown binding ${name} in render pipeline ${this.id}`)();	×
137	continue; // eslint-disable-line no-continue	×
138	}	×
139	if (!value) {	×
140	log.warn(`Unsetting binding ${name} in render pipeline ${this.id}`)();	×
141	}	×
142	switch (binding.type) {	×
143	case 'uniform':	×
144	// @ts-expect-error	×
145	if (!(value instanceof WEBGLBuffer) && !(value.buffer instanceof WEBGLBuffer)) {	×
146	throw new Error('buffer value');	×
147	}	×
148	break;	×
149	case 'texture':	×
NEW 150	if (!(value instanceof WEBGLTexture \|\| value instanceof WEBGLFramebuffer)) {	×
151	throw new Error('texture value');	×
152	}	×
153	break;	×
154	case 'sampler':	×
155	log.warn(`Ignoring sampler ${name}`)();	×
156	break;	×
157	default:	×
158	throw new Error(binding.type);	×
159	}	×
160		×
161	this.bindings[name] = value;	×
162	}	×
163	}	×
164		1✔
165	setUniforms(uniforms: Record<string, UniformValue>) {	1✔
166	// TODO - check against layout	6✔
167	Object.assign(this.uniforms, uniforms);	6✔
168	}	6✔
169		1✔
170	/** @todo needed for portable model	1✔
171	* @note The WebGL API is offers many ways to draw things	1✔
172	* This function unifies those ways into a single call using common parameters with sane defaults	1✔
173	*/	1✔
174	draw(options: {	1✔
175	renderPass: RenderPass;	×
176	/** vertex attributes */	×
177	vertexArray: VertexArray;	×
178	vertexCount?: number;	×
179	indexCount?: number;	×
180	instanceCount?: number;	×
181	firstVertex?: number;	×
182	firstIndex?: number;	×
183	firstInstance?: number;	×
184	baseVertex?: number;	×
185	}): boolean {	×
186	const {	×
187	renderPass,	×
188	vertexArray,	×
189	vertexCount,	×
190	// indexCount,	×
191	instanceCount,	×
192	firstVertex = 0	×
193	// firstIndex,	×
194	// firstInstance,	×
195	// baseVertex	×
196	} = options;	×
197		×
198	const glDrawMode = getGLDrawMode(this.props.topology);	×
199	const isIndexed: boolean = Boolean(vertexArray.indexBuffer);	×
200	const glIndexType = (vertexArray.indexBuffer as WEBGLBuffer)?.glIndexType;	×
201	const isInstanced: boolean = Number(instanceCount) > 0;	×
202		×
203	// Avoid WebGL draw call when not rendering any data or values are incomplete	×
204	// Note: async textures set as uniforms might still be loading.	×
205	// Now that all uniforms have been updated, check if any texture	×
206	// in the uniforms is not yet initialized, then we don't draw	×
207	if (!this._areTexturesRenderable() \|\| vertexCount === 0) {	×
208	// (isInstanced && instanceCount === 0)	×
209	return false;	×
210	}	×
211		×
212	this.device.gl.useProgram(this.handle);	×
213		×
214	// Note: Rebinds constant attributes before each draw call	×
215	vertexArray.bindBeforeRender(renderPass);	×
216		×
217	const primitiveMode = getGLPrimitive(this.props.topology);	×
218	const transformFeedback: any = null;	×
219	if (transformFeedback) {	×
220	transformFeedback.begin(primitiveMode);	×
221	}	×
222		×
223	// We have to apply bindings before every draw call since other draw calls will overwrite	×
224	this._applyBindings();	×
225	this._applyUniforms();	×
226		×
227	const webglRenderPass = renderPass as WEBGLRenderPass;	×
228	// // TODO - Use polyfilled WebGL2RenderingContext instead of ANGLE extension	×
229	// if (isIndexed && isInstanced) {	×
230	// // ANGLE_instanced_arrays extension	×
231	// this.device.gl2?.drawElementsInstanced(	×
232	// drawMode,	×
233	// vertexCount \|\| 0, // indexCount?	×
234	// indexType,	×
235	// firstVertex,	×
236	// instanceCount \|\| 0	×
237	// );	×
238	// // } else if (isIndexed && this.device.isWebGL2 && !isNaN(start) && !isNaN(end)) {	×
239	// // this.device.gl2.drawRangeElements(drawMode, start, end, vertexCount, indexType, offset);	×
240	// } else if (isIndexed) {	×
241	// this.device.gl.drawElements(drawMode, vertexCount \|\| 0, indexType, firstVertex); // indexCount?	×
242	// } else if (isInstanced) {	×
243	// this.device.gl2?.drawArraysInstanced(	×
244	// drawMode,	×
245	// firstVertex,	×
246	// vertexCount \|\| 0,	×
247	// instanceCount \|\| 0	×
248	// );	×
249	// } else {	×
250	// this.device.gl.drawArrays(drawMode, firstVertex, vertexCount \|\| 0);	×
251	// }	×
252	// });	×
253		×
254	withDeviceAndGLParameters(this.device, this.props.parameters, webglRenderPass.glParameters, () => {	×
255	if (isIndexed && isInstanced) {	×
256	// ANGLE_instanced_arrays extension	×
257	this.device.gl2?.drawElementsInstanced(	×
258	glDrawMode,	×
259	vertexCount \|\| 0, // indexCount?	×
260	glIndexType,	×
261	firstVertex,	×
262	instanceCount \|\| 0	×
263	);	×
264	// } else if (isIndexed && this.device.isWebGL2 && !isNaN(start) && !isNaN(end)) {	×
265	// this.device.gl2.drawRangeElements(glDrawMode, start, end, vertexCount, glIndexType, offset);	×
266	} else if (isIndexed) {	×
267	this.device.gl.drawElements(glDrawMode, vertexCount \|\| 0, glIndexType, firstVertex); // indexCount?	×
268	} else if (isInstanced) {	×
269	this.device.gl2?.drawArraysInstanced(	×
270	glDrawMode,	×
271	firstVertex,	×
272	vertexCount \|\| 0,	×
273	instanceCount \|\| 0	×
274	);	×
275	} else {	×
276	this.device.gl.drawArrays(glDrawMode, firstVertex, vertexCount \|\| 0);	×
277	}	×
278		×
279	if (transformFeedback) {	×
280	transformFeedback.end();	×
281	}	×
282	});	×
283		×
284	vertexArray.unbindAfterRender(renderPass);	×
285		×
286	return true;	×
287	}	×
288		1✔
289	// setAttributes(attributes: Record<string, Buffer>): void {}	1✔
290	// setBindings(bindings: Record<string, Binding>): void {}	1✔
291		1✔
292	protected _compileAndLink() {	1✔
293	const {gl} = this.device;	4✔
294	gl.attachShader(this.handle, this.vs.handle);	4✔
295	gl.attachShader(this.handle, this.fs.handle);	4✔
296	log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();	4✔
297	gl.linkProgram(this.handle);	4✔
298	log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();	4✔
299		4✔
300	// Avoid checking program linking error in production	4✔
301	// @ts-expect-error	4✔
302	if (!gl.debug && log.level === 0) {	4✔
303	// return;	4✔
304	}	4✔
305		4✔
306	const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);	4✔
307	if (!linked) {	4!
308	throw new Error(`Error linking: ${gl.getProgramInfoLog(this.handle)}`);	×
309	}	×
310		4✔
311	gl.validateProgram(this.handle);	4✔
312	const validated = gl.getProgramParameter(this.handle, gl.VALIDATE_STATUS);	4✔
313	if (!validated) {	4!
314	throw new Error(`Error validating: ${gl.getProgramInfoLog(this.handle)}`);	×
315	}	×
316	}	4✔
317		1✔
318	// PRIVATE METHODS	1✔
319		1✔
320	/**	1✔
321	* Checks if all texture-values uniforms are renderable (i.e. loaded)	1✔
322	* Update a texture if needed (e.g. from video)	1✔
323	* Note: This is currently done before every draw call	1✔
324	*/	1✔
325	_areTexturesRenderable() {	1✔
326	let texturesRenderable = true;	×
327		×
328	for (const [, texture] of Object.entries(this._textureUniforms)) {	×
329	texture.update();	×
330	texturesRenderable = texturesRenderable && texture.loaded;	×
331	}	×
332		×
333	for (const [, texture] of Object.entries(this.bindings)) {	×
334	// texture.update();	×
335	// @ts-expect-error	×
336	if (texture.loaded !== undefined) {	×
337	// @ts-expect-error	×
338	texturesRenderable = texturesRenderable && texture.loaded;	×
339	}	×
340	}	×
341		×
342	return texturesRenderable;	×
343	}	×
344		1✔
345	/**	1✔
346	* Constant attributes need to be reset before every draw call	1✔
347	* Any attribute that is disabled in the current vertex array object	1✔
348	* is read from the context's global constant value for that attribute location.	1✔
349	* @note Constant attributes are only supported in WebGL, not in WebGPU	1✔
350	*	1✔
351	_applyConstantAttributes(vertexArray: WEBGLVertexArray): void {	1✔
352	const attributeInfos = getAttributeInfosFromLayouts(this.shaderLayout, this.bufferLayout);	1✔
353	for (const [name, value] of Object.entries(this.)) {	1✔
354	const attributeInfo = attributeInfos[name];	1✔
355	if (!attributeInfo) {	1✔
356	log.warn(	1✔
357	`Ignoring constant value supplied for unknown attribute "${name}" in pipeline "${this.id}"`	1✔
358	)();	1✔
359	continue; // eslint-disable-line no-continue	1✔
360	}	1✔
361	vertexArray.setConstant(attributeInfo.location, value);	1✔
362	vertexArray.enable(attributeInfo.location, false);	1✔
363	}	1✔
364	}	1✔
365	*/	1✔
366		1✔
367	/** Apply any bindings (before each draw call) */	1✔
368	_applyBindings() {	1✔
369	this.device.gl.useProgram(this.handle);	×
370		×
371	const {gl2} = this.device;	×
372	if (!gl2) {	×
373	throw new Error('bindings');	×
374	}	×
375		×
376	let textureUnit = 0;	×
377	let uniformBufferIndex = 0;	×
378	for (const binding of this.shaderLayout.bindings) {	×
379	const value = this.bindings[binding.name];	×
380	if (!value) {	×
381	throw new Error(`No value for binding ${binding.name} in ${this.id}`);	×
382	}	×
383	switch (binding.type) {	×
384	case 'uniform':	×
385	// Set buffer	×
386	const {name} = binding;	×
387	const location = gl2.getUniformBlockIndex(this.handle, name);	×
388	if (location === GL.INVALID_INDEX) {	×
389	throw new Error(`Invalid uniform block name ${name}`);	×
390	}	×
391	gl2.uniformBlockBinding(this.handle, uniformBufferIndex, location);	×
392	// console.debug(binding, location);	×
393	if (value instanceof WEBGLBuffer) {	×
394	gl2.bindBufferBase(GL.UNIFORM_BUFFER, uniformBufferIndex, value.handle);	×
395	} else {	×
396	gl2.bindBufferRange(	×
397	GL.UNIFORM_BUFFER,	×
398	uniformBufferIndex,	×
399	// @ts-expect-error	×
400	value.buffer.handle,	×
401	// @ts-expect-error	×
402	value.offset \|\| 0,	×
403	// @ts-expect-error	×
404	value.size \|\| value.buffer.byteLength - value.offset	×
405	);	×
406	}	×
407	uniformBufferIndex += 1;	×
408	break;	×
409		×
410	case 'texture':	×
NEW 411	if (!(value instanceof WEBGLTexture \|\| value instanceof WEBGLFramebuffer)) {	×
412	throw new Error('texture');	×
413	}	×
NEW 414	let texture: WEBGLTexture;	×
NEW 415	if (value instanceof WEBGLTexture) {	×
NEW 416	texture = value;	×
NEW 417	} else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTexture) {	×
NEW 418	texture = value.colorAttachments[0];	×
NEW 419	} else {	×
NEW 420	throw new Error('No texture');	×
NEW 421	}	×
NEW 422		×
423	gl2.activeTexture(GL.TEXTURE0 + textureUnit);	×
424	gl2.bindTexture(texture.target, texture.handle);	×
425	// gl2.bindSampler(textureUnit, sampler.handle);	×
426	textureUnit += 1;	×
427	break;	×
428		×
429	case 'sampler':	×
430	// ignore	×
431	break;	×
432		×
433	case 'storage':	×
434	case 'read-only-storage':	×
435	throw new Error(`binding type '${binding.type}' not supported in WebGL`);	×
436	}	×
437	}	×
438	}	×
439		1✔
440	/**	1✔
441	* Due to program sharing, uniforms need to be reset before every draw call	1✔
442	* (though caching will avoid redundant WebGL calls)	1✔
443	*/	1✔
444	_applyUniforms() {	1✔
UNCOV 445	for (const uniformLayout of this.shaderLayout.uniforms \|\| []) {	×
446	const {name, location, type, textureUnit} = uniformLayout;	×
447	const value = this.uniforms[name] ?? textureUnit;	×
448	if (value !== undefined) {	×
449	setUniform(this.device.gl, location, type, value);	×
450	}	×
451	}	×
452	}	×
453	}	1✔
454		1✔
455	/** Get the primitive type for draw */	1✔
UNCOV 456	function getGLDrawMode(	×
457	topology: PrimitiveTopology	×
458	):	×
459	\| GL.POINTS	×
460	\| GL.LINES	×
461	\| GL.LINE_STRIP	×
462	\| GL.LINE_LOOP	×
463	\| GL.TRIANGLES	×
464	\| GL.TRIANGLE_STRIP	×
465	\| GL.TRIANGLE_FAN {	×
466	// prettier-ignore	×
467	switch (topology) {	×
468	case 'point-list': return GL.POINTS;	×
469	case 'line-list': return GL.LINES;	×
470	case 'line-strip': return GL.LINE_STRIP;	×
471	case 'line-loop-webgl': return GL.LINE_LOOP;	×
472	case 'triangle-list': return GL.TRIANGLES;	×
473	case 'triangle-strip': return GL.TRIANGLE_STRIP;	×
474	case 'triangle-fan-webgl': return GL.TRIANGLE_FAN;	×
475	default: throw new Error(topology);	×
476	}	×
477	}	×
478		1✔
479	/** Get the primitive type for transform feedback */	1✔
UNCOV 480	function getGLPrimitive(topology: PrimitiveTopology): GL.POINTS \| GL.LINES \| GL.TRIANGLES {	×
481	// prettier-ignore	×
482	switch (topology) {	×
483	case 'point-list': return GL.POINTS;	×
484	case 'line-list': return GL.LINES;	×
485	case 'line-strip': return GL.LINES;	×
486	case 'line-loop-webgl': return GL.LINES;	×
487	case 'triangle-list': return GL.TRIANGLES;	×
488	case 'triangle-strip': return GL.TRIANGLES;	×
489	case 'triangle-fan-webgl': return GL.TRIANGLES;	×
490	default: throw new Error(topology);	×
491	}	×
492	}	×

visgl / luma.gl / 6744610589

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