shaderlab pbr support refraction

packages/core/src/material/PBRMaterial.ts

@@ -317,7 +317,7 @@ export class PBRMaterial extends PBRBaseMaterial {
   set refractionMode(value: RefractionMode) {
     if (value !== this._refractionMode) {
       this._refractionMode = value;
-      this._setRefractionMode(value);
+      this.shaderData.enableMacro("REFRACTION_MODE", value.toString());
     }
   }
 
@@ -524,18 +524,4 @@ export class PBRMaterial extends PBRBaseMaterial {
       }
     }
   }
-
-  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/shader-shaderlab/src/shaders/Common.glsl

@@ -6,7 +6,7 @@
 #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 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 )
 
@@ -99,10 +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);
-// }
+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

@@ -58,6 +58,10 @@ Shader "PBR.gs" {
       Header("Transmission"){
         material_Transmission("Transmission", Range(0, 1, 0.01)) = 0;
         material_TransmissionTexture("TransmissionTexture", Texture2D);
+        material_AttenuationColor("AttenuationColor", Color ) = (1, 1, 1, 1);
+        material_AttenuationDistance("AttenuationDistance", Range(0, 1, 0.01)) = 0;
+        material_Thickness("Thickness", Range(0, 5, 0.01)) = 0;
+        material_ThicknessTexture("ThicknessTexture", Texture2D);
       }
 
       Header("Common") {

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

@@ -7,16 +7,30 @@
     sampler2D camera_OpaqueTexture;
     vec3 evaluateRefraction(SurfaceData surfaceData, BRDFData brdfData) {
         RefractionModelResult ray;
-        #ifdef REFRACTION_MODE
-            refractionModelBox(-surfaceData.viewDir, surfaceData.position, surfaceData.normal, surfaceData.IOR, 0.005, ray);
+        // '0' is refraction sphere, '1' is refraction plane, '2' is refraction thin
+        #if REFRACTION_MODE == 0
+            refractionModelSphere(-surfaceData.viewDir, surfaceData.position, surfaceData.normal, surfaceData.IOR, surfaceData.thickness, ray);
+        #elif REFRACTION_MODE == 1
+            refractionModelBox(-surfaceData.viewDir, surfaceData.position, surfaceData.normal, surfaceData.IOR, surfaceData.thickness, ray);
+        #elif REFRACTION_MODE == 2
+            refractionModelBox(-surfaceData.viewDir, surfaceData.position, surfaceData.normal, surfaceData.IOR, surfaceData.thickness, ray);
         #endif
-        //TODO: support cubemap refraction.
+
         vec3 refractedRayExit = ray.positionExit;
 
         // 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
+            #ifdef MATERIAL_HAS_THICKNESS
+                vec3 transmittance = min(vec3(1.0), exp(-surfaceData.absorptionCoefficient * ray.transmissionLength));
+            #else
+                vec3 transmittance = 1.0 - surfaceData.absorptionCoefficient;
+            #endif
+       #endif
+
         // Sample the opaque texture to get the transmitted light
 		vec4 getTransmission = texture2D(camera_OpaqueTexture, refractionCoords);
         vec3 refractionTransmitted = getTransmission.rgb;
@@ -27,6 +41,10 @@
         vec3 specularDFG =  brdfData.envSpecularDFG;
 
         refractionTransmitted *= (1.0 - specularDFG);
+
+       #ifdef MATERIAL_HAS_ABSORPTION
+            refractionTransmitted *= transmittance;
+       #endif
 
     return refractionTransmitted;
     }

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

@@ -62,11 +62,20 @@ float material_OcclusionTextureCoord;
     #endif
 #endif
 
-#ifdef MATERIAL_ENABLE_TRANSMISSION    
-        float material_Transmission;
-        #ifdef MATERIAL_HAS_TRANSMISSION_TEXTURE
-            sampler2D material_TransmissionTexture;
+#ifdef MATERIAL_HAS_TRANSMISSION 
+    vec3 material_AttenuationColor;
+    float material_AttenuationDistance;
+    float material_Transmission;
+    #ifdef MATERIAL_HAS_TRANSMISSION_TEXTURE
+        sampler2D material_TransmissionTexture;
+    #endif
+
+    #ifdef MATERIAL_HAS_THICKNESS
+        float material_Thickness;
+        #ifdef MATERIAL_HAS_THICKNESS_TEXTURE
+            sampler2D material_ThicknessTexture;
         #endif
+    #endif
 #endif
 
 // Texture
@@ -302,10 +311,24 @@ SurfaceData getSurfaceData(Varyings v, vec2 aoUV, bool isFrontFacing){
     #endif
 
     #ifdef MATERIAL_ENABLE_TRANSMISSION 
-            surfaceData.transmission = material_Transmission;
-            #ifdef MATERIAL_HAS_TRANSMISSION_TEXTURE
-                surfaceData.transmission *= texture2D(material_TransmissionTexture, uv).r;
+        surfaceData.transmission = material_Transmission;
+        #ifdef MATERIAL_HAS_TRANSMISSION_TEXTURE
+            surfaceData.transmission *= texture2D(material_TransmissionTexture, uv).r;
+        #endif
+
+        surfaceData.absorptionCoefficient = -log(material_AttenuationColor + HALF_EPS) / max(HALF_EPS, material_AttenuationDistance);
+
+        #ifdef MATERIAL_HAS_THICKNESS
+            #if REFRACTION_MODE == 2
+                //https://zh.wikipedia.org/wiki/%E8%96%84%E8%86%9C%E5%85%89%E5%AD%A6
+                surfaceData.thickness = 0.005;
+            #else
+                surfaceData.thickness = max(material_Thickness, 0.0001);
+                #ifdef MATERIAL_HAS_THICKNESS_TEXTURE
+                    surfaceData.thickness *= texture2D( material_ThicknessTexture, uv).g;
+                #endif
             #endif
+        #endif    
     #endif
 
     // AO

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

@@ -9,6 +9,27 @@ struct RefractionModelResult{
     // vec3 directionExit;     // out ray direction
 };
 
+//https://docs.unity3d.com/Packages/[email protected]/manual/refraction-models.html
+ void refractionModelSphere(vec3 V, vec3 positionWS, vec3 normalWS, float ior, float thickness, out RefractionModelResult ray){
+    // Refracted ray
+    vec3 R1 = refract(V, normalWS, 1.0 / ior);
+    // Center of the tangent sphere
+    vec3 C = positionWS - normalWS * thickness * 0.5;
+
+    // Second refraction (tangent sphere out)
+    float dist = dot(-normalWS, R1) * thickness;
+    // Out hit point in the tangent sphere
+    vec3 P1 = positionWS + R1 * dist;
+    // Out normal
+    vec3 N1 = safeNormalize(C - P1);
+    // Out refracted ray
+    // vec3 R2 = refract(R1, N1, ior);
+
+    ray.transmissionLength = dist;
+    ray.positionExit = P1;
+    // ray.directionExit = R2; 
+}
+
 void refractionModelBox(vec3 V, vec3 positionWS, vec3 normalWS, float ior, float thickness, out RefractionModelResult ray){
     // Refracted ray
     vec3 R = refract(V, normalWS, 1.0 / ior);