shaderlab pbr support refraction

packages/core/src/material/PBRMaterial.ts

@@ -528,13 +528,13 @@
   private _setRefractionMode(refractionMode: RefractionMode): void {
     switch (refractionMode) {
       case RefractionMode.Sphere:
-        this.shaderData.enableMacro("REFRACTION_MODE", "SPHERE");
+        this.shaderData.enableMacro("REFRACTION_MODE", "0");
         break;
       case RefractionMode.Plane:
-        this.shaderData.enableMacro("REFRACTION_MODE", "PLANE");
+        this.shaderData.enableMacro("REFRACTION_MODE", "1");
         break;
       case RefractionMode.Thin:
-        this.shaderData.enableMacro("REFRACTION_MODE", "THIN");
+        this.shaderData.enableMacro("REFRACTION_MODE", "2");
         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

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

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

@@ -3,20 +3,35 @@
 
 #include "Refraction.glsl"
 
+#define REFRACTION_MODE 9
 #ifdef MATERIAL_ENABLE_TRANSMISSION 
     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 +42,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 == THIN
+                //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/LightIndirectPBR.glsl

@@ -15,6 +15,7 @@
     #define FUNCTION_SHEEN_IBL evaluateSheenIBL
 #endif
 #include "BRDF.glsl"
+#include "BTDF.glsl"
 #include "Light.glsl"
 #include "LightIndirectFunctions.glsl"
 

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);