@luma.gl/shadertools 9.1.0-alpha.1 → 9.1.0-alpha.10

package/src/lib/shader-module/shader-module.ts

@@ -2,10 +2,15 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {NumberArray} from '@math.gl/types';
-import {UniformFormat} from '../../types';
-import {PropType} from '../filters/prop-types';
+import type {NumberArray} from '@math.gl/types';
+import {Sampler, Texture} from '@luma.gl/core';
+import type {UniformFormat} from '../../types';
+import {PropType, PropValidator} from '../filters/prop-types';
+import {ShaderInjection} from '../shader-assembly/shader-injections';
+import {makePropValidators, getValidatedProperties} from '../filters/prop-types';
+import {normalizeInjections} from '../shader-assembly/shader-injections';
 
+export type BindingValue = Buffer | Texture | Sampler;
 export type UniformValue = number | boolean | Readonly<NumberArray>; // Float32Array> | Readonly<Int32Array> | Readonly<Uint32Array> | Readonly<number[]>;
 
 export type UniformInfo = {
@@ -14,20 +19,26 @@ export type UniformInfo = {
 
 /**
  * A shader module definition object
- * @note Can be viewed as the ShaderModuleProps for a ShaderModuleInstance
+ *
+ * @note Needs to be initialized with `initializeShaderModules`
  */
 export type ShaderModule<
   PropsT extends Record<string, unknown> = Record<string, unknown>,
   UniformsT extends Record<string, UniformValue> = Record<string, UniformValue>,
-  BindingsT extends Record<string, unknown> = {}
+  BindingsT extends Record<string, BindingValue> = Record<string, BindingValue>
 > = {
   /** Used for type inference not for values */
-  props?: Required<PropsT>;
+  props?: PropsT;
   /** Used for type inference, not currently used for values */
   uniforms?: UniformsT;
 
   name: string;
+
+  /** WGSL code */
+  source?: string;
+  /** GLSL fragment shader code */
   fs?: string;
+  /** GLSL vertex shader code */
   vs?: string;
 
   /** Uniform shader types @note: Both order and types MUST match uniform block declarations in shader */
@@ -37,9 +48,8 @@ export type ShaderModule<
   /** Default uniform values */
   defaultUniforms?: Required<UniformsT>; // Record<keyof UniformsT, UniformValue>;
 
-  /** Function that maps settings to uniforms */
-  // getUniforms?: (settings?: Partial<SettingsT>, prevUniforms?: any /* UniformsT */) => UniformsT;
-  getUniforms?: (settings?: any, prevUniforms?: any) => Record<string, UniformValue>;
+  /** Function that maps props to uniforms & bindings */
+  getUniforms?: (props?: any, oldProps?: any) => Record<string, BindingValue | UniformValue>;
 
   /** uniform buffers, textures, samplers, storage, ... */
   bindings?: Record<keyof BindingsT, {location: number; type: 'texture' | 'sampler' | 'uniforms'}>;
@@ -51,8 +61,16 @@ export type ShaderModule<
   /** Information on deprecated properties */
   deprecations?: ShaderModuleDeprecation[];
 
-  /** Internal */
-  normalized?: boolean;
+  /** The instance field contains information that is generated at run-time */
+  instance?: {
+    propValidators?: Record<string, PropValidator>;
+    parsedDeprecations: ShaderModuleDeprecation[];
+
+    normalizedInjections: {
+      vertex: Record<string, ShaderInjection>;
+      fragment: Record<string, ShaderInjection>;
+    };
+  };
 };
 
 /** Use to generate deprecations when shader module is used */
@@ -64,16 +82,109 @@ export type ShaderModuleDeprecation = {
   deprecated?: boolean;
 };
 
+// SHNDER MODULE API
+
+export function initializeShaderModules(modules: ShaderModule[]): void {
+  modules.map((module: ShaderModule) => initializeShaderModule(module));
+}
+
+export function initializeShaderModule(module: ShaderModule): void {
+  if (module.instance) {
+    return;
+  }
+
+  initializeShaderModules(module.dependencies || []);
+
+  const {
+    uniformPropTypes = {},
+    deprecations = [],
+    // defines = {},
+    inject = {}
+  } = module;
+
+  const instance: Required<ShaderModule>['instance'] = {
+    normalizedInjections: normalizeInjections(inject),
+    parsedDeprecations: parseDeprecationDefinitions(deprecations)
+  };
+
+  if (uniformPropTypes) {
+    instance.propValidators = makePropValidators(uniformPropTypes);
+  }
+
+  module.instance = instance;
+}
+
 /** Convert module props to uniforms */
 export function getShaderModuleUniforms<
   ShaderModuleT extends ShaderModule<Record<string, unknown>, Record<string, UniformValue>>
->(module: ShaderModuleT, props: ShaderModuleT['props']): ShaderModuleT['uniforms'] {
-  const uniforms = {...module.defaultUniforms};
+>(
+  module: ShaderModuleT,
+  props: ShaderModuleT['props'],
+  oldUniforms?: ShaderModuleT['uniforms']
+): Record<string, BindingValue | UniformValue> {
+  initializeShaderModule(module);
+
+  const uniforms = oldUniforms || {...module.defaultUniforms};
+  // If module has a getUniforms function, use it
   if (module.getUniforms) {
-    // @ts-expect-error
-    Object.assign(props, module.getUniforms(props));
-  } else {
-    Object.assign(uniforms, props);
+    return module.getUniforms(props, uniforms);
   }
-  return uniforms;
+
+  // Build uniforms from the uniforms array
+  // @ts-expect-error
+  return getValidatedProperties(props, module.instance?.propValidators, module.name);
+}
+
+/* TODO this looks like it was unused code
+  _defaultGetUniforms(opts: Record<string, any> = {}): Record<string, any> {
+    const uniforms: Record<string, any> = {};
+    const propTypes = this.uniforms;
+
+    for (const key in propTypes) {
+      const propDef = propTypes[key];
+      if (key in opts && !propDef.private) {
+        if (propDef.validate) {
+          assert(propDef.validate(opts[key], propDef), `${this.name}: invalid ${key}`);
+        }
+        uniforms[key] = opts[key];
+      } else {
+        uniforms[key] = propDef.value;
+      }
+    }
+
+    return uniforms;
+  }
+}
+*/
+// Warn about deprecated uniforms or functions
+export function checkShaderModuleDeprecations(
+  shaderModule: ShaderModule,
+  shaderSource: string,
+  log: any
+): void {
+  shaderModule.deprecations?.forEach(def => {
+    if (def.regex?.test(shaderSource)) {
+      if (def.deprecated) {
+        log.deprecated(def.old, def.new)();
+      } else {
+        log.removed(def.old, def.new)();
+      }
+    }
+  });
+}
+
+// HELPERS
+
+function parseDeprecationDefinitions(deprecations: ShaderModuleDeprecation[]) {
+  deprecations.forEach(def => {
+    switch (def.type) {
+      case 'function':
+        def.regex = new RegExp(`\\b${def.old}\\(`);
+        break;
+      default:
+        def.regex = new RegExp(`${def.type} ${def.old};`);
+    }
+  });
+
+  return deprecations;
 }

package/src/lib/shader-module/shader-pass.ts

@@ -5,8 +5,8 @@
 import type {ShaderModule, UniformValue} from './shader-module';
 
 /**
- * A shaderpass is a shader module with additional information
- * on how to run
+ * A ShaderPass is a ShaderModule that can be run "standalone" (e.g. post processing effects)
+ * It adds additional information on how to run the module in one or more passes.
  */
 export type ShaderPass<
   PropsT extends Record<string, unknown> = Record<string, unknown>,
@@ -15,6 +15,7 @@ export type ShaderPass<
   passes: ShaderPassData[];
 };
 
+/** Information on how to run a specific pass */
 type ShaderPassData = {
   sampler?: boolean;
   filter?: boolean;

package/src/module-injectors.ts

@@ -2,15 +2,13 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {glsl} from './lib/glsl-utils/highlight';
-
-export const MODULE_INJECTORS_VS = glsl`\
+export const MODULE_INJECTORS_VS = /* glsl */ `\
 #ifdef MODULE_LOGDEPTH
   logdepth_adjustPosition(gl_Position);
 #endif
 `;
 
-export const MODULE_INJECTORS_FS = glsl`\
+export const MODULE_INJECTORS_FS = /* glsl */ `\
 #ifdef MODULE_MATERIAL
   gl_FragColor = material_filterColor(gl_FragColor);
 #endif

package/src/modules/engine/geometry/geometry.ts

@@ -3,10 +3,9 @@
 // Copyright (c) vis.gl contributors
 
 // import {ShaderModule} from '../../types';
-import {glsl} from '../../../lib/glsl-utils/highlight';
 
 // TODO - reuse normal from geometry module
-const vs = glsl`\
+const vs = /* glsl */ `\
 varying vec4 geometry_vPosition;
 varying vec3 geometry_vNormal;
 
@@ -23,7 +22,7 @@ void geometry_setPosition(vec3 position) {
 }
 `;
 
-const fs = glsl`\
+const fs = /* glsl */ `\
 varying vec4 geometry_vPosition;
 varying vec3 geometry_vNormal;
 

package/src/modules/engine/picking/picking.ts

@@ -3,7 +3,6 @@
 // Copyright (c) vis.gl contributors
 
 import {NumberArray} from '../../../types';
-import {glsl} from '../../../lib/glsl-utils/highlight';
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
 
 // cyan color
@@ -50,7 +49,7 @@ export type PickingUniforms = {
   highlightColor?: NumberArray;
 };
 
-const vs = glsl`\
+const vs = /* glsl */ `\
 uniform pickingUniforms {
   float isActive;
   float isAttribute;
@@ -124,7 +123,7 @@ void picking_setPickingAttribute(vec3 value) {
 }
 `;
 
-const fs = glsl`\
+const fs = /* glsl */ `\
 uniform pickingUniforms {
   float isActive;
   float isAttribute;
@@ -191,7 +190,11 @@ vec4 picking_filterColor(vec4 color) {
  * primitives with the same picking color in non-instanced draw-calls
  */
 export const picking = {
+  props: {} as PickingProps,
+  uniforms: {} as PickingUniforms,
+
   name: 'picking',
+
   uniformTypes: {
     isActive: 'f32',
     isAttribute: 'f32',
@@ -208,10 +211,9 @@ export const picking = {
     highlightedObjectColor: new Float32Array([0, 0, 0]),
     highlightColor: DEFAULT_HIGHLIGHT_COLOR
   },
+
   vs,
   fs,
-  props: {} as Required<PickingProps>,
-  uniforms: {} as PickingUniforms,
   getUniforms
 } as const satisfies ShaderModule<PickingProps, PickingUniforms>;
 

package/src/modules/engine/project/project.ts

@@ -4,7 +4,6 @@
 
 import {NumericArray as NumberArray, Matrix4, Vector3} from '@math.gl/core';
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
-import {glsl} from '../../../lib/glsl-utils/highlight';
 
 const IDENTITY_MATRIX: Readonly<NumberArray> = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 
@@ -70,7 +69,7 @@ function getUniforms(
  * @note varyings must match vertex shader
  * @note project module uses unprefixed uniforms to match conventions
  */
-const vs = glsl`\
+const vs = /* glsl */ `\
 varying vec4 project_vPositionWorld;
 varying vec3 project_vNormalWorld;
 
@@ -132,7 +131,7 @@ vec4 project_to_clipspace(vec3 position) {
  * Functions to get the position and normal from the vertex shader
  * @note varyings must match vertex shader
  */
-const fs = glsl`\
+const fs = /* glsl */ `\
 varying vec4 project_vPositionWorld;
 varying vec3 project_vNormalWorld;
 

package/src/modules/engine/transform/transform.ts

@@ -2,9 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {glsl} from '../../../lib/glsl-utils/highlight';
-
-const vs = glsl`\
+const vs = /* glsl */ `\
 attribute float transform_elementID;
 
 // returns half of pixel size, used to move the pixel position to center of the pixel.

package/src/modules/lighting/gouraud-material/gouraud-material.ts

@@ -18,6 +18,9 @@ export type GouraudMaterialUniforms = {
 
 /** In Gouraud shading, color is calculated for each triangle vertex normal, and then color is interpolated colors across the triangle */
 export const gouraudMaterial = {
+  props: {} as GouraudMaterialProps,
+  uniforms: {} as GouraudMaterialUniforms,
+
   name: 'gouraud-lighting',
   // Note these are switched between phong and gouraud
   vs: GOURAUD_VS,
@@ -38,6 +41,7 @@ export const gouraudMaterial = {
     shininess: 32,
     specularColor: [0.15, 0.15, 0.15]
   },
+
   getUniforms(props: GouraudMaterialProps): GouraudMaterialUniforms {
     return {...gouraudMaterial.defaultUniforms, ...props};
   }

package/src/modules/lighting/gouraud-material/gouraud-shaders-glsl.ts

@@ -2,9 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {glsl} from '../../../lib/glsl-utils/highlight';
-
-export const GOURAUD_VS = glsl`\
+export const GOURAUD_VS = /* glsl */ `\
 uniform materialUniforms {
   uniform float ambient;
   uniform float diffuse;
@@ -13,7 +11,7 @@ uniform materialUniforms {
 } material;
 `;
 
-export const GOURAUD_FS = glsl`\
+export const GOURAUD_FS = /* glsl */ `\
 uniform materialUniforms {
   uniform float ambient;
   uniform float diffuse;

package/src/modules/lighting/lights/lighting-uniforms-glsl.ts

@@ -2,9 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {glsl} from '../../../lib/glsl-utils/highlight';
-
-export const lightingUniforms = glsl`\
+export const lightingUniforms = /* glsl */ `\
 precision highp int;
 
 // #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))

package/src/modules/lighting/lights/lighting.ts

@@ -68,7 +68,11 @@ export type LightingUniforms = {
 
 /** UBO ready lighting module */
 export const lighting = {
+  props: {} as LightingProps,
+  uniforms: {} as LightingUniforms,
+
   name: 'lighting',
+
   defines: {
     MAX_LIGHTS
   },
@@ -99,8 +103,6 @@ export const lighting = {
   vs: lightingUniforms,
   fs: lightingUniforms,
 
-  props: {} as Required<LightingProps>,
-  uniforms: {} as LightingUniforms,
   getUniforms
 } as const satisfies ShaderModule<LightingProps, LightingUniforms>;
 

package/src/modules/lighting/no-material/dirlight.ts

@@ -3,7 +3,6 @@
 // Copyright (c) vis.gl contributors
 
 import type {NumberArray} from '@math.gl/types';
-import {glsl} from '../../../lib/glsl-utils/highlight';
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
 
 export type DirlightProps = {
@@ -32,7 +31,7 @@ fn dirlight_filterColor(color: vec4<f32>, dirlightInputs): vec4<f32> {
 }
 `;
 
-const VS_GLSL = glsl`\
+const VS_GLSL = /* glsl */ `\
 out vec3 dirlight_vNormal;
 
 void dirlight_setNormal(vec3 normal) {
@@ -40,7 +39,7 @@ void dirlight_setNormal(vec3 normal) {
 }
 `;
 
-const FS_GLSL = glsl`\
+const FS_GLSL = /* glsl */ `\
 uniform dirlightUniforms {
   vec3 lightDirection;
 } dirlight;
@@ -58,10 +57,14 @@ vec4 dirlight_filterColor(vec4 color) {
  * Cheap lighting - single directional light, single dot product, one uniform
  */
 export const dirlight = {
+  props: {} as DirlightProps,
+  uniforms: {} as DirlightUniforms,
+
   name: 'dirlight',
   dependencies: [],
   vs: VS_GLSL,
   fs: FS_GLSL,
+
   // fragmentInputs: [
   //   {
   //     name: 'dirlight_vNormal',
@@ -74,8 +77,6 @@ export const dirlight = {
   defaultUniforms: {
     lightDirection: new Float32Array([1, 1, 2])
   },
-  props: {} as Required<DirlightProps>,
-  uniforms: {} as DirlightUniforms,
   getUniforms
 } as const satisfies ShaderModule<DirlightProps, DirlightUniforms>;
 

package/src/modules/lighting/pbr-material/pbr-fragment-glsl.ts

@@ -9,9 +9,8 @@
 // a microfacet surface material defined by a glTF model.
 
 // TODO - better do the checks outside of shader
-import {glsl} from '../../../lib/glsl-utils/highlight';
 
-export const fs = glsl`\
+export const fs = /* glsl */ `\
 precision highp float;
 
 uniform Projection {

package/src/modules/lighting/pbr-material/pbr-material.ts

@@ -15,35 +15,35 @@ import {vs} from './pbr-vertex-glsl';
 import {fs} from './pbr-fragment-glsl';
 
 export type PBRMaterialProps = PBRMaterialBindings & {
-  unlit: boolean;
+  unlit?: boolean;
 
   // Base color map
-  baseColorMapEnabled: boolean;
-  baseColorFactor: Readonly<Vector4 | NumberArray>;
+  baseColorMapEnabled?: boolean;
+  baseColorFactor?: Readonly<Vector4 | NumberArray>;
 
-  normalMapEnabled: boolean;
-  normalScale: number; // #ifdef HAS_NORMALMAP
+  normalMapEnabled?: boolean;
+  normalScale?: number; // #ifdef HAS_NORMALMAP
 
-  emissiveMapEnabled: boolean;
-  emissiveFactor: Readonly<Vector3 | NumberArray>; // #ifdef HAS_EMISSIVEMAP
+  emissiveMapEnabled?: boolean;
+  emissiveFactor?: Readonly<Vector3 | NumberArray>; // #ifdef HAS_EMISSIVEMAP
 
-  metallicRoughnessValues: Readonly<Vector2 | NumberArray>;
-  metallicRoughnessMapEnabled: boolean;
+  metallicRoughnessValues?: Readonly<Vector2 | NumberArray>;
+  metallicRoughnessMapEnabled?: boolean;
 
-  occlusionMapEnabled: boolean;
-  occlusionStrength: number; // #ifdef HAS_OCCLUSIONMAP
+  occlusionMapEnabled?: boolean;
+  occlusionStrength?: number; // #ifdef HAS_OCCLUSIONMAP
 
-  alphaCutoffEnabled: boolean;
-  alphaCutoff: number; // #ifdef ALPHA_CUTOFF
+  alphaCutoffEnabled?: boolean;
+  alphaCutoff?: number; // #ifdef ALPHA_CUTOFF
 
   // IBL
-  IBLenabled: boolean;
-  scaleIBLAmbient: Readonly<Vector2 | NumberArray>; // #ifdef USE_IBL
+  IBLenabled?: boolean;
+  scaleIBLAmbient?: Readonly<Vector2 | NumberArray>; // #ifdef USE_IBL
 
   // debugging flags used for shader output of intermediate PBR variables
   // #ifdef PBR_DEBUG
-  scaleDiffBaseMR: Readonly<Vector4 | NumberArray>;
-  scaleFGDSpec: Readonly<Vector4 | NumberArray>;
+  scaleDiffBaseMR?: Readonly<Vector4 | NumberArray>;
+  scaleFGDSpec?: Readonly<Vector4 | NumberArray>;
 };
 
 /** Non-uniform block bindings for pbr module */
@@ -56,41 +56,41 @@ type PBRMaterialBindings = {
   occlusionSampler?: Texture | null; // #ifdef HAS_OCCLUSIONMAP
 
   // IBL Samplers
-  diffuseEnvSampler: Texture | null; // #ifdef USE_IBL (samplerCube)
-  specularEnvSampler: Texture | null; // #ifdef USE_IBL (samplerCube)
+  diffuseEnvSampler?: Texture | null; // #ifdef USE_IBL (samplerCube)
+  specularEnvSampler?: Texture | null; // #ifdef USE_IBL (samplerCube)
   brdfLUT?: Texture | null; // #ifdef USE_IBL
 };
 
 export type PBRMaterialUniforms = {
-  unlit: boolean;
+  unlit?: boolean;
 
   // Base color map
-  baseColorMapEnabled: boolean;
-  baseColorFactor: Readonly<Vector4 | NumberArray>;
+  baseColorMapEnabled?: boolean;
+  baseColorFactor?: Readonly<Vector4 | NumberArray>;
 
-  normalMapEnabled: boolean;
-  normalScale: number; // #ifdef HAS_NORMALMAP
+  normalMapEnabled?: boolean;
+  normalScale?: number; // #ifdef HAS_NORMALMAP
 
-  emissiveMapEnabled: boolean;
-  emissiveFactor: Readonly<Vector3 | NumberArray>; // #ifdef HAS_EMISSIVEMAP
+  emissiveMapEnabled?: boolean;
+  emissiveFactor?: Readonly<Vector3 | NumberArray>; // #ifdef HAS_EMISSIVEMAP
 
-  metallicRoughnessValues: Readonly<Vector2 | NumberArray>;
-  metallicRoughnessMapEnabled: boolean;
+  metallicRoughnessValues?: Readonly<Vector2 | NumberArray>;
+  metallicRoughnessMapEnabled?: boolean;
 
-  occlusionMapEnabled: boolean;
-  occlusionStrength: number; // #ifdef HAS_OCCLUSIONMAP
+  occlusionMapEnabled?: boolean;
+  occlusionStrength?: number; // #ifdef HAS_OCCLUSIONMAP
 
-  alphaCutoffEnabled: boolean;
-  alphaCutoff: number; // #ifdef ALPHA_CUTOFF
+  alphaCutoffEnabled?: boolean;
+  alphaCutoff?: number; // #ifdef ALPHA_CUTOFF
 
   // IBL
-  IBLenabled: boolean;
-  scaleIBLAmbient: Readonly<Vector2 | NumberArray>; // #ifdef USE_IBL
+  IBLenabled?: boolean;
+  scaleIBLAmbient?: Readonly<Vector2 | NumberArray>; // #ifdef USE_IBL
 
   // debugging flags used for shader output of intermediate PBR variables
   // #ifdef PBR_DEBUG
-  scaleDiffBaseMR: Readonly<Vector4 | NumberArray>;
-  scaleFGDSpec: Readonly<Vector4 | NumberArray>;
+  scaleDiffBaseMR?: Readonly<Vector4 | NumberArray>;
+  scaleFGDSpec?: Readonly<Vector4 | NumberArray>;
 };
 
 /**
@@ -98,9 +98,14 @@ export type PBRMaterialUniforms = {
  * Physically Based Shading of a microfacet surface defined by a glTF material.
  */
 export const pbrMaterial = {
+  props: {} as PBRMaterialProps,
+  uniforms: {} as PBRMaterialUniforms,
+
   name: 'pbr',
+  dependencies: [lighting],
   vs,
   fs,
+
   defines: {
     LIGHTING_FRAGMENT: 1,
     HAS_NORMALMAP: 0,
@@ -112,6 +117,7 @@ export const pbrMaterial = {
     USE_IBL: 0,
     PBR_DEBUG: 0
   },
+
   uniformTypes: {
     // Material is unlit
     unlit: 'i32',
@@ -144,6 +150,7 @@ export const pbrMaterial = {
     scaleDiffBaseMR: 'vec4<f32>',
     scaleFGDSpec: 'vec4<f32>'
   },
+
   bindings: {
     baseColorSampler: {type: 'texture', location: 8}, // #ifdef HAS_BASECOLORMAP
     normalSampler: {type: 'texture', location: 9}, // #ifdef HAS_NORMALMAP
@@ -154,6 +161,5 @@ export const pbrMaterial = {
     diffuseEnvSampler: {type: 'texture', location: 13}, // #ifdef USE_IBL (samplerCube)
     specularEnvSampler: {type: 'texture', location: 14}, // #ifdef USE_IBL (samplerCube)
     brdfLUT: {type: 'texture', location: 15} // #ifdef USE_IBL
-  },
-  dependencies: [lighting]
+  }
 } as const satisfies ShaderModule<PBRMaterialProps, PBRMaterialUniforms>;

package/src/modules/lighting/pbr-material/pbr-uniforms-glsl.ts

@@ -2,9 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {glsl} from '../../../lib/glsl-utils/highlight';
-
-export const pbrMaterialUniforms = glsl`\
+export const pbrMaterialUniforms = /* glsl */ `\
 uniform Projection {
   // Projection
   vec3 u_Camera;

package/src/modules/lighting/pbr-material/pbr-vertex-glsl.ts

@@ -2,9 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {glsl} from '../../../lib/glsl-utils/highlight';
-
-export const vs = glsl`\
+export const vs = /* glsl */ `\
 uniform projection {
   mat4 u_MVPMatrix;
   mat4 u_ModelMatrix;