pbr support transmission

packages/core/src/material/PBRMaterial.ts

@@ -1,9 +1,11 @@
 import { MathUtil, Vector2, Vector3, Vector4, Color } from "@galacean/engine-math";
 import { Engine } from "../Engine";
-import { ShaderProperty } from "../shader";
+import { ShaderMacro, ShaderProperty } from "../shader";
 import { Shader } from "../shader/Shader";
 import { Texture2D } from "../texture/Texture2D";
 import { PBRBaseMaterial } from "./PBRBaseMaterial";
+import { RefractionMode } from "./enums/Refraction";
+import { RenderQueueType } from "../shader/enums/RenderQueueType";
 
 /**
  * PBR (Metallic-Roughness Workflow) Material.
@@ -18,19 +20,34 @@ export class PBRMaterial extends PBRBaseMaterial {
   private static _anisotropyInfoProp = ShaderProperty.getByName("material_AnisotropyInfo");
   private static _anisotropyTextureProp = ShaderProperty.getByName("material_AnisotropyTexture");
 
-  private _anisotropyRotation: number = 0;
-
   private static _iridescenceInfoProp = ShaderProperty.getByName("material_IridescenceInfo");
   private static _iridescenceThicknessTextureProp = ShaderProperty.getByName("material_IridescenceThicknessTexture");
   private static _iridescenceTextureProp = ShaderProperty.getByName("material_IridescenceTexture");
-  private _iridescenceRange = new Vector2(100, 400);
 
-  private _sheenEnabled = false;
   private static _sheenColorProp = ShaderProperty.getByName("material_SheenColor");
   private static _sheenRoughnessProp = ShaderProperty.getByName("material_SheenRoughness");
   private static _sheenTextureProp = ShaderProperty.getByName("material_SheenTexture");
   private static _sheenRoughnessTextureProp = ShaderProperty.getByName("material_SheenRoughnessTexture");
 
+  private static _transmissionMacro: ShaderMacro = ShaderMacro.getByName("MATERIAL_ENABLE_TRANSMISSION");
+  private static _thicknessMacro: ShaderMacro = ShaderMacro.getByName("MATERIAL_HAS_THICKNESS");
+  private static _absorptionMacro: ShaderMacro = ShaderMacro.getByName("MATERIAL_HAS_ABSORPTION");
+  private static _thicknessTextureMacro: ShaderMacro = ShaderMacro.getByName("MATERIAL_HAS_THICKNESS_TEXTURE");
+  private static _transmissionTextureMacro: ShaderMacro = ShaderMacro.getByName("MATERIAL_HAS_TRANSMISSION_TEXTURE");
+  private static _transmissionProp = ShaderProperty.getByName("material_Transmission");
+  private static _transmissionTextureProp = ShaderProperty.getByName("material_TransmissionTexture");
+  private static _attenuationColorProp = ShaderProperty.getByName("material_AttenuationColor");
+  private static _attenuationDistanceProp = ShaderProperty.getByName("material_AttenuationDistance");
+  private static _thicknessProp = ShaderProperty.getByName("material_Thickness");
+  private static _thicknessTextureProp = ShaderProperty.getByName("material_ThicknessTexture");
+
+  private _refractionMode: RefractionMode;
+  private _anisotropyRotation: number = 0;
+  private _iridescenceRange = new Vector2(100, 400);
+  private _sheenEnabled = false;
+  private _absorptionEnabled = true;
+  private _lastRenderQueueType = RenderQueueType.Opaque;
+
   /**
    * Index Of Refraction.
    * @defaultValue `1.5`
@@ -289,6 +306,146 @@ export class PBRMaterial extends PBRBaseMaterial {
     }
   }
 
+  /**
+   * Refraction switch.
+   * @remarks Use refractionMode to set the refraction shape.
+   */
+  get refractionMode(): RefractionMode {
+    return this._refractionMode;
+  }
+
+  set refractionMode(value: RefractionMode) {
+    if (value !== this._refractionMode) {
+      if (value) {
+        this.renderState.renderQueueType = RenderQueueType.Transparent;
+      } else {
+        this.renderState.renderQueueType = this._lastRenderQueueType;
+      }
+      this._refractionMode = value;
+      this._setRefractionMode(value);
+    }
+  }
+
+  override set isTransparent(value: boolean) {
+    super.isTransparent = value;
+    this._lastRenderQueueType = this.renderState.renderQueueType;
+    if (this.transmission > 0) {
+      // If transmission enabled, always use transparent queue to ensure get correct opaque texture
+      this.renderState.renderQueueType = RenderQueueType.Transparent;
+    }
+  }
+
+  override set alphaCutoff(value: number) {
+    super.alphaCutoff = value;
+    this._lastRenderQueueType = this.renderState.renderQueueType;
+    if (this.transmission > 0) {
+      // If transmission enabled, always use transparent queue to ensure get correct opaque texture
+      this.renderState.renderQueueType = RenderQueueType.Transparent;
+    }
+  }
+
+  /**
+   * Transmission factor.
+   * @defaultValue `0.0`
+   */
+  get transmission(): number {
+    return this.shaderData.getFloat(PBRMaterial._transmissionProp);
+  }
+
+  set transmission(value: number) {
+    value = MathUtil.clamp(value, 0, 1);
+    if (!!this.shaderData.getFloat(PBRMaterial._transmissionProp) !== !!value) {
+      if (value > 0) {
+        this.shaderData.enableMacro(PBRMaterial._transmissionMacro);
+        this.renderState.renderQueueType = RenderQueueType.Transparent;
+      } else {
+        this.shaderData.disableMacro(PBRMaterial._transmissionMacro);
+      }
+    }
+    this.shaderData.setFloat(PBRMaterial._transmissionProp, value);
+  }
+
+  /**
+   * Transmission texture.
+   * @remarks Use red channel, and multiply 'transmission'.
+   */
+  get transmissionTexture(): Texture2D {
+    return <Texture2D>this.shaderData.getTexture(PBRMaterial._transmissionTextureProp);
+  }
+
+  set transmissionTexture(value: Texture2D) {
+    this.shaderData.setTexture(PBRMaterial._transmissionTextureProp, value);
+    if (value) {
+      this.shaderData.enableMacro(PBRMaterial._transmissionTextureMacro);
+    } else {
+      this.shaderData.disableMacro(PBRMaterial._transmissionTextureMacro);
+    }
+  }
+
+  /**
+   * Attenuation color.
+   * @defaultValue `[1,1,1]`
+   */
+  get attenuationColor(): Color {
+    return this.shaderData.getColor(PBRMaterial._attenuationColorProp);
+  }
+
+  set attenuationColor(value: Color) {
+    const attenuationColor = this.shaderData.getColor(PBRMaterial._attenuationColorProp);
+    if (value !== attenuationColor) {
+      attenuationColor.copyFrom(value);
+    }
+  }
+
+  /**
+   * Attenuation distance, greater than 0.0.
+   * @defaultValue `infinity`
+   */
+  get attenuationDistance(): number {
+    return this.shaderData.getFloat(PBRMaterial._attenuationDistanceProp);
+  }
+
+  set attenuationDistance(value: number) {
+    value = Math.max(0, value);
+    this.shaderData.setFloat(PBRMaterial._attenuationDistanceProp, value);
+  }
+
+  /**
+   * Thickness, greater than or equal to 0.0.
+   * @defaultValue `0.0`
+   */
+  get thickness(): number {
+    return this.shaderData.getFloat(PBRMaterial._thicknessProp);
+  }
+
+  set thickness(value: number) {
+    value = Math.max(0, value);
+    if (!!this.shaderData.getFloat(PBRMaterial._thicknessProp) !== !!value) {
+      if (value > 0) {
+        this.shaderData.enableMacro(PBRMaterial._thicknessMacro);
+      } else {
+        this.shaderData.disableMacro(PBRMaterial._thicknessMacro);
+      }
+    }
+    this.shaderData.setFloat(PBRMaterial._thicknessProp, value);
+  }
+
+  /**
+   * Thickness texture.
+   * @remarks Use green channel, and multiply 'thickness', range is 0.0 to 1.0.
+   */
+  get thicknessTexture(): Texture2D {
+    return <Texture2D>this.shaderData.getTexture(PBRMaterial._thicknessTextureProp);
+  }
+
+  set thicknessTexture(value: Texture2D) {
+    this.shaderData.setTexture(PBRMaterial._thicknessTextureProp, value);
+    if (value) {
+      this.shaderData.enableMacro(PBRMaterial._thicknessTextureMacro);
+    } else {
+      this.shaderData.disableMacro(PBRMaterial._thicknessTextureMacro);
+    }
+  }
   /**
    * Create a pbr metallic-roughness workflow material instance.
    * @param engine - Engine to which the material belongs
@@ -304,8 +461,20 @@ export class PBRMaterial extends PBRBaseMaterial {
     shaderData.setVector4(PBRMaterial._iridescenceInfoProp, new Vector4(0, 1.3, 100, 400));
     const sheenColor = new Color(0, 0, 0);
     shaderData.setColor(PBRMaterial._sheenColorProp, sheenColor);
+    this.refractionMode = RefractionMode.Plane;
+    shaderData.setFloat(PBRMaterial._transmissionProp, 0);
+    shaderData.setFloat(PBRMaterial._thicknessProp, 0);
+    shaderData.setFloat(PBRMaterial._attenuationDistanceProp, Infinity);
+    const attenuationColor = new Color(1, 1, 1);
+    shaderData.setColor(PBRMaterial._attenuationColorProp, attenuationColor);
+    shaderData.enableMacro(PBRMaterial._absorptionMacro);
+
     // @ts-ignore
-    this._iridescenceRange._onValueChanged = this._onIridescenceRangeChanged.bind(this);
+    this._iridescenceRange._onValueChanged = () => {
+      const iridescenceInfo = this.shaderData.getVector4(PBRMaterial._iridescenceInfoProp);
+      iridescenceInfo.z = this._iridescenceRange.x;
+      iridescenceInfo.w = this._iridescenceRange.y;
+    };
     // @ts-ignore
     sheenColor._onValueChanged = () => {
       const enableSheen = sheenColor.r + sheenColor.g + sheenColor.b > 0;
@@ -318,12 +487,18 @@ export class PBRMaterial extends PBRBaseMaterial {
         }
       }
     };
-  }
-
-  private _onIridescenceRangeChanged(): void {
-    const iridescenceInfo = this.shaderData.getVector4(PBRMaterial._iridescenceInfoProp);
-    iridescenceInfo.z = this._iridescenceRange.x;
-    iridescenceInfo.w = this._iridescenceRange.y;
+    // @ts-ignore
+    attenuationColor._onValueChanged = () => {
+      const enableAbsorption = attenuationColor.r + attenuationColor.g + attenuationColor.b > 0;
+      if (enableAbsorption !== this._absorptionEnabled) {
+        this._absorptionEnabled = enableAbsorption;
+        if (enableAbsorption) {
+          this.shaderData.enableMacro(PBRMaterial._absorptionMacro);
+        } else {
+          this.shaderData.disableMacro(PBRMaterial._absorptionMacro);
+        }
+      }
+    };
   }
 
   /**
@@ -334,4 +509,18 @@ export class PBRMaterial extends PBRBaseMaterial {
     this.cloneTo(dest);
     return dest;
   }
+
+  private _setRefractionMode(refractionMode: RefractionMode): void {
+    switch (refractionMode) {
+      case RefractionMode.Sphere:
+        this.shaderData.enableMacro("REFRACTION_MODE", "SPHERE");
+        break;
+      case RefractionMode.Plane:
+        this.shaderData.enableMacro("REFRACTION_MODE", "PLANE");
+        break;
+      case RefractionMode.Thin:
+        this.shaderData.enableMacro("REFRACTION_MODE", "THIN");
+        break;
+    }
+  }
 }

packages/core/src/material/enums/Refraction.ts

@@ -0,0 +1,11 @@
+/**
+ * Refraction mode.
+ */
+export enum RefractionMode {
+  /** Refraction shape is sphere. */
+  Sphere,
+  /** Refraction shape is plane. */
+  Plane,
+  /** Refraction shape is thin. */
+  Thin
+}

packages/core/src/material/index.ts

@@ -8,3 +8,4 @@ export { PBRBaseMaterial } from "./PBRBaseMaterial";
 export { PBRMaterial } from "./PBRMaterial";
 export { PBRSpecularMaterial } from "./PBRSpecularMaterial";
 export { UnlitMaterial } from "./UnlitMaterial";
+export { RefractionMode } from "./enums/Refraction";

packages/loader/src/gltf/extensions/GLTFExtensionSchema.ts

@@ -188,6 +188,16 @@ export interface IKHRMaterialsIridescence {
   iridescenceThicknessTexture?: ITextureInfo;
 }
 
+/**
+ * Interfaces from the KHR_materials_volume extension
+ */
+export interface IKHRMaterialsVolume {
+  thicknessFactor?: number;
+  thicknessTexture?: ITextureInfo;
+  attenuationDistance?: number;
+  attenuationColor?: number[];
+}
+
 export type GLTFExtensionSchema =
   | IKHRLightsPunctual_Light
   | IKHRMaterialsClearcoat
@@ -207,4 +217,5 @@ export type GLTFExtensionSchema =
   | IKHRXmp_Node
   | IGalaceanAnimation
   | IKHRMaterialsIridescence
+  | IKHRMaterialsVolume
   | Object;

packages/loader/src/gltf/extensions/KHR_materials_transmission.ts

@@ -0,0 +1,21 @@
+import { PBRMaterial, Texture2D } from "@galacean/engine-core";
+import { GLTFMaterialParser } from "../parser/GLTFMaterialParser";
+import { registerGLTFExtension } from "../parser/GLTFParser";
+import { GLTFParserContext, GLTFParserType } from "../parser/GLTFParserContext";
+import { GLTFExtensionMode, GLTFExtensionParser } from "./GLTFExtensionParser";
+import { IKHRMaterialsTransmission } from "./GLTFExtensionSchema";
+@registerGLTFExtension("KHR_materials_transmission", GLTFExtensionMode.AdditiveParse)
+class KHR_materials_transmission extends GLTFExtensionParser {
+  override additiveParse(context: GLTFParserContext, material: PBRMaterial, schema: IKHRMaterialsTransmission): void {
+    const { transmissionFactor = 0, transmissionTexture } = schema;
+    material.transmission = transmissionFactor;
+
+    if (transmissionTexture) {
+      GLTFMaterialParser._checkOtherTextureTransform(transmissionTexture, "Transmission texture");
+
+      context.get<Texture2D>(GLTFParserType.Texture, transmissionTexture.index).then((texture) => {
+        material.transmissionTexture = texture;
+      });
+    }
+  }
+}

packages/loader/src/gltf/extensions/KHR_materials_volume.ts

@@ -0,0 +1,33 @@
+import { PBRMaterial, Texture2D } from "@galacean/engine-core";
+import { Color } from "@galacean/engine-math";
+import { GLTFMaterialParser } from "../parser/GLTFMaterialParser";
+import { registerGLTFExtension } from "../parser/GLTFParser";
+import { GLTFParserContext, GLTFParserType } from "../parser/GLTFParserContext";
+import { GLTFExtensionMode, GLTFExtensionParser } from "./GLTFExtensionParser";
+import { IKHRMaterialsVolume } from "./GLTFExtensionSchema";
+
+@registerGLTFExtension("KHR_materials_volume", GLTFExtensionMode.AdditiveParse)
+class KHR_materials_volume extends GLTFExtensionParser {
+  override additiveParse(context: GLTFParserContext, material: PBRMaterial, schema: IKHRMaterialsVolume): void {
+    const { thicknessFactor = 0, thicknessTexture, attenuationDistance = Infinity, attenuationColor } = schema;
+    material.thickness = thicknessFactor;
+    material.attenuationDistance = attenuationDistance;
+
+    if (attenuationColor) {
+      material.attenuationColor.set(
+        Color.linearToGammaSpace(attenuationColor[0]),
+        Color.linearToGammaSpace(attenuationColor[1]),
+        Color.linearToGammaSpace(attenuationColor[2]),
+        undefined
+      );
+    }
+
+    if (thicknessTexture) {
+      GLTFMaterialParser._checkOtherTextureTransform(thicknessTexture, "Thickness texture");
+
+      context.get<Texture2D>(GLTFParserType.Texture, thicknessTexture.index).then((texture) => {
+        material.thicknessTexture = texture;
+      });
+    }
+  }
+}

packages/shader-shaderlab/src/shaders/Common.glsl

@@ -5,6 +5,8 @@
 #define RECIPROCAL_PI 0.31830988618
 #define EPSILON 1e-6
 #define LOG2 1.442695
+#define HALF_MIN 6.103515625e-5  // 2^-14, the same value for 10, 11 and 16-bit: https://www.khronos.org/opengl/wiki/Small_Float_Formats
+// #define HALF_EPS 4.8828125e-4    // 2^-11, machine epsilon: 1 + EPS = 1 (half of the ULP for 1.0f)
 
 #define saturate( a ) clamp( a, 0.0, 1.0 )
 
@@ -97,5 +99,10 @@ float remapDepthBufferLinear01(float z){
 	#define INVERSE_MAT(mat) inverseMat(mat)
 #endif
 
+// vec3 safeNormalize(vec3 inVec)
+// {
+//     float dp3 = max(float(HALF_MIN), dot(inVec, inVec));
+//     return inVec * inversesqrt(dp3);
+// }
 
 #endif

packages/shader-shaderlab/src/shaders/PBR.gs

@@ -54,6 +54,11 @@ Shader "PBR.gs" {
         material_SheenTexture("ColorTexture", Texture2D);
         material_SheenRoughnessTexture("RoughnessTexture", Texture2D);
       }
+
+      Header("Transmission"){
+        material_Transmission("Transmission", Range(0, 1, 0.01)) = 0;
+        material_TransmissionTexture("TransmissionTexture", Texture2D);
+      }
 
       Header("Common") {
         material_AlphaCutoff( "AlphaCutoff", Range(0, 1, 0.01) ) = 0;