8114606077

Committed 01 Mar 2024 05:01PM UTC coverage: 76.888% (-0.07%) from 76.96%

Build # 8114606077

Build Type

Pull #1980

github

Committed by

web-flow

Commit Message

Merge 040e4b45e into f0bc8f2f8

Pull Request Pull Request #1980: feat(shadertools): ShaderAssembler.assembleSingleShader/assembleShade…

Run Details

1853 of 2391 branches covered (77.5%)

Branch coverage included in aggregate %.

73 of 106 new or added lines in 5 files covered. (68.87%)

19 existing lines in 2 files now uncovered.

22535 of 29328 relevant lines covered (76.84%)

21.92 hits per line

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

71.21

/modules/shadertools/src/lib/shader-assembly/assemble-shaders.ts

// luma.gl
// SPDX-License-Identifier: MIT
// Copyright (c) vis.gl contributors

import {glsl} from '../glsl-utils/highlight';
import {resolveModules} from './resolve-modules';
import {PlatformInfo} from './platform-info';
import {getPlatformShaderDefines, getVersionDefines} from './platform-defines';
import {injectShader, DECLARATION_INJECT_MARKER} from './shader-injections';
import {transpileGLSLShader} from '../shader-transpiler/transpile-glsl-shader';
import {ShaderModuleInstance} from '../shader-module/shader-module-instance';
import type {ShaderInjection} from './shader-injections';
import type {ShaderModule} from '../shader-module/shader-module';
import {ShaderHook, normalizeShaderHooks, getShaderHooks} from './shader-hooks';
import {assert} from '../utils/assert';
import {getShaderInfo} from '../glsl-utils/get-shader-info';

/** Define map */
export type ShaderDefine = string | number | boolean;

const INJECT_SHADER_DECLARATIONS = `\n\n${DECLARATION_INJECT_MARKER}\n`;

/**
 * Precision prologue to inject before functions are injected in shader
 * TODO - extract any existing prologue in the fragment source and move it up...
 */
const FRAGMENT_SHADER_PROLOGUE = glsl`\
precision highp float;
`;

export type HookFunction = {hook: string; header: string; footer: string; signature?: string};

export type AssembleShaderOptions = {
  /** information about the platform (which shader language & version, extensions etc.) */
  platformInfo: PlatformInfo;
  /** Inject shader id #defines */
  id?: string;
  /** Single WGSL shader */
  source?: string;
  /** Vertex shader */
  vs?: string;
  /** Fragment shader */
  fs?: string;
  /** Modules to be injected */
  modules?: (ShaderModule | ShaderModuleInstance)[];
  /** Defines to be injected */
  defines?: Record<string, ShaderDefine>;
  /** Hook functions */
  hookFunctions?: (ShaderHook | string)[];
  /** Code injections */
  inject?: Record<string, string | ShaderInjection>;
  /** Whether to inject prologue */
  prologue?: boolean;
  /** logger object */
  log?: any;
};

type AssembleStageOptions = {
  /** Inject shader id #defines */
  id?: string;
  /** Vertex shader */
  source: string;
  stage: 'vertex' | 'fragment';
  /** Modules to be injected */
  modules: any[];
  /** Defines to be injected */
  defines?: Record<string, ShaderDefine>;
  /** Hook functions */
  hookFunctions?: (ShaderHook | string)[];
  /** Code injections */
  inject?: Record<string, string | ShaderInjection>;
  /** Whether to inject prologue */
  prologue?: boolean;
  /** logger object */
  log?: any;
};

/**
 * getUniforms function returned from the shader module system
 */
export type GetUniformsFunc = (opts: Record<string, any>) => Record<string, any>;

/**
 * Inject a list of shader modules into a single shader source for WGSL
 */
export function assembleSingleShaderWGSL(options: AssembleShaderOptions): {
  source: string;
  getUniforms: GetUniformsFunc;
} {
  const modules = resolveModules(options.modules || []);
  return {
    source: assembleWGSLShader(options.platformInfo, {
      ...options,
      source: options.source,
      stage: 'vertex',
      modules
    }),
    getUniforms: assembleGetUniforms(modules)
  };
}

/**
 * Injects dependent shader module sources into pair of main vertex/fragment shader sources for WGSL
 */
export function assembleShaderPairWGSL(options: AssembleShaderOptions): {
  vs: string;
  fs: string;
  getUniforms: GetUniformsFunc;
} {
  const modules = resolveModules(options.modules || []);

  return {
    vs: assembleWGSLShader(options.platformInfo, {
      ...options,
      source: options.vs,
      stage: 'vertex',
      modules
    }),
    fs: assembleWGSLShader(options.platformInfo, {
      ...options,
      source: options.fs,
      stage: 'fragment',
      modules
    }),
    getUniforms: assembleGetUniforms(modules)
  };
}

/**
 * Injects dependent shader module sources into pair of main vertex/fragment shader sources for GLSL
 */
export function assembleShaderPairGLSL(options: AssembleShaderOptions): {
  vs: string;
  fs: string;
  getUniforms: GetUniformsFunc;
} {
  const {vs, fs} = options;
  const modules = resolveModules(options.modules || []);

  return {
    vs: assembleGLSLShader(options.platformInfo, {
      ...options,
      source: vs,
      stage: 'vertex',
      modules
    }),
    fs: assembleGLSLShader(options.platformInfo, {
      ...options,
      source: fs,
      stage: 'fragment',
      modules
    }),
    getUniforms: assembleGetUniforms(modules)
  };
}

/**
 * Pulls together complete source code for either a vertex or a fragment shader
 * adding prologues, requested module chunks, and any final injections.
 * @param gl
 * @param options
 * @returns
 */
export function assembleWGSLShader(platformInfo: PlatformInfo, options: AssembleStageOptions) {
  const {
    // id,
    source,
    stage,
    modules,
    // defines = {},
    hookFunctions = [],
    inject = {},
    log
  } = options;

  assert(typeof source === 'string', 'shader source must be a string');

  // const isVertex = type === 'vs';
  // const sourceLines = source.split('\n');

  const coreSource = source;

  // Combine Module and Application Defines
  // const allDefines = {};
  // modules.forEach(module => {
  //   Object.assign(allDefines, module.getDefines());
  // });
  // Object.assign(allDefines, defines);

  // Add platform defines (use these to work around platform-specific bugs and limitations)
  // Add common defines (GLSL version compatibility, feature detection)
  // Add precision declaration for fragment shaders
  let assembledSource = '';
  //   prologue
  //     ? `\
  // ${getShaderNameDefine({id, source, type})}
  // ${getShaderType(type)}
  // ${getPlatformShaderDefines(platformInfo)}
  // ${getVersionDefines(platformInfo)}
  // ${getApplicationDefines(allDefines)}
  // ${isVertex ? '' : FRAGMENT_SHADER_PROLOGUE}
  // `
  // `;

  const hookFunctionMap = normalizeShaderHooks(hookFunctions);

  // Add source of dependent modules in resolved order
  const hookInjections: Record<string, ShaderInjection[]> = {};
  const declInjections: Record<string, ShaderInjection[]> = {};
  const mainInjections: Record<string, ShaderInjection[]> = {};

  for (const key in inject) {
    const injection =
      typeof inject[key] === 'string' ? {injection: inject[key], order: 0} : inject[key];
    const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key);
    if (match) {
      const hash = match[2];
      const name = match[3];
      if (hash) {
        if (name === 'decl') {
          declInjections[key] = [injection as any];
        } else {
          mainInjections[key] = [injection as any];
        }
      } else {
        hookInjections[key] = [injection as any];
      }
    } else {
      // Regex injection
      mainInjections[key] = [injection as any];
    }
  }

  // TODO - hack until shadertool modules support WebGPU
  const modulesToInject = platformInfo.type !== 'webgpu' ? modules : [];

  for (const module of modulesToInject) {
    if (log) {
      module.checkDeprecations(coreSource, log);
    }
    const moduleSource = module.getModuleSource(stage, 'wgsl');
    // Add the module source, and a #define that declares it presence
    assembledSource += moduleSource;

    const injections = module.injections[stage];
    for (const key in injections) {
      const match = /^(v|f)s:#([\w-]+)$/.exec(key);
      if (match) {
        const name = match[2];
        const injectionType = name === 'decl' ? declInjections : mainInjections;
        injectionType[key] = injectionType[key] || [];
        injectionType[key].push(injections[key]);
      } else {
        hookInjections[key] = hookInjections[key] || [];
        hookInjections[key].push(injections[key]);
      }
    }
  }

  // For injectShader
  assembledSource += INJECT_SHADER_DECLARATIONS;

  assembledSource = injectShader(assembledSource, stage, declInjections);

  assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);

  // Add the version directive and actual source of this shader
  assembledSource += coreSource;

  // Apply any requested shader injections
  assembledSource = injectShader(assembledSource, stage, mainInjections);

  return assembledSource;
}

/**
 * Pulls together complete source code for either a vertex or a fragment shader
 * adding prologues, requested module chunks, and any final injections.
 * @param gl
 * @param options
 * @returns
 */
function assembleGLSLShader(
  platformInfo: PlatformInfo,
  options: {
    id?: string;
    source: string;
    language?: 'glsl' | 'wgsl';
    stage: 'vertex' | 'fragment';
    modules: ShaderModuleInstance[];
    defines?: Record<string, ShaderDefine>;
    hookFunctions?: any[];
    inject?: Record<string, string | ShaderInjection>;
    prologue?: boolean;
    log?: any;
  }
) {
  const {
    id,
    source,
    stage,
    language = 'glsl',
    modules,
    defines = {},
    hookFunctions = [],
    inject = {},
    prologue = true,
    log
  } = options;

  assert(typeof source === 'string', 'shader source must be a string');

  const sourceVersion = language === 'glsl' ? getShaderInfo(source).version : -1;
  const targetVersion = platformInfo.shaderLanguageVersion;

  const sourceVersionDirective = sourceVersion === 100 ? '#version 100' : '#version 300 es';

  const sourceLines = source.split('\n');
  // TODO : keep all pre-processor statements at the beginning of the shader.
  const coreSource = sourceLines.slice(1).join('\n');

  // Combine Module and Application Defines
  const allDefines = {};
  modules.forEach(module => {
    Object.assign(allDefines, module.getDefines());
  });
  Object.assign(allDefines, defines);

  // Add platform defines (use these to work around platform-specific bugs and limitations)
  // Add common defines (GLSL version compatibility, feature detection)
  // Add precision declaration for fragment shaders
  let assembledSource = '';
  switch (language) {
    case 'wgsl':
      break;
    case 'glsl':
      assembledSource = prologue
        ? `\
${sourceVersionDirective}

// ----- PROLOGUE -------------------------
${getShaderNameDefine({id, source, stage})}
${`#define SHADER_TYPE_${stage.toUpperCase()}`}
${getPlatformShaderDefines(platformInfo)}
${getVersionDefines(platformInfo)}
${stage === 'fragment' ? FRAGMENT_SHADER_PROLOGUE : ''}

// ----- APPLICATION DEFINES -------------------------

${getApplicationDefines(allDefines)}

`
        : `${sourceVersionDirective}
`;
      break;
  }

  const hookFunctionMap = normalizeShaderHooks(hookFunctions);

  // Add source of dependent modules in resolved order
  const hookInjections: Record<string, ShaderInjection[]> = {};
  const declInjections: Record<string, ShaderInjection[]> = {};
  const mainInjections: Record<string, ShaderInjection[]> = {};

  for (const key in inject) {
    // @ts-expect-error
    const injection: ShaderInjection =
      typeof inject[key] === 'string' ? {injection: inject[key], order: 0} : inject[key];
    const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key);
    if (match) {
      const hash = match[2];
      const name = match[3];
      if (hash) {
        if (name === 'decl') {
          declInjections[key] = [injection];
        } else {
          mainInjections[key] = [injection];
        }
      } else {
        hookInjections[key] = [injection];
      }
    } else {
      // Regex injection
      mainInjections[key] = [injection];
    }
  }

  for (const module of modules) {
    if (log) {
      module.checkDeprecations(coreSource, log);
    }
    const moduleSource = module.getModuleSource(stage);
    // Add the module source, and a #define that declares it presence
    assembledSource += moduleSource;

    const injections = module.injections[stage];
    for (const key in injections) {
      const match = /^(v|f)s:#([\w-]+)$/.exec(key);
      if (match) {
        const name = match[2];
        const injectionType = name === 'decl' ? declInjections : mainInjections;
        injectionType[key] = injectionType[key] || [];
        injectionType[key].push(injections[key]);
      } else {
        hookInjections[key] = hookInjections[key] || [];
        hookInjections[key].push(injections[key]);
      }
    }
  }

  assembledSource += '// ----- MAIN SHADER SOURCE -------------------------';

  // For injectShader
  assembledSource += INJECT_SHADER_DECLARATIONS;

  assembledSource = injectShader(assembledSource, stage, declInjections);

  assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);

  // Add the version directive and actual source of this shader
  assembledSource += coreSource;

  // Apply any requested shader injections
  assembledSource = injectShader(assembledSource, stage, mainInjections);

  if (language === 'glsl' && sourceVersion !== targetVersion) {
    assembledSource = transpileGLSLShader(assembledSource, stage);
  }

  return assembledSource.trim();
}

/**
 * Returns a combined `getUniforms` covering the options for all the modules,
 * the created function will pass on options to the inidividual `getUniforms`
 * function of each shader module and combine the results into one object that
 * can be passed to setUniforms.
 * @param modules
 * @returns
 */
export function assembleGetUniforms(modules: ShaderModuleInstance[]) {
  return function getUniforms(opts: Record<string, any>): Record<string, any> {
    const uniforms = {};
    for (const module of modules) {
      // `modules` is already sorted by dependency level. This guarantees that
      // modules have access to the uniforms that are generated by their dependencies.
      const moduleUniforms = module.getUniforms(opts, uniforms);
      Object.assign(uniforms, moduleUniforms);
    }
    return uniforms;
  };
}

/**
 * Generate "glslify-compatible" SHADER_NAME defines
 * These are understood by the GLSL error parsing function
 * If id is provided and no SHADER_NAME constant is present in source, create one
 */
function getShaderNameDefine(options: {
  id?: string;
  source: string;
  stage: 'vertex' | 'fragment';
}): string {
  const {id, source, stage} = options;
  const injectShaderName = id && source.indexOf('SHADER_NAME') === -1;
  return injectShaderName
    ? `
#define SHADER_NAME ${id}_${stage}

`
    : '';
}

/** Generates application defines from an object of key value pairs */
function getApplicationDefines(defines: Record<string, ShaderDefine> = {}): string {
  let sourceText = '';
  for (const define in defines) {
    const value = defines[define];
    if (value || Number.isFinite(value)) {
      sourceText += `#define ${define.toUpperCase()} ${defines[define]}\n`;
    }
  }
  return sourceText;
}

/*
function getHookFunctions(
  hookFunctions: Record<string, HookFunction>,
  hookInjections: Record<string, Injection[]>
): string {
  let result = '';
  for (const hookName in hookFunctions) {
    const hookFunction = hookFunctions[hookName];
    result += `void ${hookFunction.signature} {\n`;
    if (hookFunction.header) {
      result += `  ${hookFunction.header}`;
    }
    if (hookInjections[hookName]) {
      const injections = hookInjections[hookName];
      injections.sort((a: {order: number}, b: {order: number}): number => a.order - b.order);
      for (const injection of injections) {
        result += `  ${injection.injection}\n`;
      }
    }
    if (hookFunction.footer) {
      result += `  ${hookFunction.footer}`;
    }
    result += '}\n';
  }

  return result;
}

function normalizeHookFunctions(hookFunctions: (string | HookFunction)[]): {
  vs: Record<string, HookFunction>;
  fs: Record<string, HookFunction>;
} {
  const result: {vs: Record<string, any>; fs: Record<string, any>} = {
    vs: {},
    fs: {}
  };

  hookFunctions.forEach((hookFunction: string | HookFunction) => {
    let opts: HookFunction;
    let hook: string;
    if (typeof hookFunction !== 'string') {
      opts = hookFunction;
      hook = opts.hook;
    } else {
      opts = {} as HookFunction;
      hook = hookFunction;
    }
    hook = hook.trim();
    const [stage, signature] = hook.split(':');
    const name = hook.replace(/\(.+/, '');
    if (stage !== 'vs' && stage !== 'fs') {
      throw new Error(stage);
    }
    result[stage][name] = Object.assign(opts, {signature});
  });

  return result;
}
*/

1	// luma.gl	1✔
2	// SPDX-License-Identifier: MIT	1✔
3	// Copyright (c) vis.gl contributors	1✔
4		1✔
5	import {glsl} from '../glsl-utils/highlight';	1✔
6	import {resolveModules} from './resolve-modules';	1✔
7	import {PlatformInfo} from './platform-info';	1✔
8	import {getPlatformShaderDefines, getVersionDefines} from './platform-defines';	1✔
9	import {injectShader, DECLARATION_INJECT_MARKER} from './shader-injections';	1✔
10	import {transpileGLSLShader} from '../shader-transpiler/transpile-glsl-shader';	1✔
11	import {ShaderModuleInstance} from '../shader-module/shader-module-instance';	1✔
12	import type {ShaderInjection} from './shader-injections';	1✔
13	import type {ShaderModule} from '../shader-module/shader-module';	1✔
14	import {ShaderHook, normalizeShaderHooks, getShaderHooks} from './shader-hooks';	1✔
15	import {assert} from '../utils/assert';	1✔
16	import {getShaderInfo} from '../glsl-utils/get-shader-info';	1✔
17		1✔
18	/** Define map */	1✔
19	export type ShaderDefine = string \| number \| boolean;	1✔
20		1✔
21	const INJECT_SHADER_DECLARATIONS = `\n\n${DECLARATION_INJECT_MARKER}\n`;	1✔
22		1✔
23	/**	1✔
24	* Precision prologue to inject before functions are injected in shader	1✔
25	* TODO - extract any existing prologue in the fragment source and move it up...	1✔
26	*/	1✔
27	const FRAGMENT_SHADER_PROLOGUE = glsl`\	1✔
28	precision highp float;	1✔
29	`;	1✔
30		1✔
31	export type HookFunction = {hook: string; header: string; footer: string; signature?: string};	1✔
32		1✔
33	export type AssembleShaderOptions = {	1✔
34	/** information about the platform (which shader language & version, extensions etc.) */	1✔
35	platformInfo: PlatformInfo;	1✔
36	/** Inject shader id #defines */	1✔
37	id?: string;	1✔
38	/** Single WGSL shader */	1✔
39	source?: string;	1✔
40	/** Vertex shader */	1✔
41	vs?: string;	1✔
42	/** Fragment shader */	1✔
43	fs?: string;	1✔
44	/** Modules to be injected */	1✔
45	modules?: (ShaderModule \| ShaderModuleInstance)[];	1✔
46	/** Defines to be injected */	1✔
47	defines?: Record<string, ShaderDefine>;	1✔
48	/** Hook functions */	1✔
49	hookFunctions?: (ShaderHook \| string)[];	1✔
50	/** Code injections */	1✔
51	inject?: Record<string, string \| ShaderInjection>;	1✔
52	/** Whether to inject prologue */	1✔
53	prologue?: boolean;	1✔
54	/** logger object */	1✔
55	log?: any;	1✔
56	};	1✔
57		1✔
58	type AssembleStageOptions = {	1✔
59	/** Inject shader id #defines */	1✔
60	id?: string;	1✔
61	/** Vertex shader */	1✔
62	source: string;	1✔
63	stage: 'vertex' \| 'fragment';	1✔
64	/** Modules to be injected */	1✔
65	modules: any[];	1✔
66	/** Defines to be injected */	1✔
67	defines?: Record<string, ShaderDefine>;	1✔
68	/** Hook functions */	1✔
69	hookFunctions?: (ShaderHook \| string)[];	1✔
70	/** Code injections */	1✔
71	inject?: Record<string, string \| ShaderInjection>;	1✔
72	/** Whether to inject prologue */	1✔
73	prologue?: boolean;	1✔
74	/** logger object */	1✔
75	log?: any;	1✔
76	};	1✔
77		1✔
78	/**	1✔
79	* getUniforms function returned from the shader module system	1✔
80	*/	1✔
81	export type GetUniformsFunc = (opts: Record<string, any>) => Record<string, any>;	1✔
82		1✔
83	/**	1✔
84	* Inject a list of shader modules into a single shader source for WGSL	1✔
85	*/	1✔
86	export function assembleSingleShaderWGSL(options: AssembleShaderOptions): {	1✔
NEW 87	source: string;	×
NEW 88	getUniforms: GetUniformsFunc;	×
NEW 89	} {	×
NEW 90	const modules = resolveModules(options.modules \|\| []);	×
NEW 91	return {	×
NEW 92	source: assembleWGSLShader(options.platformInfo, {	×
NEW 93	...options,	×
NEW 94	source: options.source,	×
NEW 95	stage: 'vertex',	×
NEW 96	modules	×
NEW 97	}),	×
NEW 98	getUniforms: assembleGetUniforms(modules)	×
NEW 99	};	×
NEW 100	}	×
101		1✔
102	/**	1✔
103	* Injects dependent shader module sources into pair of main vertex/fragment shader sources for WGSL	1✔
104	*/	1✔
105	export function assembleShaderPairWGSL(options: AssembleShaderOptions): {	1✔
UNCOV 106	vs: string;	×
UNCOV 107	fs: string;	×
UNCOV 108	getUniforms: GetUniformsFunc;	×
UNCOV 109	} {	×
UNCOV 110	const modules = resolveModules(options.modules \|\| []);	×
UNCOV 111		×
NEW 112	return {	×
NEW 113	vs: assembleWGSLShader(options.platformInfo, {	×
NEW 114	...options,	×
NEW 115	source: options.vs,	×
NEW 116	stage: 'vertex',	×
NEW 117	modules	×
NEW 118	}),	×
NEW 119	fs: assembleWGSLShader(options.platformInfo, {	×
NEW 120	...options,	×
NEW 121	source: options.fs,	×
NEW 122	stage: 'fragment',	×
NEW 123	modules	×
NEW 124	}),	×
NEW 125	getUniforms: assembleGetUniforms(modules)	×
NEW 126	};	×
NEW 127	}	×
128		1✔
129	/**	1✔
130	* Injects dependent shader module sources into pair of main vertex/fragment shader sources for GLSL	1✔
131	*/	1✔
132	export function assembleShaderPairGLSL(options: AssembleShaderOptions): {	1✔
133	vs: string;	56✔
134	fs: string;	56✔
135	getUniforms: GetUniformsFunc;	56✔
136	} {	56✔
137	const {vs, fs} = options;	56✔
138	const modules = resolveModules(options.modules \|\| []);	56✔
139		56✔
140	return {	56✔
141	vs: assembleGLSLShader(options.platformInfo, {	56✔
142	...options,	56✔
143	source: vs,	56✔
144	stage: 'vertex',	56✔
145	modules	56✔
146	}),	56✔
147	fs: assembleGLSLShader(options.platformInfo, {	56✔
148	...options,	56✔
149	source: fs,	56✔
150	stage: 'fragment',	56✔
151	modules	56✔
152	}),	56✔
153	getUniforms: assembleGetUniforms(modules)	56✔
154	};	56✔
155	}	56✔
156		1✔
157	/**	1✔
158	* Pulls together complete source code for either a vertex or a fragment shader	1✔
159	* adding prologues, requested module chunks, and any final injections.	1✔
160	* @param gl	1✔
161	* @param options	1✔
162	* @returns	1✔
163	*/	1✔
164	export function assembleWGSLShader(platformInfo: PlatformInfo, options: AssembleStageOptions) {	1✔
165	const {	×
166	// id,	×
167	source,	×
168	stage,	×
169	modules,	×
170	// defines = {},	×
171	hookFunctions = [],	×
172	inject = {},	×
173	log	×
174	} = options;	×
175		×
176	assert(typeof source === 'string', 'shader source must be a string');	×
177		×
178	// const isVertex = type === 'vs';	×
179	// const sourceLines = source.split('\n');	×
180		×
181	const coreSource = source;	×
182		×
183	// Combine Module and Application Defines	×
184	// const allDefines = {};	×
185	// modules.forEach(module => {	×
186	// Object.assign(allDefines, module.getDefines());	×
187	// });	×
188	// Object.assign(allDefines, defines);	×
189		×
190	// Add platform defines (use these to work around platform-specific bugs and limitations)	×
191	// Add common defines (GLSL version compatibility, feature detection)	×
192	// Add precision declaration for fragment shaders	×
193	let assembledSource = '';	×
194	// prologue	×
195	// ? `\	×
196	// ${getShaderNameDefine({id, source, type})}	×
197	// ${getShaderType(type)}	×
198	// ${getPlatformShaderDefines(platformInfo)}	×
199	// ${getVersionDefines(platformInfo)}	×
200	// ${getApplicationDefines(allDefines)}	×
201	// ${isVertex ? '' : FRAGMENT_SHADER_PROLOGUE}	×
202	// `	×
203	// `;	×
204		×
205	const hookFunctionMap = normalizeShaderHooks(hookFunctions);	×
206		×
207	// Add source of dependent modules in resolved order	×
208	const hookInjections: Record<string, ShaderInjection[]> = {};	×
209	const declInjections: Record<string, ShaderInjection[]> = {};	×
210	const mainInjections: Record<string, ShaderInjection[]> = {};	×
211		×
212	for (const key in inject) {	×
213	const injection =	×
214	typeof inject[key] === 'string' ? {injection: inject[key], order: 0} : inject[key];	×
215	const match = /^(v\|f)s:(#)?([\w-]+)$/.exec(key);	×
216	if (match) {	×
217	const hash = match[2];	×
218	const name = match[3];	×
219	if (hash) {	×
220	if (name === 'decl') {	×
221	declInjections[key] = [injection as any];	×
222	} else {	×
223	mainInjections[key] = [injection as any];	×
224	}	×
225	} else {	×
226	hookInjections[key] = [injection as any];	×
227	}	×
228	} else {	×
229	// Regex injection	×
230	mainInjections[key] = [injection as any];	×
231	}	×
232	}	×
233		×
234	// TODO - hack until shadertool modules support WebGPU	×
235	const modulesToInject = platformInfo.type !== 'webgpu' ? modules : [];	×
236		×
237	for (const module of modulesToInject) {	×
238	if (log) {	×
239	module.checkDeprecations(coreSource, log);	×
240	}	×
241	const moduleSource = module.getModuleSource(stage, 'wgsl');	×
242	// Add the module source, and a #define that declares it presence	×
243	assembledSource += moduleSource;	×
244		×
245	const injections = module.injections[stage];	×
246	for (const key in injections) {	×
247	const match = /^(v\|f)s:#([\w-]+)$/.exec(key);	×
248	if (match) {	×
249	const name = match[2];	×
250	const injectionType = name === 'decl' ? declInjections : mainInjections;	×
251	injectionType[key] = injectionType[key] \|\| [];	×
252	injectionType[key].push(injections[key]);	×
253	} else {	×
254	hookInjections[key] = hookInjections[key] \|\| [];	×
255	hookInjections[key].push(injections[key]);	×
256	}	×
257	}	×
258	}	×
259		×
260	// For injectShader	×
261	assembledSource += INJECT_SHADER_DECLARATIONS;	×
262		×
263	assembledSource = injectShader(assembledSource, stage, declInjections);	×
264		×
265	assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);	×
266		×
267	// Add the version directive and actual source of this shader	×
268	assembledSource += coreSource;	×
269		×
270	// Apply any requested shader injections	×
271	assembledSource = injectShader(assembledSource, stage, mainInjections);	×
272		×
273	return assembledSource;	×
274	}	×
275		1✔
276	/**	1✔
277	* Pulls together complete source code for either a vertex or a fragment shader	1✔
278	* adding prologues, requested module chunks, and any final injections.	1✔
279	* @param gl	1✔
280	* @param options	1✔
281	* @returns	1✔
282	*/	1✔
283	function assembleGLSLShader(	112✔
284	platformInfo: PlatformInfo,	112✔
285	options: {	112✔
286	id?: string;	112✔
287	source: string;	112✔
288	language?: 'glsl' \| 'wgsl';	112✔
289	stage: 'vertex' \| 'fragment';	112✔
290	modules: ShaderModuleInstance[];	112✔
291	defines?: Record<string, ShaderDefine>;	112✔
292	hookFunctions?: any[];	112✔
293	inject?: Record<string, string \| ShaderInjection>;	112✔
294	prologue?: boolean;	112✔
295	log?: any;	112✔
296	}	112✔
297	) {	112✔
298	const {	112✔
299	id,	112✔
300	source,	112✔
301	stage,	112✔
302	language = 'glsl',	112✔
303	modules,	112✔
304	defines = {},	112✔
305	hookFunctions = [],	112✔
306	inject = {},	112✔
307	prologue = true,	112✔
308	log	112✔
309	} = options;	112✔
310		112✔
311	assert(typeof source === 'string', 'shader source must be a string');	112✔
312		112✔
313	const sourceVersion = language === 'glsl' ? getShaderInfo(source).version : -1;	112!
314	const targetVersion = platformInfo.shaderLanguageVersion;	112✔
315		112✔
316	const sourceVersionDirective = sourceVersion === 100 ? '#version 100' : '#version 300 es';	112!
317		112✔
318	const sourceLines = source.split('\n');	112✔
319	// TODO : keep all pre-processor statements at the beginning of the shader.	112✔
320	const coreSource = sourceLines.slice(1).join('\n');	112✔
321		112✔
322	// Combine Module and Application Defines	112✔
323	const allDefines = {};	112✔
324	modules.forEach(module => {	112✔
325	Object.assign(allDefines, module.getDefines());	58✔
326	});	112✔
327	Object.assign(allDefines, defines);	112✔
328		112✔
329	// Add platform defines (use these to work around platform-specific bugs and limitations)	112✔
330	// Add common defines (GLSL version compatibility, feature detection)	112✔
331	// Add precision declaration for fragment shaders	112✔
332	let assembledSource = '';	112✔
333	switch (language) {	112✔
334	case 'wgsl':	112!
335	break;	×
336	case 'glsl':	112✔
337	assembledSource = prologue	112✔
338	? `\	110✔
339	${sourceVersionDirective}	110✔
340		110✔
341	// ----- PROLOGUE -------------------------	110✔
342	${getShaderNameDefine({id, source, stage})}	110✔
343	${`#define SHADER_TYPE_${stage.toUpperCase()}`}	110✔
344	${getPlatformShaderDefines(platformInfo)}	110✔
345	${getVersionDefines(platformInfo)}	110✔
346	${stage === 'fragment' ? FRAGMENT_SHADER_PROLOGUE : ''}	110✔
347		110✔
348	// ----- APPLICATION DEFINES -------------------------	110✔
349		110✔
350	${getApplicationDefines(allDefines)}	110✔
351		2✔
352	`	2✔
353	: `${sourceVersionDirective}	2✔
354	`;	112✔
355	break;	112✔
356	}	112✔
357		112✔
358	const hookFunctionMap = normalizeShaderHooks(hookFunctions);	112✔
359		112✔
360	// Add source of dependent modules in resolved order	112✔
361	const hookInjections: Record<string, ShaderInjection[]> = {};	112✔
362	const declInjections: Record<string, ShaderInjection[]> = {};	112✔
363	const mainInjections: Record<string, ShaderInjection[]> = {};	112✔
364		112✔
365	for (const key in inject) {	112✔
366	// @ts-expect-error	32✔
367	const injection: ShaderInjection =	32✔
368	typeof inject[key] === 'string' ? {injection: inject[key], order: 0} : inject[key];	32!
369	const match = /^(v\|f)s:(#)?([\w-]+)$/.exec(key);	32✔
370	if (match) {	32✔
371	const hash = match[2];	30✔
372	const name = match[3];	30✔
373	if (hash) {	30✔
374	if (name === 'decl') {	16✔
375	declInjections[key] = [injection];	8✔
376	} else {	8✔
377	mainInjections[key] = [injection];	8✔
378	}	8✔
379	} else {	30✔
380	hookInjections[key] = [injection];	14✔
381	}	14✔
382	} else {	32✔
383	// Regex injection	2✔
384	mainInjections[key] = [injection];	2✔
385	}	2✔
386	}	32✔
387		112✔
388	for (const module of modules) {	112✔
389	if (log) {	58!
390	module.checkDeprecations(coreSource, log);	×
391	}	×
392	const moduleSource = module.getModuleSource(stage);	58✔
393	// Add the module source, and a #define that declares it presence	58✔
394	assembledSource += moduleSource;	58✔
395		58✔
396	const injections = module.injections[stage];	58✔
397	for (const key in injections) {	58✔
398	const match = /^(v\|f)s:#([\w-]+)$/.exec(key);	16✔
399	if (match) {	16✔
400	const name = match[2];	5✔
401	const injectionType = name === 'decl' ? declInjections : mainInjections;	5✔
402	injectionType[key] = injectionType[key] \|\| [];	5✔
403	injectionType[key].push(injections[key]);	5✔
404	} else {	16✔
405	hookInjections[key] = hookInjections[key] \|\| [];	11✔
406	hookInjections[key].push(injections[key]);	11✔
407	}	11✔
408	}	16✔
409	}	58✔
410		112✔
411	assembledSource += '// ----- MAIN SHADER SOURCE -------------------------';	112✔
412		112✔
413	// For injectShader	112✔
414	assembledSource += INJECT_SHADER_DECLARATIONS;	112✔
415		112✔
416	assembledSource = injectShader(assembledSource, stage, declInjections);	112✔
417		112✔
418	assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);	112✔
419		112✔
420	// Add the version directive and actual source of this shader	112✔
421	assembledSource += coreSource;	112✔
422		112✔
423	// Apply any requested shader injections	112✔
424	assembledSource = injectShader(assembledSource, stage, mainInjections);	112✔
425		112✔
426	if (language === 'glsl' && sourceVersion !== targetVersion) {	112!
427	assembledSource = transpileGLSLShader(assembledSource, stage);	×
428	}	×
429		112✔
430	return assembledSource.trim();	112✔
431	}	112✔
432		1✔
433	/**	1✔
434	* Returns a combined `getUniforms` covering the options for all the modules,	1✔
435	* the created function will pass on options to the inidividual `getUniforms`	1✔
436	* function of each shader module and combine the results into one object that	1✔
437	* can be passed to setUniforms.	1✔
438	* @param modules	1✔
439	* @returns	1✔
440	*/	1✔
441	export function assembleGetUniforms(modules: ShaderModuleInstance[]) {	1✔
442	return function getUniforms(opts: Record<string, any>): Record<string, any> {	56✔
443	const uniforms = {};	×
444	for (const module of modules) {	×
445	// `modules` is already sorted by dependency level. This guarantees that	×
446	// modules have access to the uniforms that are generated by their dependencies.	×
447	const moduleUniforms = module.getUniforms(opts, uniforms);	×
448	Object.assign(uniforms, moduleUniforms);	×
449	}	×
450	return uniforms;	×
451	};	×
452	}	56✔
453		1✔
454	/**	1✔
455	* Generate "glslify-compatible" SHADER_NAME defines	1✔
456	* These are understood by the GLSL error parsing function	1✔
457	* If id is provided and no SHADER_NAME constant is present in source, create one	1✔
458	*/	1✔
459	function getShaderNameDefine(options: {	110✔
460	id?: string;	110✔
461	source: string;	110✔
462	stage: 'vertex' \| 'fragment';	110✔
463	}): string {	110✔
464	const {id, source, stage} = options;	110✔
465	const injectShaderName = id && source.indexOf('SHADER_NAME') === -1;	110✔
466	return injectShaderName	110✔
467	? `	58✔
468	#define SHADER_NAME ${id}_${stage}	58✔
469		52✔
470	`	52✔
471	: '';	52✔
472	}	110✔
473		1✔
474	/** Generates application defines from an object of key value pairs */	1✔
475	function getApplicationDefines(defines: Record<string, ShaderDefine> = {}): string {	110✔
476	let sourceText = '';	110✔
477	for (const define in defines) {	110✔
478	const value = defines[define];	12✔
479	if (value \|\| Number.isFinite(value)) {	12!
480	sourceText += `#define ${define.toUpperCase()} ${defines[define]}\n`;	12✔
481	}	12✔
482	}	12✔
483	return sourceText;	110✔
484	}	110✔
485		1✔
486	/*	1✔
487	function getHookFunctions(	1✔
488	hookFunctions: Record<string, HookFunction>,	1✔
489	hookInjections: Record<string, Injection[]>	1✔
490	): string {	1✔
491	let result = '';	1✔
492	for (const hookName in hookFunctions) {	1✔
493	const hookFunction = hookFunctions[hookName];	1✔
494	result += `void ${hookFunction.signature} {\n`;	1✔
495	if (hookFunction.header) {	1✔
496	result += ` ${hookFunction.header}`;	1✔
497	}	1✔
498	if (hookInjections[hookName]) {	1✔
499	const injections = hookInjections[hookName];	1✔
500	injections.sort((a: {order: number}, b: {order: number}): number => a.order - b.order);	1✔
501	for (const injection of injections) {	1✔
502	result += ` ${injection.injection}\n`;	1✔
503	}	1✔
504	}	1✔
505	if (hookFunction.footer) {	1✔
506	result += ` ${hookFunction.footer}`;	1✔
507	}	1✔
508	result += '}\n';	1✔
509	}	1✔
510		1✔
511	return result;	1✔
512	}	1✔
513		1✔
514	function normalizeHookFunctions(hookFunctions: (string \| HookFunction)[]): {	1✔
515	vs: Record<string, HookFunction>;	1✔
516	fs: Record<string, HookFunction>;	1✔
517	} {	1✔
518	const result: {vs: Record<string, any>; fs: Record<string, any>} = {	1✔
519	vs: {},	1✔
520	fs: {}	1✔
521	};	1✔
522		1✔
523	hookFunctions.forEach((hookFunction: string \| HookFunction) => {	1✔
524	let opts: HookFunction;	1✔
525	let hook: string;	1✔
526	if (typeof hookFunction !== 'string') {	1✔
527	opts = hookFunction;	1✔
528	hook = opts.hook;	1✔
529	} else {	1✔
530	opts = {} as HookFunction;	1✔
531	hook = hookFunction;	1✔
532	}	1✔
533	hook = hook.trim();	1✔
534	const [stage, signature] = hook.split(':');	1✔
535	const name = hook.replace(/\(.+/, '');	1✔
536	if (stage !== 'vs' && stage !== 'fs') {	1✔
537	throw new Error(stage);	1✔
538	}	1✔
539	result[stage][name] = Object.assign(opts, {signature});	1✔
540	});	1✔
541		1✔
542	return result;	1✔
543	}	1✔
544	*/	1✔

visgl / luma.gl / 8114606077

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