6858084886

Committed 14 Nov 2023 01:41AM UTC coverage: 76.474% (-0.01%) from 76.486%

Build # 6858084886

Build Type

push

github

Committed by

web-flow

Commit Message

chore(shadertools): Rename uniformPropTypes field (#1839)

Run Details

1792 of 2396 branches covered (0.0%)

Branch coverage included in aggregate %.

26 of 27 new or added lines in 23 files covered. (96.3%)

2 existing lines in 1 file now uncovered.

33018 of 43123 relevant lines covered (76.57%)

45.54 hits per line

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

56.74

/modules/engine/src/shadertools/shader-module-uniforms.ts

// luma.gl, MIT license
import {NumberArray, isNumberArray} from '@luma.gl/core';
import {Device, Buffer, UniformBufferLayout, ShaderUniformType} from '@luma.gl/core';
import {ShaderModule} from '@luma.gl/shadertools';

/** Duplicates definition in core module to avoid cross dependencies */
export type UniformValue = number | boolean | Readonly<NumberArray>; // Float32Array> | Readonly<Int32Array> | Readonly<Uint32Array> | Readonly<number[]>;

/** A uniform store holds a number of uniform values and does some book keeping on what has changes */
export class ShaderModuleUniforms<TUniforms extends Record<string, UniformValue>> {
  device: Device;
  shaderModule: ShaderModule<TUniforms>;

  useUniformBuffers: boolean;
  uniformBufferLayout: UniformBufferLayout;
  uniformBuffer: Buffer | null = null;

  uniforms: Record<string, UniformValue> = {};
  modifiedUniforms: Record<string, boolean> = {};
  modified: boolean = true;

  needsRedraw: string | false = 'initialized';

  constructor(props?: {
    device: Device;
    shaderModule: ShaderModule<TUniforms>
  }) {
    this.device = props.device;
    this.shaderModule = props.shaderModule;
    this.useUniformBuffers = this.device.info.type !== 'webgl';

    // extract uniform formats and create a uniform buffer layout
    const uniformTypes: Record<string, ShaderUniformType> = {};
    for (const [name, {format}] of Object.entries(props.shaderModule.uniformPropTypes || {})) {
      uniformTypes[name] = format;
    }
    this.uniformBufferLayout = new UniformBufferLayout(uniformTypes);

    // create a uniform buffer
    if (this.useUniformBuffers) {
      this.uniformBuffer = this.device.createBuffer({
        usage: Buffer.UNIFORM,
        byteLength: this.uniformBufferLayout.byteLength
      });  
    }
  }

  /** Set a map of uniforms */
  setUniforms(uniforms: TUniforms): void {
    for (const [key, value] of Object.entries(uniforms)) {
      this._setUniform(key, value);
      this.setNeedsRedraw(key);
    }
  }

  setNeedsRedraw(reason: string): void {
    this.needsRedraw = this.needsRedraw || reason;
  }

  /** 
   * Updates the uniform buffer if needed. 
   * Clears the dirty flag.
   */
  getUniformBuffer(): Buffer {
    if (this.needsRedraw) {
      const modifiedUniforms = this.getModifiedUniforms();
      const data = this.uniformBufferLayout.getData(modifiedUniforms);
      this.uniformBuffer.write(data);
    }
    return this.uniformBuffer;
  }

  /** Returns all uniforms */
  getUniforms(groupName: string): Record<string, UniformValue> {
    this.modifiedUniforms = {};
    this.needsRedraw = false;
    return (this.uniforms[groupName] || {}) as Record<string, UniformValue>;
  }

  /** Returns modified uniforms */
  getModifiedUniforms() {
    const modifiedUniforms = this.modifiedUniforms;
    this.modifiedUniforms = {};
    this.needsRedraw = false;
    return modifiedUniforms;
  }

  /** Set a single uniform */
  private _setUniform(key: string, value: UniformValue) {
    // if (this.layout[key] !== undefined) {
    //   this.uniforms[key] = value;
    //   this.modifiedUniforms[key] = true;
    //   this.modified = true;
    // } else {
    //   log.warn(`Unknown uniform ${key}`)
    // }
    if (arrayEqual(this.uniforms[key], value)) {
      return;
    }
    this.uniforms[key] = value;
    this.modifiedUniforms[key] = true;
    this.modified = true;
  }
}

function arrayEqual(a: unknown, b: unknown, limit: number = 16) {
  if (a !== b) {
    return false;
  }
  const arrayA = isNumberArray(a);
  if (!arrayA) {
    return false;
  }
  const arrayB = isNumberArray(b);
  if (arrayB && arrayA.length === arrayB.length) {
    for (let i = 0; i < arrayA.length; ++i) {
      if (arrayB[i] !== arrayA[i]) {
        return false;
      }
    }
  }
  return true;
}


// export function makeUniformStore<I extends Record<string, Record<string, unknown>>>(name: string, uniforms: I): UniformStore<{ [P in keyof I]: I[P] }> {
//   return new UniformStore<{ [P in keyof I]: I[P] }>({name, uniforms});
// }

// type ShaderModule<Uniforms extends Record<string, unknown> = {}> = {
//   uniformTypes: Record<keyof Uniforms, string>;
// };

// type Module1Uniforms = {
//   uniform1?: number;
//   uniform2?: [number, number];
// }

// type Module2Uniforms = {
//   uniform3: number;
//   uniform4: [number, number];
// }

// const shaderModule: ShaderModule<Module1Uniforms> = {
//   uniformTypes: {
//     uniform1: 'aaa',
//     uniform2: 'aaa'
//   }
// }


// const module1Uniforms = new ShaderModuleUniforms<Module1Uniforms>();

// module1Uniforms.setUniforms({
//   uniform1: 1,
//   uniform2: [1, 1]
// });



// setUniformStore(pipeline, blockIndex, block);

// GLSL utilities


// TYPE TESTS

/*
new UniformStore<ModuleUniforms>().setUniforms({
  uniform1: 1,
  uniform2: 1,
});

new UniformStore<ModuleUniforms>().setUniforms({
  three: 1,
  uniform1: 1,
});
*/

1	// luma.gl, MIT license	1✔
2	import {NumberArray, isNumberArray} from '@luma.gl/core';	1✔
3	import {Device, Buffer, UniformBufferLayout, ShaderUniformType} from '@luma.gl/core';	1✔
4	import {ShaderModule} from '@luma.gl/shadertools';	1✔
5		1✔
6	/** Duplicates definition in core module to avoid cross dependencies */	1✔
7	export type UniformValue = number \| boolean \| Readonly<NumberArray>; // Float32Array> \| Readonly<Int32Array> \| Readonly<Uint32Array> \| Readonly<number[]>;	1✔
8		1✔
9	/** A uniform store holds a number of uniform values and does some book keeping on what has changes */	1✔
10	export class ShaderModuleUniforms<TUniforms extends Record<string, UniformValue>> {	1✔
11	device: Device;	1✔
12	shaderModule: ShaderModule<TUniforms>;	1✔
13		1✔
14	useUniformBuffers: boolean;	1✔
15	uniformBufferLayout: UniformBufferLayout;	1✔
16	uniformBuffer: Buffer \| null = null;	1✔
17		1✔
18	uniforms: Record<string, UniformValue> = {};	1✔
19	modifiedUniforms: Record<string, boolean> = {};	1✔
20	modified: boolean = true;	1✔
21		1✔
22	needsRedraw: string \| false = 'initialized';	1✔
23		1✔
24	constructor(props?: {	1✔
25	device: Device;	×
26	shaderModule: ShaderModule<TUniforms>	×
27	}) {	×
28	this.device = props.device;	×
29	this.shaderModule = props.shaderModule;	×
30	this.useUniformBuffers = this.device.info.type !== 'webgl';	×
31		×
32	// extract uniform formats and create a uniform buffer layout	×
33	const uniformTypes: Record<string, ShaderUniformType> = {};	×
NEW 34	for (const [name, {format}] of Object.entries(props.shaderModule.uniformPropTypes \|\| {})) {	×
35	uniformTypes[name] = format;	×
36	}	×
37	this.uniformBufferLayout = new UniformBufferLayout(uniformTypes);	×
38		×
39	// create a uniform buffer	×
40	if (this.useUniformBuffers) {	×
41	this.uniformBuffer = this.device.createBuffer({	×
42	usage: Buffer.UNIFORM,	×
43	byteLength: this.uniformBufferLayout.byteLength	×
44	});	×
45	}	×
46	}	×
47		1✔
48	/** Set a map of uniforms */	1✔
49	setUniforms(uniforms: TUniforms): void {	1✔
50	for (const [key, value] of Object.entries(uniforms)) {	×
51	this._setUniform(key, value);	×
52	this.setNeedsRedraw(key);	×
53	}	×
54	}	×
55		1✔
56	setNeedsRedraw(reason: string): void {	1✔
57	this.needsRedraw = this.needsRedraw \|\| reason;	×
58	}	×
59		1✔
60	/**	1✔
61	* Updates the uniform buffer if needed.	1✔
62	* Clears the dirty flag.	1✔
63	*/	1✔
64	getUniformBuffer(): Buffer {	1✔
65	if (this.needsRedraw) {	×
66	const modifiedUniforms = this.getModifiedUniforms();	×
67	const data = this.uniformBufferLayout.getData(modifiedUniforms);	×
68	this.uniformBuffer.write(data);	×
69	}	×
70	return this.uniformBuffer;	×
71	}	×
72		1✔
73	/** Returns all uniforms */	1✔
74	getUniforms(groupName: string): Record<string, UniformValue> {	1✔
75	this.modifiedUniforms = {};	×
76	this.needsRedraw = false;	×
77	return (this.uniforms[groupName] \|\| {}) as Record<string, UniformValue>;	×
78	}	×
79		1✔
80	/** Returns modified uniforms */	1✔
81	getModifiedUniforms() {	1✔
82	const modifiedUniforms = this.modifiedUniforms;	×
83	this.modifiedUniforms = {};	×
84	this.needsRedraw = false;	×
85	return modifiedUniforms;	×
86	}	×
87		1✔
88	/** Set a single uniform */	1✔
89	private _setUniform(key: string, value: UniformValue) {	1✔
90	// if (this.layout[key] !== undefined) {	×
91	// this.uniforms[key] = value;	×
92	// this.modifiedUniforms[key] = true;	×
93	// this.modified = true;	×
94	// } else {	×
95	// log.warn(`Unknown uniform ${key}`)	×
96	// }	×
97	if (arrayEqual(this.uniforms[key], value)) {	×
98	return;	×
99	}	×
100	this.uniforms[key] = value;	×
101	this.modifiedUniforms[key] = true;	×
102	this.modified = true;	×
103	}	×
104	}	1✔
105		1✔
106	function arrayEqual(a: unknown, b: unknown, limit: number = 16) {	×
107	if (a !== b) {	×
108	return false;	×
109	}	×
110	const arrayA = isNumberArray(a);	×
111	if (!arrayA) {	×
112	return false;	×
113	}	×
114	const arrayB = isNumberArray(b);	×
115	if (arrayB && arrayA.length === arrayB.length) {	×
116	for (let i = 0; i < arrayA.length; ++i) {	×
117	if (arrayB[i] !== arrayA[i]) {	×
118	return false;	×
119	}	×
120	}	×
121	}	×
122	return true;	×
123	}	×
124		1✔
125		1✔
126	// export function makeUniformStore<I extends Record<string, Record<string, unknown>>>(name: string, uniforms: I): UniformStore<{ [P in keyof I]: I[P] }> {	1✔
127	// return new UniformStore<{ [P in keyof I]: I[P] }>({name, uniforms});	1✔
128	// }	1✔
129		1✔
130	// type ShaderModule<Uniforms extends Record<string, unknown> = {}> = {	1✔
131	// uniformTypes: Record<keyof Uniforms, string>;	1✔
132	// };	1✔
133		1✔
134	// type Module1Uniforms = {	1✔
135	// uniform1?: number;	1✔
136	// uniform2?: [number, number];	1✔
137	// }	1✔
138		1✔
139	// type Module2Uniforms = {	1✔
140	// uniform3: number;	1✔
141	// uniform4: [number, number];	1✔
142	// }	1✔
143		1✔
144	// const shaderModule: ShaderModule<Module1Uniforms> = {	1✔
145	// uniformTypes: {	1✔
146	// uniform1: 'aaa',	1✔
147	// uniform2: 'aaa'	1✔
148	// }	1✔
149	// }	1✔
150		1✔
151		1✔
152	// const module1Uniforms = new ShaderModuleUniforms<Module1Uniforms>();	1✔
153		1✔
154	// module1Uniforms.setUniforms({	1✔
155	// uniform1: 1,	1✔
156	// uniform2: [1, 1]	1✔
157	// });	1✔
158		1✔
159		1✔
160		1✔
161	// setUniformStore(pipeline, blockIndex, block);	1✔
162		1✔
163	// GLSL utilities	1✔
164		1✔
165		1✔
166	// TYPE TESTS	1✔
167		1✔
168	/*	1✔
169	new UniformStore<ModuleUniforms>().setUniforms({	1✔
170	uniform1: 1,	1✔
171	uniform2: 1,	1✔
172	});	1✔
173		1✔
174	new UniformStore<ModuleUniforms>().setUniforms({	1✔
175	three: 1,	1✔
176	uniform1: 1,	1✔
177	});	1✔
178	*/	1✔

visgl / luma.gl / 6858084886

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