Skip to content

Commit fe839d1

Browse files
author
Mike Bond
committed
Revert "Finish glTFLoader dynamic material load"
This reverts commit c1c7c59.
1 parent a32a8f4 commit fe839d1

File tree

7 files changed

+101
-217
lines changed

7 files changed

+101
-217
lines changed

‎packages/dev/loaders/src/glTF/2.0/Extensions/KHR_materials_sheen.ts

Lines changed: 20 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,6 @@
11
import type { Nullable } from "core/types";
2-
import type { PBRMaterial } from "core/Materials/PBR/pbrMaterial";
3-
import type { OpenPBRMaterial } from "core/Materials/PBR/openPbrMaterial";
2+
import { PBRMaterial } from "core/Materials/PBR/pbrMaterial";
43
import type { Material } from "core/Materials/material";
5-
import type { BaseTexture } from "core/Materials/Textures/baseTexture";
64

75
import type { IMaterial, ITextureInfo } from "../glTFLoaderInterfaces";
86
import type { IGLTFLoaderExtension } from "../glTFLoaderExtension";
@@ -24,8 +22,6 @@ declare module "../../glTFFileLoader" {
2422
}
2523
}
2624

27-
let PBRMaterialClass: typeof PBRMaterial | typeof OpenPBRMaterial;
28-
2925
/**
3026
* [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_sheen/README.md)
3127
* [Playground Sample](https://www.babylonjs-playground.com/frame.html#BNIZX6#4)
@@ -66,78 +62,63 @@ export class KHR_materials_sheen implements IGLTFLoaderExtension {
6662
* @internal
6763
*/
6864
// eslint-disable-next-line no-restricted-syntax
69-
public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material, useOpenPBR: boolean = false): Nullable<Promise<void>> {
65+
public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {
7066
return GLTFLoader.LoadExtensionAsync<IKHRMaterialsSheen>(context, material, this.name, async (extensionContext, extension) => {
71-
if (useOpenPBR) {
72-
const mod = await import("core/Materials/PBR/openPbrMaterial");
73-
PBRMaterialClass = mod.OpenPBRMaterial;
74-
} else {
75-
const mod = await import("core/Materials/PBR/pbrMaterial");
76-
PBRMaterialClass = mod.PBRMaterial;
77-
}
7867
const promises = new Array<Promise<any>>();
7968
promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));
80-
promises.push(this._loadSheenPropertiesAsync(extensionContext, extension, babylonMaterial, useOpenPBR));
69+
promises.push(this._loadSheenPropertiesAsync(extensionContext, extension, babylonMaterial));
8170
// eslint-disable-next-line github/no-then
8271
return await Promise.all(promises).then(() => {});
8372
});
8473
}
8574

8675
// eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax
87-
private _loadSheenPropertiesAsync(context: string, properties: IKHRMaterialsSheen, babylonMaterial: Material, useOpenPBR: boolean): Promise<void> {
88-
if (!(babylonMaterial instanceof PBRMaterialClass)) {
76+
private _loadSheenPropertiesAsync(context: string, properties: IKHRMaterialsSheen, babylonMaterial: Material): Promise<void> {
77+
if (!(babylonMaterial instanceof PBRMaterial)) {
8978
throw new Error(`${context}: Material type not supported`);
9079
}
9180

92-
let sheenColor = Color3.Black();
93-
let sheenColorTexture: Nullable<BaseTexture> = null;
94-
let sheenRoughness = 0.0;
95-
let sheenRoughnessTexture: Nullable<BaseTexture> = null;
96-
9781
const promises = new Array<Promise<any>>();
9882

83+
babylonMaterial.sheen.isEnabled = true;
84+
babylonMaterial.sheen.intensity = 1;
85+
9986
if (properties.sheenColorFactor != undefined) {
100-
sheenColor = Color3.FromArray(properties.sheenColorFactor);
87+
babylonMaterial.sheen.color = Color3.FromArray(properties.sheenColorFactor);
88+
} else {
89+
babylonMaterial.sheen.color = Color3.Black();
10190
}
10291

10392
if (properties.sheenColorTexture) {
10493
promises.push(
10594
this._loader.loadTextureInfoAsync(`${context}/sheenColorTexture`, properties.sheenColorTexture, (texture) => {
10695
texture.name = `${babylonMaterial.name} (Sheen Color)`;
107-
sheenColorTexture = texture;
96+
babylonMaterial.sheen.texture = texture;
10897
})
10998
);
11099
}
111100

112101
if (properties.sheenRoughnessFactor !== undefined) {
113-
sheenRoughness = properties.sheenRoughnessFactor;
102+
babylonMaterial.sheen.roughness = properties.sheenRoughnessFactor;
103+
} else {
104+
babylonMaterial.sheen.roughness = 0;
114105
}
115106

116107
if (properties.sheenRoughnessTexture) {
117108
(properties.sheenRoughnessTexture as ITextureInfo).nonColorData = true;
118109
promises.push(
119110
this._loader.loadTextureInfoAsync(`${context}/sheenRoughnessTexture`, properties.sheenRoughnessTexture, (texture) => {
120111
texture.name = `${babylonMaterial.name} (Sheen Roughness)`;
121-
sheenRoughnessTexture = texture;
112+
babylonMaterial.sheen.textureRoughness = texture;
122113
})
123114
);
124115
}
125116

117+
babylonMaterial.sheen.albedoScaling = true;
118+
babylonMaterial.sheen.useRoughnessFromMainTexture = false;
119+
126120
// eslint-disable-next-line github/no-then
127-
return Promise.all(promises).then(() => {
128-
if (useOpenPBR) {
129-
return;
130-
}
131-
const pbrMaterial = babylonMaterial as PBRMaterial;
132-
pbrMaterial.sheen.isEnabled = true;
133-
pbrMaterial.sheen.intensity = 1;
134-
pbrMaterial.sheen.color = sheenColor;
135-
pbrMaterial.sheen.texture = sheenColorTexture;
136-
pbrMaterial.sheen.roughness = sheenRoughness;
137-
pbrMaterial.sheen.textureRoughness = sheenRoughnessTexture;
138-
pbrMaterial.sheen.albedoScaling = true;
139-
pbrMaterial.sheen.useRoughnessFromMainTexture = false;
140-
});
121+
return Promise.all(promises).then(() => {});
141122
}
142123
}
143124

‎packages/dev/loaders/src/glTF/2.0/Extensions/KHR_materials_specular.ts

Lines changed: 9 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
import type { Nullable } from "core/types";
2-
import type { PBRMaterial } from "core/Materials/PBR/pbrMaterial";
3-
import type { OpenPBRMaterial } from "core/Materials/PBR/openPbrMaterial";
2+
import { PBRMaterial } from "core/Materials/PBR/pbrMaterial";
3+
import { OpenPBRMaterial } from "core/Materials/PBR/openPbrMaterial";
44
import type { Material } from "core/Materials/material";
55

66
import type { IMaterial, ITextureInfo } from "../glTFLoaderInterfaces";
@@ -24,8 +24,6 @@ declare module "../../glTFFileLoader" {
2424
}
2525
}
2626

27-
let PBRMaterialClass: typeof PBRMaterial | typeof OpenPBRMaterial;
28-
2927
/**
3028
* [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_specular/README.md)
3129
*/
@@ -65,25 +63,18 @@ export class KHR_materials_specular implements IGLTFLoaderExtension {
6563
* @internal
6664
*/
6765
// eslint-disable-next-line no-restricted-syntax
68-
public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material, useOpenPBR: boolean = false): Nullable<Promise<void>> {
66+
public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {
6967
return GLTFLoader.LoadExtensionAsync<IKHRMaterialsSpecular>(context, material, this.name, async (extensionContext, extension) => {
70-
if (useOpenPBR) {
71-
const mod = await import("core/Materials/PBR/openPbrMaterial");
72-
PBRMaterialClass = mod.OpenPBRMaterial;
73-
} else {
74-
const mod = await import("core/Materials/PBR/pbrMaterial");
75-
PBRMaterialClass = mod.PBRMaterial;
76-
}
7768
const promises = new Array<Promise<any>>();
7869
promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));
79-
promises.push(this._loadSpecularPropertiesAsync(extensionContext, extension, babylonMaterial, useOpenPBR));
70+
promises.push(this._loadSpecularPropertiesAsync(extensionContext, extension, babylonMaterial));
8071
// Handle the EXT_materials_specular_edge_color sub-extension
8172
// https://github.com/KhronosGroup/glTF/blob/2a1111b88f052cbd3e2d82abb9faee56e7494904/extensions/2.0/Vendor/EXT_materials_specular_edge_color/README.md
82-
if (!useOpenPBR && extension.extensions && extension.extensions.EXT_materials_specular_edge_color) {
73+
if (extension.extensions && extension.extensions.EXT_materials_specular_edge_color && babylonMaterial instanceof PBRMaterial) {
8374
const specularEdgeColorExtension = extension.extensions.EXT_materials_specular_edge_color as IEXTMaterialsSpecularEdgeColor;
8475
if (specularEdgeColorExtension.specularEdgeColorEnabled) {
85-
(babylonMaterial as PBRMaterial).brdf.dielectricSpecularModel = Constants.MATERIAL_DIELECTRIC_SPECULAR_MODEL_OPENPBR;
86-
(babylonMaterial as PBRMaterial).brdf.conductorSpecularModel = Constants.MATERIAL_CONDUCTOR_SPECULAR_MODEL_OPENPBR;
76+
babylonMaterial.brdf.dielectricSpecularModel = Constants.MATERIAL_DIELECTRIC_SPECULAR_MODEL_OPENPBR;
77+
babylonMaterial.brdf.conductorSpecularModel = Constants.MATERIAL_CONDUCTOR_SPECULAR_MODEL_OPENPBR;
8778
}
8879
}
8980
// eslint-disable-next-line github/no-then
@@ -92,8 +83,8 @@ export class KHR_materials_specular implements IGLTFLoaderExtension {
9283
}
9384

9485
// eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax
95-
private _loadSpecularPropertiesAsync(context: string, properties: IKHRMaterialsSpecular, babylonMaterial: Material, useOpenPBR: boolean): Promise<void> {
96-
if (!(babylonMaterial instanceof PBRMaterialClass)) {
86+
private _loadSpecularPropertiesAsync(context: string, properties: IKHRMaterialsSpecular, babylonMaterial: Material): Promise<void> {
87+
if (!(babylonMaterial instanceof PBRMaterial) && !(babylonMaterial instanceof OpenPBRMaterial)) {
9788
throw new Error(`${context}: Material type not supported`);
9889
}
9990

‎packages/dev/loaders/src/glTF/2.0/Extensions/KHR_materials_transmission.ts

Lines changed: 37 additions & 67 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,5 @@
11
import type { Nullable } from "core/types";
2-
import type { PBRMaterial } from "core/Materials/PBR/pbrMaterial";
3-
import type { OpenPBRMaterial } from "core/Materials/PBR/openPbrMaterial";
2+
import { PBRMaterial } from "core/Materials/PBR/pbrMaterial";
43
import type { Material } from "core/Materials/material";
54
import type { BaseTexture } from "core/Materials/Textures/baseTexture";
65
import type { IMaterial, ITextureInfo } from "../glTFLoaderInterfaces";
@@ -63,8 +62,6 @@ interface ITransmissionHelperOptions {
6362
clearColor?: Color4;
6463
}
6564

66-
let PBRMaterialClass: typeof PBRMaterial | typeof OpenPBRMaterial;
67-
6865
/**
6966
* A class to handle setting up the rendering of opaque objects to be shown through transmissive objects.
7067
*/
@@ -169,7 +166,7 @@ class TransmissionHelper {
169166
if (!material) {
170167
return false;
171168
}
172-
if (material instanceof PBRMaterialClass && (material as any).subSurface.isRefractionEnabled) {
169+
if (material instanceof PBRMaterial && material.subSurface.isRefractionEnabled) {
173170
return true;
174171
}
175172
return false;
@@ -223,8 +220,8 @@ class TransmissionHelper {
223220
// If the material is transparent, make sure that it's added to the transparent list and removed from the opaque list
224221
const useTransmission = this._shouldRenderAsTransmission(mesh.material);
225222
if (useTransmission) {
226-
if (mesh.material instanceof PBRMaterialClass) {
227-
(mesh.material as any).subSurface.refractionTexture = this._opaqueRenderTarget;
223+
if (mesh.material instanceof PBRMaterial) {
224+
mesh.material.subSurface.refractionTexture = this._opaqueRenderTarget;
228225
}
229226
if (opaqueIdx !== -1) {
230227
this._opaqueMeshesCache.splice(opaqueIdx, 1);
@@ -369,87 +366,60 @@ export class KHR_materials_transmission implements IGLTFLoaderExtension {
369366
* @internal
370367
*/
371368
// eslint-disable-next-line no-restricted-syntax
372-
public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material, useOpenPBR: boolean = false): Nullable<Promise<void>> {
369+
public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {
373370
return GLTFLoader.LoadExtensionAsync<IKHRMaterialsTransmission>(context, material, this.name, async (extensionContext, extension) => {
374-
if (useOpenPBR) {
375-
const mod = await import("core/Materials/PBR/openPbrMaterial");
376-
PBRMaterialClass = mod.OpenPBRMaterial;
377-
} else {
378-
const mod = await import("core/Materials/PBR/pbrMaterial");
379-
PBRMaterialClass = mod.PBRMaterial;
380-
}
381371
const promises = new Array<Promise<any>>();
382372
promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));
383-
promises.push(this._loadTransparentPropertiesAsync(extensionContext, material, babylonMaterial, extension, useOpenPBR));
373+
promises.push(this._loadTransparentPropertiesAsync(extensionContext, material, babylonMaterial, extension));
384374
// eslint-disable-next-line github/no-then
385375
return await Promise.all(promises).then(() => {});
386376
});
387377
}
388378

389379
// eslint-disable-next-line no-restricted-syntax, @typescript-eslint/promise-function-async
390-
private _loadTransparentPropertiesAsync(
391-
context: string,
392-
material: IMaterial,
393-
babylonMaterial: Material,
394-
extension: IKHRMaterialsTransmission,
395-
useOpenPBR: boolean
396-
): Promise<void> {
397-
if (!(babylonMaterial instanceof PBRMaterialClass)) {
380+
private _loadTransparentPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material, extension: IKHRMaterialsTransmission): Promise<void> {
381+
if (!(babylonMaterial instanceof PBRMaterial)) {
398382
throw new Error(`${context}: Material type not supported`);
399383
}
384+
const pbrMaterial = babylonMaterial;
385+
386+
// Enables "refraction" texture which represents transmitted light.
387+
pbrMaterial.subSurface.isRefractionEnabled = true;
388+
389+
// Since this extension models thin-surface transmission only, we must make IOR = 1.0
390+
pbrMaterial.subSurface.volumeIndexOfRefraction = 1.0;
400391

401-
let transmissionWeight = 0.0;
402-
let transmissionWeightTexture: Nullable<BaseTexture> = null;
392+
// Albedo colour will tint transmission.
393+
pbrMaterial.subSurface.useAlbedoToTintRefraction = true;
403394

404-
const promises = new Array<Promise<any>>();
405395
if (extension.transmissionFactor !== undefined) {
406-
transmissionWeight = extension.transmissionFactor;
396+
pbrMaterial.subSurface.refractionIntensity = extension.transmissionFactor;
397+
const scene = pbrMaterial.getScene() as unknown as ITransmissionHelperHolder;
398+
if (pbrMaterial.subSurface.refractionIntensity && !scene._transmissionHelper) {
399+
new TransmissionHelper({}, pbrMaterial.getScene());
400+
} else if (pbrMaterial.subSurface.refractionIntensity && !scene._transmissionHelper?._isRenderTargetValid()) {
401+
// If the render target is not valid, recreate it.
402+
scene._transmissionHelper?._setupRenderTargets();
403+
}
407404
} else {
405+
pbrMaterial.subSurface.refractionIntensity = 0.0;
406+
pbrMaterial.subSurface.isRefractionEnabled = false;
408407
return Promise.resolve();
409408
}
409+
410+
pbrMaterial.subSurface.minimumThickness = 0.0;
411+
pbrMaterial.subSurface.maximumThickness = 0.0;
410412
if (extension.transmissionTexture) {
411413
(extension.transmissionTexture as ITextureInfo).nonColorData = true;
412414
// eslint-disable-next-line github/no-then
413-
promises.push(
414-
this._loader.loadTextureInfoAsync(`${context}/transmissionTexture`, extension.transmissionTexture, (texture: BaseTexture) => {
415-
texture.name = `${babylonMaterial.name} (Transmission)`;
416-
transmissionWeightTexture = texture;
417-
})
418-
);
415+
return this._loader.loadTextureInfoAsync(`${context}/transmissionTexture`, extension.transmissionTexture, undefined).then((texture: BaseTexture) => {
416+
texture.name = `${babylonMaterial.name} (Transmission)`;
417+
pbrMaterial.subSurface.refractionIntensityTexture = texture;
418+
pbrMaterial.subSurface.useGltfStyleTextures = true;
419+
});
420+
} else {
421+
return Promise.resolve();
419422
}
420-
421-
// eslint-disable-next-line github/no-then
422-
return Promise.all(promises).then(() => {
423-
if (useOpenPBR) {
424-
return;
425-
}
426-
const pbrMaterial = babylonMaterial as PBRMaterial;
427-
428-
// Enables "refraction" texture which represents transmitted light.
429-
pbrMaterial.subSurface.isRefractionEnabled = transmissionWeight !== 0;
430-
431-
// Since this extension models thin-surface transmission only, we must make IOR = 1.0
432-
pbrMaterial.subSurface.volumeIndexOfRefraction = 1.0;
433-
434-
// Albedo colour will tint transmission.
435-
pbrMaterial.subSurface.useAlbedoToTintRefraction = true;
436-
437-
pbrMaterial.subSurface.refractionIntensity = transmissionWeight;
438-
439-
if (transmissionWeight) {
440-
const scene = pbrMaterial.getScene() as unknown as ITransmissionHelperHolder;
441-
if (pbrMaterial.subSurface.refractionIntensity && !scene._transmissionHelper) {
442-
new TransmissionHelper({}, pbrMaterial.getScene());
443-
} else if (pbrMaterial.subSurface.refractionIntensity && !scene._transmissionHelper?._isRenderTargetValid()) {
444-
// If the render target is not valid, recreate it.
445-
scene._transmissionHelper?._setupRenderTargets();
446-
}
447-
}
448-
pbrMaterial.subSurface.minimumThickness = 0.0;
449-
pbrMaterial.subSurface.maximumThickness = 0.0;
450-
pbrMaterial.subSurface.refractionIntensityTexture = transmissionWeightTexture;
451-
pbrMaterial.subSurface.useGltfStyleTextures = true;
452-
});
453423
}
454424
}
455425

0 commit comments

Comments
 (0)