325 lines
16 KiB
C#
325 lines
16 KiB
C#
using System;
|
|
using UnityEngine;
|
|
using UnityEngine.Rendering;
|
|
using UnityEditor;
|
|
using UnityEngine.Experimental.Rendering;
|
|
|
|
namespace UnityEditor.Rendering.Universal
|
|
{
|
|
internal class TerrainLitShaderGUI : UnityEditor.ShaderGUI, ITerrainLayerCustomUI
|
|
{
|
|
private class StylesLayer
|
|
{
|
|
public readonly GUIContent warningHeightBasedBlending = new GUIContent("Height-based blending is disabled if you have more than four TerrainLayer materials!");
|
|
|
|
public readonly GUIContent enableHeightBlend = new GUIContent("Enable Height-based Blend", "Blend terrain layers based on height values.");
|
|
public readonly GUIContent heightTransition = new GUIContent("Height Transition", "Size in world units of the smooth transition between layers.");
|
|
public readonly GUIContent enableInstancedPerPixelNormal = new GUIContent("Enable Per-pixel Normal", "Enable per-pixel normal when the terrain uses instanced rendering.");
|
|
|
|
public readonly GUIContent diffuseTexture = new GUIContent("Diffuse");
|
|
public readonly GUIContent colorTint = new GUIContent("Color Tint");
|
|
public readonly GUIContent opacityAsDensity = new GUIContent("Opacity as Density", "Enable Density Blend (if unchecked, opacity is used as Smoothness)");
|
|
public readonly GUIContent normalMapTexture = new GUIContent("Normal Map");
|
|
public readonly GUIContent normalScale = new GUIContent("Normal Scale");
|
|
public readonly GUIContent maskMapTexture = new GUIContent("Mask", "R: Metallic\nG: AO\nB: Height\nA: Smoothness");
|
|
public readonly GUIContent maskMapTextureWithoutHeight = new GUIContent("Mask Map", "R: Metallic\nG: AO\nA: Smoothness");
|
|
public readonly GUIContent channelRemapping = new GUIContent("Channel Remapping");
|
|
public readonly GUIContent defaultValues = new GUIContent("Channel Default Values");
|
|
public readonly GUIContent metallic = new GUIContent("R: Metallic");
|
|
public readonly GUIContent ao = new GUIContent("G: AO");
|
|
public readonly GUIContent height = new GUIContent("B: Height");
|
|
public readonly GUIContent heightParametrization = new GUIContent("Parametrization");
|
|
public readonly GUIContent heightAmplitude = new GUIContent("Amplitude (cm)");
|
|
public readonly GUIContent heightBase = new GUIContent("Base (cm)");
|
|
public readonly GUIContent heightMin = new GUIContent("Min (cm)");
|
|
public readonly GUIContent heightMax = new GUIContent("Max (cm)");
|
|
public readonly GUIContent heightCm = new GUIContent("B: Height (cm)");
|
|
public readonly GUIContent smoothness = new GUIContent("A: Smoothness");
|
|
}
|
|
|
|
static StylesLayer s_Styles = null;
|
|
private static StylesLayer styles { get { if (s_Styles == null) s_Styles = new StylesLayer(); return s_Styles; } }
|
|
|
|
public TerrainLitShaderGUI()
|
|
{
|
|
}
|
|
|
|
// Height blend params
|
|
MaterialProperty enableHeightBlend = null;
|
|
const string kEnableHeightBlend = "_EnableHeightBlend";
|
|
|
|
MaterialProperty heightTransition = null;
|
|
const string kHeightTransition = "_HeightTransition";
|
|
|
|
// Per-pixel Normal (while instancing)
|
|
MaterialProperty enableInstancedPerPixelNormal = null;
|
|
const string kEnableInstancedPerPixelNormal = "_EnableInstancedPerPixelNormal";
|
|
|
|
private bool m_ShowChannelRemapping = false;
|
|
enum HeightParametrization
|
|
{
|
|
Amplitude,
|
|
MinMax
|
|
};
|
|
private HeightParametrization m_HeightParametrization = HeightParametrization.Amplitude;
|
|
|
|
private static bool DoesTerrainUseMaskMaps(TerrainLayer[] terrainLayers)
|
|
{
|
|
for (int i = 0; i < terrainLayers.Length; ++i)
|
|
{
|
|
if (terrainLayers[i].maskMapTexture != null)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
protected void FindMaterialProperties(MaterialProperty[] props)
|
|
{
|
|
enableHeightBlend = FindProperty(kEnableHeightBlend, props, false);
|
|
heightTransition = FindProperty(kHeightTransition, props, false);
|
|
enableInstancedPerPixelNormal = FindProperty(kEnableInstancedPerPixelNormal, props, false);
|
|
}
|
|
|
|
static public void SetupMaterialKeywords(Material material)
|
|
{
|
|
bool enableHeightBlend = (material.HasProperty(kEnableHeightBlend) && material.GetFloat(kEnableHeightBlend) > 0);
|
|
CoreUtils.SetKeyword(material, "_TERRAIN_BLEND_HEIGHT", enableHeightBlend);
|
|
|
|
bool enableInstancedPerPixelNormal = material.GetFloat(kEnableInstancedPerPixelNormal) > 0.0f;
|
|
CoreUtils.SetKeyword(material, "_TERRAIN_INSTANCED_PERPIXEL_NORMAL", enableInstancedPerPixelNormal);
|
|
}
|
|
|
|
static public bool TextureHasAlpha(Texture2D inTex)
|
|
{
|
|
if (inTex != null)
|
|
{
|
|
return GraphicsFormatUtility.HasAlphaChannel(GraphicsFormatUtility.GetGraphicsFormat(inTex.format, true));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public override void OnGUI(MaterialEditor materialEditorIn, MaterialProperty[] properties)
|
|
{
|
|
if (materialEditorIn == null)
|
|
throw new ArgumentNullException("materialEditorIn");
|
|
|
|
FindMaterialProperties(properties);
|
|
|
|
bool optionsChanged = false;
|
|
EditorGUI.BeginChangeCheck();
|
|
{
|
|
if (enableHeightBlend != null)
|
|
{
|
|
EditorGUI.indentLevel++;
|
|
materialEditorIn.ShaderProperty(enableHeightBlend, styles.enableHeightBlend);
|
|
if (enableHeightBlend.floatValue > 0)
|
|
{
|
|
EditorGUI.indentLevel++;
|
|
EditorGUILayout.HelpBox(styles.warningHeightBasedBlending.text, MessageType.Info);
|
|
materialEditorIn.ShaderProperty(heightTransition, styles.heightTransition);
|
|
EditorGUI.indentLevel--;
|
|
}
|
|
EditorGUI.indentLevel--;
|
|
}
|
|
|
|
EditorGUILayout.Space();
|
|
}
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
optionsChanged = true;
|
|
}
|
|
|
|
bool enablePerPixelNormalChanged = false;
|
|
|
|
// Since Instanced Per-pixel normal is actually dependent on instancing enabled or not, it is not
|
|
// important to check it in the GUI. The shader will make sure it is enabled/disabled properly.s
|
|
if (enableInstancedPerPixelNormal != null)
|
|
{
|
|
EditorGUI.indentLevel++;
|
|
EditorGUI.BeginChangeCheck();
|
|
materialEditorIn.ShaderProperty(enableInstancedPerPixelNormal, styles.enableInstancedPerPixelNormal);
|
|
enablePerPixelNormalChanged = EditorGUI.EndChangeCheck();
|
|
EditorGUI.indentLevel--;
|
|
}
|
|
|
|
if (optionsChanged || enablePerPixelNormalChanged)
|
|
{
|
|
foreach (var obj in materialEditorIn.targets)
|
|
{
|
|
SetupMaterialKeywords((Material)obj);
|
|
}
|
|
}
|
|
|
|
// We should always do this call at the end
|
|
materialEditorIn.serializedObject.ApplyModifiedProperties();
|
|
}
|
|
|
|
bool ITerrainLayerCustomUI.OnTerrainLayerGUI(TerrainLayer terrainLayer, Terrain terrain)
|
|
{
|
|
var terrainLayers = terrain.terrainData.terrainLayers;
|
|
|
|
// Don't use the member field enableHeightBlend as ShaderGUI.OnGUI might not be called if the material UI is folded.
|
|
// heightblend shouldn't be available if we are in multi-pass mode, because it is guaranteed to be broken.
|
|
bool heightBlendAvailable = (terrainLayers.Length <= 4);
|
|
bool heightBlend = heightBlendAvailable && terrain.materialTemplate.HasProperty(kEnableHeightBlend) && (terrain.materialTemplate.GetFloat(kEnableHeightBlend) > 0);
|
|
|
|
terrainLayer.diffuseTexture = EditorGUILayout.ObjectField(styles.diffuseTexture, terrainLayer.diffuseTexture, typeof(Texture2D), false) as Texture2D;
|
|
TerrainLayerUtility.ValidateDiffuseTextureUI(terrainLayer.diffuseTexture);
|
|
|
|
var diffuseRemapMin = terrainLayer.diffuseRemapMin;
|
|
var diffuseRemapMax = terrainLayer.diffuseRemapMax;
|
|
EditorGUI.BeginChangeCheck();
|
|
|
|
bool enableDensity = false;
|
|
if (terrainLayer.diffuseTexture != null)
|
|
{
|
|
var rect = GUILayoutUtility.GetLastRect();
|
|
rect.y += 16 + 4;
|
|
rect.width = EditorGUIUtility.labelWidth + 64;
|
|
rect.height = 16;
|
|
|
|
++EditorGUI.indentLevel;
|
|
|
|
var diffuseTint = new Color(diffuseRemapMax.x, diffuseRemapMax.y, diffuseRemapMax.z);
|
|
diffuseTint = EditorGUI.ColorField(rect, styles.colorTint, diffuseTint, true, false, false);
|
|
diffuseRemapMax.x = diffuseTint.r;
|
|
diffuseRemapMax.y = diffuseTint.g;
|
|
diffuseRemapMax.z = diffuseTint.b;
|
|
diffuseRemapMin.x = diffuseRemapMin.y = diffuseRemapMin.z = 0;
|
|
|
|
if (!heightBlend)
|
|
{
|
|
rect.y = rect.yMax + 2;
|
|
enableDensity = EditorGUI.Toggle(rect, styles.opacityAsDensity, diffuseRemapMin.w > 0);
|
|
}
|
|
|
|
--EditorGUI.indentLevel;
|
|
}
|
|
diffuseRemapMax.w = 1;
|
|
diffuseRemapMin.w = enableDensity ? 1 : 0;
|
|
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
terrainLayer.diffuseRemapMin = diffuseRemapMin;
|
|
terrainLayer.diffuseRemapMax = diffuseRemapMax;
|
|
}
|
|
|
|
// Display normal map UI
|
|
terrainLayer.normalMapTexture = EditorGUILayout.ObjectField(styles.normalMapTexture, terrainLayer.normalMapTexture, typeof(Texture2D), false) as Texture2D;
|
|
TerrainLayerUtility.ValidateNormalMapTextureUI(terrainLayer.normalMapTexture, TerrainLayerUtility.CheckNormalMapTextureType(terrainLayer.normalMapTexture));
|
|
|
|
if (terrainLayer.normalMapTexture != null)
|
|
{
|
|
var rect = GUILayoutUtility.GetLastRect();
|
|
rect.y += 16 + 4;
|
|
rect.width = EditorGUIUtility.labelWidth + 64;
|
|
rect.height = 16;
|
|
|
|
++EditorGUI.indentLevel;
|
|
terrainLayer.normalScale = EditorGUI.FloatField(rect, styles.normalScale, terrainLayer.normalScale);
|
|
--EditorGUI.indentLevel;
|
|
}
|
|
|
|
// Display the mask map UI and the remap controls
|
|
terrainLayer.maskMapTexture = EditorGUILayout.ObjectField(heightBlend ? styles.maskMapTexture : styles.maskMapTextureWithoutHeight, terrainLayer.maskMapTexture, typeof(Texture2D), false) as Texture2D;
|
|
TerrainLayerUtility.ValidateMaskMapTextureUI(terrainLayer.maskMapTexture);
|
|
|
|
var maskMapRemapMin = terrainLayer.maskMapRemapMin;
|
|
var maskMapRemapMax = terrainLayer.maskMapRemapMax;
|
|
var smoothness = terrainLayer.smoothness;
|
|
var metallic = terrainLayer.metallic;
|
|
|
|
++EditorGUI.indentLevel;
|
|
EditorGUI.BeginChangeCheck();
|
|
|
|
m_ShowChannelRemapping = EditorGUILayout.Foldout(m_ShowChannelRemapping, terrainLayer.maskMapTexture != null ? s_Styles.channelRemapping : s_Styles.defaultValues);
|
|
|
|
if (m_ShowChannelRemapping)
|
|
{
|
|
if (terrainLayer.maskMapTexture != null)
|
|
{
|
|
float min, max;
|
|
min = maskMapRemapMin.x; max = maskMapRemapMax.x;
|
|
EditorGUILayout.MinMaxSlider(s_Styles.metallic, ref min, ref max, 0, 1);
|
|
maskMapRemapMin.x = min; maskMapRemapMax.x = max;
|
|
|
|
min = maskMapRemapMin.y; max = maskMapRemapMax.y;
|
|
EditorGUILayout.MinMaxSlider(s_Styles.ao, ref min, ref max, 0, 1);
|
|
maskMapRemapMin.y = min; maskMapRemapMax.y = max;
|
|
|
|
if (heightBlend)
|
|
{
|
|
EditorGUILayout.LabelField(styles.height);
|
|
++EditorGUI.indentLevel;
|
|
m_HeightParametrization = (HeightParametrization)EditorGUILayout.EnumPopup(styles.heightParametrization, m_HeightParametrization);
|
|
if (m_HeightParametrization == HeightParametrization.Amplitude)
|
|
{
|
|
// (height - heightBase) * amplitude
|
|
float amplitude = Mathf.Max(maskMapRemapMax.z - maskMapRemapMin.z, Mathf.Epsilon); // to avoid divide by zero
|
|
float heightBase = maskMapRemapMin.z / amplitude;
|
|
amplitude = EditorGUILayout.FloatField(styles.heightAmplitude, amplitude * 100) / 100;
|
|
heightBase = EditorGUILayout.FloatField(styles.heightBase, heightBase * 100) / 100;
|
|
maskMapRemapMin.z = heightBase * amplitude;
|
|
maskMapRemapMax.z = (1.0f - heightBase) * amplitude;
|
|
}
|
|
else
|
|
{
|
|
maskMapRemapMin.z = EditorGUILayout.FloatField(styles.heightMin, maskMapRemapMin.z * 100) / 100;
|
|
maskMapRemapMax.z = EditorGUILayout.FloatField(styles.heightMax, maskMapRemapMax.z * 100) / 100;
|
|
}
|
|
--EditorGUI.indentLevel;
|
|
}
|
|
|
|
min = maskMapRemapMin.w; max = maskMapRemapMax.w;
|
|
EditorGUILayout.MinMaxSlider(s_Styles.smoothness, ref min, ref max, 0, 1);
|
|
maskMapRemapMin.w = min; maskMapRemapMax.w = max;
|
|
}
|
|
else
|
|
{
|
|
metallic = EditorGUILayout.Slider(s_Styles.metallic, metallic, 0, 1);
|
|
// AO and Height are still exclusively controlled via the maskRemap controls
|
|
// metallic and smoothness have their own values as fields within the LayerData.
|
|
maskMapRemapMax.y = EditorGUILayout.Slider(s_Styles.ao, maskMapRemapMax.y, 0, 1);
|
|
if (heightBlend)
|
|
{
|
|
maskMapRemapMax.z = EditorGUILayout.FloatField(s_Styles.heightCm, maskMapRemapMax.z * 100) / 100;
|
|
}
|
|
|
|
// There's a possibility that someone could slide max below the existing min value
|
|
// so we'll just protect against that by locking the min value down a little bit.
|
|
// In the case of height (Z), we are trying to set min to no lower than zero value unless
|
|
// max goes negative. Zero is a good sensible value for the minimum. For AO (Y), we
|
|
// don't need this extra protection step because the UI blocks us from going negative
|
|
// anyway. In both cases, pushing the slider below the min value will lock them together,
|
|
// but min will be "left behind" if you go back up.
|
|
maskMapRemapMin.y = Mathf.Min(maskMapRemapMin.y, maskMapRemapMax.y);
|
|
maskMapRemapMin.z = Mathf.Min(Mathf.Max(0, maskMapRemapMin.z), maskMapRemapMax.z);
|
|
|
|
if (TextureHasAlpha(terrainLayer.diffuseTexture))
|
|
{
|
|
GUIStyle warnStyle = new GUIStyle(GUI.skin.label);
|
|
warnStyle.wordWrap = true;
|
|
GUILayout.Label("Smoothness is controlled by diffuse alpha channel", warnStyle);
|
|
}
|
|
else
|
|
smoothness = EditorGUILayout.Slider(s_Styles.smoothness, smoothness, 0, 1);
|
|
}
|
|
}
|
|
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
terrainLayer.maskMapRemapMin = maskMapRemapMin;
|
|
terrainLayer.maskMapRemapMax = maskMapRemapMax;
|
|
terrainLayer.smoothness = smoothness;
|
|
terrainLayer.metallic = metallic;
|
|
}
|
|
--EditorGUI.indentLevel;
|
|
|
|
EditorGUILayout.Space();
|
|
TerrainLayerUtility.TilingSettingsUI(terrainLayer);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|