7267382589

Committed 19 Dec 2023 08:44PM UTC coverage: 71.491% (-1.3%) from 72.749%

Build # 7267382589

Build Type

Pull #1891

github

Committed by

web-flow

Commit Message

Merge 93a1cd3a6 into b4bc0fa8b

Pull Request Pull Request #1891: chore(shadertools): Improve ShaderModule typings

Run Details

1343 of 1808 branches covered (0.0%)

Branch coverage included in aggregate %.

83 of 172 new or added lines in 31 files covered. (48.26%)

357 existing lines in 11 files now uncovered.

20624 of 28919 relevant lines covered (71.32%)

16.73 hits per line

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

9.73

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

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

import {RenderPass, RenderPassProps, NumberArray, RenderPassParameters} from '@luma.gl/core';
import {WebGLDevice} from '../webgl-device';
import {GL, GLParameters} from '@luma.gl/constants';
import {withGLParameters} from '../../context/state-tracker/with-parameters';
import {setGLParameters} from '../../context/parameters/unified-parameter-api';
import {pushContextState, popContextState} from '../../context/state-tracker/track-context-state';

// Should collapse during minification
const GL_DEPTH_BUFFER_BIT = 0x00000100;
const GL_STENCIL_BUFFER_BIT = 0x00000400;
const GL_COLOR_BUFFER_BIT = 0x00004000;

const GL_COLOR = 0x1800;

export class WEBGLRenderPass extends RenderPass {
  readonly device: WebGLDevice;

  /** Parameters that should be applied before each draw call */
  glParameters: GLParameters;

  constructor(device: WebGLDevice, props: RenderPassProps) {
    super(device, props);
    this.device = device;

    // TODO - do parameters (scissorRect) affect the clear operation?
    pushContextState(this.device.gl);
    this.setParameters(this.props.parameters);

    // Hack - for now WebGL draws in "immediate mode" (instead of queueing the operations)...
    this.clear();
  }

  end(): void {
    popContextState(this.device.gl);
    if (this.props.framebuffer) {
      setGLParameters(this.device, {framebuffer: null});
    }
    // should add commands to CommandEncoder.
  }

  pushDebugGroup(groupLabel: string): void {}
  popDebugGroup(): void {}
  insertDebugMarker(markerLabel: string): void {}

  // writeTimestamp(querySet: GPUQuerySet, queryIndex: number): void;

  // beginOcclusionQuery(queryIndex: number): void;
  // endOcclusionQuery(): void;

  // executeBundles(bundles: Iterable<GPURenderBundle>): void;

  /**
   * Maps RenderPass parameters to GL parameters
   */
  setParameters(parameters: RenderPassParameters = {}): void {
    const glParameters: GLParameters = {};

    // Framebuffers are specified using parameters in WebGL
    if (this.props.framebuffer) {
      glParameters.framebuffer = this.props.framebuffer;
    }

    if (this.props.depthReadOnly) {
      glParameters.depthMask = !this.props.depthReadOnly;
    }

    glParameters.stencilMask = this.props.stencilReadOnly ? 0 : 1;

    glParameters[GL.RASTERIZER_DISCARD] = this.props.discard;

    // Map the four renderpass parameters to WebGL parameters
    if (parameters.viewport) {
      // WebGPU viewports are 6 coordinates (X, Y, Z)
      if (parameters.viewport.length >= 6) {
        glParameters.viewport = parameters.viewport.slice(0, 4);
        glParameters.depthRange = [parameters.viewport[4], parameters.viewport[5]];
      } else {
        // WebGL viewports are 4 coordinates (X, Y)
        glParameters.viewport = parameters.viewport;
      }
    }
    glParameters.scissorTest = Boolean(parameters.scissorRect);
    if (parameters.scissorRect) {
      glParameters.scissor = parameters.scissorRect;
    }
    if (parameters.blendConstant) {
      glParameters.blendColor = parameters.blendConstant;
    }
    if (parameters.stencilReference) {
      // eslint-disable-next-line no-console
      console.warn('RenderPassParameters.stencilReference not yet implemented in WebGL');
      // parameters.stencilFunc = [func, ref, mask];
      // Does this work?
      parameters[GL.STENCIL_REF] = parameters.stencilReference;
    }

    this.glParameters = glParameters;

    setGLParameters(this.device, glParameters);
  }

  // Internal

  /**
   * Optionally clears depth, color and stencil buffers based on parameters
   */
  protected clear(): void {
    const glParameters: GLParameters = {...this.glParameters};

    let clearMask = 0;

    if (this.props.clearColor !== false) {
      clearMask |= GL_COLOR_BUFFER_BIT;
      glParameters.clearColor = this.props.clearColor;
    }
    if (this.props.clearDepth !== false) {
      clearMask |= GL_DEPTH_BUFFER_BIT;
      glParameters.clearDepth = this.props.clearDepth;
    }
    if (this.props.clearStencil !== false) {
      clearMask |= GL_STENCIL_BUFFER_BIT;
      glParameters.clearStencil = this.props.clearStencil;
    }

    if (clearMask !== 0) {
      // Temporarily set any clear "colors" and call clear
      withGLParameters(this.device, glParameters, () => {
        this.device.gl.clear(clearMask);
      });

      // TODO - clear multiple color attachments
      // for (attachment of this.framebuffer.colorAttachments) {
      //   this.clearColorBuffer  
      // }
    }
  }

  /** 
   * WebGL2 - clear a specific color buffer 
   */
  protected clearColorBuffer(drawBuffer: number = 0, value: NumberArray = [0, 0, 0, 0]) {
    withGLParameters(this.device.gl2, {framebuffer: this.props.framebuffer}, () => {
      // Method selection per OpenGL ES 3 docs
      switch (value.constructor) {
        case Int32Array:
          this.device.gl2.clearBufferiv(GL_COLOR, drawBuffer, value);
          break;
        case Uint32Array:
          this.device.gl2.clearBufferuiv(GL_COLOR, drawBuffer, value);
          break;
        case Float32Array:
        default:
          this.device.gl2.clearBufferfv(GL_COLOR, drawBuffer, value);
          break;
      }
    });
  }

  // clearDepthStencil() {
  // const GL_DEPTH = 0x1801;
  // const GL_STENCIL = 0x1802;
  // const GL_DEPTH_STENCIL = 0x84f9;

  //     case GL_DEPTH:
  //       this.device.gl2.clearBufferfv(GL_DEPTH, 0, [value]);
  //       break;

  //     case GL_STENCIL:
  //       this.device.gl2.clearBufferiv(GL_STENCIL, 0, [value]);
  //       break;

  //     case GL_DEPTH_STENCIL:
  //       const [depth, stencil] = value;
  //       this.device.gl2.clearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil);
  //       break;

  //     default:
  //       assert(false, ERR_ARGUMENTS);
  //   }
  // });
}


1	// luma.gl, MIT license	1✔
2	// Copyright (c) vis.gl contributors	1✔
3		1✔
4	import {RenderPass, RenderPassProps, NumberArray, RenderPassParameters} from '@luma.gl/core';	1✔
5	import {WebGLDevice} from '../webgl-device';	1✔
6	import {GL, GLParameters} from '@luma.gl/constants';	1✔
7	import {withGLParameters} from '../../context/state-tracker/with-parameters';	1✔
8	import {setGLParameters} from '../../context/parameters/unified-parameter-api';	1✔
9	import {pushContextState, popContextState} from '../../context/state-tracker/track-context-state';	1✔
10		1✔
11	// Should collapse during minification	1✔
12	const GL_DEPTH_BUFFER_BIT = 0x00000100;	1✔
13	const GL_STENCIL_BUFFER_BIT = 0x00000400;	1✔
14	const GL_COLOR_BUFFER_BIT = 0x00004000;	1✔
15		1✔
16	const GL_COLOR = 0x1800;	1✔
17		1✔
18	export class WEBGLRenderPass extends RenderPass {	1!
UNCOV 19	readonly device: WebGLDevice;	×
UNCOV 20		×
UNCOV 21	/** Parameters that should be applied before each draw call */	×
UNCOV 22	glParameters: GLParameters;	×
UNCOV 23		×
UNCOV 24	constructor(device: WebGLDevice, props: RenderPassProps) {	×
25	super(device, props);	×
26	this.device = device;	×
27		×
28	// TODO - do parameters (scissorRect) affect the clear operation?	×
29	pushContextState(this.device.gl);	×
30	this.setParameters(this.props.parameters);	×
31		×
32	// Hack - for now WebGL draws in "immediate mode" (instead of queueing the operations)...	×
33	this.clear();	×
34	}	×
UNCOV 35		×
UNCOV 36	end(): void {	×
37	popContextState(this.device.gl);	×
38	if (this.props.framebuffer) {	×
39	setGLParameters(this.device, {framebuffer: null});	×
40	}	×
41	// should add commands to CommandEncoder.	×
42	}	×
UNCOV 43		×
UNCOV 44	pushDebugGroup(groupLabel: string): void {}	×
UNCOV 45	popDebugGroup(): void {}	×
UNCOV 46	insertDebugMarker(markerLabel: string): void {}	×
UNCOV 47		×
UNCOV 48	// writeTimestamp(querySet: GPUQuerySet, queryIndex: number): void;	×
UNCOV 49		×
UNCOV 50	// beginOcclusionQuery(queryIndex: number): void;	×
UNCOV 51	// endOcclusionQuery(): void;	×
UNCOV 52		×
UNCOV 53	// executeBundles(bundles: Iterable<GPURenderBundle>): void;	×
UNCOV 54		×
UNCOV 55	/**	×
UNCOV 56	* Maps RenderPass parameters to GL parameters	×
UNCOV 57	*/	×
UNCOV 58	setParameters(parameters: RenderPassParameters = {}): void {	×
59	const glParameters: GLParameters = {};	×
60		×
61	// Framebuffers are specified using parameters in WebGL	×
62	if (this.props.framebuffer) {	×
63	glParameters.framebuffer = this.props.framebuffer;	×
64	}	×
65		×
66	if (this.props.depthReadOnly) {	×
67	glParameters.depthMask = !this.props.depthReadOnly;	×
68	}	×
69		×
70	glParameters.stencilMask = this.props.stencilReadOnly ? 0 : 1;	×
71		×
72	glParameters[GL.RASTERIZER_DISCARD] = this.props.discard;	×
73		×
74	// Map the four renderpass parameters to WebGL parameters	×
75	if (parameters.viewport) {	×
76	// WebGPU viewports are 6 coordinates (X, Y, Z)	×
77	if (parameters.viewport.length >= 6) {	×
78	glParameters.viewport = parameters.viewport.slice(0, 4);	×
79	glParameters.depthRange = [parameters.viewport[4], parameters.viewport[5]];	×
80	} else {	×
81	// WebGL viewports are 4 coordinates (X, Y)	×
82	glParameters.viewport = parameters.viewport;	×
83	}	×
84	}	×
85	glParameters.scissorTest = Boolean(parameters.scissorRect);	×
86	if (parameters.scissorRect) {	×
87	glParameters.scissor = parameters.scissorRect;	×
88	}	×
89	if (parameters.blendConstant) {	×
90	glParameters.blendColor = parameters.blendConstant;	×
91	}	×
92	if (parameters.stencilReference) {	×
93	// eslint-disable-next-line no-console	×
94	console.warn('RenderPassParameters.stencilReference not yet implemented in WebGL');	×
95	// parameters.stencilFunc = [func, ref, mask];	×
96	// Does this work?	×
97	parameters[GL.STENCIL_REF] = parameters.stencilReference;	×
98	}	×
99		×
100	this.glParameters = glParameters;	×
101		×
102	setGLParameters(this.device, glParameters);	×
103	}	×
UNCOV 104		×
UNCOV 105	// Internal	×
UNCOV 106		×
UNCOV 107	/**	×
UNCOV 108	* Optionally clears depth, color and stencil buffers based on parameters	×
UNCOV 109	*/	×
UNCOV 110	protected clear(): void {	×
111	const glParameters: GLParameters = {...this.glParameters};	×
112		×
113	let clearMask = 0;	×
114		×
115	if (this.props.clearColor !== false) {	×
116	clearMask \|= GL_COLOR_BUFFER_BIT;	×
117	glParameters.clearColor = this.props.clearColor;	×
118	}	×
119	if (this.props.clearDepth !== false) {	×
120	clearMask \|= GL_DEPTH_BUFFER_BIT;	×
121	glParameters.clearDepth = this.props.clearDepth;	×
122	}	×
123	if (this.props.clearStencil !== false) {	×
124	clearMask \|= GL_STENCIL_BUFFER_BIT;	×
125	glParameters.clearStencil = this.props.clearStencil;	×
126	}	×
127		×
128	if (clearMask !== 0) {	×
129	// Temporarily set any clear "colors" and call clear	×
130	withGLParameters(this.device, glParameters, () => {	×
131	this.device.gl.clear(clearMask);	×
132	});	×
133		×
134	// TODO - clear multiple color attachments	×
135	// for (attachment of this.framebuffer.colorAttachments) {	×
136	// this.clearColorBuffer	×
137	// }	×
138	}	×
139	}	×
UNCOV 140		×
UNCOV 141	/**	×
UNCOV 142	* WebGL2 - clear a specific color buffer	×
UNCOV 143	*/	×
UNCOV 144	protected clearColorBuffer(drawBuffer: number = 0, value: NumberArray = [0, 0, 0, 0]) {	×
145	withGLParameters(this.device.gl2, {framebuffer: this.props.framebuffer}, () => {	×
146	// Method selection per OpenGL ES 3 docs	×
147	switch (value.constructor) {	×
148	case Int32Array:	×
149	this.device.gl2.clearBufferiv(GL_COLOR, drawBuffer, value);	×
150	break;	×
151	case Uint32Array:	×
152	this.device.gl2.clearBufferuiv(GL_COLOR, drawBuffer, value);	×
153	break;	×
154	case Float32Array:	×
155	default:	×
156	this.device.gl2.clearBufferfv(GL_COLOR, drawBuffer, value);	×
157	break;	×
158	}	×
159	});	×
160	}	×
UNCOV 161		×
UNCOV 162	// clearDepthStencil() {	×
UNCOV 163	// const GL_DEPTH = 0x1801;	×
UNCOV 164	// const GL_STENCIL = 0x1802;	×
UNCOV 165	// const GL_DEPTH_STENCIL = 0x84f9;	×
UNCOV 166		×
UNCOV 167	// case GL_DEPTH:	×
UNCOV 168	// this.device.gl2.clearBufferfv(GL_DEPTH, 0, [value]);	×
UNCOV 169	// break;	×
UNCOV 170		×
UNCOV 171	// case GL_STENCIL:	×
UNCOV 172	// this.device.gl2.clearBufferiv(GL_STENCIL, 0, [value]);	×
UNCOV 173	// break;	×
UNCOV 174		×
UNCOV 175	// case GL_DEPTH_STENCIL:	×
UNCOV 176	// const [depth, stencil] = value;	×
UNCOV 177	// this.device.gl2.clearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil);	×
UNCOV 178	// break;	×
UNCOV 179		×
UNCOV 180	// default:	×
UNCOV 181	// assert(false, ERR_ARGUMENTS);	×
UNCOV 182	// }	×
UNCOV 183	// });	×
UNCOV 184	}	×
185

visgl / luma.gl / 7267382589

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