7065709184

Committed 01 Dec 2023 10:08PM UTC coverage: 76.433% (+0.1%) from 76.294%

Build # 7065709184

Build Type

Pull #1859

github

Committed by

web-flow

Commit Message

Merge 1946f2e9d into f516c2c56

Pull Request Pull Request #1859: Fix `babel-plugin-inline-webgl-constants`

Run Details

1830 of 2435 branches covered (0.0%)

Branch coverage included in aggregate %.

27 of 47 new or added lines in 4 files covered. (57.45%)

13 existing lines in 2 files now uncovered.

34650 of 45293 relevant lines covered (76.5%)

43.43 hits per line

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

54.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 {GL} from '@luma.gl/constants';
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[];
};

/**
 * 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: []
  };

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

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

visgl / luma.gl / 7065709184

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