Initial commit

2026-06-02 20:24:26 -07:00 · 2022-01-22 20:13:49 -08:00
parent f9d23e5bcf
commit 687473573d
878 changed files with 70957 additions and 0 deletions
@@ -0,0 +1,207 @@
+// Alloy Physical Shader Framework
+// Copyright 2013-2017 RUST LLC.
+// http://www.alloy.rustltd.com/
+
+/////////////////////////////////////////////////////////////////////////////////
+/// @file EyeParallax.cginc
+/// @brief Surface heightmap-based texcoord modification.
+/////////////////////////////////////////////////////////////////////////////////
+
+#ifndef ALLOY_LEGACY_SHADERS_FEATURE_EYE_PARALLAX_CGINC
+#define ALLOY_LEGACY_SHADERS_FEATURE_EYE_PARALLAX_CGINC
+
+#ifdef A_EYE_PARALLAX_REFRACTION
+    #if defined(UNITY_PASS_SHADOWCASTER) || defined(UNITY_PASS_META)
+        #undef A_EYE_PARALLAX_REFRACTION
+    #elif !defined(A_VIEW_DIR_TANGENT_ON)
+        #define A_VIEW_DIR_TANGENT_ON
+    #endif
+#endif
+
+#include "Assets/Alloy/Shaders/Framework/Feature.cginc"
+    
+#ifdef A_EYE_PARALLAX_REFRACTION
+    /// Number of samples used for direct view of POM effect.
+    /// Expects values in the range [1,n].
+    float _MinSamples;
+    
+    /// Number of samples used for grazing view of POM effect.
+    /// Expects values in the range [1,n].
+    float _MaxSamples;
+
+    #ifdef A_EYE_PARALLAX_REFRACTION
+        /// Iris parallax depth scale.
+        /// Expects values in the range [0,1].
+        half _EyeParallax;
+
+        /// Iris pupil dilation.
+        /// Expects values in the range [0,1].
+        half _EyePupilSize;
+    #endif
+#endif
+
+/// Applies texture coordinate offsets to surface data.
+/// @param[in,out]  s       Material surface data.
+/// @param[in]      offset  Texture coordinate offset.
+void aEyeApplyParallaxOffset(
+    inout ASurface s,
+    float2 offset)
+{
+    offset *= s.mask;
+    
+    // To apply the parallax offset to secondary textures without causing swimming,
+    // we must normalize it by removing the implicitly multiplied base map tiling. 
+    s.uv01 += (offset / s.baseTiling).xyxy;
+    s.baseUv += A_BV(s, offset);
+}
+
+/// Calculates Offset Bump Mapping texture offsets.
+/// @param[in,out]  s           Material surface data.
+/// @param[in]      parallaxMap Height map.
+/// @param[in]      parallax    Height scale of the heightmap [0,0.08].
+void aEyeOffsetBumpMapping(
+    inout ASurface s,
+    sampler2D parallaxMap, 
+    half parallax)
+{
+    // NOTE: Prevents NaN compiler errors in DX9 mode for shadow pass.
+#if !defined(UNITY_PASS_SHADOWCASTER) && !defined(UNITY_PASS_META)
+    #ifdef _VIRTUALTEXTURING_ON
+        half h = VTSampleBase(s.baseVirtualCoord).a;
+    #else
+        half h = tex2D(parallaxMap, s.baseUv).w;
+    #endif
+
+    h = h * parallax - parallax / 2.0h;
+    
+    half3 v = s.viewDirTangent;
+    v.z += 0.42h;
+        
+    aEyeApplyParallaxOffset(s, h * (v.xy / v.z));
+#endif
+}
+
+/// Calculates Parallax Occlusion Mapping texture offsets.
+/// @param[in,out]  s           Material surface data.
+/// @param[in]      parallaxMap Height map.
+/// @param[in]      parallax    Height scale of the heightmap [0,0.08].
+/// @param[in]      minSamples  Minimum number of samples for POM effect [1,n].
+/// @param[in]      maxSamples  Maximum number of samples for POM effect [1,n].
+void aEyeParallaxOcclusionMapping(
+    inout ASurface s,
+    sampler2D parallaxMap,
+    float parallax,
+    float minSamples,
+    float maxSamples)
+{
+    // NOTE: Prevents NaN compiler errors in DX9 mode for shadow pass.
+#if !defined(UNITY_PASS_SHADOWCASTER) && !defined(UNITY_PASS_META)
+    // Parallax Occlusion Mapping
+    // cf http://www.gamedev.net/page/resources/_/technical/graphics-programming-and-theory/a-closer-look-at-parallax-occlusion-mapping-r3262
+    float2 offset = float2(0.0f, 0.0f);
+
+    // Calculate the parallax offset vector max length.
+    // This is equivalent to the tangent of the angle between the
+    // viewer position and the fragment location.
+    float parallaxLimit = -length(s.viewDirTangent.xy) / s.viewDirTangent.z;
+
+    // Scale the parallax limit according to heightmap scale.
+    parallaxLimit *= parallax;						
+
+    // Calculate the parallax offset vector direction and maximum offset.
+    float2 offsetDirTangent = normalize(s.viewDirTangent.xy);
+    float2 maxOffset = offsetDirTangent * parallaxLimit;
+    
+    // Calculate how many samples should be taken along the view ray
+    // to find the surface intersection.  This is based on the angle
+    // between the surface normal and the view vector.
+    int numSamples = (int)lerp(maxSamples, minSamples, s.NdotV);
+    int currentSample = 0;
+    
+    // Specify the view ray step size.  Each sample will shift the current
+    // view ray by this amount.
+    float stepSize = 1.0f / (float)numSamples;
+
+    // Initialize the starting view ray height and the texture offsets.
+    float currentRayHeight = 1.0f;	
+    float2 lastOffset = float2(0.0f, 0.0f);
+    
+    float lastSampledHeight = 1.0f;
+    float currentSampledHeight = 1.0f;
+
+    #ifdef _VIRTUALTEXTURING_ON
+        VirtualCoord vcoord = s.baseVirtualCoord;
+    #else
+        // Calculate the texture coordinate partial derivatives in screen
+        // space for the tex2Dgrad texture sampling instruction.
+        float2 dx = ddx(s.baseUv);
+        float2 dy = ddy(s.baseUv);
+    #endif
+
+    while (currentSample < numSamples) {
+        #ifdef _VIRTUALTEXTURING_ON
+            vcoord = VTUpdateVirtualCoord(vcoord, s.baseUv + offset);
+            currentSampledHeight = VTSampleBase(vcoord).a;
+        #else
+            // Sample the heightmap at the current texcoord offset.
+            currentSampledHeight = tex2Dgrad(parallaxMap, s.baseUv + offset, dx, dy).w;
+        #endif
+
+        // Test if the view ray has intersected the surface.
+        UNITY_BRANCH
+        if (currentSampledHeight > currentRayHeight) {
+            // Find the relative height delta before and after the intersection.
+            // This provides a measure of how close the intersection is to 
+            // the final sample location.
+            float delta1 = currentSampledHeight - currentRayHeight;
+            float delta2 = (currentRayHeight + stepSize) - lastSampledHeight;
+            float ratio = delta1 / (delta1 + delta2);
+
+            // Interpolate between the final two segments to 
+            // find the true intersection point offset.
+            offset = lerp(offset, lastOffset, ratio);
+            
+            // Force the exit of the while loop
+            currentSample = numSamples + 1;	
+        }
+        else {
+            // The intersection was not found.  Now set up the loop for the next
+            // iteration by incrementing the sample count,
+            currentSample++;
+
+            // take the next view ray height step,
+            currentRayHeight -= stepSize;
+            
+            // save the current texture coordinate offset and increment
+            // to the next sample location, 
+            lastOffset = offset;
+            offset += stepSize * maxOffset;
+
+            // and finally save the current heightmap height.
+            lastSampledHeight = currentSampledHeight;
+        }
+    }
+
+    aEyeApplyParallaxOffset(s, offset);
+#endif
+}
+
+void aEyeParallax(
+    inout ASurface s) 
+{
+#ifdef A_EYE_PARALLAX_REFRACTION
+    // Cornea "Refraction".
+    aEyeParallaxOcclusionMapping(s, _MainTex, _EyeParallax * _Color.a, 10.0f, 25.0f);
+    //aEyeOffsetBumpMapping(s, _MainTex, _EyeParallax * _Color.a);
+
+    // Pupil Dilation
+    // HACK: Use the heightmap as the gradient, since it matches the other maps.
+    // http://www.polycount.com/forum/showpost.php?p=1511423&postcount=13
+    half mask = 1.0h - aSampleBase(s).a;
+    float2 centeredUv = frac(s.baseUv) + float2(-0.5f, -0.5f);
+
+    s.baseUv -= A_BV(s, centeredUv * mask * _EyePupilSize);
+#endif 
+}
+
+#endif // ALLOY_LEGACY_SHADERS_FEATURE_EYE_PARALLAX_CGINC