HDRenderPipeline: Cleanup GUI for lit and layered lit material

- reorganize attributes
- remove inputs options
- Add SkyBox/Cubemap to the project

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

 
             public readonly GUIContent materialLayerText = new GUIContent("Material");
             public readonly GUIContent syncButtonText = new GUIContent("Re-Synchronize Layers", "Re-synchronize all layers's properties with the referenced Material");
-            public readonly GUIContent layersText = new GUIContent("Layers");
+            public readonly GUIContent layersText = new GUIContent("Inputs");
-            public readonly GUIContent objectScaleAffectTileText = new GUIContent("Object Scale affect tiling", "Tiling will be affected by the object scale.");
-                        
+            public readonly GUIContent objectScaleAffectTileText = new GUIContent("Tiling 0123 follow object Scale", "Tiling will be affected by the object scale.");
+            public readonly GUIContent objectScaleAffectTileText2 = new GUIContent("Tiling 123 follow object Scale", "Tiling will be affected by the object scale.");
+
-            public readonly GUIContent layerTexWorldScaleText = new GUIContent("Tiling", "Tiling factor applied to Planar/Trilinear mapping");
+            public readonly GUIContent layerTexWorldScaleText = new GUIContent("World Scale", "Tiling factor applied to Planar/Trilinear mapping");
             public readonly GUIContent UVBaseText = new GUIContent("Base UV Mapping", "Base UV Mapping mode of the layer.");
             public readonly GUIContent UVBlendMaskText = new GUIContent("BlendMask UV Mapping", "Base UV Mapping mode of the layer.");
             public readonly GUIContent UVDetailText = new GUIContent("Detail UV Mapping", "Detail UV Mapping mode of the layer.");
                 EditorGUI.indentLevel++;
                 m_MaterialEditor.ShaderProperty(layerTexWorldScale[layerIndex], styles.layerTexWorldScaleText);
                 EditorGUI.indentLevel--;
+
+                if (((LayerUVBaseMapping)layerUVBase[layerIndex].floatValue == LayerUVBaseMapping.Planar))
+                    GUILayout.Label("       " + styles.UVDetailText.text + ": Planar");
+                else
+                    GUILayout.Label("       " + styles.UVDetailText.text + ": Triplanar");
             }
             else
             {
                 EditorGUI.indentLevel--;
             }
 
-            EditorGUILayout.LabelField(styles.heightControlText, EditorStyles.boldLabel);
+            // Display height control if they have a meaning
+            if ( (tessellationMode != null && ((TessellationMode)tessellationMode.floatValue == TessellationMode.Displacement || (TessellationMode)tessellationMode.floatValue == TessellationMode.DisplacementPhong))
+                || (enablePerPixelDisplacement.floatValue > 0.0f)
+                || (useHeightBasedBlend.floatValue > 0.0f)
+                )
+            {
+                EditorGUILayout.LabelField(styles.heightControlText, EditorStyles.boldLabel);
-            EditorGUI.indentLevel++;
-            m_MaterialEditor.ShaderProperty(heightFactor[layerIndex], styles.heightFactorText);
-            layerHeightAmplitude[layerIndex].floatValue = material.GetFloat(kHeightAmplitude + layerIndex) * heightFactor[layerIndex].floatValue;
-            m_MaterialEditor.ShaderProperty(heightCenterOffset[layerIndex], styles.heightCenterOffsetText);
-            layerCenterOffset[layerIndex].floatValue = material.GetFloat(kHeightCenter + layerIndex) + heightCenterOffset[layerIndex].floatValue;
+                EditorGUI.indentLevel++;
+                m_MaterialEditor.ShaderProperty(heightFactor[layerIndex], styles.heightFactorText);
+                layerHeightAmplitude[layerIndex].floatValue = material.GetFloat(kHeightAmplitude + layerIndex) * heightFactor[layerIndex].floatValue;
+                m_MaterialEditor.ShaderProperty(heightCenterOffset[layerIndex], styles.heightCenterOffsetText);
+                layerCenterOffset[layerIndex].floatValue = material.GetFloat(kHeightCenter + layerIndex) + heightCenterOffset[layerIndex].floatValue;
+                EditorGUI.indentLevel--;
+            }            
-            EditorGUI.indentLevel--;
 
             // influence
             if (layerIndex > 0)
-                bool heightBasedBlendEnable = useHeightBasedBlend.floatValue != 0.0f; 
+                bool heightBasedBlendEnable = useHeightBasedBlend.floatValue > 0.0f; 
                 if (heightBasedBlendEnable)
                 {
                     EditorGUI.indentLevel++;
             }
 
             m_MaterialEditor.TexturePropertySingleLine(styles.layerMapMaskText, layerMaskMap);
+
+            EditorGUI.indentLevel++;
-                EditorGUI.indentLevel++;
-                EditorGUI.indentLevel--;
-                EditorGUI.indentLevel++;
-                EditorGUI.indentLevel--;
+            EditorGUI.indentLevel--;
+
+            m_MaterialEditor.ShaderProperty(vertexColorMode, styles.vertexColorModeText);
 
             EditorGUI.BeginChangeCheck();
             EditorGUI.showMixedValue = useMainLayerInfluence.hasMixedValue;
                 useMainLayerInfluence.floatValue = mainLayerModeInfluenceEnable ? 1.0f : 0.0f;
-            }
-
-            m_MaterialEditor.ShaderProperty(vertexColorMode, styles.vertexColorModeText);
+            }            
 
             EditorGUI.BeginChangeCheck();
             EditorGUI.showMixedValue = useDensityMode.hasMixedValue;
                 useHeightBasedBlend.floatValue = enabled ? 1.0f : 0.0f;
             }
 
-            m_MaterialEditor.ShaderProperty(objectScaleAffectTile, styles.objectScaleAffectTileText);            
+            m_MaterialEditor.ShaderProperty(objectScaleAffectTile, mainLayerModeInfluenceEnable ? styles.objectScaleAffectTileText2 : styles.objectScaleAffectTileText);            
 
             EditorGUILayout.Space();
 
             m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, layerEmissiveColorMap, layerEmissiveColor);
             m_MaterialEditor.ShaderProperty(layerEmissiveIntensity, Styles.emissiveIntensityText);
             m_MaterialEditor.LightmapEmissionProperty(1);
-            m_MaterialEditor.ShaderProperty(horizonFade, Styles.horizonFadeText);
             EditorGUI.indentLevel--;
 
             if (layerChanged || optionsChanged)

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

     {
         protected static class Styles
         {
-            public static string optionText = "Options";
+            public static string optionText = "Surface options";
             public static string surfaceTypeText = "Surface Type";
             public static string blendModeText = "Blend Mode";
             public static string detailText = "Inputs Detail";
             public static GUIContent distortionEnableText = new GUIContent("Distortion", "Enable distortion on this shader");
             public static GUIContent distortionOnlyText = new GUIContent("Distortion Only", "This shader will only be use to render distortion");
             public static GUIContent distortionDepthTestText = new GUIContent("Distortion Depth Test", "Enable the depth test for distortion");
-            public static GUIContent depthOffsetEnableText = new GUIContent("DepthOffset", "EnableDepthOffset on this shader (Use with heightmap)");
-            public static GUIContent horizonFadeText = new GUIContent("HorizonFade", "horizon fade is use to control specular occlusion");            
+            public static GUIContent depthOffsetEnableText = new GUIContent("Enable Depth Offset", "EnableDepthOffset on this shader (Use with heightmap)");
+            public static GUIContent horizonFadeText = new GUIContent("Horizon Fade (Spec occlusion)", "horizon fade is use to control specular occlusion");            
-
-            public static string InputsOptionsText = "Inputs options";
-            public static GUIContent UVBaseMappingText = new GUIContent("UV set for Base", "");
-            public static GUIContent texWorldScaleText = new GUIContent("Tiling", "Tiling factor applied to Planar/Trilinear mapping");
-            public static GUIContent UVBaseDetailMappingText = new GUIContent("UV set for Base and Detail", "");
+            public static GUIContent UVBaseMappingText = new GUIContent("Base UV mapping", "");
+            public static GUIContent texWorldScaleText = new GUIContent("World scale", "Tiling factor applied to Planar/Trilinear mapping");
             public static GUIContent normalMapSpaceText = new GUIContent("Normal/Tangent Map space", "");
             public static GUIContent enablePerPixelDisplacementText = new GUIContent("Enable Per Pixel Displacement", "");
             public static GUIContent ppdMinSamplesText = new GUIContent("Minimum samples", "Minimun samples to use with per pixel displacement mapping");
             public static GUIContent detailMapModeText = new GUIContent("Detail Map with Normal", "Detail Map with AO / Height");
-            public static GUIContent UVDetailMappingText = new GUIContent("UV set for Detail", "");
+            public static GUIContent UVDetailMappingText = new GUIContent("Detail UV mapping", "");
             public static GUIContent emissiveColorModeText = new GUIContent("Emissive Color Usage", "Use emissive color or emissive mask");
 
             public static string InputsText = "Inputs";
                 m_MaterialEditor.ShaderProperty(alphaCutoff, Styles.alphaCutoffText.text);
             }
             m_MaterialEditor.ShaderProperty(doubleSidedMode, Styles.doubleSidedModeText.text);
-            m_MaterialEditor.ShaderProperty(depthOffsetEnable, Styles.depthOffsetEnableText.text);
+
+            m_MaterialEditor.ShaderProperty(enablePerPixelDisplacement, Styles.enablePerPixelDisplacementText);
+            if (enablePerPixelDisplacement.floatValue > 0.0)
+            {
+                EditorGUI.indentLevel++;
+                m_MaterialEditor.ShaderProperty(ppdMinSamples, Styles.ppdMinSamplesText);
+                m_MaterialEditor.ShaderProperty(ppdMaxSamples, Styles.ppdMaxSamplesText);
+                ppdMinSamples.floatValue = Mathf.Min(ppdMinSamples.floatValue, ppdMaxSamples.floatValue);
+                m_MaterialEditor.ShaderProperty(ppdLodThreshold, Styles.ppdLodThresholdText);
+                m_MaterialEditor.ShaderProperty(depthOffsetEnable, Styles.depthOffsetEnableText.text);
+                EditorGUI.indentLevel--;
+            }
+
+            m_MaterialEditor.ShaderProperty(horizonFade, Styles.horizonFadeText);
 
             EditorGUI.indentLevel--;
 
                 m_MaterialEditor.ShaderProperty(tessellationObjectScale, Styles.tessellationObjectScaleText);
                 EditorGUI.indentLevel--;
             }
-
-            GUILayout.Label(Styles.perPixelDisplacementText, EditorStyles.boldLabel);
-            EditorGUI.indentLevel++;
-            m_MaterialEditor.ShaderProperty(enablePerPixelDisplacement, Styles.enablePerPixelDisplacementText);
-            if (enablePerPixelDisplacement.floatValue > 0.0)
-            {
-                EditorGUI.indentLevel++;
-                m_MaterialEditor.ShaderProperty(ppdMinSamples, Styles.ppdMinSamplesText);
-                m_MaterialEditor.ShaderProperty(ppdMaxSamples, Styles.ppdMaxSamplesText);
-                ppdMinSamples.floatValue = Mathf.Min(ppdMinSamples.floatValue, ppdMaxSamples.floatValue);
-                m_MaterialEditor.ShaderProperty(ppdLodThreshold, Styles.ppdLodThresholdText);
-                EditorGUI.indentLevel--;
-            }
-            EditorGUI.indentLevel--;
         }
 
         protected void FindCommonOptionProperties(MaterialProperty[] props)
                 ShaderOptionsGUI();
                 EditorGUILayout.Space();
 
-                ShaderInputOptionsGUI();
-
                 EditorGUILayout.Space();
                 ShaderInputGUI();
             }
 
         protected abstract void FindMaterialProperties(MaterialProperty[] props);
 		protected abstract void ShaderInputGUI();
-        protected abstract void ShaderInputOptionsGUI();
         protected abstract void SetupMaterialKeywords(Material material);
         protected abstract bool ShouldEmissionBeEnabled(Material material);
     }

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

             thicknessMap        = FindProperty(kThicknessMap,        props);
         }
 
-        override protected void ShaderInputOptionsGUI()
-        {
-            // When Planar or Triplanar is enable the UVDetail use the same mode, so we disable the choice on UVDetail
-            bool enableUVDetail = (UVBaseMapping)UVBase.floatValue == UVBaseMapping.UV0;
-
-            EditorGUI.indentLevel++;
-            GUILayout.Label(Styles.InputsOptionsText, EditorStyles.boldLabel);
-            m_MaterialEditor.ShaderProperty(materialID, Styles.materialIDText);
-            m_MaterialEditor.ShaderProperty(UVBase, enableUVDetail ? Styles.UVBaseDetailMappingText : Styles.UVBaseMappingText);
-
-            float X, Y, Z, W;
-            X = ((UVBaseMapping)UVBase.floatValue == UVBaseMapping.UV0) ? 1.0f : 0.0f;
-            UVMappingMask.colorValue = new Color(X, 0.0f, 0.0f, 0.0f);
-            UVMappingPlanar.floatValue = ((UVBaseMapping)UVBase.floatValue == UVBaseMapping.Planar) ? 1.0f : 0.0f;
-            if (((UVBaseMapping)UVBase.floatValue == UVBaseMapping.Planar) || ((UVBaseMapping)UVBase.floatValue == UVBaseMapping.Triplanar))
-            {
-                EditorGUI.indentLevel++;
-                m_MaterialEditor.ShaderProperty(TexWorldScale, Styles.texWorldScaleText);
-                EditorGUI.indentLevel--;
-            }
-            if (enableUVDetail)
-            {
-                m_MaterialEditor.ShaderProperty(UVDetail, Styles.UVDetailMappingText);
-            }
-
-            X = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV0) ? 1.0f : 0.0f;
-            Y = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV1) ? 1.0f : 0.0f;
-            Z = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV2) ? 1.0f : 0.0f;
-            W = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV3) ? 1.0f : 0.0f;
-            UVDetailsMappingMask.colorValue = new Color(X, Y, Z, W);
-
-            m_MaterialEditor.ShaderProperty(normalMapSpace, Styles.normalMapSpaceText);
-            m_MaterialEditor.ShaderProperty(emissiveColorMode, Styles.emissiveColorModeText);            
-
-            EditorGUI.indentLevel--;
-        }
-
         protected void ShaderSSSInputGUI()
         {
             m_MaterialEditor.ShaderProperty(subsurfaceProfile, Styles.subsurfaceProfileText);
         }
 
         override protected void ShaderInputGUI()
-        {
-            EditorGUI.indentLevel++;
+        {            
+
+            EditorGUI.indentLevel++;
+            m_MaterialEditor.ShaderProperty(materialID, Styles.materialIDText);
+
             m_MaterialEditor.TexturePropertySingleLine(Styles.baseColorText, baseColorMap, baseColor);
             m_MaterialEditor.ShaderProperty(metallic, Styles.metallicText);
             m_MaterialEditor.ShaderProperty(smoothness, Styles.smoothnessText);
 
             m_MaterialEditor.TexturePropertySingleLine(Styles.specularOcclusionMapText, specularOcclusionMap);
 
+            m_MaterialEditor.ShaderProperty(normalMapSpace, Styles.normalMapSpaceText);
             m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMap, normalScale);
 
             m_MaterialEditor.TexturePropertySingleLine(Styles.heightMapText, heightMap);
             }
 
             EditorGUILayout.Space();
-            GUILayout.Label(Styles.textureControlText, EditorStyles.label);
+            GUILayout.Label("    " + Styles.textureControlText, EditorStyles.label);
+            m_MaterialEditor.ShaderProperty(UVBase, Styles.UVBaseMappingText);
+            // UVSet0 is always set, planar and triplanar will override it.
+            UVMappingMask.colorValue = new Color(1.0f, 0.0f, 0.0f, 0.0f); // This is override in the shader anyway but just in case.
+            UVMappingPlanar.floatValue = ((UVBaseMapping)UVBase.floatValue == UVBaseMapping.Planar) ? 1.0f : 0.0f;
+            if (((UVBaseMapping)UVBase.floatValue == UVBaseMapping.Planar) || ((UVBaseMapping)UVBase.floatValue == UVBaseMapping.Triplanar))
+            {
+                m_MaterialEditor.ShaderProperty(TexWorldScale, Styles.texWorldScaleText);
+            }
-            m_MaterialEditor.TexturePropertySingleLine(Styles.detailMaskText, detailMask);               
-
+            m_MaterialEditor.TexturePropertySingleLine(Styles.detailMaskText, detailMask);
+            
+            EditorGUI.indentLevel++;            
+            // When Planar or Triplanar is enable the UVDetail use the same mode, so we disable the choice on UVDetail
+            if ((UVBaseMapping)UVBase.floatValue == UVBaseMapping.UV0)
+            {
+                m_MaterialEditor.ShaderProperty(UVDetail, Styles.UVDetailMappingText);
+            }
+            else if ((UVBaseMapping)UVBase.floatValue == UVBaseMapping.Planar)
+            {
+                GUILayout.Label("       " + Styles.UVDetailMappingText.text + ": Planar");
+            }
+            else if ((UVBaseMapping)UVBase.floatValue == UVBaseMapping.Triplanar)
+            {
+                GUILayout.Label("       " + Styles.UVDetailMappingText.text + ": Triplanar");
+            }
+
+            // IF planar/triplanar is not chose, setup the UVSet chosen
+            float X, Y, Z, W;
+            X = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV0) ? 1.0f : 0.0f;
+            Y = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV1) ? 1.0f : 0.0f;
+            Z = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV2) ? 1.0f : 0.0f;
+            W = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV3) ? 1.0f : 0.0f;
+            UVDetailsMappingMask.colorValue = new Color(X, Y, Z, W);
+
-            EditorGUI.indentLevel++;
             m_MaterialEditor.ShaderProperty(detailAlbedoScale, Styles.detailAlbedoScaleText);
             m_MaterialEditor.ShaderProperty(detailNormalScale, Styles.detailNormalScaleText);
             m_MaterialEditor.ShaderProperty(detailSmoothnessScale, Styles.detailSmoothnessScaleText);
             GUILayout.Label(Styles.lightingText, EditorStyles.boldLabel);
+            m_MaterialEditor.ShaderProperty(emissiveColorMode, Styles.emissiveColorModeText);
+
-            m_MaterialEditor.LightmapEmissionProperty(MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);
-            m_MaterialEditor.ShaderProperty(horizonFade, Styles.horizonFadeText);
+            m_MaterialEditor.LightmapEmissionProperty(MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);            
             EditorGUI.indentLevel--;
 
             EditorGUILayout.Space();

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

 #endif
 
     // Be sure that the compiler is aware that we don't touch UV1 to UV3 for main layer so it can optimize code
-    _UVMappingMask.yzw = float3(0.0, 0.0, 0.0);
+    // Also we have always UVset to 1, if planar/triplanar is enable, it will override it.
+    _UVMappingMask = float4(1.0, 0.0, 0.0, 0.0);
     ComputeLayerTexCoord(   texCoord0, texCoord1, texCoord2, texCoord3, 
                             positionWS, normalWS,  _UVMappingPlanar > 0.0, isTriplanar, _TexWorldScale, layerTexCoord);
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Editor/BaseUnlitUI.cs

             public static readonly string[] surfaceTypeNames = Enum.GetNames(typeof(SurfaceType));
             public static readonly string[] blendModeNames = Enum.GetNames(typeof(BlendMode));
 
-            public static string InputsOptionsText = "Inputs options";
-
             public static string InputsText = "Inputs";
 
             public static string InputsMapText = "";
                 ShaderOptionsGUI();
                 EditorGUILayout.Space();
 
-                ShaderInputOptionsGUI();
-
                 EditorGUILayout.Space();
                 ShaderInputGUI();
             }
 
         protected abstract void FindMaterialProperties(MaterialProperty[] props);
         protected abstract void ShaderInputGUI();
-        protected abstract void ShaderInputOptionsGUI();
 		protected abstract void SetupMaterialKeywords(Material material);
         protected abstract bool ShouldEmissionBeEnabled(Material material);
     }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Editor/UnlitUI.cs

             EditorGUI.indentLevel--;
         }
 
-        override protected void ShaderInputOptionsGUI()
-        {
-        }
-
         protected override void SetupMaterialKeywords(Material material)
         {
 			SetupCommonOptionsKeywords(material);

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/FragInputs.hlsl

     float2 texCoord1;
     float2 texCoord2;
     float2 texCoord3;
-    float3 tangentToWorld[3]; // These 3 vectors are normalized (no need for the material to normalize)
+    float3 tangentToWorld[3]; // These 3 vectors are normalized (no need for the material to normalize) and these are only for UVSet 0
     float4 color; // vertex color
 
     // For two sided lighting

ProjectSettings/GraphicsSettings.asset

   - {fileID: 4800000, guid: 595434cc3b6405246b6cd3086d0b6f7d, type: 3}
   - {fileID: 16000, guid: 0000000000000000f000000000000000, type: 0}
   - {fileID: 16001, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 103, guid: 0000000000000000f000000000000000, type: 0}
   m_PreloadedShaders: []
   m_SpritesDefaultMaterial: {fileID: 10754, guid: 0000000000000000f000000000000000,
     type: 0}