shaderlab pbr support refraction

packages/core/src/material/PBRMaterial.ts

@@ -1,6 +1,6 @@
 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";
@@ -31,6 +31,14 @@
   private static _sheenTextureProp = ShaderProperty.getByName("material_SheenTexture");
   private static _sheenRoughnessTextureProp = ShaderProperty.getByName("material_SheenRoughnessTexture");
 
+  private _refractionEnabled = false;
+  private static _refactionMacro: ShaderMacro = ShaderMacro.getByName("MATERIAL_ENABLE_SS_REFRACTION");
+  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");
   /**
    * Index Of Refraction.
    * @defaultValue `1.5`
@@ -289,6 +297,122 @@
     }
   }
 
+  /**
+   * Refraction switch.
+   */
+  get enableRefraction(): boolean {
+    return this._refractionEnabled;
+  }
+
+  set enableRefraction(value: boolean) {
+    if (value !== this._refractionEnabled) {
+      this._refractionEnabled = value;
+      if (value) {
+        this.shaderData.enableMacro(PBRMaterial._refactionMacro);
+      } else {
+        this.shaderData.enableMacro(PBRMaterial._refactionMacro);
+      }
+    }
+  }
+
+  /**
+   * Transmission factor.
+   * @defaultValue `0.0`
+   */
+  get transmission(): number {
+    return this.shaderData.getFloat(PBRMaterial._transmissionProp);
+  }
+
+  set transmission(value: number) {
+    this.shaderData.setFloat(PBRMaterial._transmissionProp, value);
+    if (value) {
+      this.shaderData.enableMacro("MATERIAL_HAS_TRANSMISSION");
+    } else {
+      this.shaderData.disableMacro("MATERIAL_HAS_TRANSMISSION");
+    }
+  }
+
+  /**
+   * 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("MATERIAL_HAS_TRANSMISSION_TEXTURE");
+    } else {
+      this.shaderData.disableMacro("MATERIAL_HAS_TRANSMISSION_TEXTURE");
+    }
+  }
+
+  /**
+   * 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) {
+    if (value <= 0) {
+      throw new Error("attenuationDistance must be greater than 0.0");
+    }
+    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);
+    this.shaderData.setFloat(PBRMaterial._thicknessProp, value);
+    if (value) {
+      this.shaderData.enableMacro("MATERIAL_HAS_THICKNESS");
+    } else {
+      this.shaderData.disableMacro("MATERIAL_HAS_THICKNESS");
+    }
+  }
+
+  /**
+   * 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("MATERIAL_HAS_THICKNESS_TEXTURE");
+    } else {
+      this.shaderData.disableMacro("MATERIAL_HAS_THICKNESS_TEXTURE");
+    }
+  }
   /**
    * Create a pbr metallic-roughness workflow material instance.
    * @param engine - Engine to which the material belongs
@@ -304,6 +428,8 @@
     shaderData.setVector4(PBRMaterial._iridescenceInfoProp, new Vector4(0, 1.3, 100, 400));
     const sheenColor = new Color(0, 0, 0);
     shaderData.setColor(PBRMaterial._sheenColorProp, sheenColor);
+    const attenuationColor = new Color(1, 1, 1);
+    shaderData.setColor(PBRMaterial._attenuationColorProp, attenuationColor);
     // @ts-ignore
     this._iridescenceRange._onValueChanged = this._onIridescenceRangeChanged.bind(this);
     // @ts-ignore
@@ -318,6 +444,15 @@
         }
       }
     };
+    // @ts-ignore
+    attenuationColor._onValueChanged = () => {
+      const enableAbsorption = attenuationColor.r + attenuationColor.g + attenuationColor.b > 1;
+      if (enableAbsorption) {
+        this.shaderData.enableMacro("MATERIAL_HAS_ABSORPTION");
+      } else {
+        this.shaderData.disableMacro("MATERIAL_HAS_ABSORPTION");
+      }
+    };
   }
 
   private _onIridescenceRangeChanged(): void {

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

@@ -1,0 +1,23 @@
+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

@@ -1,0 +1,34 @@
+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/shadingPBR/BRDF.glsl

@@ -24,6 +24,7 @@ struct SurfaceData{
     float specularAO;
     float f0;
     float opacity;
+    float IOR;
 
     // geometry
     vec3 position;
@@ -64,6 +65,12 @@ struct SurfaceData{
         vec3  sheenColor;
     #endif
 
+    #ifdef MATERIAL_ENABLE_SS_REFRACTION 
+        vec3 attenuationColor;
+        float attenuationDistance;
+        float transmission;
+        float thickness;
+    #endif
 };
 
 

packages/shader-shaderlab/src/shaders/shadingPBR/BTDF.glsl

@@ -0,0 +1,54 @@
+#ifndef BTDF_INCLUDED
+#define BTDF_INCLUDED
+
+#include "Refraction.glsl"
+
+sampler2D camera_OpaqueTexture;
+
+#ifdef MATERIAL_ENABLE_SS_REFRACTION 
+    vec3 evaluateRefraction(SurfaceData surfaceData, BRDFData brdfData, vec3 specularColor) {
+        RefractionModel ray;
+        #if defined(REFRACTION_SPHERE) 
+            RefractionModelSphere(-surfaceData.viewDir, surfaceData.position, surfaceData.normal, surfaceData.IOR, surfaceData.thickness, ray);
+        #elif defined(REFRACTION_PLANE)
+            RefractionModelBox(-surfaceData.viewDir, surfaceData.position, surfaceData.normal, surfaceData.IOR, surfaceData.thickness, ray);
+        #elif defined(REFRACTION_THIN)
+            RefractionModelBox(-surfaceData.viewDir, surfaceData.position, surfaceData.normal, surfaceData.IOR, 0.005, ray);
+        #endif
+        //TODO: support cubemap refraction.
+        vec3 refractedRayExit = ray.position;
+
+        // We calculate the screen space position of the refracted point
+        vec4 samplingPositionNDC = camera_ProjMat * camera_ViewMat * vec4( refractedRayExit, 1.0 );
+        vec2 refractionCoords = (samplingPositionNDC.xy / samplingPositionNDC.w) * 0.5 + 0.5;
+
+        // Absorption coefficient from Disney: http://blog.selfshadow.com/publications/s2015-shading-course/burley/s2015_pbs_disney_bsdf_notes.pdf
+       #ifdef MATERIAL_HAS_ABSORPTION
+            vec3 absorptionCoefficient = -log(clamp(surfaceData.attenuationColor, 1e-5f, 1.0f)) / max(1e-5f, surfaceData.attenuationDistance);
+            #ifdef MATERIAL_HAS_THICKNESS
+                vec3 transmittance = min(vec3(1.0), exp(-absorptionCoefficient * ray.dist));
+            #else
+                vec3 transmittance = 1.0 - absorptionCoefficient;
+            #endif
+       #endif
+
+        // Sample the opaque texture to get the transmitted light
+		vec4 getTransmission = texture2D(camera_OpaqueTexture, refractionCoords);
+
+        vec3 refractionTransmitted = getTransmission.rgb;
+        refractionTransmitted *= brdfData.diffuseColor;
+
+        // Use specularFGD as an approximation of the fresnel effect
+        // https://blog.selfshadow.com/publications/s2017-shading-course/imageworks/s2017_pbs_imageworks_slides_v2.pdf
+        vec3 specularFGD = envBRDFApprox(specularColor, surfaceData.roughness, surfaceData.dotNV);
+        refractionTransmitted *= (1.0 - specularFGD);
+
+       #ifdef MATERIAL_HAS_ABSORPTION
+            refractionTransmitted *= transmittance;
+       #endif
+
+    return refractionTransmitted;
+    }
+#endif
+
+#endif

packages/shader-shaderlab/src/shaders/shadingPBR/FragmentPBR.glsl

@@ -62,6 +62,25 @@ float material_OcclusionTextureCoord;
     #endif
 #endif
 
+#ifdef MATERIAL_ENABLE_SS_REFRACTION 
+    vec3 material_attenuationColor;
+    float material_attenuationDistance;
+
+    #ifdef MATERIAL_HAS_TRANSMISSION
+    float material_transmission;
+        #ifdef MATERIAL_HAS_TRANSMISSION_TEXTURE
+            sampler2D material_TransmissionTexture;
+        #endif
+    #endif
+
+    #ifdef MATERIAL_HAS_THICKNESS
+        float material_thickness;
+        #ifdef MATERIAL_HAS_THICKNESS_TEXTURE
+            sampler2D material_ThicknessTexture;
+        #endif
+    #endif
+#endif
+
 // Texture
 #ifdef MATERIAL_HAS_BASETEXTURE
     sampler2D material_BaseTexture;
@@ -292,6 +311,27 @@ SurfaceData getSurfaceData(Varyings v, vec2 aoUV, bool isFrontFacing){
         #endif
     #endif
 
+    #ifdef MATERIAL_ENABLE_SS_REFRACTION 
+        surfaceData.attenuationColor = material_attenuationColor;
+        surfaceData.IOR = material_IOR;
+        surfaceData.attenuationDistance = max(material_attenuationDistance, 0.001);
+
+        #ifdef MATERIAL_HAS_TRANSMISSION
+            surfaceData.transmission = material_transmission;
+            #ifdef MATERIAL_HAS_TRANSMISSION_TEXTURE
+                surfaceData.transmission *= texture2D(material_TransmissionTexture, uv).r;
+            #endif
+        #else
+            surfaceData.transmission = 1.0;
+        #endif
+
+        #ifdef MATERIAL_HAS_THICKNESS
+            surfaceData.thickness = max(material_thickness, 0.0);
+            #ifdef MATERIAL_HAS_THICKNESS_TEXTURE
+                surfaceData.thickness *= texture2D( material_ThicknessTexture, uv).g;
+            #endif
+        #endif
+    #endif
     // AO
     float diffuseAO = 1.0;
     float specularAO = 1.0;