8217921255

Committed 09 Mar 2024 11:37PM UTC coverage: 76.909% (+0.4%) from 76.531%

Build # 8217921255

Build Type

Pull #1860

github

Committed by

web-flow

Commit Message

Merge 8308f3a5b into d98bc4db5

Pull Request Pull Request #1860: chore(webgl): Refactor WEBGLTexture class - WIP for v9.1

Run Details

1796 of 2345 branches covered (76.59%)

Branch coverage included in aggregate %.

1122 of 1509 new or added lines in 22 files covered. (74.35%)

35 existing lines in 3 files now uncovered.

22875 of 29733 relevant lines covered (76.93%)

20.67 hits per line

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

55.02

/modules/gltf/src/pbr/parse-pbr-material.ts

import type {Device, Texture, Binding, Parameters} from '@luma.gl/core';
import {log} from '@luma.gl/core';
import {PBREnvironment} from './pbr-environment';

/* eslint-disable camelcase */

export type ParsePBRMaterialOptions = {
  /** Debug PBR shader */
  pbrDebug?: boolean;
  /** Enable lights */
  lights?: any;
  /** Use tangents */
  useTangents?: boolean;
  /** provide an image based (texture cube) lighting environment */
  imageBasedLightingEnvironment?: PBREnvironment;
};

export type ParsedPBRMaterial = {
  readonly defines: Record<string, number | boolean>;
  readonly bindings: Record<string, Binding>;
  readonly uniforms: Record<string, any>;
  readonly parameters: Parameters;
  readonly glParameters: Record<string, any>;
  /** List of all generated textures, makes it easy to destroy them later */
  readonly generatedTextures: Texture[];
};

// NOTE: Modules other than `@luma.gl/webgl` should not import `GL` from
// `@luma.gl/constants`. Locally we use `GLEnum` instead of `GL` to avoid
// conflicts with the `babel-plugin-inline-webgl-constants` plugin.
enum GLEnum {
  FUNC_ADD = 0x8006,
  ONE = 1,
  SRC_ALPHA = 0x0302,
  ONE_MINUS_SRC_ALPHA = 0x0303,
  TEXTURE_MIN_FILTER = 0x2801,
  LINEAR = 0x2601,
  LINEAR_MIPMAP_NEAREST = 0x2701,
  UNPACK_FLIP_Y_WEBGL = 0x9240
}

/**
 * Parses a GLTF material definition into uniforms and parameters for the PBR shader module
 */
export function parsePBRMaterial(
  device: Device,
  material,
  attributes: Record<string, any>,
  options: ParsePBRMaterialOptions
): ParsedPBRMaterial {
  const parsedMaterial: ParsedPBRMaterial = {
    defines: {
      // TODO: Use EXT_sRGB if available (Standard in WebGL 2.0)
      MANUAL_SRGB: 1,
      SRGB_FAST_APPROXIMATION: 1
    },
    bindings: {},
    uniforms: {
      // TODO: find better values?
      u_Camera: [0, 0, 0], // Model should override

      u_MetallicRoughnessValues: [1, 1] // Default is 1 and 1
    },
    parameters: {},
    glParameters: {},
    generatedTextures: []
  };

  // TODO - always available
  parsedMaterial.defines.USE_TEX_LOD = 1;

  const {imageBasedLightingEnvironment} = options;
  if (imageBasedLightingEnvironment) {
    parsedMaterial.bindings.u_DiffuseEnvSampler =
      imageBasedLightingEnvironment.diffuseEnvSampler.texture;
    parsedMaterial.bindings.u_SpecularEnvSampler =
      imageBasedLightingEnvironment.specularEnvSampler.texture;
    parsedMaterial.bindings.u_brdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
    parsedMaterial.uniforms.u_ScaleIBLAmbient = [1, 1];
  }

  if (options?.pbrDebug) {
    parsedMaterial.defines.PBR_DEBUG = 1;
    // Override final color for reference app visualization of various parameters in the lighting equation.
    parsedMaterial.uniforms.u_ScaleDiffBaseMR = [0, 0, 0, 0];
    parsedMaterial.uniforms.u_ScaleFGDSpec = [0, 0, 0, 0];
  }

  if (attributes.NORMAL) parsedMaterial.defines.HAS_NORMALS = 1;
  if (attributes.TANGENT && options?.useTangents) parsedMaterial.defines.HAS_TANGENTS = 1;
  if (attributes.TEXCOORD_0) parsedMaterial.defines.HAS_UV = 1;

  if (options?.imageBasedLightingEnvironment) parsedMaterial.defines.USE_IBL = 1;
  if (options?.lights) parsedMaterial.defines.USE_LIGHTS = 1;

  if (material) {
    parseMaterial(device, material, parsedMaterial);
  }

  return parsedMaterial;
}

/** Parse GLTF material record */
function parseMaterial(device: Device, material, parsedMaterial: ParsedPBRMaterial): void {
  parsedMaterial.uniforms.pbr_uUnlit = Boolean(material.unlit);

  if (material.pbrMetallicRoughness) {
    parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);
  }
  if (material.normalTexture) {
    addTexture(device, material.normalTexture, 'u_NormalSampler', 'HAS_NORMALMAP', parsedMaterial);

    const {scale = 1} = material.normalTexture;
    parsedMaterial.uniforms.u_NormalScale = scale;
  }
  if (material.occlusionTexture) {
    addTexture(
      device,
      material.occlusionTexture,
      'u_OcclusionSampler',
      'HAS_OCCLUSIONMAP',
      parsedMaterial
    );

    const {strength = 1} = material.occlusionTexture;
    parsedMaterial.uniforms.u_OcclusionStrength = strength;
  }
  if (material.emissiveTexture) {
    addTexture(
      device,
      material.emissiveTexture,
      'u_EmissiveSampler',
      'HAS_EMISSIVEMAP',
      parsedMaterial
    );
    parsedMaterial.uniforms.u_EmissiveFactor = material.emissiveFactor || [0, 0, 0];
  }

  switch (material.alphaMode) {
    case 'MASK':
      const {alphaCutoff = 0.5} = material;
      parsedMaterial.defines.ALPHA_CUTOFF = 1;
      parsedMaterial.uniforms.u_AlphaCutoff = alphaCutoff;
      break;
    case 'BLEND':
      log.warn('glTF BLEND alphaMode might not work well because it requires mesh sorting')();

      // WebGPU style parameters
      parsedMaterial.parameters.blendColorOperation = 'add';
      parsedMaterial.parameters.blendColorSrcFactor = 'src-alpha';
      parsedMaterial.parameters.blendColorDstFactor = 'one-minus-src-alpha';

      parsedMaterial.parameters.blendAlphaOperation = 'add';
      parsedMaterial.parameters.blendAlphaSrcFactor = 'one';
      parsedMaterial.parameters.blendAlphaDstFactor = 'one-minus-src-alpha';

      // GL parameters
      parsedMaterial.glParameters.blend = true;
      parsedMaterial.glParameters.blendEquation = GLEnum.FUNC_ADD;
      parsedMaterial.glParameters.blendFunc = [
        GLEnum.SRC_ALPHA,
        GLEnum.ONE_MINUS_SRC_ALPHA,
        GLEnum.ONE,
        GLEnum.ONE_MINUS_SRC_ALPHA
      ];

      break;
  }
}

/** Parse GLTF material sub record */
function parsePbrMetallicRoughness(
  device: Device,
  pbrMetallicRoughness,
  parsedMaterial: ParsedPBRMaterial
): void {
  if (pbrMetallicRoughness.baseColorTexture) {
    addTexture(
      device,
      pbrMetallicRoughness.baseColorTexture,
      'u_BaseColorSampler',
      'HAS_BASECOLORMAP',
      parsedMaterial
    );
  }
  parsedMaterial.uniforms.u_BaseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];

  if (pbrMetallicRoughness.metallicRoughnessTexture) {
    addTexture(
      device,
      pbrMetallicRoughness.metallicRoughnessTexture,
      'u_MetallicRoughnessSampler',
      'HAS_METALROUGHNESSMAP',
      parsedMaterial
    );
  }
  const {metallicFactor = 1, roughnessFactor = 1} = pbrMetallicRoughness;
  parsedMaterial.uniforms.u_MetallicRoughnessValues = [metallicFactor, roughnessFactor];
}

/** Create a texture from a glTF texture/sampler/image combo and add it to bindings */
function addTexture(
  device: Device,
  gltfTexture,
  uniformName: string,
  define = null,
  parsedMaterial: ParsedPBRMaterial
): void {
  const parameters = gltfTexture?.texture?.sampler?.parameters || {};

  const image = gltfTexture.texture.source.image;
  let textureOptions;
  let specialTextureParameters = {};
  if (image.compressed) {
    textureOptions = image;
    specialTextureParameters = {
      [GLEnum.TEXTURE_MIN_FILTER]:
        image.data.length > 1 ? GLEnum.LINEAR_MIPMAP_NEAREST : GLEnum.LINEAR
    };
  } else {
    // Texture2D accepts a promise that returns an image as data (Async Textures)
    textureOptions = {data: image};
  }

  const texture: Texture = device.createTexture({
    id: gltfTexture.uniformName || gltfTexture.id,
    parameters: {
      ...parameters,
      ...specialTextureParameters
    },
    pixelStore: {
      [GLEnum.UNPACK_FLIP_Y_WEBGL]: false
    },
    ...textureOptions
  });
  parsedMaterial.bindings[uniformName] = texture;
  if (define) parsedMaterial.defines[define] = 1;
  parsedMaterial.generatedTextures.push(texture);
}

/*
/**
 * Parses a GLTF material definition into uniforms and parameters for the PBR shader module
 *
export class PBRMaterialParser {
  readonly device: Device;

  readonly defines: Record<string, number | boolean>;
  readonly bindings: Record<string, Binding>;
  readonly uniforms: Record<string, any>;
  readonly parameters: Record<string, any>;

  /** Hold on to generated textures, we destroy them in the destroy method *
  readonly generatedTextures: Texture[];

  constructor(device: Device, props: PBRMaterialParserProps) {
    const {attributes, material, pbrDebug, imageBasedLightingEnvironment, lights, useTangents} =
      props;
    this.device = device;

    this.defines = {
      // TODO: Use EXT_sRGB if available (Standard in WebGL 2.0)
      MANUAL_SRGB: 1,
      SRGB_FAST_APPROXIMATION: 1
    };

    if (this.device.features.has('glsl-texture-lod')) {
      this.defines.USE_TEX_LOD = 1;
    }

    this.uniforms = {
      // TODO: find better values?
      u_Camera: [0, 0, 0], // Model should override

      u_MetallicRoughnessValues: [1, 1] // Default is 1 and 1
    };

    this.bindings = {};

    this.parameters = {};
    this.generatedTextures = [];

    if (imageBasedLightingEnvironment) {
      this.bindings.u_DiffuseEnvSampler = imageBasedLightingEnvironment.getDiffuseEnvSampler();
      this.bindings.u_SpecularEnvSampler = imageBasedLightingEnvironment.getSpecularEnvSampler();
      this.bindings.u_brdfLUT = imageBasedLightingEnvironment.getBrdfTexture();
      this.uniforms.u_ScaleIBLAmbient = [1, 1];
    }

    if (pbrDebug) {
      // Override final color for reference app visualization
      // of various parameters in the lighting equation.
      this.uniforms.u_ScaleDiffBaseMR = [0, 0, 0, 0];
      this.uniforms.u_ScaleFGDSpec = [0, 0, 0, 0];
    }

    this.defineIfPresent(attributes.NORMAL, 'HAS_NORMALS');
    this.defineIfPresent(attributes.TANGENT && useTangents, 'HAS_TANGENTS');
    this.defineIfPresent(attributes.TEXCOORD_0, 'HAS_UV');

    this.defineIfPresent(imageBasedLightingEnvironment, 'USE_IBL');
    this.defineIfPresent(lights, 'USE_LIGHTS');
    this.defineIfPresent(pbrDebug, 'PBR_DEBUG');

    if (material) {
      this.parseMaterial(material);
    }
  }

  /**
   * Destroy all generated resources to release memory.
   *
  destroy(): void {
    this.generatedTextures.forEach(texture => texture.destroy());
  }

  /** Add a define if the the value is non-nullish *
  defineIfPresent(value: unknown, name: string): void {
    if (value) {
      this.defines[name] = 1;
    }
  }

  /** Parse GLTF material record *
  parseMaterial(material) {
    this.uniforms.pbr_uUnlit = Boolean(material.unlit);

    if (material.pbrMetallicRoughness) {
      this.parsePbrMetallicRoughness(material.pbrMetallicRoughness);
    }
    if (material.normalTexture) {
      this.addTexture(material.normalTexture, 'u_NormalSampler', 'HAS_NORMALMAP');

      const {scale = 1} = material.normalTexture;
      this.uniforms.u_NormalScale = scale;
    }
    if (material.occlusionTexture) {
      this.addTexture(material.occlusionTexture, 'u_OcclusionSampler', 'HAS_OCCLUSIONMAP');

      const {strength = 1} = material.occlusionTexture;
      this.uniforms.u_OcclusionStrength = strength;
    }
    if (material.emissiveTexture) {
      this.addTexture(material.emissiveTexture, 'u_EmissiveSampler', 'HAS_EMISSIVEMAP');
      this.uniforms.u_EmissiveFactor = material.emissiveFactor || [0, 0, 0];
    }
    if (material.alphaMode === 'MASK') {
      const {alphaCutoff = 0.5} = material;
      this.defines.ALPHA_CUTOFF = 1;
      this.uniforms.u_AlphaCutoff = alphaCutoff;
    } else if (material.alphaMode === 'BLEND') {
      log.warn('BLEND alphaMode might not work well because it requires mesh sorting')();
      Object.assign(this.parameters, {
        blend: true,
        blendEquation: GL.FUNC_ADD,
        blendFunc: [GL.SRC_ALPHA, GL.ONE_MINUS_SRC_ALPHA, GL.ONE, GL.ONE_MINUS_SRC_ALPHA]
      });
    }
  }

  /** Parse GLTF material sub record *
  parsePbrMetallicRoughness(pbrMetallicRoughness) {
    if (pbrMetallicRoughness.baseColorTexture) {
      this.addTexture(
        pbrMetallicRoughness.baseColorTexture,
        'u_BaseColorSampler',
        'HAS_BASECOLORMAP'
      );
    }
    this.uniforms.u_BaseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];

    if (pbrMetallicRoughness.metallicRoughnessTexture) {
      this.addTexture(
        pbrMetallicRoughness.metallicRoughnessTexture,
        'u_MetallicRoughnessSampler',
        'HAS_METALROUGHNESSMAP'
      );
    }
    const {metallicFactor = 1, roughnessFactor = 1} = pbrMetallicRoughness;
    this.uniforms.u_MetallicRoughnessValues = [metallicFactor, roughnessFactor];
  }

  /** Create a texture from a glTF texture/sampler/image combo and add it to bindings *
  addTexture(gltfTexture, name, define = null) {
    const parameters = gltfTexture?.texture?.sampler?.parameters || {};

    const image = gltfTexture.texture.source.image;
    let textureOptions;
    let specialTextureParameters = {};
    if (image.compressed) {
      textureOptions = image;
      specialTextureParameters = {
        [GL.TEXTURE_MIN_FILTER]: image.data.length > 1 ? GL.LINEAR_MIPMAP_NEAREST : GL.LINEAR
      };
    } else {
      // Texture2D accepts a promise that returns an image as data (Async Textures)
      textureOptions = {data: image};
    }

    const texture: Texture = this.device.createTexture({
      id: gltfTexture.name || gltfTexture.id,
      parameters: {
        ...parameters,
        ...specialTextureParameters
      },
      pixelStore: {
        [GL.UNPACK_FLIP_Y_WEBGL]: false
      },
      ...textureOptions
    });
    this.bindings[name] = texture;
    this.defineIfPresent(define, define);
    this.generatedTextures.push(texture);
  }
}
*/

1	import type {Device, Texture, Binding, Parameters} from '@luma.gl/core';	1✔
2	import {log} from '@luma.gl/core';	1✔
3	import {PBREnvironment} from './pbr-environment';	1✔
4		1✔
5	/* eslint-disable camelcase */	1✔
6		1✔
7	export type ParsePBRMaterialOptions = {	1✔
8	/** Debug PBR shader */	1✔
9	pbrDebug?: boolean;	1✔
10	/** Enable lights */	1✔
11	lights?: any;	1✔
12	/** Use tangents */	1✔
13	useTangents?: boolean;	1✔
14	/** provide an image based (texture cube) lighting environment */	1✔
15	imageBasedLightingEnvironment?: PBREnvironment;	1✔
16	};	1✔
17		1✔
18	export type ParsedPBRMaterial = {	1✔
19	readonly defines: Record<string, number \| boolean>;	1✔
20	readonly bindings: Record<string, Binding>;	1✔
21	readonly uniforms: Record<string, any>;	1✔
22	readonly parameters: Parameters;	1✔
23	readonly glParameters: Record<string, any>;	1✔
24	/** List of all generated textures, makes it easy to destroy them later */	1✔
25	readonly generatedTextures: Texture[];	1✔
26	};	1✔
27		1✔
28	// NOTE: Modules other than `@luma.gl/webgl` should not import `GL` from	1✔
29	// `@luma.gl/constants`. Locally we use `GLEnum` instead of `GL` to avoid	1✔
30	// conflicts with the `babel-plugin-inline-webgl-constants` plugin.	1✔
31	enum GLEnum {	1✔
32	FUNC_ADD = 0x8006,	1✔
33	ONE = 1,	1✔
34	SRC_ALPHA = 0x0302,	1✔
35	ONE_MINUS_SRC_ALPHA = 0x0303,	1✔
36	TEXTURE_MIN_FILTER = 0x2801,	1✔
37	LINEAR = 0x2601,	1✔
38	LINEAR_MIPMAP_NEAREST = 0x2701,	1✔
39	UNPACK_FLIP_Y_WEBGL = 0x9240	1✔
40	}	1✔
41		1✔
42	/**	1✔
43	* Parses a GLTF material definition into uniforms and parameters for the PBR shader module	1✔
44	*/	1✔
45	export function parsePBRMaterial(	1✔
46	device: Device,	×
47	material,	×
48	attributes: Record<string, any>,	×
49	options: ParsePBRMaterialOptions	×
50	): ParsedPBRMaterial {	×
51	const parsedMaterial: ParsedPBRMaterial = {	×
52	defines: {	×
53	// TODO: Use EXT_sRGB if available (Standard in WebGL 2.0)	×
54	MANUAL_SRGB: 1,	×
55	SRGB_FAST_APPROXIMATION: 1	×
56	},	×
57	bindings: {},	×
58	uniforms: {	×
59	// TODO: find better values?	×
60	u_Camera: [0, 0, 0], // Model should override	×
61		×
62	u_MetallicRoughnessValues: [1, 1] // Default is 1 and 1	×
63	},	×
64	parameters: {},	×
65	glParameters: {},	×
66	generatedTextures: []	×
67	};	×
68		×
69	// TODO - always available	×
70	parsedMaterial.defines.USE_TEX_LOD = 1;	×
71		×
72	const {imageBasedLightingEnvironment} = options;	×
73	if (imageBasedLightingEnvironment) {	×
NEW 74	parsedMaterial.bindings.u_DiffuseEnvSampler =	×
NEW 75	imageBasedLightingEnvironment.diffuseEnvSampler.texture;	×
NEW 76	parsedMaterial.bindings.u_SpecularEnvSampler =	×
NEW 77	imageBasedLightingEnvironment.specularEnvSampler.texture;	×
NEW 78	parsedMaterial.bindings.u_brdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;	×
79	parsedMaterial.uniforms.u_ScaleIBLAmbient = [1, 1];	×
80	}	×
81		×
82	if (options?.pbrDebug) {	×
83	parsedMaterial.defines.PBR_DEBUG = 1;	×
84	// Override final color for reference app visualization of various parameters in the lighting equation.	×
85	parsedMaterial.uniforms.u_ScaleDiffBaseMR = [0, 0, 0, 0];	×
86	parsedMaterial.uniforms.u_ScaleFGDSpec = [0, 0, 0, 0];	×
87	}	×
88		×
89	if (attributes.NORMAL) parsedMaterial.defines.HAS_NORMALS = 1;	×
90	if (attributes.TANGENT && options?.useTangents) parsedMaterial.defines.HAS_TANGENTS = 1;	×
91	if (attributes.TEXCOORD_0) parsedMaterial.defines.HAS_UV = 1;	×
92		×
93	if (options?.imageBasedLightingEnvironment) parsedMaterial.defines.USE_IBL = 1;	×
94	if (options?.lights) parsedMaterial.defines.USE_LIGHTS = 1;	×
95		×
96	if (material) {	×
97	parseMaterial(device, material, parsedMaterial);	×
98	}	×
99		×
100	return parsedMaterial;	×
101	}	×
102		1✔
103	/** Parse GLTF material record */	1✔
104	function parseMaterial(device: Device, material, parsedMaterial: ParsedPBRMaterial): void {	×
105	parsedMaterial.uniforms.pbr_uUnlit = Boolean(material.unlit);	×
106		×
107	if (material.pbrMetallicRoughness) {	×
108	parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);	×
109	}	×
110	if (material.normalTexture) {	×
111	addTexture(device, material.normalTexture, 'u_NormalSampler', 'HAS_NORMALMAP', parsedMaterial);	×
112		×
113	const {scale = 1} = material.normalTexture;	×
114	parsedMaterial.uniforms.u_NormalScale = scale;	×
115	}	×
116	if (material.occlusionTexture) {	×
117	addTexture(	×
118	device,	×
119	material.occlusionTexture,	×
120	'u_OcclusionSampler',	×
121	'HAS_OCCLUSIONMAP',	×
122	parsedMaterial	×
123	);	×
124		×
125	const {strength = 1} = material.occlusionTexture;	×
126	parsedMaterial.uniforms.u_OcclusionStrength = strength;	×
127	}	×
128	if (material.emissiveTexture) {	×
129	addTexture(	×
130	device,	×
131	material.emissiveTexture,	×
132	'u_EmissiveSampler',	×
133	'HAS_EMISSIVEMAP',	×
134	parsedMaterial	×
135	);	×
136	parsedMaterial.uniforms.u_EmissiveFactor = material.emissiveFactor \|\| [0, 0, 0];	×
137	}	×
138		×
139	switch (material.alphaMode) {	×
140	case 'MASK':	×
141	const {alphaCutoff = 0.5} = material;	×
142	parsedMaterial.defines.ALPHA_CUTOFF = 1;	×
143	parsedMaterial.uniforms.u_AlphaCutoff = alphaCutoff;	×
144	break;	×
145	case 'BLEND':	×
146	log.warn('glTF BLEND alphaMode might not work well because it requires mesh sorting')();	×
147		×
148	// WebGPU style parameters	×
149	parsedMaterial.parameters.blendColorOperation = 'add';	×
150	parsedMaterial.parameters.blendColorSrcFactor = 'src-alpha';	×
151	parsedMaterial.parameters.blendColorDstFactor = 'one-minus-src-alpha';	×
152		×
153	parsedMaterial.parameters.blendAlphaOperation = 'add';	×
154	parsedMaterial.parameters.blendAlphaSrcFactor = 'one';	×
155	parsedMaterial.parameters.blendAlphaDstFactor = 'one-minus-src-alpha';	×
156		×
157	// GL parameters	×
158	parsedMaterial.glParameters.blend = true;	×
159	parsedMaterial.glParameters.blendEquation = GLEnum.FUNC_ADD;	×
160	parsedMaterial.glParameters.blendFunc = [	×
161	GLEnum.SRC_ALPHA,	×
162	GLEnum.ONE_MINUS_SRC_ALPHA,	×
163	GLEnum.ONE,	×
164	GLEnum.ONE_MINUS_SRC_ALPHA	×
165	];	×
166		×
167	break;	×
168	}	×
169	}	×
170		1✔
171	/** Parse GLTF material sub record */	1✔
172	function parsePbrMetallicRoughness(	×
173	device: Device,	×
174	pbrMetallicRoughness,	×
175	parsedMaterial: ParsedPBRMaterial	×
176	): void {	×
177	if (pbrMetallicRoughness.baseColorTexture) {	×
178	addTexture(	×
179	device,	×
180	pbrMetallicRoughness.baseColorTexture,	×
181	'u_BaseColorSampler',	×
182	'HAS_BASECOLORMAP',	×
183	parsedMaterial	×
184	);	×
185	}	×
186	parsedMaterial.uniforms.u_BaseColorFactor = pbrMetallicRoughness.baseColorFactor \|\| [1, 1, 1, 1];	×
187		×
188	if (pbrMetallicRoughness.metallicRoughnessTexture) {	×
189	addTexture(	×
190	device,	×
191	pbrMetallicRoughness.metallicRoughnessTexture,	×
192	'u_MetallicRoughnessSampler',	×
193	'HAS_METALROUGHNESSMAP',	×
194	parsedMaterial	×
195	);	×
196	}	×
197	const {metallicFactor = 1, roughnessFactor = 1} = pbrMetallicRoughness;	×
198	parsedMaterial.uniforms.u_MetallicRoughnessValues = [metallicFactor, roughnessFactor];	×
199	}	×
200		1✔
201	/** Create a texture from a glTF texture/sampler/image combo and add it to bindings */	1✔
202	function addTexture(	×
203	device: Device,	×
204	gltfTexture,	×
205	uniformName: string,	×
206	define = null,	×
207	parsedMaterial: ParsedPBRMaterial	×
208	): void {	×
209	const parameters = gltfTexture?.texture?.sampler?.parameters \|\| {};	×
210		×
211	const image = gltfTexture.texture.source.image;	×
212	let textureOptions;	×
213	let specialTextureParameters = {};	×
214	if (image.compressed) {	×
215	textureOptions = image;	×
216	specialTextureParameters = {	×
217	[GLEnum.TEXTURE_MIN_FILTER]:	×
218	image.data.length > 1 ? GLEnum.LINEAR_MIPMAP_NEAREST : GLEnum.LINEAR	×
219	};	×
220	} else {	×
221	// Texture2D accepts a promise that returns an image as data (Async Textures)	×
222	textureOptions = {data: image};	×
223	}	×
224		×
225	const texture: Texture = device.createTexture({	×
226	id: gltfTexture.uniformName \|\| gltfTexture.id,	×
227	parameters: {	×
228	...parameters,	×
229	...specialTextureParameters	×
230	},	×
231	pixelStore: {	×
232	[GLEnum.UNPACK_FLIP_Y_WEBGL]: false	×
233	},	×
234	...textureOptions	×
235	});	×
236	parsedMaterial.bindings[uniformName] = texture;	×
237	if (define) parsedMaterial.defines[define] = 1;	×
238	parsedMaterial.generatedTextures.push(texture);	×
239	}	×
240		1✔
241	/*	1✔
242	/**	1✔
243	* Parses a GLTF material definition into uniforms and parameters for the PBR shader module	1✔
244	*	1✔
245	export class PBRMaterialParser {	1✔
246	readonly device: Device;	1✔
247		1✔
248	readonly defines: Record<string, number \| boolean>;	1✔
249	readonly bindings: Record<string, Binding>;	1✔
250	readonly uniforms: Record<string, any>;	1✔
251	readonly parameters: Record<string, any>;	1✔
252		1✔
253	/** Hold on to generated textures, we destroy them in the destroy method *	1✔
254	readonly generatedTextures: Texture[];	1✔
255		1✔
256	constructor(device: Device, props: PBRMaterialParserProps) {	1✔
257	const {attributes, material, pbrDebug, imageBasedLightingEnvironment, lights, useTangents} =	1✔
258	props;	1✔
259	this.device = device;	1✔
260		1✔
261	this.defines = {	1✔
262	// TODO: Use EXT_sRGB if available (Standard in WebGL 2.0)	1✔
263	MANUAL_SRGB: 1,	1✔
264	SRGB_FAST_APPROXIMATION: 1	1✔
265	};	1✔
266		1✔
267	if (this.device.features.has('glsl-texture-lod')) {	1✔
268	this.defines.USE_TEX_LOD = 1;	1✔
269	}	1✔
270		1✔
271	this.uniforms = {	1✔
272	// TODO: find better values?	1✔
273	u_Camera: [0, 0, 0], // Model should override	1✔
274		1✔
275	u_MetallicRoughnessValues: [1, 1] // Default is 1 and 1	1✔
276	};	1✔
277		1✔
278	this.bindings = {};	1✔
279		1✔
280	this.parameters = {};	1✔
281	this.generatedTextures = [];	1✔
282		1✔
283	if (imageBasedLightingEnvironment) {	1✔
284	this.bindings.u_DiffuseEnvSampler = imageBasedLightingEnvironment.getDiffuseEnvSampler();	1✔
285	this.bindings.u_SpecularEnvSampler = imageBasedLightingEnvironment.getSpecularEnvSampler();	1✔
286	this.bindings.u_brdfLUT = imageBasedLightingEnvironment.getBrdfTexture();	1✔
287	this.uniforms.u_ScaleIBLAmbient = [1, 1];	1✔
288	}	1✔
289		1✔
290	if (pbrDebug) {	1✔
291	// Override final color for reference app visualization	1✔
292	// of various parameters in the lighting equation.	1✔
293	this.uniforms.u_ScaleDiffBaseMR = [0, 0, 0, 0];	1✔
294	this.uniforms.u_ScaleFGDSpec = [0, 0, 0, 0];	1✔
295	}	1✔
296		1✔
297	this.defineIfPresent(attributes.NORMAL, 'HAS_NORMALS');	1✔
298	this.defineIfPresent(attributes.TANGENT && useTangents, 'HAS_TANGENTS');	1✔
299	this.defineIfPresent(attributes.TEXCOORD_0, 'HAS_UV');	1✔
300		1✔
301	this.defineIfPresent(imageBasedLightingEnvironment, 'USE_IBL');	1✔
302	this.defineIfPresent(lights, 'USE_LIGHTS');	1✔
303	this.defineIfPresent(pbrDebug, 'PBR_DEBUG');	1✔
304		1✔
305	if (material) {	1✔
306	this.parseMaterial(material);	1✔
307	}	1✔
308	}	1✔
309		1✔
310	/**	1✔
311	* Destroy all generated resources to release memory.	1✔
312	*	1✔
313	destroy(): void {	1✔
314	this.generatedTextures.forEach(texture => texture.destroy());	1✔
315	}	1✔
316		1✔
317	/** Add a define if the the value is non-nullish *	1✔
318	defineIfPresent(value: unknown, name: string): void {	1✔
319	if (value) {	1✔
320	this.defines[name] = 1;	1✔
321	}	1✔
322	}	1✔
323		1✔
324	/** Parse GLTF material record *	1✔
325	parseMaterial(material) {	1✔
326	this.uniforms.pbr_uUnlit = Boolean(material.unlit);	1✔
327		1✔
328	if (material.pbrMetallicRoughness) {	1✔
329	this.parsePbrMetallicRoughness(material.pbrMetallicRoughness);	1✔
330	}	1✔
331	if (material.normalTexture) {	1✔
332	this.addTexture(material.normalTexture, 'u_NormalSampler', 'HAS_NORMALMAP');	1✔
333		1✔
334	const {scale = 1} = material.normalTexture;	1✔
335	this.uniforms.u_NormalScale = scale;	1✔
336	}	1✔
337	if (material.occlusionTexture) {	1✔
338	this.addTexture(material.occlusionTexture, 'u_OcclusionSampler', 'HAS_OCCLUSIONMAP');	1✔
339		1✔
340	const {strength = 1} = material.occlusionTexture;	1✔
341	this.uniforms.u_OcclusionStrength = strength;	1✔
342	}	1✔
343	if (material.emissiveTexture) {	1✔
344	this.addTexture(material.emissiveTexture, 'u_EmissiveSampler', 'HAS_EMISSIVEMAP');	1✔
345	this.uniforms.u_EmissiveFactor = material.emissiveFactor \|\| [0, 0, 0];	1✔
346	}	1✔
347	if (material.alphaMode === 'MASK') {	1✔
348	const {alphaCutoff = 0.5} = material;	1✔
349	this.defines.ALPHA_CUTOFF = 1;	1✔
350	this.uniforms.u_AlphaCutoff = alphaCutoff;	1✔
351	} else if (material.alphaMode === 'BLEND') {	1✔
352	log.warn('BLEND alphaMode might not work well because it requires mesh sorting')();	1✔
353	Object.assign(this.parameters, {	1✔
354	blend: true,	1✔
355	blendEquation: GL.FUNC_ADD,	1✔
356	blendFunc: [GL.SRC_ALPHA, GL.ONE_MINUS_SRC_ALPHA, GL.ONE, GL.ONE_MINUS_SRC_ALPHA]	1✔
357	});	1✔
358	}	1✔
359	}	1✔
360		1✔
361	/** Parse GLTF material sub record *	1✔
362	parsePbrMetallicRoughness(pbrMetallicRoughness) {	1✔
363	if (pbrMetallicRoughness.baseColorTexture) {	1✔
364	this.addTexture(	1✔
365	pbrMetallicRoughness.baseColorTexture,	1✔
366	'u_BaseColorSampler',	1✔
367	'HAS_BASECOLORMAP'	1✔
368	);	1✔
369	}	1✔
370	this.uniforms.u_BaseColorFactor = pbrMetallicRoughness.baseColorFactor \|\| [1, 1, 1, 1];	1✔
371		1✔
372	if (pbrMetallicRoughness.metallicRoughnessTexture) {	1✔
373	this.addTexture(	1✔
374	pbrMetallicRoughness.metallicRoughnessTexture,	1✔
375	'u_MetallicRoughnessSampler',	1✔
376	'HAS_METALROUGHNESSMAP'	1✔
377	);	1✔
378	}	1✔
379	const {metallicFactor = 1, roughnessFactor = 1} = pbrMetallicRoughness;	1✔
380	this.uniforms.u_MetallicRoughnessValues = [metallicFactor, roughnessFactor];	1✔
381	}	1✔
382		1✔
383	/** Create a texture from a glTF texture/sampler/image combo and add it to bindings *	1✔
384	addTexture(gltfTexture, name, define = null) {	1✔
385	const parameters = gltfTexture?.texture?.sampler?.parameters \|\| {};	1✔
386		1✔
387	const image = gltfTexture.texture.source.image;	1✔
388	let textureOptions;	1✔
389	let specialTextureParameters = {};	1✔
390	if (image.compressed) {	1✔
391	textureOptions = image;	1✔
392	specialTextureParameters = {	1✔
393	[GL.TEXTURE_MIN_FILTER]: image.data.length > 1 ? GL.LINEAR_MIPMAP_NEAREST : GL.LINEAR	1✔
394	};	1✔
395	} else {	1✔
396	// Texture2D accepts a promise that returns an image as data (Async Textures)	1✔
397	textureOptions = {data: image};	1✔
398	}	1✔
399		1✔
400	const texture: Texture = this.device.createTexture({	1✔
401	id: gltfTexture.name \|\| gltfTexture.id,	1✔
402	parameters: {	1✔
403	...parameters,	1✔
404	...specialTextureParameters	1✔
405	},	1✔
406	pixelStore: {	1✔
407	[GL.UNPACK_FLIP_Y_WEBGL]: false	1✔
408	},	1✔
409	...textureOptions	1✔
410	});	1✔
411	this.bindings[name] = texture;	1✔
412	this.defineIfPresent(define, define);	1✔
413	this.generatedTextures.push(texture);	1✔
414	}	1✔
415	}	1✔
416	*/	1✔

visgl / luma.gl / 8217921255

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