Merge pull request #93 from Unity-Technologies/Improve-tessellation

HDRenderPipeline: Add Phong tesselation

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/LayeredLit/Editor/LayeredLitUI.cs

         MaterialProperty layerEmissiveColor = null;
         MaterialProperty layerEmissiveColorMap = null;
         MaterialProperty layerEmissiveIntensity = null;
-        MaterialProperty layerTesselationFactor = null;
-        
 
         override protected void FindMaterialProperties(MaterialProperty[] props)
         {
             layerEmissiveColor = FindProperty(kEmissiveColor, props);
             layerEmissiveColorMap = FindProperty(kEmissiveColorMap, props);
             layerEmissiveIntensity = FindProperty(kEmissiveIntensity, props);
-            layerTesselationFactor = FindProperty(kTesselationFactor, props, false);
         }
 
         int numLayer
             m_MaterialEditor.ShaderProperty(layerEmissiveIntensity, Styles.emissiveIntensityText);
             m_MaterialEditor.LightmapEmissionProperty(1);
             EditorGUI.indentLevel--;
-
-            if (layerTesselationFactor != null)
-            {
-                GUILayout.Label(Styles.tesselationText, EditorStyles.boldLabel);
-                EditorGUI.indentLevel++;
-                m_MaterialEditor.ShaderProperty(layerTesselationFactor, Styles.tesselationFactorText);
-                EditorGUI.indentLevel--;
-            }
 
             CheckLayerConsistency();
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

         [HideInInspector] _UVDetailsMappingMask1("_UVDetailsMappingMask1", Color) = (1, 0, 0, 0)
         [HideInInspector] _UVDetailsMappingMask2("_UVDetailsMappingMask2", Color) = (1, 0, 0, 0)
         [HideInInspector] _UVDetailsMappingMask3("_UVDetailsMappingMask3", Color) = (1, 0, 0, 0)
-
+  
-        _TesselationFactor("Tesselation Factor", Float) = 3.0
+        [Enum(Phong, 0, Displacement, 1, DisplacementPhong, 2)] _TessellationMode("Tessellation mode", Float) = 1
+        _TessellationFactorFixed("Tessellation Factor", Float) = 4.0 // if != -1.0 force fixed factor
+        _TessellationFactorMaxDistance("Tessellation max distance factor", Float) = 12.0
+        _TessellationFactorTriangleSize("Tessellation triangle size", Float) = 20.0
+        _TessellationShapeFactor("Tessellation shape factor", Range(0.0, 1.0)) = 0.75 // Only use with Phong
+        _TessellationBackFaceCullEpsilon("Tessellation back face epsilon", Range(-1.0, 1.0)) = 0.25
+        [ToggleOff] _TessellationObjectScale("Tessellation object scale", Float) = 0.0
+        // TODO: Handle culling mode for backface culling
     }
 
     HLSLINCLUDE
     #pragma shader_feature _DISTORTION_ON
     #pragma shader_feature _DEPTHOFFSET_ON
     #pragma shader_feature _ _DOUBLESIDED_LIGHTING_FLIP _DOUBLESIDED_LIGHTING_MIRROR
+    // Default is _TESSELATION_PHONG
+    #pragma shader_feature _ _TESSELATION_DISPLACEMENT _TESSELATION_DISPLACEMENT_PHONG
 
     #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
     #pragma shader_feature _LAYER_MAPPING_TRIPLANAR_0
     #pragma shader_feature _DETAIL_MAP
     #pragma shader_feature _ _LAYER_MASK_VERTEX_COLOR_MUL _LAYER_MASK_VERTEX_COLOR_ADD
     #pragma shader_feature _HEIGHT_BASED_BLEND
-    #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS
+    #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS    
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
     #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Editor/BaseLitUI.cs

     {
         protected static class Styles
         {
-            public static string OptionText = "Options";
-            public static string SurfaceTypeText = "Surface Type";
-            public static string BlendModeText = "Blend Mode";
+            public static string optionText = "Options";
+            public static string surfaceTypeText = "Surface Type";
+            public static string blendModeText = "Blend Mode";
             public static string detailText = "Inputs Detail";
             public static string lightingText = "Inputs Lighting";
 
             public static GUIContent emissiveWarning = new GUIContent("Emissive value is animated but the material has not been configured to support emissive. Please make sure the material itself has some amount of emissive.");
             public static GUIContent emissiveColorWarning = new GUIContent("Ensure emissive color is non-black for emission to have effect.");
 
-            public static GUIContent tesselationText = new GUIContent("Tesselation options", "Tesselation options");
-            public static GUIContent tesselationFactorText = new GUIContent("Tesselation factor", "Tesselation factor");
+            public static string tessellationModeText = "Tessellation Mode";
+            public static readonly string[] tessellationModeNames = Enum.GetNames(typeof(TessellationMode));
+
+            public static GUIContent tessellationText = new GUIContent("Tessellation options", "Tessellation options");
+            public static GUIContent tessellationFactorFixedText = new GUIContent("Fixed tessellation factor", "If non negative, this value is a fixed tessellation factor use for tessellation");
+            public static GUIContent tessellationFactorMaxDistanceText = new GUIContent("Max Distance", "Maximun distance to the camera where triangle are tesselated");
+            public static GUIContent tessellationFactorTriangleSizeText = new GUIContent("Triangle size", "Desired screen space sized of triangle. Smaller value mean smaller triangle.");
+            public static GUIContent tessellationShapeFactorText = new GUIContent("Shape factor", "Strength of Phong tessellation shape (lerp factor)");
+            public static GUIContent tessellationBackFaceCullEpsilonText = new GUIContent("Triangle culling Epsilon", "If non zero, backface culling is enabled for tessellation, smaller number mean more aggressive culling and better performance");
+            public static GUIContent tessellationObjectScaleText = new GUIContent("Enable object scale", "Scale displacement taking into account the object scale");
         }
 
         public enum SurfaceType
         }
+
         public enum BlendMode
         {
             Lerp,
             Premultiply
         }
+
         public enum DoubleSidedMode
         {
             None,
         }
 
+        public enum TessellationMode
+        {
+            Phong,
+            Displacement,
+            DisplacementPhong,
+        }
+
         void SurfaceTypePopup()
         {
             EditorGUI.showMixedValue = surfaceType.hasMixedValue;
-            mode = (SurfaceType)EditorGUILayout.Popup(Styles.SurfaceTypeText, (int)mode, Styles.surfaceTypeNames);
+            mode = (SurfaceType)EditorGUILayout.Popup(Styles.surfaceTypeText, (int)mode, Styles.surfaceTypeNames);
             if (EditorGUI.EndChangeCheck())
             {
                 m_MaterialEditor.RegisterPropertyChangeUndo("Surface Type");
             EditorGUI.showMixedValue = false;
         }
 
+        void TessellationModePopup()
+        {
+            EditorGUI.showMixedValue = tessellationMode.hasMixedValue;
+            var mode = (TessellationMode)tessellationMode.floatValue;
+
+            EditorGUI.BeginChangeCheck();
+            mode = (TessellationMode)EditorGUILayout.Popup(Styles.tessellationModeText, (int)mode, Styles.tessellationModeNames);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_MaterialEditor.RegisterPropertyChangeUndo("Tessellation Mode");
+                tessellationMode.floatValue = (float)mode;
+            }
+
+            EditorGUI.showMixedValue = false;
+        }
+
-            GUILayout.Label(Styles.OptionText, EditorStyles.boldLabel);
+            GUILayout.Label(Styles.optionText, EditorStyles.boldLabel);
             SurfaceTypePopup();
             if ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent)
             {
             m_MaterialEditor.ShaderProperty(depthOffsetEnable, Styles.depthOffsetEnableText.text);
 
             EditorGUI.indentLevel--;
+
+            if (tessellationMode != null)
+            {
+                GUILayout.Label(Styles.tessellationText, EditorStyles.boldLabel);
+                EditorGUI.indentLevel++;
+                TessellationModePopup();
+                m_MaterialEditor.ShaderProperty(tessellationFactorFixed, Styles.tessellationFactorFixedText);
+                m_MaterialEditor.ShaderProperty(tessellationFactorMaxDistance, Styles.tessellationFactorMaxDistanceText);
+                m_MaterialEditor.ShaderProperty(tessellationFactorTriangleSize, Styles.tessellationFactorTriangleSizeText);
+                if ((TessellationMode)tessellationMode.floatValue == TessellationMode.Phong ||
+                    (TessellationMode)tessellationMode.floatValue == TessellationMode.DisplacementPhong)
+                {
+                    m_MaterialEditor.ShaderProperty(tessellationShapeFactor, Styles.tessellationShapeFactorText);
+                }
+                m_MaterialEditor.ShaderProperty(tessellationBackFaceCullEpsilon, Styles.tessellationBackFaceCullEpsilonText);
+                m_MaterialEditor.ShaderProperty(tessellationObjectScale, Styles.tessellationObjectScaleText);
+                EditorGUI.indentLevel--;
+            }
         }
 
         private void BlendModePopup()
 
             EditorGUI.BeginChangeCheck();
-            mode = (BlendMode)EditorGUILayout.Popup(Styles.BlendModeText, (int)mode, Styles.blendModeNames);
+            mode = (BlendMode)EditorGUILayout.Popup(Styles.blendModeText, (int)mode, Styles.blendModeNames);
             if (EditorGUI.EndChangeCheck())
             {
                 m_MaterialEditor.RegisterPropertyChangeUndo("Blend Mode");
             distortionOnly = FindProperty(kDistortionOnly, props);
             distortionDepthTest = FindProperty(kDistortionDepthTest, props);
             depthOffsetEnable = FindProperty(kDepthOffsetEnable, props);
+
+            // tessellation specific, silent if not found
+            tessellationMode = FindProperty(kTessellationMode, props, false);
+            tessellationFactorFixed = FindProperty(kTessellationFactorFixed, props, false);
+            tessellationFactorMaxDistance = FindProperty(kTessellationFactorMaxDistance, props, false);
+            tessellationFactorTriangleSize = FindProperty(kTessellationFactorTriangleSize, props, false);
+            tessellationShapeFactor = FindProperty(kTessellationShapeFactor, props, false);
+            tessellationBackFaceCullEpsilon = FindProperty(kTessellationBackFaceCullEpsilon, props, false);
+            tessellationObjectScale = FindProperty(kTessellationObjectScale, props, false);
         }
 
         protected void SetupCommonOptionsKeywords(Material material)
             BlendMode blendMode = (BlendMode)material.GetFloat(kBlendMode);
             DoubleSidedMode doubleSidedMode = (DoubleSidedMode)material.GetFloat(kDoubleSidedMode);
- 
+
             if (surfaceType == SurfaceType.Opaque)
             {
                 material.SetOverrideTag("RenderType", alphaTestEnable ? "TransparentCutout" : "");
             SetKeyword(material, "_DEPTHOFFSET_ON", depthOffsetEnable);
 
             SetupEmissionGIFlags(material);
+
+            if (tessellationMode != null)
+            {
+                TessellationMode tessMode = (TessellationMode)material.GetFloat(kTessellationMode);
+
+                if (tessMode == TessellationMode.Phong)
+                {
+                    material.DisableKeyword("_TESSELLATION_DISPLACEMENT");
+                    material.DisableKeyword("_TESSELLATION_DISPLACEMENT_PHONG");
+                }
+                else if (tessMode == TessellationMode.Displacement)
+                {
+                    material.EnableKeyword("_TESSELLATION_DISPLACEMENT");
+                    material.DisableKeyword("_TESSELLATION_DISPLACEMENT_PHONG");
+                }
+                else
+                {
+                    material.DisableKeyword("_TESSELLATION_DISPLACEMENT");
+                    material.EnableKeyword("_TESSELLATION_DISPLACEMENT_PHONG");
+                }
+            }
         }
 
         protected void SetKeyword(Material m, string keyword, bool state)
         protected MaterialEditor m_MaterialEditor;
 
         MaterialProperty surfaceType = null;
+        const string kSurfaceType = "_SurfaceType";
+        const string kAlphaCutoffEnabled = "_AlphaCutoffEnable";
+        const string kBlendMode = "_BlendMode";
+        const string kAlphaCutoff = "_AlphaCutoff";
+        const string kDoubleSidedMode = "_DoubleSidedMode";
+        const string kDistortionEnable = "_DistortionEnable";
+        const string kDistortionOnly = "_DistortionOnly";
-        MaterialProperty depthOffsetEnable = null;
-
-        const string kSurfaceType = "_SurfaceType";
-        const string kBlendMode = "_BlendMode";
-        const string kAlphaCutoff = "_AlphaCutoff";
-        const string kAlphaCutoffEnabled = "_AlphaCutoffEnable";
-        const string kDoubleSidedMode = "_DoubleSidedMode";
-        const string kDistortionEnable = "_DistortionEnable";
-        const string kDistortionOnly = "_DistortionOnly";
+        MaterialProperty depthOffsetEnable = null;       
+
+        // tessellation params
+        MaterialProperty tessellationMode = null;
+        const string kTessellationMode = "_TessellationMode";
+        MaterialProperty tessellationFactorFixed = null;
+        const string kTessellationFactorFixed = "_TessellationFactorFixed";
+        MaterialProperty tessellationFactorMaxDistance = null;
+        const string kTessellationFactorMaxDistance = "_TessellationFactorMaxDistance";
+        MaterialProperty tessellationFactorTriangleSize = null;
+        const string kTessellationFactorTriangleSize = "_TessellationFactorTriangleSize";
+        MaterialProperty tessellationShapeFactor = null;
+        const string kTessellationShapeFactor = "_TessellationShapeFactor";
+        MaterialProperty tessellationBackFaceCullEpsilon = null;
+        const string kTessellationBackFaceCullEpsilon = "_TessellationBackFaceCullEpsilon";
+        MaterialProperty tessellationObjectScale = null;
+        const string kTessellationObjectScale = "_TessellationObjectScale";
+
         protected static string[] reservedProperties = new string[] { kSurfaceType, kBlendMode, kAlphaCutoff, kAlphaCutoffEnabled, kDoubleSidedMode };
 
         protected abstract void FindMaterialProperties(MaterialProperty[] props);

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Editor/LitUI.cs

         protected MaterialProperty emissiveIntensity = null;
         protected const string kEmissiveIntensity = "_EmissiveIntensity";
 
-        // tesselation params
-        protected MaterialProperty tesselationFactor = null;
-        protected const string kTesselationFactor = "_TesselationFactor";
 
         // These are options that are shared with the LayeredLit shader. Don't put anything that can't be shared here:
         // For instance, properties like BaseColor and such don't exist in the LayeredLit so don't put them here.
             emissiveColor = FindProperty(kEmissiveColor, props);
             emissiveColorMap = FindProperty(kEmissiveColorMap, props);
             emissiveIntensity = FindProperty(kEmissiveIntensity, props);
-
-            // tesselation specific, don't care if not found
-            tesselationFactor = FindProperty(kTesselationFactor, props, false);
         }
 
         override protected void ShaderInputOptionsGUI()
             EditorGUI.indentLevel--;
 
             EditorGUILayout.Space();
-            
-            if (tesselationFactor != null)
-            {
-                GUILayout.Label(Styles.tesselationText, EditorStyles.boldLabel);
-                EditorGUI.indentLevel++;
-                m_MaterialEditor.ShaderProperty(tesselationFactor, Styles.tesselationFactorText);
-                EditorGUI.indentLevel--;
-            }
         }
 
         public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LitData.hlsl

 #define ADD_IDX(Name) Name
 #define ADD_ZERO_IDX(Name) Name
 #include "LitDataInternal.hlsl"
-#ifdef TESSELATION_ON
-#include "LitTesselation.hlsl"
+#ifdef TESSELLATION_ON
+#include "LitTessellation.hlsl"
 #endif
 
 void GetSurfaceAndBuiltinData(FragInputs input, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData)
 #define LAYER_INDEX 0
 #define ADD_IDX(Name) Name##0
 #include "LitDataInternal.hlsl"
-#ifdef TESSELATION_ON
-#include "LitTesselation.hlsl" // Include only one time for layer 0
+#ifdef TESSELLATION_ON
+#include "LitTessellation.hlsl" // Include only one time for layer 0
 #endif
 #undef LAYER_INDEX
 #undef ADD_IDX

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LitProperties.hlsl

 
 #endif // LAYERED_LIT_SHADER
 
-// Tesselation specific
+// Tessellation specific
-#ifdef TESSELATION_ON
-float _TesselationFactor;
+#ifdef TESSELLATION_ON
+float _TessellationFactorFixed;
+float _TessellationFactorMaxDistance;
+float _TessellationFactorTriangleSize;
+float _TessellationShapeFactor;
+float _TessellationBackFaceCullEpsilon;
+float _TessellationObjectScale;
 #endif

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LitTessellation.shader

-Shader "HDRenderPipeline/LitTesselation"
+Shader "HDRenderPipeline/LitTessellation"
 {
     Properties
     {
         [HideInInspector] _UVDetailsMappingMask("_UVDetailsMappingMask", Color) = (1, 0, 0, 0)
         [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
 
-        // Tesselation specific
-        _TesselationFactor("Tesselation Factor", Float) = 3.0
+        // Tessellation specific
+        [Enum(Phong, 0, Displacement, 1, DisplacementPhong, 2)] _TessellationMode("Tessellation mode", Float) = 0
+        _TessellationFactorFixed("Tessellation Factor", Float) = 4.0 // if != -1.0 force fixed factor
+        _TessellationFactorMaxDistance("Tessellation max distance factor", Float) = 12.0
+        _TessellationFactorTriangleSize("Tessellation triangle size", Float) = 20.0        
+        _TessellationShapeFactor("Tessellation shape factor", Range(0.0, 1.0)) = 0.75 // Only use with Phong
+        _TessellationBackFaceCullEpsilon("Tessellation back face epsilon", Range(-1.0, 1.0)) = 0.25
+        [ToggleOff] _TessellationObjectScale("Tessellation object scale", Float) = 0.0
+         // TODO: Handle culling mode for backface culling
     }
 
     HLSLINCLUDE
     #pragma shader_feature _DISTORTION_ON
     #pragma shader_feature _DEPTHOFFSET_ON
     #pragma shader_feature _ _DOUBLESIDED_LIGHTING_FLIP _DOUBLESIDED_LIGHTING_MIRROR
+    // Default is _TESSELLATION_PHONG
+    #pragma shader_feature _ _TESSELLATION_DISPLACEMENT _TESSELLATION_DISPLACEMENT_PHONG
 
     #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
     #pragma shader_feature _MAPPING_TRIPLANAR
     #pragma shader_feature _HEIGHTMAP
     #pragma shader_feature _TANGENTMAP
     #pragma shader_feature _ANISOTROPYMAP
-    #pragma shader_feature _DETAIL_MAP  
+    #pragma shader_feature _DETAIL_MAP      
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
     #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
     //-------------------------------------------------------------------------------------
 
     #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
-    #define TESSELATION_ON
+    #define TESSELLATION_ON
 
     //-------------------------------------------------------------------------------------
     // Include
-    #include "tesselation.hlsl"
+    #include "tessellation.hlsl"
     #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderConfig.cs.hlsl"
     #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl"
     #include "Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Attributes.hlsl"
 
             HLSLPROGRAM
 
-            #pragma vertex VertTesselation
+            #pragma vertex VertTessellation
 			#pragma hull Hull
 			#pragma domain Domain
 
             #include "LitData.hlsl"            
-            #include "../Tesselation/TesselationShare.hlsl"
+            #include "../Tessellation/TessellationShare.hlsl"
 
             #include "../../ShaderPass/ShaderPassGBuffer.hlsl"
 
 
             HLSLPROGRAM
 
-            #pragma vertex VertTesselation
+            #pragma vertex VertTessellation
 			#pragma hull Hull
 			#pragma domain Domain
 
             #include "LitData.hlsl"            
-            #include "../Tesselation/TesselationShare.hlsl"
+            #include "../Tessellation/TessellationShare.hlsl"
             
             #include "../../ShaderPass/ShaderPassDebugViewMaterial.hlsl"
 
             // DYNAMICLIGHTMAP_ON is used when we have an "enlighten lightmap" ie a lightmap updated at runtime by enlighten.This lightmap contain indirect lighting from realtime lights and realtime emissive material.Offline baked lighting(from baked material / light, 
             // both direct and indirect lighting) will hand up in the "regular" lightmap->LIGHTMAP_ON.
 
-			// No tesselation for Meta pass
+			// No tessellation for Meta pass
             #pragma vertex Vert
 
             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
 
             HLSLPROGRAM
 
-            #pragma vertex VertTesselation
+            #pragma vertex VertTessellation
 			#pragma hull Hull
 			#pragma domain Domain
 
             #include "LitData.hlsl"            
-            #include "../Tesselation/TesselationShare.hlsl"
+            #include "../Tessellation/TessellationShare.hlsl"
 
             #include "../../ShaderPass/ShaderPassDepthOnly.hlsl"
 
  
             HLSLPROGRAM
 
-            #pragma vertex VertTesselation
+            #pragma vertex VertTessellation
 			#pragma hull Hull
 			#pragma domain Domain
 
             #include "LitData.hlsl"            
-            #include "../Tesselation/TesselationShare.hlsl"
+            #include "../Tessellation/TessellationShare.hlsl"
 
             #include "../../ShaderPass/ShaderPassDepthOnly.hlsl"
 
 
             HLSLPROGRAM
 
-            #pragma vertex VertTesselation
+            #pragma vertex VertTessellation
 			#pragma hull Hull
 			#pragma domain Domain
 
             #include "LitData.hlsl"            
-            #include "../Tesselation/TesselationShare.hlsl"
+            #include "../Tessellation/TessellationShare.hlsl"
 
             #include "../../ShaderPass/ShaderPassVelocity.hlsl"
 
 
             HLSLPROGRAM
 
-            #pragma vertex VertTesselation
+            #pragma vertex VertTessellation
 			#pragma hull Hull
 			#pragma domain Domain
 
             #include "LitData.hlsl"
-            #include "../Tesselation/TesselationShare.hlsl"
+            #include "../Tessellation/TessellationShare.hlsl"
 
             #include "../../ShaderPass/ShaderPassDistortion.hlsl"
 
 
             HLSLPROGRAM
 
-            #pragma vertex VertTesselation
+            #pragma vertex VertTessellation
 			#pragma hull Hull
 			#pragma domain Domain
 
             #include "../../Lighting/Lighting.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"
-            #include "../Tesselation/TesselationShare.hlsl"
+            #include "../Tessellation/TessellationShare.hlsl"
 
             #include "../../ShaderPass/ShaderPassForward.hlsl"
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/ShaderPass/LitDepthPass.hlsl

 
 // Check if Alpha test is enabled. If it is, check if parallax is enabled on this material
 #define NEED_TEXCOORD0 1 // defined(_ALPHATEST_ON)
-#define NEED_TANGENT_TO_WORLD 1 // NEED_TEXCOORD0 && (defined(_HEIGHTMAP) && defined(_PER_PIXEL_DISPLACEMENT))  TEMP!!!: until we fix tesselation so it can access normalOS
+#define NEED_TANGENT_TO_WORLD 1 // NEED_TEXCOORD0 && (defined(_HEIGHTMAP) && defined(_PER_PIXEL_DISPLACEMENT))  TEMP!!!: until we fix tessellation so it can access normalOS
-// When modifying this structure, update the tesselation code below
+// When modifying this structure, update the tessellation code below
 struct Attributes
 {
     float3 positionOS : POSITION;
 #endif
 };
 
-#ifdef TESSELATION_ON
+#ifdef TESSELLATION_ON
-struct AttributesTesselation
+struct AttributesTessellation
 {
     float3 positionOS : INTERNALTESSPOS;
 #if NEED_TEXCOORD0
 #endif
 };
 
-AttributesTesselation AttributesToAttributesTesselation(Attributes input)
+AttributesTessellation AttributesToAttributesTessellation(Attributes input)
-    AttributesTesselation output;
+    AttributesTessellation output;
     output.positionOS = input.positionOS;
 #if NEED_TEXCOORD0
     output.uv0 = input.uv0;
     return output;
 }
 
-Attributes AttributesTesselationToAttributes(AttributesTesselation input)
+Attributes AttributesTessellationToAttributes(AttributesTessellation input)
 {
     Attributes output;
     output.positionOS = input.positionOS;
     return output;
 }
 
-AttributesTesselation InterpolateWithBary(AttributesTesselation input0, AttributesTesselation input1, AttributesTesselation input2, float3 baryWeight)
+AttributesTessellation InterpolateWithBaryCoords(AttributesTessellation input0, AttributesTessellation input1, AttributesTessellation input2, float3 baryCoords)
-    AttributesTesselation ouput;
+    AttributesTessellation ouput;
-    TESSELATION_INTERPOLATE_BARY(positionOS, baryWeight);
+    TESSELLATION_INTERPOLATE_BARY(positionOS, baryCoords);
-    TESSELATION_INTERPOLATE_BARY(uv0, baryWeight);
+    TESSELLATION_INTERPOLATE_BARY(uv0, baryCoords);
-    TESSELATION_INTERPOLATE_BARY(normalOS, baryWeight);
-    TESSELATION_INTERPOLATE_BARY(tangentOS, baryWeight);
+    TESSELLATION_INTERPOLATE_BARY(normalOS, baryCoords);
+    TESSELLATION_INTERPOLATE_BARY(tangentOS, baryCoords);
-#endif // TESSELATION_ON
+#endif // TESSELLATION_ON
 
 struct Varyings
 {

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/ShaderPass/LitDistortionPass.hlsl

 #endif
 };
 
-#ifdef TESSELATION_ON
+#ifdef TESSELLATION_ON
-struct AttributesTesselation
+struct AttributesTessellation
 {
     float3 positionOS : INTERNALTESSPOS;
     float2 uv0 : TEXCOORD0;
 #endif
 };
 
-AttributesTesselation AttributesToAttributesTesselation(Attributes input)
+AttributesTessellation AttributesToAttributesTessellation(Attributes input)
-    AttributesTesselation output;
+    AttributesTessellation output;
     output.positionOS = input.positionOS;
     output.uv0 = input.uv0;
 #if NEED_TANGENT_TO_WORLD
     return output;
 }
 
-Attributes AttributesTesselationToAttributes(AttributesTesselation input)
+Attributes AttributesTessellationToAttributes(AttributesTessellation input)
 {
     Attributes output;
     output.positionOS = input.positionOS;
     return output;
 }
 
-AttributesTesselation InterpolateWithBary(AttributesTesselation input0, AttributesTesselation input1, AttributesTesselation input2, float3 baryWeight)
+AttributesTessellation InterpolateWithBaryCoords(AttributesTessellation input0, AttributesTessellation input1, AttributesTessellation input2, float3 baryCoords)
-    AttributesTesselation ouput;
+    AttributesTessellation ouput;
-    TESSELATION_INTERPOLATE_BARY(positionOS, baryWeight);
-    TESSELATION_INTERPOLATE_BARY(uv0, baryWeight);
+    TESSELLATION_INTERPOLATE_BARY(positionOS, baryCoords);
+    TESSELLATION_INTERPOLATE_BARY(uv0, baryCoords);
-    TESSELATION_INTERPOLATE_BARY(normalOS, baryWeight);
-    TESSELATION_INTERPOLATE_BARY(tangentOS, baryWeight);
+    TESSELLATION_INTERPOLATE_BARY(normalOS, baryCoords);
+    TESSELLATION_INTERPOLATE_BARY(tangentOS, baryCoords);
-#endif // TESSELATION_ON
+#endif // TESSELLATION_ON
 
 struct Varyings
 {

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/ShaderPass/LitSharePass.hlsl

     // UNITY_INSTANCE_ID
 };
 
-#ifdef TESSELATION_ON
+#ifdef TESSELLATION_ON
-struct AttributesTesselation
+struct AttributesTessellation
 {
     float3 positionOS   : INTERNALTESSPOS;
     float3 normalOS     : NORMAL;
     float4 color        : COLOR;
 };
 
-AttributesTesselation AttributesToAttributesTesselation(Attributes input)
+AttributesTessellation AttributesToAttributesTessellation(Attributes input)
-    AttributesTesselation output;
+    AttributesTessellation output;
     output.positionOS = input.positionOS;
     output.normalOS = input.normalOS;
     output.uv0 = input.uv0;
     return output;
 }
 
-Attributes AttributesTesselationToAttributes(AttributesTesselation input)
+Attributes AttributesTessellationToAttributes(AttributesTessellation input)
 {
     Attributes output;
     output.positionOS = input.positionOS;
     return output;
 }
 
-AttributesTesselation InterpolateWithBary(AttributesTesselation input0, AttributesTesselation input1, AttributesTesselation input2, float3 baryWeight)
+AttributesTessellation InterpolateWithBaryCoords(AttributesTessellation input0, AttributesTessellation input1, AttributesTessellation input2, float3 baryCoords)
-    AttributesTesselation ouput;
+    AttributesTessellation ouput;
-    TESSELATION_INTERPOLATE_BARY(positionOS, baryWeight);
-    TESSELATION_INTERPOLATE_BARY(normalOS, baryWeight);
-    TESSELATION_INTERPOLATE_BARY(uv0, baryWeight);
-    TESSELATION_INTERPOLATE_BARY(uv1, baryWeight);
+    TESSELLATION_INTERPOLATE_BARY(positionOS, baryCoords);
+    TESSELLATION_INTERPOLATE_BARY(normalOS, baryCoords);
+    TESSELLATION_INTERPOLATE_BARY(uv0, baryCoords);
+    TESSELLATION_INTERPOLATE_BARY(uv1, baryCoords);
-    TESSELATION_INTERPOLATE_BARY(uv2, baryWeight);
+    TESSELLATION_INTERPOLATE_BARY(uv2, baryCoords);
-    TESSELATION_INTERPOLATE_BARY(uv3, baryWeight);
+    TESSELLATION_INTERPOLATE_BARY(uv3, baryCoords);
-    TESSELATION_INTERPOLATE_BARY(tangentOS, baryWeight);
-    TESSELATION_INTERPOLATE_BARY(color, baryWeight);
+    TESSELLATION_INTERPOLATE_BARY(tangentOS, baryCoords);
+    TESSELLATION_INTERPOLATE_BARY(color, baryCoords);
-#endif // TESSELATION_ON
+#endif // TESSELLATION_ON
 
 
 struct Varyings

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/ShaderPass/LitVelocityPass.hlsl

 #endif
 };
 
-#ifdef TESSELATION_ON
+#ifdef TESSELLATION_ON
-struct AttributesTesselation
+struct AttributesTessellation
 {
     float3 positionOS : INTERNALTESSPOS;
     float3 previousPositionOS : NORMAL;
 #endif
 };
 
-AttributesTesselation AttributesToAttributesTesselation(Attributes input)
+AttributesTessellation AttributesToAttributesTessellation(Attributes input)
-    AttributesTesselation output;
+    AttributesTessellation output;
     output.positionOS = input.positionOS;
     output.previousPositionOS = input.previousPositionOS;
 #if NEED_TEXCOORD0
     return output;
 }
 
-Attributes AttributesTesselationToAttributes(AttributesTesselation input)
+Attributes AttributesTessellationToAttributes(AttributesTessellation input)
 {
     Attributes output;
     output.positionOS = input.positionOS;
     return output;
 }
 
-AttributesTesselation InterpolateWithBary(AttributesTesselation input0, AttributesTesselation input1, AttributesTesselation input2, float3 baryWeight)
+AttributesTessellation InterpolateWithBaryCoords(AttributesTessellation input0, AttributesTessellation input1, AttributesTessellation input2, float3 baryCoords)
-    AttributesTesselation ouput;
+    AttributesTessellation ouput;
-    TESSELATION_INTERPOLATE_BARY(positionOS, baryWeight);
-    TESSELATION_INTERPOLATE_BARY(previousPositionOS, baryWeight);
+    TESSELLATION_INTERPOLATE_BARY(positionOS, baryCoords);
+    TESSELLATION_INTERPOLATE_BARY(previousPositionOS, baryCoords);
-    TESSELATION_INTERPOLATE_BARY(uv0, baryWeight);
+    TESSELLATION_INTERPOLATE_BARY(uv0, baryCoords);
-//    TESSELATION_INTERPOLATE_BARY(normalOS, baryWeight);
-    TESSELATION_INTERPOLATE_BARY(tangentOS, baryWeight);
+//    TESSELLATION_INTERPOLATE_BARY(normalOS, baryCoords);
+    TESSELLATION_INTERPOLATE_BARY(tangentOS, baryCoords);
-#endif // TESSELATION_ON
+#endif // TESSELLATION_ON
 
 struct Varyings
 {

Assets/ScriptableRenderLoop/ShaderLibrary/Tessellation.hlsl

-#define TESSELATION_INTERPOLATE_BARY(name, bary) ouput.name = input0.name * bary.x +  input1.name * bary.y +  input2.name * bary.z
+#define TESSELLATION_INTERPOLATE_BARY(name, bary) ouput.name = input0.name * bary.x +  input1.name * bary.y +  input2.name * bary.z
+
+float3 ProjectPointOnPlane(float3 position, float3 planePosition, float3 planeNormal)
+{
+    return position - (dot(position - planePosition, planeNormal) * planeNormal);
+}
+
+// p0, p1, p2 triangle world position
+// p0, p1, p2 triangle world vertex normal
+float3 PhongTessellation(float3 positionWS, float3 p0, float3 p1, float3 p2, float3 n0, float3 n1, float3 n2, float3 baryCoords, float shape)
+{
+    float3 c0 = ProjectPointOnPlane(positionWS, p0, n0);
+    float3 c1 = ProjectPointOnPlane(positionWS, p1, n1);
+    float3 c2 = ProjectPointOnPlane(positionWS, p2, n2);
+
+    float3 phongPositionWS = baryCoords.x * c0 + baryCoords.y * c1 + baryCoords.z * c2;
+
+    return lerp(positionWS, phongPositionWS, shape);
+}
-float UnityCalcDistanceTessFactor(float3 positionOS, float minDist, float maxDist, float tess, float4x4 objectToWorld, float3 cameraPosWS)
+float CalcDistanceTessFactor(float3 positionWS, float minDist, float maxDist, float4x4 objectToWorld, float3 cameraPosWS)
-    float3 positionWS = mul(objectToWorld, float4(positionOS, 1.0)).xyz;
-    float f = clamp(1.0 - (dist - minDist) / (maxDist - minDist), 0.01, 1.0) * tess;
+    float f = clamp(1.0 - (dist - minDist) / (maxDist - minDist), 0.01, 1.0);
     return f;
 }
 
 // Distance based tessellation:
 // Tessellation level is "tess" before "minDist" from camera, and linearly decreases to 1
 // up to "maxDist" from camera.
-float4 UnityDistanceBasedTess(float3 positionOS0, float3 positionOS1, float3 positionOS2, float minDist, float maxDist, float tess, float4x4 objectToWorld, float3 cameraPosWS)
+float4 DistanceBasedTess(float3 p0, float3 p1, float3 p2, float minDist, float maxDist, float4x4 objectToWorld, float3 cameraPosWS)
-    f.x = UnityCalcDistanceTessFactor(positionOS0, minDist, maxDist, tess, objectToWorld, cameraPosWS);
-    f.y = UnityCalcDistanceTessFactor(positionOS1, minDist, maxDist, tess, objectToWorld, cameraPosWS);
-    f.z = UnityCalcDistanceTessFactor(positionOS2, minDist, maxDist, tess, objectToWorld, cameraPosWS);
+    f.x = CalcDistanceTessFactor(p0, minDist, maxDist, objectToWorld, cameraPosWS);
+    f.y = CalcDistanceTessFactor(p1, minDist, maxDist, objectToWorld, cameraPosWS);
+    f.z = CalcDistanceTessFactor(p2, minDist, maxDist, objectToWorld, cameraPosWS);
     return UnityCalcTriEdgeTessFactors(f);
 }
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LitTessellation.hlsl

+/*
+float _Tess;
+float _TessNear;
+float _TessFar;
+float _UseDisplacementfalloff;
+float _DisplacementfalloffNear;
+float _DisplacementfalloffFar;
+*/
+
+float4 TessellationEdge(float3 p0, float3 p1, float3 p2, float3 n0, float3 n1, float3 n2)
+{
+  //  if (_TessellationFactorFixed >= 0.0f)
+    {
+    //    return  _TessellationFactorFixed.xxxx;
+    }
+ 
+    return DistanceBasedTess(p0, p1, p2, 0.0, _TessellationFactorMaxDistance, unity_ObjectToWorld, _WorldSpaceCameraPos) *  _TessellationFactorFixed.xxxx;
+}
+
+void Displacement(inout Attributes v)
+{
+    /*
+    float LengthLerp = length(ObjSpaceViewDir(v.vertex));
+    LengthLerp -= _DisplacementfalloffNear;
+    LengthLerp /= _DisplacementfalloffFar - _DisplacementfalloffNear;
+    LengthLerp = 1 - (saturate(LengthLerp));
+
+    float d = ((tex2Dlod(_DispTex, float4(v.texcoord.xy * _Tiling, 0, 0)).r) - _DisplacementCenter) * (_Displacement * LengthLerp);
+    d /= max(0.0001, _Tiling);
+    */
+
+#ifdef _HEIGHTMAP
+    float height = (SAMPLE_TEXTURE2D_LOD(ADD_ZERO_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), v.uv0, 0).r - ADD_ZERO_IDX(_HeightCenter)) * ADD_IDX(_HeightAmplitude);
+#else
+    float height = 0.0;
+#endif
+
+#if (SHADERPASS != SHADERPASS_VELOCITY) && (SHADERPASS != SHADERPASS_DISTORTION)
+    v.positionOS.xyz += height * v.normalOS;
+#endif
+}

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Tessellation/TessellationShare.hlsl

+AttributesTessellation VertTessellation(Attributes input)
+{
+    return AttributesToAttributesTessellation(input);
+}
+
+struct TessellationFactors
+{
+    float edge[3] : SV_TessFactor;
+    float inside : SV_InsideTessFactor;
+};
+
+TessellationFactors HullConstant(InputPatch<AttributesTessellation, 3> input)
+{
+    Attributes params[3];
+    params[0] = AttributesTessellationToAttributes(input[0]);
+    params[1] = AttributesTessellationToAttributes(input[1]);
+    params[2] = AttributesTessellationToAttributes(input[2]);
+ 
+#if (SHADERPASS != SHADERPASS_VELOCITY) && (SHADERPASS != SHADERPASS_DISTORTION)
+
+    // TEMP: We will provide world position but for now convert to world position here
+    float3 p0 = TransformObjectToWorld(input[0].positionOS);
+    float3 n0 = TransformObjectToWorldNormal(input[0].normalOS);
+
+    float3 p1 = TransformObjectToWorld(input[1].positionOS);
+    float3 n1 = TransformObjectToWorldNormal(input[1].normalOS);
+
+    float3 p2 = TransformObjectToWorld(input[2].positionOS);
+    float3 n2 = TransformObjectToWorldNormal(input[2].normalOS);
+
+    float4 tf = TessellationEdge(p0, p1, p2, n0, n1, n2);
+#else
+    float4 tf = float4(0.0, 0.0, 0.0, 0.0);
+#endif
+
+    TessellationFactors ouput;
+    ouput.edge[0] = tf.x;
+    ouput.edge[1] = tf.y;
+    ouput.edge[2] = tf.z;
+    ouput.inside = tf.w;
+
+    return ouput;
+}
+
+[maxtessfactor(15.0)] // AMD recommand this value for GCN http://amd-dev.wpengine.netdna-cdn.com/wordpress/media/2013/05/GCNPerformanceTweets.pdf
+[domain("tri")]
+[partitioning("fractional_odd")]
+[outputtopology("triangle_cw")]
+[patchconstantfunc("HullConstant")]
+[outputcontrolpoints(3)]
+AttributesTessellation Hull(InputPatch<AttributesTessellation, 3> input, uint id : SV_OutputControlPointID)
+{
+    return input[id];
+}
+
+[domain("tri")]
+PackedVaryings Domain(TessellationFactors tessFactors, const OutputPatch<AttributesTessellation, 3> input, float3 baryCoords : SV_DomainLocation)
+{
+    Attributes params = InterpolateWithBaryCoords(input[0], input[1], input[2], baryCoords);
+
+#ifndef _TESSELLATION_DISPLACEMENT // We have Phong tessellation in all case where we don't have only displacement
+#if (SHADERPASS != SHADERPASS_VELOCITY) && (SHADERPASS != SHADERPASS_DISTORTION)
+    params.positionOS = PhongTessellation(  params.positionOS,
+                                            input[0].positionOS, input[1].positionOS, input[2].positionOS,
+                                            input[0].normalOS, input[1].normalOS, input[2].normalOS,
+                                            baryCoords, _TessellationShapeFactor);
+#endif
+#endif
+
+    // perform displacement
+    Displacement(params);
+
+    // Evaluate regular vertex shader
+    PackedVaryings outout = Vert(params);
+
+    return outout;
+}

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LitTesselation.hlsl

-/*
-float _Tess;
-float _TessNear;
-float _TessFar;
-float _UseDisplacementfalloff;
-float _DisplacementfalloffNear;
-float _DisplacementfalloffFar;
-*/
-
-float4 TesselationEdge(Attributes input0, Attributes input1, Attributes input2)
-{
- //   float minDist = 0; // _TessNear;
-//    float maxDist = 15; // _TessFar;
-
- //   return UnityDistanceBasedTess(input0.positionOS, input1.positionOS, input2.positionOS, minDist, maxDist, 0.5 /* _Tess */, unity_ObjectToWorld, _WorldSpaceCameraPos);
-
-    return float4(_TesselationFactor, _TesselationFactor, _TesselationFactor, _TesselationFactor);
-}
-
-void Displacement(inout Attributes v)
-{
-    /*
-    float LengthLerp = length(ObjSpaceViewDir(v.vertex));
-    LengthLerp -= _DisplacementfalloffNear;
-    LengthLerp /= _DisplacementfalloffFar - _DisplacementfalloffNear;
-    LengthLerp = 1 - (saturate(LengthLerp));
-
-    float d = ((tex2Dlod(_DispTex, float4(v.texcoord.xy * _Tiling, 0, 0)).r) - _DisplacementCenter) * (_Displacement * LengthLerp);
-    d /= max(0.0001, _Tiling);
-    */
-
-#ifdef _HEIGHTMAP
-    float height = (SAMPLE_TEXTURE2D_LOD(ADD_ZERO_IDX(_HeightMap), ADD_ZERO_IDX(sampler_HeightMap), v.uv0, 0).r - ADD_ZERO_IDX(_HeightCenter)) * ADD_IDX(_HeightAmplitude);
-#else
-    float height = 0.0;
-#endif
-
-#if (SHADERPASS != SHADERPASS_VELOCITY) && (SHADERPASS != SHADERPASS_DISTORTION)
-    v.positionOS.xyz += height * v.normalOS;
-#endif
-}