add glass

cocos · Jul 19, 2023 · 6282c75 · 6282c75
1 parent 96be289
commit 6282c75
Show file tree

Hide file tree

Showing 9 changed files with 487 additions and 178 deletions.
diff --git a/editor/assets/chunks/common/lighting/brdf.chunk b/editor/assets/chunks/common/lighting/brdf.chunk
@@ -1,5 +1,6 @@
 #include <common/math/number>
 
+// for dielectric(non-metal) surfaces
 float F0ToIor(float F0)
 {
 	return 2.0f / (1.0f - sqrt(F0)) - 1.0f;

diff --git a/editor/assets/chunks/common/lighting/bxdf.chunk b/editor/assets/chunks/common/lighting/bxdf.chunk
@@ -1,6 +1,6 @@
 
 // saturated N dot V
-// for env reflection with non-metal and smooth surface
+// for env reflection with dielectric(non-metal) and smooth surface
 float CalculateFresnelCoefficient(float ior, float NoVSat)
 {
 	float g, c, n, prev, next;
@@ -22,3 +22,35 @@ vec3 CalculateScattering(vec3 unscatteredColor, float distance, float outScatter
 	vec3 outScattered = unscatteredColor * extinction.x * outScatterColor;
     return outScattered + inScattered;
 }
+
+
+// LastLayerF for temporary use
+// S is spec without GF
+void InitializeLayerBlending(out vec3 blendedBaseLayerD, out vec3 blendedBaseLayerS,
+                             out vec3 blendedSubLayerD, out vec3 blendedSubLayerS,
+                             out vec3 lastLayerF,
+                             in vec3 baseD, in vec3 baseS
+                             )
+{
+  blendedBaseLayerD = baseD;
+  blendedBaseLayerS = baseS;
+  blendedSubLayerD = blendedSubLayerS = vec3(0.0);
+  lastLayerF = vec3(1.0);  
+}
+
+// use subLayerF instead of subLayerGF for ior-dependent 0-1 range
+void CalculateLayerBlending(inout vec3 blendedBaseLayerD, inout vec3 blendedBaseLayerS,
+                            inout vec3 blendedSubLayerD, inout vec3 blendedSubLayerS,
+                            inout vec3 lastLayerF,
+                            in vec3 subLayerD, in vec3 subLayerDiffuseColor,
+                            in vec3 subLayerS, in vec3 subLayerSpecularColor,
+                            in float subLayerOpacity, inout vec3 subLayerF
+                            )
+{
+  subLayerF = saturate(subLayerF * subLayerOpacity);
+  blendedSubLayerD = blendedSubLayerD * (vec3(1.0) - lastLayerF) + subLayerD * subLayerDiffuseColor * subLayerF;
+  blendedSubLayerS = blendedSubLayerS *(vec3(1.0) - lastLayerF) + subLayerS * subLayerSpecularColor * subLayerF;
+  blendedBaseLayerD *= vec3(1.0) - subLayerF;
+  blendedBaseLayerS *= vec3(1.0) - subLayerF;
+  lastLayerF = subLayerF;
+}
diff --git a/editor/assets/chunks/lighting-models/data-structures/lighting-result.chunk b/editor/assets/chunks/lighting-models/data-structures/lighting-result.chunk
@@ -39,7 +39,7 @@ struct LightingResult
 
 
 /* for multi-layer materials, should define:
-struct LightingResultLayer
+struct LightingResultPerLayer
 {
   vec3 diffuseColorWithLighting, specularColorWithLighting;
   vec3 directDiffuse, directSpecular, directGF;

diff --git a/editor/assets/chunks/lighting-models/lighting-flow/common-flow.chunk b/editor/assets/chunks/lighting-models/lighting-flow/common-flow.chunk
@@ -118,6 +118,9 @@
           CCSurfacesLightingCalculateDirectTT(lightingResult, lightingData, attenuatedLightColorAndIntensity);
         #endif
 
+        #if CC_SURFACES_LIGHTING_USE_MULTIPLE_LAYER_BLEND
+          CCSurfacesLightingCalculateDirectMultiLayerBlending(lightingResult, lightingData2ndSpecular);
+        #endif
 
         // user-defined lighting model
         #ifdef CC_SURFACES_LIGHTING_MODIFY_FINAL_RESULT
@@ -254,50 +257,17 @@
 
         CCSurfacesLightingCalculateDirect2ndSpecular(lightingResult.direct2ndSpecular, lightingData2ndSpecular, cc_mainLitColor, surfaceData2ndSpecular.intensity2ndSpecular, lightingResult.directSpecular);
         CCSurfaceLightingCalculateDirectFresnel(lightingResult.directGF2ndSpecular, lightingData2ndSpecular, lightingResult.specularColorWithLighting2ndSpecular, lightingResult.environmentGF2ndSpecular);
-
-        #if CC_SURFACES_LIGHTING_USE_MULTIPLE_LAYER_BLEND
-          vec3 lastLayerF, zeroVector = vec3(0.0);
-          vec3 blendedBaseD = lightingResult.directDiffuse, blendedBaseS = lightingResult.directSpecular;
-          CCSurfaceLightingCalculateDirectSubLayerFresnel(lightingResult.directSubLayerF, lightingData2ndSpecular, lightingResult.specularColorWithLighting2ndSpecular);
-          InitializeLayerBlending(blendedBaseD, blendedBaseS,
-                                  lightingResult.directDiffuseSubLayers, lightingResult.directSpecularSubLayers,
-                                  lastLayerF,
-                                  lightingResult.directDiffuse, lightingResult.directSpecular
-                                  );
-          CalculateLayerBlending (blendedBaseD, blendedBaseS,
-                                  lightingResult.directDiffuseSubLayers, lightingResult.directSpecularSubLayers,
-                                  lastLayerF,
-                                  zeroVector, zeroVector,
-                                  lightingResult.direct2ndSpecular, lightingResult.specularColorWithLighting2ndSpecular,
-                                  lightingData2ndSpecular.layerOpacity, lightingResult.directSubLayerF
-                                  );
-          lightingResult.directDiffuse = blendedBaseD;
-          lightingResult.directSpecular = blendedBaseS;
-
-          zeroVector = vec3(0.0);
-          blendedBaseD = lightingResult.environmentDiffuse; blendedBaseS = lightingResult.environmentSpecular;
-          CCSurfaceLightingCalculateEnvironmentSubLayerFresnel(lightingResult.environmentSubLayerF, lightingData2ndSpecular, lightingResult.specularColorWithLighting2ndSpecular);
-          InitializeLayerBlending(blendedBaseD, blendedBaseS,
-                                  lightingResult.environmentDiffuseSubLayers, lightingResult.environmentSpecularSubLayers,
-                                  lastLayerF,
-                                  lightingResult.environmentDiffuse, lightingResult.environmentSpecular
-                                  );
-          CalculateLayerBlending (blendedBaseD, blendedBaseS,
-                                  lightingResult.environmentDiffuseSubLayers, lightingResult.environmentSpecularSubLayers,
-                                  lastLayerF,
-                                  zeroVector, zeroVector,
-                                  lightingResult.environment2ndSpecular, lightingResult.specularColorWithLighting2ndSpecular,
-                                  lightingData2ndSpecular.layerOpacity, lightingResult.environmentSubLayerF
-                                  );
-          lightingResult.environmentDiffuse = blendedBaseD;
-          lightingResult.environmentSpecular = blendedBaseS;
-        #endif
       #endif
 
       #if CC_SURFACES_LIGHTING_TT
         CCSurfacesLightingCalculateDirectTT(lightingResult, lightingData, cc_mainLitColor);
       #endif
 
+      #if CC_SURFACES_LIGHTING_USE_MULTIPLE_LAYER_BLEND
+        CCSurfacesLightingCalculateDirectMultiLayerBlending(lightingResult, lightingData2ndSpecular);
+        CCSurfacesLightingCalculateEnvironmentMultiLayerBlending(lightingResult, lightingData2ndSpecular);
+      #endif
+
       // user-defined lighting model
       #ifdef CC_SURFACES_LIGHTING_MODIFY_FINAL_RESULT
         LightingMiscData miscData;

diff --git a/editor/assets/chunks/lighting-models/model-functions/standard.chunk b/editor/assets/chunks/lighting-models/model-functions/standard.chunk
@@ -249,46 +249,69 @@ void CCSurfaceLightingCalculateEnvironmentSubLayerFresnel(out vec3 subLayerF, in
   }
 #endif
 
+#if CC_SURFACES_LIGHTING_USE_MULTIPLE_LAYER_BLEND
+  // todo: layer result in LightingResult separate to single structure like LightingResultPerLayer
+  void CCSurfacesLightingCalculateDirectMultiLayerBlending(inout LightingResult lightingResult
+      , in LightingIntermediateData lightingData2ndLayer
+    #if CC_SURFACES_LIGHTING_USE_MULTIPLE_LAYER_BLEND > 1
+      // add more layers...
+    #endif
+    )
+  {
+    vec3 lastLayerF, zeroVector = vec3(0.0);
+    vec3 blendedBaseD = lightingResult.directDiffuse, blendedBaseS = lightingResult.directSpecular;
+    InitializeLayerBlending(blendedBaseD, blendedBaseS,
+                            lightingResult.directDiffuseSubLayers, lightingResult.directSpecularSubLayers,
+                            lastLayerF,
+                            lightingResult.directDiffuse, lightingResult.directSpecular
+                            );
 
-// LastLayerF for temporary use
-// S is spec without GF
-void InitializeLayerBlending(out vec3 blendedBaseLayerD, out vec3 blendedBaseLayerS,
-                             out vec3 blendedSubLayerD, out vec3 blendedSubLayerS,
-                             out vec3 lastLayerF,
-                             in vec3 baseD, in vec3 baseS
-                             )
-{
-  blendedBaseLayerD = baseD;
-  blendedBaseLayerS = baseS;
-  blendedSubLayerD = blendedSubLayerS = vec3(0.0);
-  lastLayerF = vec3(1.0);  
-}
+      CCSurfaceLightingCalculateDirectSubLayerFresnel(lightingResult.directSubLayerF, lightingData2ndLayer, lightingResult.specularColorWithLighting2ndSpecular);
+      CalculateLayerBlending (blendedBaseD, blendedBaseS,
+                              lightingResult.directDiffuseSubLayers, lightingResult.directSpecularSubLayers,
+                              lastLayerF,
+                              zeroVector, zeroVector,
+                              lightingResult.direct2ndSpecular, lightingResult.specularColorWithLighting2ndSpecular,
+                              lightingData2ndLayer.layerOpacity, lightingResult.directSubLayerF
+                              );
+    #if CC_SURFACES_LIGHTING_USE_MULTIPLE_LAYER_BLEND > 1
+      // add more layers...
+    #endif
 
-// use subLayerF instead of subLayerGF for ior-dependent 0-1 range
-void CalculateLayerBlending(inout vec3 blendedBaseLayerD, inout vec3 blendedBaseLayerS,
-                            inout vec3 blendedSubLayerD, inout vec3 blendedSubLayerS,
-                            inout vec3 lastLayerF,
-                            in vec3 subLayerD, in vec3 subLayerDiffuseColor,
-                            in vec3 subLayerS, in vec3 subLayerSpecularColor,
-                            in float subLayerOpacity, inout vec3 subLayerF
-                            )
-{
-  subLayerF = saturate(subLayerF * subLayerOpacity);
-  blendedSubLayerD = blendedSubLayerD * (vec3(1.0) - lastLayerF) + subLayerD * subLayerDiffuseColor * subLayerF;
-  blendedSubLayerS = blendedSubLayerS *(vec3(1.0) - lastLayerF) + subLayerS * subLayerSpecularColor * subLayerF;
-  blendedBaseLayerD *= vec3(1.0) - subLayerF;
-  blendedBaseLayerS *= vec3(1.0) - subLayerF;
-  lastLayerF = subLayerF;
-}
-/*void CCSurfacesLightingInitializeLayerBlending(inout LightingResult lightingResult, out vec3 lastLayerF)
-{
-  InitializeLayerBlending(lightingResult.directDiffuseSubLayers, lightingResult.directDiffuseSubLayers,
-                          lightingResult.directDiffuseSubLayers, lightingResult.directDiffuseSubLayers);
-}
-void CCSurfacesLightingCalculateLayerBlending(inout LightingResult lightingResult, inout vec3 lastLayerF,
-                                              in vec3 subLayerD, in vec3 subLayerS, inout vec3 subLayerF
-                                              )
-{
-  // CalculateLayerBlending(lightingResult.);
-}
-*/
+    // output
+    lightingResult.directDiffuse = blendedBaseD;
+    lightingResult.directSpecular = blendedBaseS;
+  }
+
+  void CCSurfacesLightingCalculateEnvironmentMultiLayerBlending(inout LightingResult lightingResult
+      , in LightingIntermediateData lightingData2ndLayer
+    #if CC_SURFACES_LIGHTING_USE_MULTIPLE_LAYER_BLEND > 1
+      // add more layers...
+    #endif
+    )
+  {
+    vec3 lastLayerF, zeroVector = vec3(0.0);
+    vec3 blendedBaseD = lightingResult.environmentDiffuse, blendedBaseS = lightingResult.environmentSpecular;
+    InitializeLayerBlending(blendedBaseD, blendedBaseS,
+                            lightingResult.environmentDiffuseSubLayers, lightingResult.environmentSpecularSubLayers,
+                            lastLayerF,
+                            lightingResult.environmentDiffuse, lightingResult.environmentSpecular
+                            );
+
+      CCSurfaceLightingCalculateEnvironmentSubLayerFresnel(lightingResult.environmentSubLayerF, lightingData2ndLayer, lightingResult.specularColorWithLighting2ndSpecular);
+      CalculateLayerBlending (blendedBaseD, blendedBaseS,
+                              lightingResult.environmentDiffuseSubLayers, lightingResult.environmentSpecularSubLayers,
+                              lastLayerF,
+                              zeroVector, zeroVector,
+                              lightingResult.environment2ndSpecular, lightingResult.specularColorWithLighting2ndSpecular,
+                              lightingData2ndLayer.layerOpacity, lightingResult.environmentSubLayerF
+                              );
+    #if CC_SURFACES_LIGHTING_USE_MULTIPLE_LAYER_BLEND > 1
+      // add more layers...
+    #endif
+
+    // output
+    lightingResult.environmentDiffuse = blendedBaseD;
+    lightingResult.environmentSpecular = blendedBaseS;
+  }
+#endif
diff --git a/editor/assets/chunks/surfaces/module-functions/standard-fs.chunk b/editor/assets/chunks/surfaces/module-functions/standard-fs.chunk
@@ -390,87 +390,8 @@ vec4 CCSurfacesShading(in SurfacesMaterialData surfaceData, in LightingResult li
   ;
 
   color.xyz += lightingResult.emissive;
-  return color;
-
-  //todo:
-  //ior and fresnel range?
-  //整理代码blend layers
-
-  //test
-  LightingIntermediateData lightingData;
-  CCSurfacesInitializeLightingIntermediateData(lightingData, surfaceData);
-  CCSurfacesLightingCalculateIntermediateData_PerLight(lightingData, surfaceData, -cc_mainLitDir.xyz);
-
-  #if CC_SURFACES_LIGHTING_USE_MULTIPLE_LAYER_BLEND
-    #if CC_SURFACES_LIGHTING_2ND_LAYER_SPECULAR
-      color.xyz = lightingResult.environmentSpecularSubLayers;
-      // color.xyz = lightingResult.environment2ndSpecular * lightingResult.specularColorWithLighting2ndSpecular * surfaceData.color2ndSpecular * lightingResult.environmentGF2ndSpecular;
-      color.xyz = lightingResult.environmentSpecular * lightingResult.specularColorWithLighting * lightingResult.environmentGF;
-      // color.xyz = vec3(lightingResult.environmentSubLayerF);
-      return color;
-    #endif
-
-    float VoH = lightingData.VoH;
-  	float Fc = exp2( (-5.55473 * VoH - 6.98316) * VoH );
-
-    float LoH = dot(lightingData.L, lightingData.H);
-    color.xyz = F_Schlick(lightingResult.specularColorWithLighting, lightingData.VoH);
-    color.xyz = F_Schlick(lightingResult.specularColorWithLighting, LoH);
-    color.xyz = lightingResult.environmentSpecularSubLayers;
-    color.xyz = vec3(1.0 - Fc);
-    return color;
-    color.xyz = vec3(lightingResult.environmentGF2ndSpecular * lightingResult.environment2ndSpecular * lightingResult.specularColorWithLighting2ndSpecular);
-    color.xyz = vec3(lightingResult.directSpecular * lightingResult.specularColorWithLighting * lightingResult.directGF * fresnel);
-    color.xyz = vec3(lightingResult.environmentSpecular * lightingResult.specularColorWithLighting * lightingResult.environmentGF);
-    color.xyz = vec3(0.0);
-      color.xyz +=
-    ( lightingResult.directDiffuse * lightingResult.diffuseColorWithLighting
-    + lightingResult.directSpecular * lightingResult.specularColorWithLighting * lightingResult.directGF * fresnel
-  #if CC_SURFACES_LIGHTING_TRANSMIT_SPECULAR
-    + lightingResult.directTransmitSpecular * lightingResult.specularColorWithLighting * lightingResult.directGF * invFresnel
-  #endif
-  #if CC_SURFACES_LIGHTING_2ND_LAYER_SPECULAR
-    + lightingResult.direct2ndSpecular * lightingResult.specularColorWithLighting2ndSpecular * surfaceData.color2ndSpecular * lightingResult.directGF2ndSpecular
-  #endif
-  #if CC_SURFACES_LIGHTING_USE_MULTIPLE_LAYER_BLEND
-    + lightingResult.directDiffuseSubLayers
-    + lightingResult.directSpecularSubLayers
-  #endif
-  #if CC_SURFACES_LIGHTING_TT
-    + lightingResult.directTT * lightingResult.diffuseColorWithLightingTT
-  #endif
-    )
-    * lightingResult.shadow
-  #if CC_SURFACES_LIGHTING_TRANSMIT_DIFFUSE
-    + lightingResult.directTransmitDiffuse
-  #endif
-  ;
-
-    #if CC_SURFACES_USE_LIGHT_MAP == LIGHT_MAP_TYPE_ALL_IN_ONE
-    color.xyz += lightingResult.lightmapColor * lightingResult.diffuseColorWithLighting * lightingResult.shadow; //apply real-time shadows
-  #elif CC_SURFACES_USE_LIGHT_MAP == LIGHT_MAP_TYPE_INDIRECT_OCCLUSION
-    color.xyz += lightingResult.lightmapColor * lightingResult.diffuseColorWithLighting;
-  #endif
-
-  color.xyz +=
-    ( lightingResult.environmentDiffuse * lightingResult.diffuseColorWithLighting
-    + lightingResult.environmentSpecular * lightingResult.specularColorWithLighting * lightingResult.environmentGF * fresnel
-  #if CC_SURFACES_LIGHTING_2ND_LAYER_SPECULAR
-    + lightingResult.environment2ndSpecular * lightingResult.specularColorWithLighting2ndSpecular * surfaceData.color2ndSpecular * lightingResult.environmentGF2ndSpecular
-  #endif
-  #if CC_SURFACES_LIGHTING_USE_MULTIPLE_LAYER_BLEND
-    + lightingResult.environmentDiffuseSubLayers
-    + lightingResult.environmentSpecularSubLayers
-  #endif
-    )
-    * lightingResult.ao
-  #if CC_SURFACES_LIGHTING_TRANSMIT_DIFFUSE
-    + lightingResult.environmentTransmitDiffuse
-  #endif
-  ;
-  #endif
-  return color;
 #endif
+
   return color;
 }