7274005159

Committed 20 Dec 2023 10:18AM UTC coverage: 72.749% (-0.1%) from 72.891%

Build # 7274005159

Build Type

Pull #1888

github

Committed by

web-flow

Commit Message

Merge 18b1f1ed9 into b4bc0fa8b

Pull Request Pull Request #1888: feat(webgl) Allow passing null to setIndexBuffer

Run Details

1299 of 1751 branches covered (0.0%)

Branch coverage included in aggregate %.

2 of 3 new or added lines in 1 file covered. (66.67%)

144 existing lines in 12 files now uncovered.

20979 of 28872 relevant lines covered (72.66%)

16.41 hits per line

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

93.33

/modules/shadertools/src/lib/shader-transpiler/transpile-glsl-shader.ts

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

// TRANSPILATION TABLES

/**
 * Transpiles GLSL 3.00 shader source code to target GLSL version (3.00 or 1.00)
 *
 * @note We always run transpiler even if same version e.g. 3.00 => 3.00
 * @note For texture sampling transpilation, apps need to use non-standard texture* calls in GLSL 3.00 source
 * RFC: https://github.com/visgl/luma.gl/blob/7.0-release/dev-docs/RFCs/v6.0/portable-glsl-300-rfc.md
 */
export function transpileGLSLShader(
  source: string,
  targetGLSLVersion: 100 | 300,
  stage: 'vertex' | 'fragment'
): string {
  const sourceGLSLVersion = Number(source.match(/^#version[ \t]+(\d+)/m)?.[1] || 100);
  if (sourceGLSLVersion !== 300) {
    // TODO - longer error message to help deck.gl layer writers
    throw new Error('luma.gl v9 only supports GLSL 3.00 shader sources');
  }

  switch (targetGLSLVersion) {
    case 300:
      switch (stage) {
        case 'vertex':
          source = convertShader(source, ES300_VERTEX_REPLACEMENTS);
          return source;
        case 'fragment':
          source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS);
          return source;
        default:
          // Unknown shader stage
          throw new Error(stage);
      }
      
    case 100:
      switch (stage) {
        case 'vertex':
          source = convertShader(source, ES100_VERTEX_REPLACEMENTS);
          return source;
        case 'fragment':
          source = convertShader(source, ES100_FRAGMENT_REPLACEMENTS);
          source = convertFragmentShaderTo100(source);
          return source;
        default:
          // Unknown shader stage
          throw new Error(stage);
      }

    default:
      // Unknown GLSL version
      throw new Error(String(targetGLSLVersion));
  }
}

type GLSLReplacement = [RegExp, string];

/** Simple regex replacements for GLSL ES 1.00 syntax that has changed in GLSL ES 3.00 */
const ES300_REPLACEMENTS: GLSLReplacement[] = [
  // Fix poorly formatted version directive
  [/^(#version[ \t]+(100|300[ \t]+es))?[ \t]*\n/, '#version 300 es\n'],
  // The individual `texture...()` functions were replaced with `texture()` overloads
  [/\btexture(2D|2DProj|Cube)Lod(EXT)?\(/g, 'textureLod('],
  [/\btexture(2D|2DProj|Cube)(EXT)?\(/g, 'texture(']
];

const ES300_VERTEX_REPLACEMENTS: GLSLReplacement[] = [
  ...ES300_REPLACEMENTS,
  // `attribute` keyword replaced with `in`
  [makeVariableTextRegExp('attribute'), 'in $1'],
  // `varying` keyword replaced with `out`
  [makeVariableTextRegExp('varying'), 'out $1']
];

/** Simple regex replacements for GLSL ES 1.00 syntax that has changed in GLSL ES 3.00 */
const ES300_FRAGMENT_REPLACEMENTS: GLSLReplacement[] = [
  ...ES300_REPLACEMENTS,
  // `varying` keyword replaced with `in`
  [makeVariableTextRegExp('varying'), 'in $1']
];

const ES100_REPLACEMENTS: GLSLReplacement[] = [
  [/^#version[ \t]+300[ \t]+es/, '#version 100'],

  // In GLSL 1.00 ES these functions are provided by an extension
  [/\btexture(2D|2DProj|Cube)Lod\(/g, 'texture$1LodEXT('],

  // Overloads in GLSL 3.00 map to individual functions. Note that we cannot
  // differentiate 2D,2DProj,Cube without type analysis so we choose the most common variant.
  [/\btexture\(/g, 'texture2D('],
  [/\btextureLod\(/g, 'texture2DLodEXT(']
];

const ES100_VERTEX_REPLACEMENTS: GLSLReplacement[] = [
  ...ES100_REPLACEMENTS,
  [makeVariableTextRegExp('in'), 'attribute $1'],
  [makeVariableTextRegExp('out'), 'varying $1']
];

const ES100_FRAGMENT_REPLACEMENTS: GLSLReplacement[] = [
  ...ES100_REPLACEMENTS,
  // Replace `in` with `varying`
  [makeVariableTextRegExp('in'), 'varying $1']
];

const ES100_FRAGMENT_OUTPUT_NAME: string = 'gl_FragColor';
const ES300_FRAGMENT_OUTPUT_REGEX: RegExp = /\bout[ \t]+vec4[ \t]+(\w+)[ \t]*;\n?/;
// const REGEX_START_OF_MAIN: RegExp = /void\s+main\s*\([^)]*\)\s*\{\n?/; // Beginning of main

function convertShader(source: string, replacements: GLSLReplacement[]) {
  for (const [pattern, replacement] of replacements) {
    source = source.replace(pattern, replacement);
  }
  return source;
}

/** Transform fragment shader source code to GLSL ES 100 */
function convertFragmentShaderTo100(source: string): string {
  source = convertShader(source, ES100_FRAGMENT_REPLACEMENTS);

  // TODO - This seems like a hack to find the color output name,
  // what if we have several outputs?
  const outputMatch = ES300_FRAGMENT_OUTPUT_REGEX.exec(source);
  if (outputMatch) {
    const outputName = outputMatch[1];
    source = source
      // Remove the GLSL300 output declaration
      .replace(ES300_FRAGMENT_OUTPUT_REGEX, '')
      // Replace any found output name 
      .replace(new RegExp(`\\b${outputName}\\b`, 'g'), ES100_FRAGMENT_OUTPUT_NAME);
  }

  return source;
}

/**
 * Creates a regexp that tests for a specific variable type
 * @example
 *   should match:
 *     in float weight;
 *     out vec4 positions[2];
 *   should not match:
 *     void f(out float a, in float b) {}
 */
function makeVariableTextRegExp(qualifier: 'attribute' | 'varying' | 'in' | 'out'): RegExp {
  return new RegExp(`\\b${qualifier}[ \\t]+(\\w+[ \\t]+\\w+(\\[\\w+\\])?;)`, 'g');
}

1	// luma.gl, MIT license	1✔
2	// Copyright (c) vis.gl contributors	1✔
3		1✔
4	// TRANSPILATION TABLES	1✔
5		1✔
6	/**	1✔
7	* Transpiles GLSL 3.00 shader source code to target GLSL version (3.00 or 1.00)	1✔
8	*	1✔
9	* @note We always run transpiler even if same version e.g. 3.00 => 3.00	1✔
10	* @note For texture sampling transpilation, apps need to use non-standard texture* calls in GLSL 3.00 source	1✔
11	* RFC: https://github.com/visgl/luma.gl/blob/7.0-release/dev-docs/RFCs/v6.0/portable-glsl-300-rfc.md	1✔
12	*/	1✔
13	export function transpileGLSLShader(	1✔
14	source: string,	70✔
15	targetGLSLVersion: 100 \| 300,	70✔
16	stage: 'vertex' \| 'fragment'	70✔
17	): string {	70✔
18	const sourceGLSLVersion = Number(source.match(/^#version[ \t]+(\d+)/m)?.[1] \|\| 100);	70!
19	if (sourceGLSLVersion !== 300) {	70!
UNCOV 20	// TODO - longer error message to help deck.gl layer writers	×
UNCOV 21	throw new Error('luma.gl v9 only supports GLSL 3.00 shader sources');	×
UNCOV 22	}	×
23		70✔
24	switch (targetGLSLVersion) {	70✔
25	case 300:	70✔
26	switch (stage) {	30✔
27	case 'vertex':	30✔
28	source = convertShader(source, ES300_VERTEX_REPLACEMENTS);	15✔
29	return source;	15✔
30	case 'fragment':	30✔
31	source = convertShader(source, ES300_FRAGMENT_REPLACEMENTS);	15✔
32	return source;	15✔
33	default:	30!
UNCOV 34	// Unknown shader stage	×
UNCOV 35	throw new Error(stage);	×
36	}	30✔
37		70✔
38	case 100:	70✔
39	switch (stage) {	38✔
40	case 'vertex':	38✔
41	source = convertShader(source, ES100_VERTEX_REPLACEMENTS);	19✔
42	return source;	19✔
43	case 'fragment':	38✔
44	source = convertShader(source, ES100_FRAGMENT_REPLACEMENTS);	19✔
45	source = convertFragmentShaderTo100(source);	19✔
46	return source;	19✔
47	default:	38!
UNCOV 48	// Unknown shader stage	×
UNCOV 49	throw new Error(stage);	×
50	}	38✔
51		70✔
52	default:	70✔
53	// Unknown GLSL version	2✔
54	throw new Error(String(targetGLSLVersion));	2✔
55	}	70✔
56	}	70✔
57		1✔
58	type GLSLReplacement = [RegExp, string];	1✔
59		1✔
60	/** Simple regex replacements for GLSL ES 1.00 syntax that has changed in GLSL ES 3.00 */	1✔
61	const ES300_REPLACEMENTS: GLSLReplacement[] = [	1✔
62	// Fix poorly formatted version directive	1✔
63	[/^(#version[ \t]+(100\|300[ \t]+es))?[ \t]*\n/, '#version 300 es\n'],	1✔
64	// The individual `texture...()` functions were replaced with `texture()` overloads	1✔
65	[/\btexture(2D\|2DProj\|Cube)Lod(EXT)?\(/g, 'textureLod('],	1✔
66	[/\btexture(2D\|2DProj\|Cube)(EXT)?\(/g, 'texture(']	1✔
67	];	1✔
68		1✔
69	const ES300_VERTEX_REPLACEMENTS: GLSLReplacement[] = [	1✔
70	...ES300_REPLACEMENTS,	1✔
71	// `attribute` keyword replaced with `in`	1✔
72	[makeVariableTextRegExp('attribute'), 'in $1'],	1✔
73	// `varying` keyword replaced with `out`	1✔
74	[makeVariableTextRegExp('varying'), 'out $1']	1✔
75	];	1✔
76		1✔
77	/** Simple regex replacements for GLSL ES 1.00 syntax that has changed in GLSL ES 3.00 */	1✔
78	const ES300_FRAGMENT_REPLACEMENTS: GLSLReplacement[] = [	1✔
79	...ES300_REPLACEMENTS,	1✔
80	// `varying` keyword replaced with `in`	1✔
81	[makeVariableTextRegExp('varying'), 'in $1']	1✔
82	];	1✔
83		1✔
84	const ES100_REPLACEMENTS: GLSLReplacement[] = [	1✔
85	[/^#version[ \t]+300[ \t]+es/, '#version 100'],	1✔
86		1✔
87	// In GLSL 1.00 ES these functions are provided by an extension	1✔
88	[/\btexture(2D\|2DProj\|Cube)Lod\(/g, 'texture$1LodEXT('],	1✔
89		1✔
90	// Overloads in GLSL 3.00 map to individual functions. Note that we cannot	1✔
91	// differentiate 2D,2DProj,Cube without type analysis so we choose the most common variant.	1✔
92	[/\btexture\(/g, 'texture2D('],	1✔
93	[/\btextureLod\(/g, 'texture2DLodEXT(']	1✔
94	];	1✔
95		1✔
96	const ES100_VERTEX_REPLACEMENTS: GLSLReplacement[] = [	1✔
97	...ES100_REPLACEMENTS,	1✔
98	[makeVariableTextRegExp('in'), 'attribute $1'],	1✔
99	[makeVariableTextRegExp('out'), 'varying $1']	1✔
100	];	1✔
101		1✔
102	const ES100_FRAGMENT_REPLACEMENTS: GLSLReplacement[] = [	1✔
103	...ES100_REPLACEMENTS,	1✔
104	// Replace `in` with `varying`	1✔
105	[makeVariableTextRegExp('in'), 'varying $1']	1✔
106	];	1✔
107		1✔
108	const ES100_FRAGMENT_OUTPUT_NAME: string = 'gl_FragColor';	1✔
109	const ES300_FRAGMENT_OUTPUT_REGEX: RegExp = /\bout[ \t]+vec4[ \t]+(\w+)[ \t]*;\n?/;	1✔
110	// const REGEX_START_OF_MAIN: RegExp = /void\s+main\s\([^)]\)\s*\{\n?/; // Beginning of main	1✔
111		1✔
112	function convertShader(source: string, replacements: GLSLReplacement[]) {	87✔
113	for (const [pattern, replacement] of replacements) {	87✔
114	source = source.replace(pattern, replacement);	439✔
115	}	439✔
116	return source;	87✔
117	}	87✔
118		1✔
119	/** Transform fragment shader source code to GLSL ES 100 */	1✔
120	function convertFragmentShaderTo100(source: string): string {	19✔
121	source = convertShader(source, ES100_FRAGMENT_REPLACEMENTS);	19✔
122		19✔
123	// TODO - This seems like a hack to find the color output name,	19✔
124	// what if we have several outputs?	19✔
125	const outputMatch = ES300_FRAGMENT_OUTPUT_REGEX.exec(source);	19✔
126	if (outputMatch) {	19✔
127	const outputName = outputMatch[1];	19✔
128	source = source	19✔
129	// Remove the GLSL300 output declaration	19✔
130	.replace(ES300_FRAGMENT_OUTPUT_REGEX, '')	19✔
131	// Replace any found output name	19✔
132	.replace(new RegExp(`\\b${outputName}\\b`, 'g'), ES100_FRAGMENT_OUTPUT_NAME);	19✔
133	}	19✔
134		19✔
135	return source;	19✔
136	}	19✔
137		1✔
138	/**	1✔
139	* Creates a regexp that tests for a specific variable type	1✔
140	* @example	1✔
141	* should match:	1✔
142	* in float weight;	1✔
143	* out vec4 positions[2];	1✔
144	* should not match:	1✔
145	* void f(out float a, in float b) {}	1✔
146	*/	1✔
147	function makeVariableTextRegExp(qualifier: 'attribute' \| 'varying' \| 'in' \| 'out'): RegExp {	6✔
148	return new RegExp(`\\b${qualifier}[ \\t]+(\\w+[ \\t]+\\w+(\\[\\w+\\])?;)`, 'g');	6✔
149	}	6✔

visgl / luma.gl / 7274005159

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