using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor.ShaderGraph;
using UnityEditor.ShaderGraph.Internal;
using UnityEngine.UIElements;
using UnityEditor.ShaderGraph.Legacy;
using UnityEngine.Assertions;
using static UnityEditor.Rendering.Universal.ShaderGraph.SubShaderUtils;
using UnityEngine.Rendering.Universal;
using static Unity.Rendering.Universal.ShaderUtils;
namespace UnityEditor.Rendering.Universal.ShaderGraph
{
partial class UniversalTerrainLitSubTarget : UniversalSubTarget, ITerrainSubTarget
{
private static readonly GUID kSourceCodeGuid = new GUID("ea07e558bc2741a5ba7f1d5470eb242b"); // UniversalTerrainLitSubTarget.cs
public override int latestVersion => 1;
[SerializeField]
bool m_EnableInstancedPerPixelNormal = true;
[SerializeField]
NormalDropOffSpace m_NormalDropOffSpace = NormalDropOffSpace.Tangent;
[SerializeField]
bool m_BlendModePreserveSpecular = true;
protected override ShaderID shaderID => ShaderID.SG_TerrainLit;
public bool enableInstancedPerPixelNormal
{
get => m_EnableInstancedPerPixelNormal;
set => m_EnableInstancedPerPixelNormal = value;
}
public NormalDropOffSpace normalDropOffSpace
{
get => m_NormalDropOffSpace;
set => m_NormalDropOffSpace = value;
}
public bool blendModePreserveSpecular
{
get => m_BlendModePreserveSpecular;
set => m_BlendModePreserveSpecular = value;
}
public UniversalTerrainLitSubTarget()
{
displayName = "TerrainLit";
}
public override bool IsActive() => true;
public override void Setup(ref TargetSetupContext context)
{
context.AddAssetDependency(kSourceCodeGuid, AssetCollection.Flags.SourceDependency);
base.Setup(ref context);
var universalRPType = typeof(UniversalRenderPipelineAsset);
if (!context.HasCustomEditorForRenderPipeline(universalRPType))
context.AddCustomEditorForRenderPipeline(typeof(ShaderGraphTerrainLitGUI).FullName, universalRPType);
// terrain shaders are always opaque, so these values are hardcoded to not inherit from the Universal Target
var renderTypeOpaque = RenderType.Opaque.ToString();
var renderQueue = target.alphaClip?RenderQueue.AlphaTest.ToString():RenderQueue.Geometry.ToString();
context.AddSubShader(PostProcessSubShader(TerrainSubShaders.LitComputeDotsSubShader(target, renderTypeOpaque, renderQueue, blendModePreserveSpecular)));
context.AddSubShader(PostProcessSubShader(TerrainSubShaders.LitGLESSubShader(target, renderTypeOpaque, renderQueue, blendModePreserveSpecular)));
context.AddSubShader(PostProcessSubShader(TerrainLitAddSubShaders.LitComputeDotsSubShader(target, renderTypeOpaque, renderQueue, blendModePreserveSpecular)));
context.AddSubShader(PostProcessSubShader(TerrainLitAddSubShaders.LitGLESSubShader(target, renderTypeOpaque, renderQueue, blendModePreserveSpecular)));
context.AddSubShader(PostProcessSubShader(TerrainLitBaseMapGenSubShaders.GenerateBaseMap(target, renderTypeOpaque, renderQueue, blendModePreserveSpecular)));
}
public override void ProcessPreviewMaterial(Material material)
{
// We always need these properties regardless of whether the material is allowed to override
// Queue control & offset enable correct automatic render queue behavior
// Control == 0 is automatic, 1 is user-specified render queue
material.SetFloat(Property.QueueOffset, 0.0f);
material.SetFloat(Property.QueueControl, (float)BaseShaderGUI.QueueControl.Auto);
// call the full unlit material setup function
ShaderGraphLitGUI.UpdateMaterial(material, MaterialUpdateType.CreatedNewMaterial);
}
public override void GetFields(ref TargetFieldContext context)
{
base.GetFields(ref context);
// TerrainLit -- always controlled by subtarget
context.AddField(UniversalFields.NormalDropOffOS, normalDropOffSpace == NormalDropOffSpace.Object);
context.AddField(UniversalFields.NormalDropOffTS, normalDropOffSpace == NormalDropOffSpace.Tangent);
context.AddField(UniversalFields.NormalDropOffWS, normalDropOffSpace == NormalDropOffSpace.World);
}
public override void GetActiveBlocks(ref TargetActiveBlockContext context)
{
context.AddBlock(BlockFields.SurfaceDescription.Smoothness);
context.AddBlock(BlockFields.SurfaceDescription.NormalOS, normalDropOffSpace == NormalDropOffSpace.Object);
context.AddBlock(BlockFields.SurfaceDescription.NormalTS, normalDropOffSpace == NormalDropOffSpace.Tangent);
context.AddBlock(BlockFields.SurfaceDescription.NormalWS, normalDropOffSpace == NormalDropOffSpace.World);
context.AddBlock(BlockFields.SurfaceDescription.Emission);
context.AddBlock(BlockFields.SurfaceDescription.Occlusion);
// when the surface options are material controlled, we must show all of these blocks
// when target controlled, we can cull the unnecessary blocks
context.AddBlock(BlockFields.SurfaceDescription.Specular, target.allowMaterialOverride);
context.AddBlock(BlockFields.SurfaceDescription.Metallic);
context.AddBlock(BlockFields.SurfaceDescription.Alpha, target.alphaClip);
context.AddBlock(BlockFields.SurfaceDescription.AlphaClipThreshold, target.alphaClip);
}
public override void CollectShaderProperties(PropertyCollector collector, GenerationMode generationMode)
{
collector.AddShaderProperty(new BooleanShaderProperty
{
value = enableInstancedPerPixelNormal,
hidden = false,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_EnableInstancedPerPixelNormal",
displayName = "Enable Instanced per Pixel Normal",
});
collector.AddShaderProperty(new Texture2DShaderProperty
{
defaultType = Texture2DShaderProperty.DefaultType.White,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_TerrainHolesTexture",
displayName = "Holes Map (RGB)",
});
collector.AddShaderProperty(new Texture2DShaderProperty
{
defaultType = Texture2DShaderProperty.DefaultType.White,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_DefaultWhiteTex",
displayName = "DefaultWhiteTex",
});
collector.AddShaderProperty(new Texture2DShaderProperty
{
defaultType = Texture2DShaderProperty.DefaultType.NormalMap,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_NormalBlank",
displayName = "Empty Normal Map",
});
collector.AddShaderProperty(new Texture2DShaderProperty
{
defaultType = Texture2DShaderProperty.DefaultType.Black,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_BlackTex",
displayName = "Empty Texture",
});
collector.AddShaderProperty(new Texture2DShaderProperty
{
defaultType = Texture2DShaderProperty.DefaultType.White,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Splat0",
displayName = "Layer 0 (R)",
useTilingAndOffset = true,
});
collector.AddShaderProperty(new Texture2DShaderProperty
{
defaultType = Texture2DShaderProperty.DefaultType.White,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Splat1",
displayName = "Layer 1 (G)",
useTilingAndOffset = true,
});
collector.AddShaderProperty(new Texture2DShaderProperty
{
defaultType = Texture2DShaderProperty.DefaultType.White,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Splat2",
displayName = "Layer 2 (B)",
useTilingAndOffset = true,
});
collector.AddShaderProperty(new Texture2DShaderProperty
{
defaultType = Texture2DShaderProperty.DefaultType.White,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Splat3",
displayName = "Layer 3 (A)",
useTilingAndOffset = true,
});
collector.AddShaderProperty(new Texture2DShaderProperty
{
defaultType = Texture2DShaderProperty.DefaultType.Grey,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Mask3",
displayName = "Layer 3 (A)",
useTilingAndOffset = true,
});
collector.AddShaderProperty(new Texture2DShaderProperty
{
defaultType = Texture2DShaderProperty.DefaultType.Grey,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Mask2",
displayName = "Layer 2 (B)",
useTilingAndOffset = true,
});
collector.AddShaderProperty(new Texture2DShaderProperty
{
defaultType = Texture2DShaderProperty.DefaultType.Grey,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Mask1",
displayName = "Layer 1 (G)",
useTilingAndOffset = true,
});
collector.AddShaderProperty(new Texture2DShaderProperty
{
defaultType = Texture2DShaderProperty.DefaultType.Grey,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Mask0",
displayName = "Layer 0 (R)",
useTilingAndOffset = true,
});
collector.AddShaderProperty(new Vector1ShaderProperty
{
floatType = FloatType.Slider,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Metallic0",
displayName = "Metallic 0",
});
collector.AddShaderProperty(new Vector1ShaderProperty
{
floatType = FloatType.Slider,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Metallic1",
displayName = "Metallic 1",
});
collector.AddShaderProperty(new Vector1ShaderProperty
{
floatType = FloatType.Slider,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Metallic2",
displayName = "Metallic 2",
});
collector.AddShaderProperty(new Vector1ShaderProperty
{
floatType = FloatType.Slider,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Metallic3",
displayName = "Metallic 3",
});
collector.AddShaderProperty(new Vector1ShaderProperty
{
value = 1.0f,
floatType = FloatType.Slider,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Smoothness0",
displayName = "Smoothness 0",
});
collector.AddShaderProperty(new Vector1ShaderProperty
{
value = 1.0f,
floatType = FloatType.Slider,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Smoothness1",
displayName = "Smoothness 1",
});
collector.AddShaderProperty(new Vector1ShaderProperty
{
value = 1.0f,
floatType = FloatType.Slider,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Smoothness2",
displayName = "Smoothness 2",
});
collector.AddShaderProperty(new Vector1ShaderProperty
{
value = 1.0f,
floatType = FloatType.Slider,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare,
overrideReferenceName = "_Smoothness3",
displayName = "Smoothness 3",
});
collector.AddShaderProperty(new Vector1ShaderProperty
{
floatType = FloatType.Default,
value = 0.0f,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = HLSLDeclaration.Global,
overrideReferenceName = "_DstBlend",
displayName = "DstBlend",
});
}
public override void GetPropertiesGUI(ref TargetPropertyGUIContext context, Action onChange, Action<String> registerUndo)
{
context.AddProperty("Depth Write", new EnumField(ZWriteControl.Auto) { value = target.zWriteControl }, (evt) =>
{
if (Equals(target.zWriteControl, evt.newValue))
return;
registerUndo("Change Depth Write Control");
target.zWriteControl = (ZWriteControl)evt.newValue;
onChange();
});
context.AddProperty("Depth Test", new EnumField(ZTestModeForUI.LEqual) { value = (ZTestModeForUI)target.zTestMode }, (evt) =>
{
if (Equals(target.zTestMode, evt.newValue))
return;
registerUndo("Change Depth Test");
target.zTestMode = (ZTestMode)evt.newValue;
onChange();
});
context.AddProperty("Alpha Clipping", new Toggle() { value = target.alphaClip }, (evt) =>
{
if (Equals(target.alphaClip, evt.newValue))
return;
registerUndo("Change Alpha Clip");
target.alphaClip = evt.newValue;
onChange();
});
context.AddProperty("Cast Shadows", new Toggle() { value = target.castShadows }, (evt) =>
{
if (Equals(target.castShadows, evt.newValue))
return;
registerUndo("Change Cast Shadows");
target.castShadows = evt.newValue;
onChange();
});
context.AddProperty("Receive Shadows", new Toggle() {value = target.receiveShadows}, (evt) =>
{
if (Equals(target.receiveShadows, evt.newValue))
return;
registerUndo("Change Receive Shadows");
target.receiveShadows = evt.newValue;
onChange();
});
context.AddProperty("Fragment Normal Space", new EnumField(NormalDropOffSpace.Tangent) { value = normalDropOffSpace }, (evt) =>
{
if (Equals(normalDropOffSpace, evt.newValue))
return;
registerUndo("Change Fragment Normal Space");
normalDropOffSpace = (NormalDropOffSpace)evt.newValue;
onChange();
});
}
protected override int ComputeMaterialNeedsUpdateHash()
{
int hash = base.ComputeMaterialNeedsUpdateHash();
hash = hash * 23 + target.allowMaterialOverride.GetHashCode();
return hash;
}
// this is a copy of ZTestMode, but hides the "Disabled" option, which is invalid
enum ZTestModeForUI
{
Never = 1,
Less = 2,
Equal = 3,
LEqual = 4, // default for most rendering
Greater = 5,
NotEqual = 6,
GEqual = 7,
Always = 8,
};
internal override void OnAfterParentTargetDeserialized()
{
Assert.IsNotNull(target);
if (this.sgVersion < latestVersion)
{
// Upgrade old incorrect Premultiplied blend into
// equivalent Alpha + Preserve Specular blend mode.
if (this.sgVersion < 1)
{
if (target.alphaMode == AlphaMode.Premultiply)
{
target.alphaMode = AlphaMode.Alpha;
blendModePreserveSpecular = true;
}
else
blendModePreserveSpecular = false;
}
ChangeVersion(latestVersion);
}
}
#region Template
static class TerrainLitTemplate
{
public static readonly string kPassTemplate = "Packages/com.unity.render-pipelines.universal/Editor/Terrain/TerrainPass.template";
public static readonly string[] kSharedTemplateDirectories;
static TerrainLitTemplate()
{
kSharedTemplateDirectories = new string[UniversalTarget.kSharedTemplateDirectories.Length + 1];
Array.Copy(UniversalTarget.kSharedTemplateDirectories, kSharedTemplateDirectories, UniversalTarget.kSharedTemplateDirectories.Length);
kSharedTemplateDirectories[^1] = "Packages/com.unity.render-pipelines.universal/Editor/Terrain/";
}
}
#endregion
#region StructCollections
static class TerrainStructFields
{
public struct Varyings
{
public static FieldDescriptor uvSplat01 = new FieldDescriptor(
StructFields.Varyings.name, "uvSplat01", "", ShaderValueType.Float4, "TEXCOORD1", preprocessor: "defined(UNIVERSAL_TERRAIN_SPLAT01)", subscriptOptions: StructFieldOptions.Optional);
public static FieldDescriptor uvSplat23 = new FieldDescriptor(
StructFields.Varyings.name, "uvSplat23", "", ShaderValueType.Float4, "TEXCOORD2", preprocessor: "defined(UNIVERSAL_TERRAIN_SPLAT23)", subscriptOptions: StructFieldOptions.Optional);
public static FieldDescriptor normalViewDir = new FieldDescriptor(
StructFields.Varyings.name, "normalViewDir", "", ShaderValueType.Float4, "TEXCOORD3", "defined(_NORMALMAP) && !defined(ENABLE_TERRAIN_PERPIXEL_NORMAL)", StructFieldOptions.Optional);
public static FieldDescriptor tangentViewDir = new FieldDescriptor(
StructFields.Varyings.name, "tangentViewDir", "", ShaderValueType.Float4, "TEXCOORD4", "defined(_NORMALMAP) && !defined(ENABLE_TERRAIN_PERPIXEL_NORMAL)", StructFieldOptions.Optional);
public static FieldDescriptor bitangentViewDir = new FieldDescriptor(
StructFields.Varyings.name, "bitangentViewDir", "", ShaderValueType.Float4, "TEXCOORD5", "defined(_NORMALMAP) && !defined(ENABLE_TERRAIN_PERPIXEL_NORMAL)", StructFieldOptions.Optional);
}
public struct SurfaceDescriptionInputs
{
public static FieldDescriptor uvSplat01 = new FieldDescriptor(
StructFields.SurfaceDescriptionInputs.name, "uvSplat01", "", ShaderValueType.Float4, "TEXCOORD1", "defined(UNIVERSAL_TERRAIN_SPLAT01)");
public static FieldDescriptor uvSplat23 = new FieldDescriptor(
StructFields.SurfaceDescriptionInputs.name, "uvSplat23", "", ShaderValueType.Float4, "TEXCOORD2", "defined(UNIVERSAL_TERRAIN_SPLAT23)");
}
}
internal static class TerrainStructs
{
public static StructDescriptor Attributes = new StructDescriptor()
{
name = "Attributes",
packFields = false,
fields = new FieldDescriptor[]
{
StructFields.Attributes.positionOS,
StructFields.Attributes.normalOS,
StructFields.Attributes.uv0,
StructFields.Attributes.uv1,
StructFields.Attributes.uv2,
StructFields.Attributes.uv3,
StructFields.Attributes.color,
StructFields.Attributes.instanceID,
StructFields.Attributes.vertexID,
}
};
public static StructDescriptor MetaAttributes = new StructDescriptor()
{
name = "Attributes",
packFields = false,
fields = new FieldDescriptor[]
{
StructFields.Attributes.positionOS,
StructFields.Attributes.normalOS,
StructFields.Attributes.uv0,
StructFields.Attributes.uv1,
StructFields.Attributes.uv2,
StructFields.Attributes.uv3,
StructFields.Attributes.color,
StructFields.Attributes.instanceID,
StructFields.Attributes.vertexID,
}
};
public static StructDescriptor Varyings = new StructDescriptor()
{
name = "Varyings",
packFields = true,
populateWithCustomInterpolators = true,
fields = new FieldDescriptor[]
{
StructFields.Varyings.positionCS,
StructFields.Varyings.positionWS,
StructFields.Varyings.normalWS,
StructFields.Varyings.tangentWS,
StructFields.Varyings.texCoord0,
StructFields.Varyings.texCoord1,
StructFields.Varyings.texCoord2,
StructFields.Varyings.texCoord3,
StructFields.Varyings.color,
StructFields.Varyings.screenPosition,
TerrainStructFields.Varyings.uvSplat01,
TerrainStructFields.Varyings.uvSplat23,
TerrainStructFields.Varyings.normalViewDir,
TerrainStructFields.Varyings.tangentViewDir,
TerrainStructFields.Varyings.bitangentViewDir,
UniversalStructFields.Varyings.staticLightmapUV,
UniversalStructFields.Varyings.dynamicLightmapUV,
UniversalStructFields.Varyings.sh,
UniversalStructFields.Varyings.fogFactorAndVertexLight,
UniversalStructFields.Varyings.shadowCoord,
StructFields.Varyings.instanceID,
UniversalStructFields.Varyings.stereoTargetEyeIndexAsBlendIdx0,
UniversalStructFields.Varyings.stereoTargetEyeIndexAsRTArrayIdx,
StructFields.Varyings.cullFace,
}
};
public static StructDescriptor MetaVaryings = new StructDescriptor()
{
name = "Varyings",
packFields = true,
populateWithCustomInterpolators = true,
fields = new FieldDescriptor[]
{
StructFields.Varyings.positionCS,
StructFields.Varyings.positionWS,
StructFields.Varyings.normalWS,
StructFields.Varyings.tangentWS,
StructFields.Varyings.texCoord0,
StructFields.Varyings.texCoord1,
StructFields.Varyings.texCoord2,
StructFields.Varyings.texCoord3,
StructFields.Varyings.color,
StructFields.Varyings.screenPosition,
TerrainStructFields.Varyings.uvSplat01,
TerrainStructFields.Varyings.uvSplat23,
TerrainStructFields.Varyings.normalViewDir,
TerrainStructFields.Varyings.tangentViewDir,
TerrainStructFields.Varyings.bitangentViewDir,
UniversalStructFields.Varyings.staticLightmapUV,
UniversalStructFields.Varyings.dynamicLightmapUV,
UniversalStructFields.Varyings.sh,
UniversalStructFields.Varyings.fogFactorAndVertexLight,
UniversalStructFields.Varyings.shadowCoord,
StructFields.Varyings.instanceID,
UniversalStructFields.Varyings.stereoTargetEyeIndexAsBlendIdx0,
UniversalStructFields.Varyings.stereoTargetEyeIndexAsRTArrayIdx,
StructFields.Varyings.cullFace,
}
};
private static StructDescriptor SurfaceDescriptionInputsImpl()
{
var surfaceDescriptionInputs = Structs.SurfaceDescriptionInputs;
var terrainFieldList = new List<FieldDescriptor>();
for (int i = 0; i < surfaceDescriptionInputs.fields.Length; ++i)
terrainFieldList.Add(surfaceDescriptionInputs.fields[i]);
terrainFieldList.Add(TerrainStructFields.SurfaceDescriptionInputs.uvSplat01);
terrainFieldList.Add(TerrainStructFields.SurfaceDescriptionInputs.uvSplat23);
return new StructDescriptor()
{
name = "SurfaceDescriptionInputs",
packFields = false,
populateWithCustomInterpolators = true,
fields = terrainFieldList.ToArray(),
};
}
public static StructDescriptor SurfaceDescriptionInputs => SurfaceDescriptionInputsImpl();
}
static class TerrainStructCollections
{
public static readonly StructCollection Default = new StructCollection
{
{ TerrainStructs.Attributes },
{ TerrainStructs.Varyings },
{ Structs.VertexDescriptionInputs },
{ TerrainStructs.SurfaceDescriptionInputs },
};
public static readonly StructCollection Meta = new StructCollection()
{
{ TerrainStructs.MetaAttributes },
{ TerrainStructs.MetaVaryings },
{ Structs.VertexDescriptionInputs },
{ TerrainStructs.SurfaceDescriptionInputs },
};
}
#endregion
#region SubShader
static class TerrainSubShaders
{
public static readonly KeywordDescriptor AlphaTestOn = new KeywordDescriptor()
{
displayName = ShaderKeywordStrings._ALPHATEST_ON,
referenceName = ShaderKeywordStrings._ALPHATEST_ON,
type = KeywordType.Boolean,
definition = KeywordDefinition.MultiCompile,
scope = KeywordScope.Global,
};
// SM 4.5, compute with dots instancing
public static SubShaderDescriptor LitComputeDotsSubShader(UniversalTarget target, string renderType, string renderQueue, bool blendModePreserveSpecular)
{
SubShaderDescriptor result = new SubShaderDescriptor()
{
pipelineTag = UniversalTarget.kPipelineTag,
customTags = string.Concat(UniversalTarget.kLitMaterialTypeTag, UniversalTarget.kTerrainMaterialTypeTag),
renderType = renderType,
renderQueue = renderQueue,
generatesPreview = true,
passes = new PassCollection(),
shaderDependencies = new List<ShaderDependency>(),
};
result.passes.Add(TerrainLitPasses.Forward(target, blendModePreserveSpecular, TerrainCorePragmas.DOTSForward));
result.passes.Add(TerrainLitPasses.GBuffer(target, blendModePreserveSpecular));
// cull the shadowcaster pass if we know it will never be used
if (target.castShadows || target.allowMaterialOverride)
result.passes.Add(PassVariant(TerrainLitPasses.ShadowCaster(target), TerrainCorePragmas.DOTSInstanced));
if (target.mayWriteDepth)
result.passes.Add(PassVariant(TerrainLitPasses.DepthOnly(target), TerrainCorePragmas.DOTSInstanced));
result.passes.Add(PassVariant(TerrainLitPasses.DepthNormal(target), TerrainCorePragmas.DOTSInstanced));
result.passes.Add(PassVariant(TerrainLitPasses.Meta(target), TerrainCorePragmas.DOTSInstanced));
// Currently neither of these passes (selection/picking) can be last for the game view for
// UI shaders to render correctly. Verify [1352225] before changing this order.
result.passes.Add(PassVariant(TerrainLitPasses.SceneSelection(target), TerrainCorePragmas.DOTSDefault));
result.passes.Add(PassVariant(TerrainLitPasses.ScenePicking(target), TerrainCorePragmas.DOTSDefault));
result.shaderDependencies.Add(TerrainDependencies.AddPassShader());
result.shaderDependencies.Add(TerrainDependencies.BaseMapShader());
result.shaderDependencies.Add(TerrainDependencies.BaseMapGenShader());
return result;
}
public static SubShaderDescriptor LitGLESSubShader(UniversalTarget target, string renderType, string renderQueue, bool blendModePreserveSpecular)
{
// SM 2.0, GLES
// ForwardOnly pass is used as complex Lit SM 2.0 fallback for GLES.
// Drops advanced features and renders materials as Lit.
SubShaderDescriptor result = new SubShaderDescriptor()
{
pipelineTag = UniversalTarget.kPipelineTag,
customTags = string.Concat(UniversalTarget.kLitMaterialTypeTag, UniversalTarget.kTerrainMaterialTypeTag),
renderType = renderType,
renderQueue = renderQueue,
generatesPreview = true,
passes = new PassCollection(),
shaderDependencies = new List<ShaderDependency>(),
};
result.passes.Add(TerrainLitPasses.Forward(target, blendModePreserveSpecular));
// cull the shadowcaster pass if we know it will never be used
if (target.castShadows || target.allowMaterialOverride)
result.passes.Add(TerrainLitPasses.ShadowCaster(target));
if (target.mayWriteDepth)
result.passes.Add(TerrainLitPasses.DepthOnly(target));
result.passes.Add(TerrainLitPasses.DepthNormal(target));
result.passes.Add(TerrainLitPasses.Meta(target));
// Currently neither of these passes (selection/picking) can be last for the game view for
// UI shaders to render correctly. Verify [1352225] before changing this order.
result.passes.Add(TerrainLitPasses.SceneSelection(target));
result.passes.Add(TerrainLitPasses.ScenePicking(target));
result.shaderDependencies.Add(TerrainDependencies.AddPassShader());
result.shaderDependencies.Add(TerrainDependencies.BaseMapShader());
result.shaderDependencies.Add(TerrainDependencies.BaseMapGenShader());
return result;
}
}
#endregion
#region Pragmas
static class TerrainCorePragmas
{
private static InstancingOptions[] InstancingOptionList()
{
return new []
{
InstancingOptions.AssumeUniformScaling,
InstancingOptions.NoMatrices,
InstancingOptions.NoLightProbe,
InstancingOptions.NoLightmap,
};
}
public static readonly PragmaCollection Default = new PragmaCollection
{
{ Pragma.Target(ShaderModel.Target20) },
{ Pragma.OnlyRenderers(new[] { Platform.GLES3, Platform.GLCore, Platform.D3D11 }) },
{ Pragma.MultiCompileInstancing },
{ Pragma.InstancingOptions(InstancingOptionList()) },
{ Pragma.Vertex("vert") },
{ Pragma.Fragment("frag") },
};
public static readonly PragmaCollection Instanced = new PragmaCollection
{
{ Pragma.Target(ShaderModel.Target20) },
{ Pragma.OnlyRenderers(new[] { Platform.GLES3, Platform.GLCore, Platform.D3D11 }) },
{ Pragma.MultiCompileInstancing },
{ Pragma.InstancingOptions(InstancingOptionList()) },
{ Pragma.Vertex("vert") },
{ Pragma.Fragment("frag") },
};
public static readonly PragmaCollection Forward = new PragmaCollection
{
{ Pragma.Target(ShaderModel.Target20) },
{ Pragma.OnlyRenderers(new[] { Platform.GLES3, Platform.GLCore, Platform.D3D11 }) },
{ Pragma.MultiCompileInstancing },
{ Pragma.MultiCompileFog },
{ Pragma.InstancingOptions(InstancingOptionList()) },
{ Pragma.Vertex("vert") },
{ Pragma.Fragment("frag") },
};
public static readonly PragmaCollection DOTSDefault = new PragmaCollection
{
{ Pragma.Target(ShaderModel.Target45) },
{ Pragma.ExcludeRenderers(new[] { Platform.GLES3, Platform.GLCore }) },
{ Pragma.MultiCompileInstancing },
{ Pragma.InstancingOptions(InstancingOptionList()) },
{ Pragma.Vertex("vert") },
{ Pragma.Fragment("frag") },
};
public static readonly PragmaCollection DOTSInstanced = new PragmaCollection
{
{ Pragma.Target(ShaderModel.Target45) },
{ Pragma.ExcludeRenderers(new[] { Platform.GLES3, Platform.GLCore }) },
{ Pragma.MultiCompileInstancing },
{ Pragma.InstancingOptions(InstancingOptionList()) },
{ Pragma.DOTSInstancing },
{ Pragma.Vertex("vert") },
{ Pragma.Fragment("frag") },
};
public static readonly PragmaCollection DOTSForward = new PragmaCollection
{
{ Pragma.Target(ShaderModel.Target45) },
{ Pragma.ExcludeRenderers(new[] {Platform.GLES3, Platform.GLCore}) },
{ Pragma.MultiCompileInstancing },
{ Pragma.MultiCompileFog },
{ Pragma.InstancingOptions(InstancingOptionList()) },
{ Pragma.DOTSInstancing },
{ Pragma.Vertex("vert") },
{ Pragma.Fragment("frag") },
};
public static readonly PragmaCollection DOTSGBuffer = new PragmaCollection
{
{ Pragma.Target(ShaderModel.Target45) },
{ Pragma.ExcludeRenderers(new[] { Platform.GLES3, Platform.GLCore }) },
{ Pragma.MultiCompileInstancing },
{ Pragma.MultiCompileFog },
{ Pragma.InstancingOptions(InstancingOptionList()) },
{ Pragma.DOTSInstancing },
{ Pragma.Vertex("vert") },
{ Pragma.Fragment("frag") },
};
}
#endregion
private static RenderStateCollection GetTerrainRenderState(UniversalTarget target)
{
var result = new RenderStateCollection
{
RenderState.ZTest(target.zTestMode.ToString()),
RenderState.Cull(Cull.Back),
RenderState.Blend(Blend.One, Blend.Zero)
};
switch (target.zWriteControl)
{
case ZWriteControl.Auto:
case ZWriteControl.ForceEnabled:
result.Add(RenderState.ZWrite(ZWrite.On));
break;
default:
result.Add(RenderState.ZWrite(ZWrite.Off));
break;
}
return result;
}
#region Passes
internal static class TerrainLitPasses
{
private static void AddReceiveShadowsControlToPass(ref PassDescriptor pass, UniversalTarget target, bool receiveShadows)
{
if (!receiveShadows)
pass.defines.Add(TerrainLitKeywords.ReceiveShadowsOff, 1);
}
public static PassDescriptor Forward(UniversalTarget target, bool blendModePreserveSpecular, PragmaCollection pragmas = null)
{
var result = new PassDescriptor()
{
// Definition
displayName = "Universal Forward",
referenceName = "SHADERPASS_FORWARD",
lightMode = "UniversalForward",
useInPreview = true,
// Template
passTemplatePath = TerrainLitTemplate.kPassTemplate,
sharedTemplateDirectories = TerrainLitTemplate.kSharedTemplateDirectories,
// Port Mask
validVertexBlocks = TerrainBlockMasks.Vertex,
validPixelBlocks = TerrainBlockMasks.FragmentLit,
// Fields
structs = TerrainStructCollections.Default,
requiredFields = TerrainRequiredFields.Forward,
fieldDependencies = CoreFieldDependencies.Default,
// Conditional State
renderStates = GetTerrainRenderState(target),
pragmas = pragmas ?? TerrainCorePragmas.Forward,
defines = new DefineCollection() { CoreDefines.UseFragmentFog, },
keywords = new KeywordCollection() { TerrainLitKeywords.Forward },
includes = TerrainCoreIncludes.Forward,
// Custom Interpolator Support
customInterpolators = CoreCustomInterpDescriptors.Common
};
result.defines.Add(TerrainDefines.TerrainEnabled, 1);
result.defines.Add(TerrainDefines.TerrainSplat01, 1);
result.defines.Add(TerrainDefines.TerrainSplat23, 1);
result.keywords.Add(TerrainDefines.TerrainNormalmap);
result.keywords.Add(TerrainDefines.TerrainMaskmap);
result.keywords.Add(TerrainDefines.TerrainInstancedPerPixelNormal);
result.defines.Add(TerrainDefines.MetallicSpecGlossMap, 1);
result.defines.Add(TerrainDefines.SmoothnessTextureAlbedoChannelA, 1);
result.defines.Add(TerrainDefines.TerrainAlphaClipEnable, target.alphaClip?1:0);
CorePasses.AddAlphaClipControlToPass(ref result, target);
AddReceiveShadowsControlToPass(ref result, target, target.receiveShadows);
return result;
}
// Deferred only in SM4.5, MRT not supported in GLES2
public static PassDescriptor GBuffer(UniversalTarget target, bool blendModePreserveSpecular)
{
var result = new PassDescriptor
{
// Definition
displayName = "GBuffer",
referenceName = "SHADERPASS_GBUFFER",
lightMode = "UniversalGBuffer",
// Template
passTemplatePath = TerrainLitTemplate.kPassTemplate,
sharedTemplateDirectories = TerrainLitTemplate.kSharedTemplateDirectories,
// Port Mask
validVertexBlocks = TerrainBlockMasks.Vertex,
validPixelBlocks = TerrainBlockMasks.FragmentLit,
// Fields
structs = TerrainStructCollections.Default,
requiredFields = TerrainRequiredFields.GBuffer,
fieldDependencies = CoreFieldDependencies.Default,
// Conditional State
renderStates = GetTerrainRenderState(target),
pragmas = TerrainCorePragmas.DOTSGBuffer,
defines = new DefineCollection() { CoreDefines.UseFragmentFog },
keywords = new KeywordCollection() { TerrainLitKeywords.GBuffer },
includes = TerrainCoreIncludes.GBuffer,
// Custom Interpolator Support
customInterpolators = CoreCustomInterpDescriptors.Common
};
result.defines.Add(TerrainDefines.TerrainEnabled, 1);
result.defines.Add(TerrainDefines.TerrainSplat01, 1);
result.defines.Add(TerrainDefines.TerrainSplat23, 1);
result.keywords.Add(TerrainDefines.TerrainNormalmap);
result.keywords.Add(TerrainDefines.TerrainMaskmap);
result.keywords.Add(TerrainDefines.TerrainInstancedPerPixelNormal);
result.defines.Add(TerrainDefines.MetallicSpecGlossMap, 1);
result.defines.Add(TerrainDefines.SmoothnessTextureAlbedoChannelA, 1);
result.defines.Add(TerrainDefines.TerrainAlphaClipEnable, target.alphaClip?1:0);
CorePasses.AddAlphaClipControlToPass(ref result, target);
AddReceiveShadowsControlToPass(ref result, target, target.receiveShadows);
return result;
}
public static PassDescriptor ShadowCaster(UniversalTarget target)
{
var result = new PassDescriptor()
{
// Definition
displayName = "ShadowCaster",
referenceName = "SHADERPASS_SHADOWCASTER",
lightMode = "ShadowCaster",
// Template
passTemplatePath = TerrainLitTemplate.kPassTemplate,
sharedTemplateDirectories = TerrainLitTemplate.kSharedTemplateDirectories,
// Port Mask
validVertexBlocks = TerrainBlockMasks.Vertex,
validPixelBlocks = CoreBlockMasks.FragmentAlphaOnly,
// Fields
structs = TerrainStructCollections.Default,
requiredFields = TerrainRequiredFields.ShadowCaster,
fieldDependencies = CoreFieldDependencies.Default,
// Conditional State
renderStates = CoreRenderStates.ShadowCaster(target),
pragmas = TerrainCorePragmas.Instanced,
defines = new DefineCollection(),
keywords = new KeywordCollection() { CoreKeywords.ShadowCaster, },
includes = TerrainCoreIncludes.ShadowCaster,
// Custom Interpolator Support
customInterpolators = CoreCustomInterpDescriptors.Common
};
result.defines.Add(TerrainDefines.TerrainEnabled, 1);
result.defines.Add(TerrainDefines.TerrainAlphaClipEnable, target.alphaClip?1:0);
if (target.alphaClip)
result.defines.Add(CoreKeywordDescriptors.AlphaTestOn, 1);
return result;
}
public static PassDescriptor DepthOnly(UniversalTarget target)
{
var result = new PassDescriptor()
{
// Definition
displayName = "DepthOnly",
referenceName = "SHADERPASS_DEPTHONLY",
lightMode = "DepthOnly",
useInPreview = true,
// Template
passTemplatePath = TerrainLitTemplate.kPassTemplate,
sharedTemplateDirectories = TerrainLitTemplate.kSharedTemplateDirectories,
// Port Mask
validVertexBlocks = TerrainBlockMasks.Vertex,
validPixelBlocks = CoreBlockMasks.FragmentAlphaOnly,
// Fields
structs = TerrainStructCollections.Default,
requiredFields = TerrainRequiredFields.DepthOnly,
fieldDependencies = CoreFieldDependencies.Default,
// Conditional State
renderStates = CoreRenderStates.DepthOnly(target),
pragmas = TerrainCorePragmas.Instanced,
defines = new DefineCollection(),
keywords = new KeywordCollection() { },
includes = TerrainCoreIncludes.DepthOnly,
// Custom Interpolator Support
customInterpolators = CoreCustomInterpDescriptors.Common
};
result.defines.Add(TerrainDefines.TerrainEnabled, 1);
result.defines.Add(TerrainDefines.TerrainAlphaClipEnable, target.alphaClip?1:0);
if (target.alphaClip)
result.defines.Add(CoreKeywordDescriptors.AlphaTestOn, 1);
return result;
}
public static PassDescriptor DepthNormal(UniversalTarget target)
{
var result = new PassDescriptor()
{
// Definition
displayName = "DepthNormals",
referenceName = "SHADERPASS_DEPTHNORMALS",
lightMode = "DepthNormals",
useInPreview = false,
// Template
passTemplatePath = TerrainLitTemplate.kPassTemplate,
sharedTemplateDirectories = TerrainLitTemplate.kSharedTemplateDirectories,
// Port Mask
validVertexBlocks = TerrainBlockMasks.Vertex,
validPixelBlocks = CoreBlockMasks.FragmentDepthNormals,
// Fields
structs = TerrainStructCollections.Default,
requiredFields = TerrainRequiredFields.DepthNormals,
fieldDependencies = CoreFieldDependencies.Default,
// Conditional State
renderStates = CoreRenderStates.DepthNormalsOnly(target),
pragmas = TerrainCorePragmas.Instanced,
defines = new DefineCollection(),
keywords = new KeywordCollection() { TerrainSubShaders.AlphaTestOn, },
includes = TerrainCoreIncludes.DepthNormalsOnly,
// Custom Interpolator Support
customInterpolators = CoreCustomInterpDescriptors.Common
};
result.defines.Add(TerrainDefines.TerrainEnabled, 1);
result.defines.Add(TerrainDefines.TerrainSplat01, 1);
result.defines.Add(TerrainDefines.TerrainSplat23, 1);
result.defines.Add(TerrainDefines.TerrainAlphaClipEnable, target.alphaClip?1:0);
result.keywords.Add(TerrainDefines.TerrainNormalmap);
result.keywords.Add(TerrainDefines.TerrainInstancedPerPixelNormal);
if (target.alphaClip)
result.defines.Add(CoreKeywordDescriptors.AlphaTestOn, 1);
return result;
}
public static PassDescriptor Meta(UniversalTarget target)
{
var result = new PassDescriptor()
{
// Definition
displayName = "Meta",
referenceName = "SHADERPASS_META",
lightMode = "Meta",
// Template
passTemplatePath = TerrainLitTemplate.kPassTemplate,
sharedTemplateDirectories = TerrainLitTemplate.kSharedTemplateDirectories,
// Port Mask
validVertexBlocks = TerrainBlockMasks.Vertex,
validPixelBlocks = TerrainBlockMasks.FragmentMeta,
// Fields
structs = TerrainStructCollections.Meta,
requiredFields = TerrainRequiredFields.Meta,
fieldDependencies = CoreFieldDependencies.Default,
// Conditional State
renderStates = CoreRenderStates.Meta,
pragmas = TerrainCorePragmas.Default,
defines = new DefineCollection() { CoreDefines.UseFragmentFog },
keywords = new KeywordCollection() { CoreKeywordDescriptors.EditorVisualization, TerrainSubShaders.AlphaTestOn, },
includes = TerrainCoreIncludes.Meta,
// Custom Interpolator Support
customInterpolators = CoreCustomInterpDescriptors.Common
};
result.defines.Add(TerrainDefines.TerrainEnabled, 1);
result.defines.Add(TerrainDefines.TerrainSplat01, 1);
result.defines.Add(TerrainDefines.TerrainSplat23, 1);
result.defines.Add(TerrainDefines.MetallicSpecGlossMap, 1);
result.defines.Add(TerrainDefines.SmoothnessTextureAlbedoChannelA, 1);
result.defines.Add(TerrainDefines.TerrainAlphaClipEnable, target.alphaClip?1:0);
if (target.alphaClip)
result.defines.Add(CoreKeywordDescriptors.AlphaTestOn, 1);
return result;
}
public static PassDescriptor SceneSelection(UniversalTarget target)
{
var result = new PassDescriptor()
{
// Definition
displayName = "SceneSelectionPass",
referenceName = "SHADERPASS_DEPTHONLY",
lightMode = "SceneSelectionPass",
useInPreview = false,
// Template
passTemplatePath = TerrainLitTemplate.kPassTemplate,
sharedTemplateDirectories = TerrainLitTemplate.kSharedTemplateDirectories,
// Port Mask
validVertexBlocks = TerrainBlockMasks.Vertex,
validPixelBlocks = CoreBlockMasks.FragmentAlphaOnly,
// Fields
structs = TerrainStructCollections.Default,
requiredFields = TerrainRequiredFields.DepthOnly,
fieldDependencies = CoreFieldDependencies.Default,
// Conditional State
renderStates = CoreRenderStates.SceneSelection(target),
pragmas = TerrainCorePragmas.Default,
defines = new DefineCollection { CoreDefines.SceneSelection, },
keywords = new KeywordCollection() { TerrainSubShaders.AlphaTestOn, },
includes = TerrainCoreIncludes.SceneSelection,
// Custom Interpolator Support
customInterpolators = CoreCustomInterpDescriptors.Common
};
result.defines.Add(TerrainDefines.TerrainEnabled, 1);
result.defines.Add(TerrainDefines.TerrainAlphaClipEnable, target.alphaClip?1:0);
if (target.alphaClip)
result.defines.Add(CoreKeywordDescriptors.AlphaTestOn, 1);
return result;
}
public static PassDescriptor ScenePicking(UniversalTarget target)
{
var result = new PassDescriptor()
{
// Definition
displayName = "ScenePickingPass",
referenceName = "SHADERPASS_DEPTHONLY",
lightMode = "Picking",
useInPreview = false,
// Template
passTemplatePath = TerrainLitTemplate.kPassTemplate,
sharedTemplateDirectories = TerrainLitTemplate.kSharedTemplateDirectories,
// Port Mask
validVertexBlocks = TerrainBlockMasks.Vertex,
validPixelBlocks = CoreBlockMasks.FragmentAlphaOnly,
// Fields
structs = TerrainStructCollections.Default,
requiredFields = TerrainRequiredFields.DepthOnly,
fieldDependencies = CoreFieldDependencies.Default,
// Conditional State
renderStates = CoreRenderStates.ScenePicking(target),
pragmas = TerrainCorePragmas.Default,
defines = new DefineCollection { CoreDefines.ScenePicking, },
keywords = new KeywordCollection() { TerrainSubShaders.AlphaTestOn, },
includes = TerrainCoreIncludes.ScenePicking,
// Custom Interpolator Support
customInterpolators = CoreCustomInterpDescriptors.Common
};
result.defines.Add(TerrainDefines.TerrainEnabled, 1);
result.defines.Add(TerrainDefines.TerrainAlphaClipEnable, target.alphaClip?1:0);
if (target.alphaClip)
result.defines.Add(CoreKeywordDescriptors.AlphaTestOn, 1);
return result;
}
}
#endregion
#region Dependencies
static class TerrainDependencies
{
public static ShaderDependency AddPassShader()
{
return new ShaderDependency()
{
dependencyName = "AddPassShader",
shaderName = "Hidden/{Name}_AddPass",
};
}
public static ShaderDependency BaseMapShader()
{
return new ShaderDependency()
{
dependencyName = "BaseMapShader",
shaderName = "Hidden/Universal Render Pipeline/Terrain/Lit (Base Pass)",
};
}
public static ShaderDependency BaseMapGenShader()
{
return new ShaderDependency()
{
dependencyName = "BaseMapGenShader",
shaderName = "Hidden/{Name}_BaseMapGen",
};
}
}
#endregion
#region PortMasks
static class TerrainBlockMasks
{
public static readonly BlockFieldDescriptor[] Vertex = new BlockFieldDescriptor[]
{
BlockFields.VertexDescription.Position,
};
public static readonly BlockFieldDescriptor[] FragmentLit = new BlockFieldDescriptor[]
{
BlockFields.SurfaceDescription.BaseColor,
BlockFields.SurfaceDescription.NormalOS,
BlockFields.SurfaceDescription.NormalTS,
BlockFields.SurfaceDescription.NormalWS,
BlockFields.SurfaceDescription.Emission,
BlockFields.SurfaceDescription.Metallic,
BlockFields.SurfaceDescription.Smoothness,
BlockFields.SurfaceDescription.Occlusion,
BlockFields.SurfaceDescription.Alpha,
BlockFields.SurfaceDescription.AlphaClipThreshold,
};
public static readonly BlockFieldDescriptor[] FragmentMeta = new BlockFieldDescriptor[]
{
BlockFields.SurfaceDescription.BaseColor,
BlockFields.SurfaceDescription.Emission,
BlockFields.SurfaceDescription.Alpha,
BlockFields.SurfaceDescription.AlphaClipThreshold,
};
}
#endregion
#region RequiredField
static class TerrainRequiredFields
{
public static readonly FieldCollection Forward = new FieldCollection()
{
StructFields.Attributes.uv0,
StructFields.Attributes.instanceID,
StructFields.Varyings.positionWS,
StructFields.Varyings.normalWS,
StructFields.Varyings.texCoord0,
StructFields.Varyings.instanceID,
TerrainStructFields.Varyings.uvSplat01,
TerrainStructFields.Varyings.uvSplat23,
TerrainStructFields.Varyings.normalViewDir,
TerrainStructFields.Varyings.tangentViewDir,
TerrainStructFields.Varyings.bitangentViewDir,
UniversalStructFields.Varyings.staticLightmapUV,
UniversalStructFields.Varyings.dynamicLightmapUV,
UniversalStructFields.Varyings.sh,
UniversalStructFields.Varyings.fogFactorAndVertexLight, // fog and vertex lighting, vert input is dependency
UniversalStructFields.Varyings.shadowCoord, // shadow coord, vert input is dependency
TerrainStructFields.SurfaceDescriptionInputs.uvSplat01,
TerrainStructFields.SurfaceDescriptionInputs.uvSplat23,
};
public static readonly FieldCollection GBuffer = new FieldCollection()
{
StructFields.Attributes.uv0,
StructFields.Attributes.instanceID,
StructFields.Varyings.positionWS,
StructFields.Varyings.normalWS,
StructFields.Varyings.texCoord0,
StructFields.Varyings.instanceID,
TerrainStructFields.Varyings.uvSplat01,
TerrainStructFields.Varyings.uvSplat23,
TerrainStructFields.Varyings.normalViewDir,
TerrainStructFields.Varyings.tangentViewDir,
TerrainStructFields.Varyings.bitangentViewDir,
UniversalStructFields.Varyings.staticLightmapUV,
UniversalStructFields.Varyings.dynamicLightmapUV,
UniversalStructFields.Varyings.sh,
UniversalStructFields.Varyings.fogFactorAndVertexLight, // fog and vertex lighting, vert input is dependency
UniversalStructFields.Varyings.shadowCoord, // shadow coord, vert input is dependency
TerrainStructFields.SurfaceDescriptionInputs.uvSplat01,
TerrainStructFields.SurfaceDescriptionInputs.uvSplat23,
};
public static readonly FieldCollection ShadowCaster = new FieldCollection()
{
StructFields.Attributes.uv0,
StructFields.Attributes.instanceID,
StructFields.Varyings.texCoord0,
StructFields.Varyings.instanceID,
};
public static readonly FieldCollection DepthOnly = new FieldCollection()
{
StructFields.Attributes.uv0,
StructFields.Attributes.instanceID,
StructFields.Varyings.texCoord0,
StructFields.Varyings.instanceID,
};
public static readonly FieldCollection DepthNormals = new FieldCollection()
{
StructFields.Attributes.uv0,
StructFields.Attributes.instanceID,
StructFields.Varyings.normalWS,
StructFields.Varyings.texCoord0,
StructFields.Varyings.instanceID,
TerrainStructFields.Varyings.uvSplat01,
TerrainStructFields.Varyings.uvSplat23,
TerrainStructFields.Varyings.normalViewDir,
TerrainStructFields.Varyings.tangentViewDir,
TerrainStructFields.Varyings.bitangentViewDir,
TerrainStructFields.SurfaceDescriptionInputs.uvSplat01,
TerrainStructFields.SurfaceDescriptionInputs.uvSplat23,
};
public static readonly FieldCollection Meta = new FieldCollection()
{
StructFields.Attributes.positionOS,
StructFields.Attributes.normalOS,
StructFields.Attributes.uv0, //
StructFields.Attributes.uv1, // needed for meta vertex position
StructFields.Attributes.uv2, // needed for meta UVs
StructFields.Attributes.instanceID, // needed for rendering instanced terrain
TerrainStructFields.Varyings.uvSplat01,
TerrainStructFields.Varyings.uvSplat23,
StructFields.Varyings.positionCS,
StructFields.Varyings.texCoord0, // needed for meta UVs
StructFields.Varyings.texCoord1, // VizUV
StructFields.Varyings.texCoord2, // LightCoord
StructFields.Varyings.instanceID,
TerrainStructFields.SurfaceDescriptionInputs.uvSplat01,
TerrainStructFields.SurfaceDescriptionInputs.uvSplat23,
};
}
#endregion
#region Defines
static class TerrainDefines
{
public static readonly KeywordDescriptor TerrainEnabled = new KeywordDescriptor()
{
displayName = "Universal Terrain",
referenceName = "UNIVERSAL_TERRAIN_ENABLED",
type = KeywordType.Boolean,
definition = KeywordDefinition.Predefined,
scope = KeywordScope.Local,
};
public static readonly KeywordDescriptor TerrainSplat01 = new KeywordDescriptor()
{
displayName = "Universal Terrain Splat01",
referenceName = "UNIVERSAL_TERRAIN_SPLAT01",
type = KeywordType.Boolean,
definition = KeywordDefinition.Predefined,
scope = KeywordScope.Local,
};
public static readonly KeywordDescriptor TerrainSplat23 = new KeywordDescriptor()
{
displayName = "Universal Terrain Splat23",
referenceName = "UNIVERSAL_TERRAIN_SPLAT23",
type = KeywordType.Boolean,
definition = KeywordDefinition.Predefined,
scope = KeywordScope.Local,
};
public static readonly KeywordDescriptor TerrainAddPass = new KeywordDescriptor()
{
displayName = "Universal Terrain AddPass",
referenceName = "TERRAIN_SPLAT_ADDPASS",
type = KeywordType.Boolean,
definition = KeywordDefinition.Predefined,
scope = KeywordScope.Local,
};
public static KeywordDescriptor TerrainNormalmap = new KeywordDescriptor()
{
displayName = "Terrain Normal Map",
referenceName = "_NORMALMAP",
type = KeywordType.Boolean,
definition = KeywordDefinition.ShaderFeature,
scope = KeywordScope.Local,
};
public static KeywordDescriptor TerrainMaskmap = new KeywordDescriptor()
{
displayName = "Terrain Mask Map",
referenceName = "_MASKMAP",
type = KeywordType.Boolean,
definition = KeywordDefinition.ShaderFeature,
scope = KeywordScope.Local,
stages = KeywordShaderStage.Fragment,
};
public static KeywordDescriptor TerrainInstancedPerPixelNormal = new KeywordDescriptor()
{
displayName = "Instanced PerPixel Normal",
referenceName = "_TERRAIN_INSTANCED_PERPIXEL_NORMAL",
type = KeywordType.Boolean,
definition = KeywordDefinition.ShaderFeature,
scope = KeywordScope.Local,
};
public static readonly KeywordDescriptor MetallicSpecGlossMap = new KeywordDescriptor()
{
displayName = "Metallic SpecGloss Map",
referenceName = "_METALLICSPECGLOSSMAP",
type = KeywordType.Boolean,
definition = KeywordDefinition.Predefined,
scope = KeywordScope.Local,
};
public static readonly KeywordDescriptor SmoothnessTextureAlbedoChannelA = new KeywordDescriptor()
{
displayName = "Smoothness Texture Albedo Channel A",
referenceName = "_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A",
type = KeywordType.Boolean,
definition = KeywordDefinition.Predefined,
scope = KeywordScope.Local,
};
public static readonly KeywordDescriptor TerrainBaseMapGen = new KeywordDescriptor()
{
displayName = "Terrain Base Map Generation",
referenceName = "_TERRAIN_BASEMAP_GEN",
type = KeywordType.Boolean,
definition = KeywordDefinition.Predefined,
scope = KeywordScope.Local,
};
public static readonly KeywordDescriptor TerrainAlphaClipEnable = new KeywordDescriptor()
{
displayName = "Terrain Alpha Clip Enable",
referenceName = "_TERRAIN_SG_ALPHA_CLIP",
type = KeywordType.Boolean,
definition = KeywordDefinition.ShaderFeature,
scope = KeywordScope.Local,
stages = KeywordShaderStage.Fragment,
};
}
#endregion
#region Keywords
static class TerrainLitKeywords
{
public static readonly KeywordDescriptor ReceiveShadowsOff = new KeywordDescriptor()
{
displayName = "Receive Shadows Off",
referenceName = ShaderKeywordStrings._RECEIVE_SHADOWS_OFF,
type = KeywordType.Boolean,
definition = KeywordDefinition.ShaderFeature,
scope = KeywordScope.Local,
};
public static readonly KeywordDescriptor ScreenSpaceAmbientOcclusion = new KeywordDescriptor()
{
displayName = "Screen Space Ambient Occlusion",
referenceName = "_SCREEN_SPACE_OCCLUSION",
type = KeywordType.Boolean,
definition = KeywordDefinition.MultiCompile,
scope = KeywordScope.Global,
};
public static readonly KeywordCollection Forward = new KeywordCollection
{
{ ScreenSpaceAmbientOcclusion },
{ CoreKeywordDescriptors.StaticLightmap },
{ CoreKeywordDescriptors.DynamicLightmap },
{ CoreKeywordDescriptors.DirectionalLightmapCombined },
{ CoreKeywordDescriptors.MainLightShadows },
{ CoreKeywordDescriptors.AdditionalLights },
{ CoreKeywordDescriptors.AdditionalLightShadows },
{ CoreKeywordDescriptors.ReflectionProbeBlending },
{ CoreKeywordDescriptors.ReflectionProbeBoxProjection },
{ CoreKeywordDescriptors.ShadowsSoft },
{ CoreKeywordDescriptors.LightmapShadowMixing },
{ CoreKeywordDescriptors.ShadowsShadowmask },
{ CoreKeywordDescriptors.ClusterLightLoop },
{ CoreKeywordDescriptors.DBuffer },
{ CoreKeywordDescriptors.LightLayers },
{ CoreKeywordDescriptors.DebugDisplay },
{ CoreKeywordDescriptors.LightCookies },
};
public static readonly KeywordCollection GBuffer = new KeywordCollection
{
{ CoreKeywordDescriptors.StaticLightmap },
{ CoreKeywordDescriptors.DynamicLightmap },
{ CoreKeywordDescriptors.DirectionalLightmapCombined },
{ CoreKeywordDescriptors.MainLightShadows },
{ CoreKeywordDescriptors.ShadowsSoft },
{ CoreKeywordDescriptors.LightmapShadowMixing },
{ CoreKeywordDescriptors.MixedLightingSubtractive },
{ CoreKeywordDescriptors.DBuffer },
{ CoreKeywordDescriptors.GBufferNormalsOct },
{ CoreKeywordDescriptors.LightLayers },
{ CoreKeywordDescriptors.RenderPassEnabled },
{ CoreKeywordDescriptors.DebugDisplay },
};
}
#endregion
#region Includes
static class TerrainCoreIncludes
{
public static readonly string kVaryings = "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/Varyings.hlsl";
public static readonly string kShaderPass = "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShaderPass.hlsl";
public static readonly string kShadows = "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl";
public static readonly string kMetaInput = "Packages/com.unity.render-pipelines.universal/ShaderLibrary/MetaInput.hlsl";
public static readonly string kDepthOnlyPass = "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/DepthOnlyPass.hlsl";
public static readonly string kDepthNormalsOnlyPass = "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/Terrain/DepthNormalsOnlyPass.hlsl";
public static readonly string kShadowCasterPass = "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShadowCasterPass.hlsl";
public static readonly string kForwardPass = "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/Terrain/PBRForwardPass.hlsl";
public static readonly string kGBuffer = "Packages/com.unity.render-pipelines.universal/ShaderLibrary/GBufferOutput.hlsl";
public static readonly string kPBRGBufferPass = "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/Terrain/PBRGBufferPass.hlsl";
public static readonly string kLightingMetaPass = "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/LightingMetaPass.hlsl";
public static readonly string kSelectionPickingPass = "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/SelectionPickingPass.hlsl";
public static readonly string kTerrainLitInput = "Packages/com.unity.render-pipelines.universal/Shaders/Terrain/TerrainLitInput.hlsl";
public static readonly string kTerrainPassUtils = "Packages/com.unity.render-pipelines.universal/Editor/Terrain/TerrainPassUtils.hlsl";
public static readonly string kRenderingLayers = "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RenderingLayers.hlsl";
public static readonly IncludeCollection CorePostgraph = new IncludeCollection
{
{ kShaderPass, IncludeLocation.Pregraph },
{ kRenderingLayers, IncludeLocation.Pregraph, true },
{ kVaryings, IncludeLocation.Postgraph },
};
public static readonly IncludeCollection Forward = new IncludeCollection
{
// Pre-graph
{ CoreIncludes.CorePregraph },
{ TerrainCoreIncludes.kShadows, IncludeLocation.Pregraph },
{ CoreIncludes.ShaderGraphPregraph },
{ CoreIncludes.DBufferPregraph },
{ TerrainCoreIncludes.kTerrainLitInput, IncludeLocation.Pregraph },
{ TerrainCoreIncludes.kTerrainPassUtils, IncludeLocation.Pregraph },
// Post-graph
{ TerrainCoreIncludes.CorePostgraph },
{ TerrainCoreIncludes.kForwardPass, IncludeLocation.Postgraph },
};
public static readonly IncludeCollection DepthOnly = new IncludeCollection
{
// Pre-graph
{ CoreIncludes.CorePregraph },
{ CoreIncludes.ShaderGraphPregraph },
{ TerrainCoreIncludes.kTerrainLitInput, IncludeLocation.Pregraph },
{ TerrainCoreIncludes.kTerrainPassUtils, IncludeLocation.Pregraph },
// Post-graph
{ TerrainCoreIncludes.CorePostgraph },
{ TerrainCoreIncludes.kDepthOnlyPass, IncludeLocation.Postgraph },
};
public static readonly IncludeCollection DepthNormalsOnly = new IncludeCollection
{
// Pre-graph
{ CoreIncludes.CorePregraph },
{ CoreIncludes.ShaderGraphPregraph },
{ TerrainCoreIncludes.kTerrainLitInput, IncludeLocation.Pregraph },
{ TerrainCoreIncludes.kTerrainPassUtils, IncludeLocation.Pregraph },
// Post-graph
{ TerrainCoreIncludes.CorePostgraph },
{ TerrainCoreIncludes.kDepthNormalsOnlyPass, IncludeLocation.Postgraph },
};
public static readonly IncludeCollection ShadowCaster = new IncludeCollection
{
// Pre-graph
{ CoreIncludes.CorePregraph },
{ CoreIncludes.ShaderGraphPregraph },
{ TerrainCoreIncludes.kTerrainLitInput, IncludeLocation.Pregraph },
{ TerrainCoreIncludes.kTerrainPassUtils, IncludeLocation.Pregraph },
// Post-graph
{ TerrainCoreIncludes.CorePostgraph },
{ TerrainCoreIncludes.kShadowCasterPass, IncludeLocation.Postgraph },
};
public static readonly IncludeCollection GBuffer = new IncludeCollection
{
// Pre-graph
{ CoreIncludes.CorePregraph },
{ TerrainCoreIncludes.kShadows, IncludeLocation.Pregraph },
{ CoreIncludes.ShaderGraphPregraph },
{ CoreIncludes.DBufferPregraph },
{ TerrainCoreIncludes.kTerrainLitInput, IncludeLocation.Pregraph },
{ TerrainCoreIncludes.kTerrainPassUtils, IncludeLocation.Pregraph },
// Post-graph
{ TerrainCoreIncludes.CorePostgraph },
{ TerrainCoreIncludes.kGBuffer, IncludeLocation.Postgraph },
{ TerrainCoreIncludes.kPBRGBufferPass, IncludeLocation.Postgraph },
};
public static readonly IncludeCollection Meta = new IncludeCollection
{
// Pre-graph
{ CoreIncludes.CorePregraph },
{ CoreIncludes.ShaderGraphPregraph },
{ TerrainCoreIncludes.kMetaInput, IncludeLocation.Pregraph },
{ TerrainCoreIncludes.kTerrainLitInput, IncludeLocation.Pregraph },
{ TerrainCoreIncludes.kTerrainPassUtils, IncludeLocation.Pregraph },
// Post-graph
{ TerrainCoreIncludes.CorePostgraph },
{ TerrainCoreIncludes.kLightingMetaPass, IncludeLocation.Postgraph },
};
public static readonly IncludeCollection SceneSelection = new IncludeCollection
{
// Pre-graph
{ CoreIncludes.CorePregraph },
{ CoreIncludes.ShaderGraphPregraph },
{ TerrainCoreIncludes.kTerrainLitInput, IncludeLocation.Pregraph },
{ TerrainCoreIncludes.kTerrainPassUtils, IncludeLocation.Pregraph },
// Post-graph
{ TerrainCoreIncludes.CorePostgraph },
{ TerrainCoreIncludes.kSelectionPickingPass, IncludeLocation.Postgraph },
};
public static readonly IncludeCollection ScenePicking = new IncludeCollection
{
// Pre-graph
{ CoreIncludes.CorePregraph },
{ CoreIncludes.ShaderGraphPregraph },
{ TerrainCoreIncludes.kTerrainLitInput, IncludeLocation.Pregraph },
{ TerrainCoreIncludes.kTerrainPassUtils, IncludeLocation.Pregraph },
// Post-graph
{ TerrainCoreIncludes.CorePostgraph },
{ TerrainCoreIncludes.kSelectionPickingPass, IncludeLocation.Postgraph },
};
}
#endregion
}
}