[Feature] Compute Deformation Node

com.unity.render-pipelines.high-definition/Editor/ShaderGraph/HDStructFields.cs

@@ -1,4 +1,4 @@
-using UnityEditor.ShaderGraph;
+using UnityEditor.ShaderGraph;
 
 namespace UnityEditor.Rendering.HighDefinition.ShaderGraph
 {
@@ -28,6 +28,8 @@ public struct AttributesMesh
                 "COLOR", subscriptOptions : StructFieldOptions.Optional);
             public static FieldDescriptor instanceID = new FieldDescriptor(AttributesMesh.name, "instanceID", "", ShaderValueType.Uint,
                 "INSTANCEID_SEMANTIC", "UNITY_ANY_INSTANCING_ENABLED");
+            public static FieldDescriptor vertexID = new FieldDescriptor(AttributesMesh.name, "vertexID", "ATTRIBUTES_NEED_VERTEXID", ShaderValueType.Uint,
+                "SV_VertexID", subscriptOptions: StructFieldOptions.Optional);
         }
 
         public struct VaryingsMeshToPS

com.unity.render-pipelines.high-definition/Editor/ShaderGraph/HDStructs.cs

@@ -1,4 +1,4 @@
-using UnityEditor.ShaderGraph;
+using UnityEditor.ShaderGraph;
 
 namespace UnityEditor.Rendering.HighDefinition.ShaderGraph
 {
@@ -21,6 +21,7 @@ static class HDStructs
                 HDStructFields.AttributesMesh.instanceID,
                 HDStructFields.AttributesMesh.weights,
                 HDStructFields.AttributesMesh.indices,
+                HDStructFields.AttributesMesh.vertexID,
             }
         };
 

com.unity.render-pipelines.high-definition/Editor/ShaderGraph/HDTarget.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEngine.Rendering;
@@ -173,6 +173,7 @@ static class CoreFieldDependencies
 
             new FieldDependency(StructFields.VertexDescriptionInputs.BoneWeights,                   HDStructFields.AttributesMesh.weights),
             new FieldDependency(StructFields.VertexDescriptionInputs.BoneIndices,                   HDStructFields.AttributesMesh.indices),
+            new FieldDependency(StructFields.VertexDescriptionInputs.VertexID,                      HDStructFields.AttributesMesh.vertexID),
         };
 
         public static DependencyCollection SurfaceDescription = new DependencyCollection
@@ -212,6 +213,10 @@ static class CoreFieldDependencies
             new FieldDependency(StructFields.SurfaceDescriptionInputs.FaceSign,                      HDStructFields.FragInputs.IsFrontFace),
 
             new FieldDependency(HDFields.DepthOffset,                                                HDStructFields.FragInputs.positionRWS),
+
+            new FieldDependency(StructFields.SurfaceDescriptionInputs.BoneWeights,                   StructFields.SurfaceDescriptionInputs.BoneIndices),
+            new FieldDependency(StructFields.SurfaceDescriptionInputs.BoneIndices,                   StructFields.SurfaceDescriptionInputs.BoneWeights),
+            new FieldDependency(StructFields.SurfaceDescriptionInputs.VertexID,                      StructFields.SurfaceDescriptionInputs.VertexID),
         };
 
         public static DependencyCollection Default = new DependencyCollection

com.unity.render-pipelines.high-definition/Editor/ShaderGraph/Templates/VertexAnimation.template.hlsl

@@ -34,6 +34,7 @@ VertexDescriptionInputs AttributesMeshToVertexDescriptionInputs(AttributesMesh i
     $VertexDescriptionInputs.VertexColor:               output.VertexColor =                 input.color;
     $VertexDescriptionInputs.BoneWeights:               output.BoneWeights =                 input.weights;
     $VertexDescriptionInputs.BoneIndices:               output.BoneIndices =                 input.indices;
+    $VertexDescriptionInputs.VertexID:					output.VertexID =                    input.vertexID;
 
     return output;
 }

com.unity.shadergraph/CHANGELOG.md

@@ -25,11 +25,13 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Added AlphaToMask render state.
 - Added a field to the Master Nodes that overrides the generated shader's ShaderGUI, which determines how a Material that uses a Shader Graph looks.
 - Added Redirect Nodes. You can now double-click an edge to add a control point that allows you to route edges around other nodes and connect multiple output edges.
+- Added `Compute Deformation` Node to read deformed vertex data from Dots Deformations.
 
 ### Changed
 - Changed the `Branch` node so that it uses a ternary operator (`Out = bool ? a : B`) instead of a linear interpolate function.
 - Copied nodes are now pasted at the cursor location instead of slightly offset from their original location
 - Error messages reported on Sub Graph output nodes for invalid previews now present clearer information, with documentation support.
+- Added support for `Linear Blend Skinning` Node to Universal Render Pipeline.
 
 ### Fixed
 - Edges no longer produce errors when you save a Shader Graph.
@@ -91,6 +93,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Fixed a bug where the `Position` node would change coordinate spaces from `World` to `Absolute World` when shaders recompile. [1184617](https://issuetracker.unity3d.com/product/unity/issues/guid/1184617/)
 - Fixed a bug where instanced shaders wouldn't compile on PS4.
 - Optimized loading a large Shader Graph. [1209047](https://issuetracker.unity3d.com/issues/shader-graph-unresponsive-editor-when-using-large-graphs)
+- Fixed issue where `Linear Blend Skinning` node could not be converted to Sub Graph [1227087](https://issuetracker.unity3d.com/issues/shadergraph-linear-blend-skinning-node-reports-an-error-and-prevents-shader-compilation-when-used-within-a-sub-graph)
 
 ## [7.1.1] - 2019-09-05
 ### Added

com.unity.shadergraph/Documentation~/Compute-Deformation-Node.md

@@ -0,0 +1,12 @@
+# Compute Deformation Node
+
+## Description
+
+This node lets you pass compute deformed data to a vertex shader. You must provide `DeformedVertexData` in the `_DeformedMeshData` buffer. The node uses the `_ComputeMeshIndex` property to calculate where the `DeformedVertexData` associated with the current mesh are located in the `_DeformedMeshData` buffer. To output data, you must either install both the DOTS Hybrid Renderer and DOTS Animation packages, or use a custom solution.
+
+## Ports
+| Name         | Direction  | Type    | Stage  | Description |
+|:------------ |:-----------|:--------|:-------|:------------|
+| OutPosition  | Output     | Vector3 | Vertex | Outputs the deformed position |
+| OutNormal    | Output     | Vector3 | Vertex | Outputs the deformed normal |
+| OutTangent   | Output     | Vector3 | Vertex | Outputs the deformed tangent |

com.unity.shadergraph/Documentation~/Linear-Blend-Skinning-Node.md

@@ -0,0 +1,12 @@
+# Linear Blend Skinning Node
+
+## Description
+
+This node lets you authorize Linear Blend Vertex Skinning, and is only available in the High Definition Render Pipeline (HDRP). You must provide skinned matrices in the `_SkinMatrices` buffer. The node uses the `_SkinMatrixIndex` property to calculate where the matrices associated with the current mesh are located in the `_SkinMatrices` buffer.
+
+## Ports
+| Name         | Direction  | Type    | Stage  | Description |
+|:------------ |:-----------|:--------|:-------|:------------|
+| OutPosition  | Output     | Vector3 | Vertex | Outputs the skinned position |
+| OutNormal    | Output     | Vector3 | Vertex | Outputs the skinned normal |
+| OutTangent   | Output     | Vector3 | Vertex | Outputs the skinned tangent |

com.unity.shadergraph/Editor/Data/Graphs/ShaderGraphRequirements.cs

@@ -21,6 +21,7 @@ public struct ShaderGraphRequirements
         [SerializeField] bool m_RequiresCameraOpaqueTexture;
         [SerializeField] bool m_RequiresTime;
         [SerializeField] bool m_RequiresVertexSkinning;
+        [SerializeField] bool m_RequiresVertexID;
 
         internal static ShaderGraphRequirements none
         {
@@ -111,6 +112,12 @@ public bool requiresVertexSkinning
             internal set { m_RequiresVertexSkinning = value; }
         }
 
+        public bool requiresVertexID
+        {
+            get { return m_RequiresVertexID; }
+            internal set { m_RequiresVertexID = value; }
+        }
+
         internal bool NeedsTangentSpace()
         {
             var compoundSpaces = m_RequiresBitangent | m_RequiresNormal | m_RequiresPosition
@@ -135,6 +142,7 @@ internal ShaderGraphRequirements Union(ShaderGraphRequirements other)
             newReqs.m_RequiresCameraOpaqueTexture = other.m_RequiresCameraOpaqueTexture | m_RequiresCameraOpaqueTexture;
             newReqs.m_RequiresTime = other.m_RequiresTime | m_RequiresTime;
             newReqs.m_RequiresVertexSkinning = other.m_RequiresVertexSkinning | m_RequiresVertexSkinning;
+            newReqs.m_RequiresVertexID = other.m_RequiresVertexID | m_RequiresVertexID;
 
 
             newReqs.m_RequiresMeshUVs = new List<UVChannel>();
@@ -160,6 +168,7 @@ internal static ShaderGraphRequirements FromNodes<T>(List<T> nodes, ShaderStageC
             bool requiresCameraOpaqueTexture = nodes.OfType<IMayRequireCameraOpaqueTexture>().Any(x => x.RequiresCameraOpaqueTexture());
             bool requiresTime = nodes.Any(x => x.RequiresTime());
             bool requiresVertexSkinning = nodes.OfType<IMayRequireVertexSkinning>().Any(x => x.RequiresVertexSkinning(stageCapability));
+            bool requiresVertexID = nodes.OfType<IMayRequireVertexID>().Any(x => x.RequiresVertexID(stageCapability));
 
             var meshUV = new List<UVChannel>();
             for (int uvIndex = 0; uvIndex < ShaderGeneratorNames.UVCount; ++uvIndex)
@@ -200,10 +209,11 @@ internal static ShaderGraphRequirements FromNodes<T>(List<T> nodes, ShaderStageC
                 m_RequiresDepthTexture = requiresDepthTexture,
                 m_RequiresCameraOpaqueTexture = requiresCameraOpaqueTexture,
                 m_RequiresTime = requiresTime,
-                m_RequiresVertexSkinning = requiresVertexSkinning
+                m_RequiresVertexSkinning = requiresVertexSkinning,
+                m_RequiresVertexID = requiresVertexID,
             };
 
             return reqs;
         }
     }
-}
+}

com.unity.shadergraph/Editor/Data/Interfaces/IMayRequireVertexID.cs

@@ -0,0 +1,18 @@
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph
+{
+    interface IMayRequireVertexID
+    {
+        bool RequiresVertexID(ShaderStageCapability stageCapability = ShaderStageCapability.All);
+    }
+
+    static class MayRequireVertexIDExtensions
+    {
+        public static bool RequiresVertexID(this ISlot slot)
+        {
+            var mayRequireVertexID = slot as IMayRequireVertexID;
+            return mayRequireVertexID != null && mayRequireVertexID.RequiresVertexID();
+        }
+    }
+}

com.unity.shadergraph/Editor/Data/Nodes/Mesh Deformation/ComputeDeformNode.cs

@@ -0,0 +1,148 @@
+using UnityEngine;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Internal;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Title("Mesh Deformation", "Compute Deformation")]
+    class ComputeDeformNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction, IMayRequirePosition, IMayRequireNormal, IMayRequireTangent, IMayRequireVertexID
+    {
+        public const int kPositionOutputSlotId = 0;
+        public const int kNormalOutputSlotId = 1;
+        public const int kTangentOutputSlotId = 2;
+
+        public const string kOutputSlotPositionName = "Position";
+        public const string kOutputSlotNormalName = "Normal";
+        public const string kOutputSlotTangentName = "Tangent";
+
+        public ComputeDeformNode()
+        {
+            name = "Compute Deformation";
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector3MaterialSlot(kPositionOutputSlotId, kOutputSlotPositionName, kOutputSlotPositionName, SlotType.Output, Vector3.zero, ShaderStageCapability.Vertex));
+            AddSlot(new Vector3MaterialSlot(kNormalOutputSlotId, kOutputSlotNormalName, kOutputSlotNormalName, SlotType.Output, Vector3.zero, ShaderStageCapability.Vertex));
+            AddSlot(new Vector3MaterialSlot(kTangentOutputSlotId, kOutputSlotTangentName, kOutputSlotTangentName, SlotType.Output, Vector3.zero, ShaderStageCapability.Vertex));
+            RemoveSlotsNameNotMatching(new[] { kPositionOutputSlotId, kNormalOutputSlotId, kTangentOutputSlotId });
+        }
+
+        protected override void CalculateNodeHasError()
+        {
+#if !ENABLE_COMPUTE_DEFORMATIONS
+            owner.AddSetupError(guid, "ENABLE_COMPUTE_DEFORMATIONS define needs to be enabled in Player Settings for Compute Deformation node to work");
+            hasError = true;
+#endif
+#if !HYBRID_RENDERER_0_4_0_OR_NEWER
+            owner.AddSetupError(guid, "Could not find 0.4.0 version or newer of Hybrid Renderer installed");
+            hasError = true;
+#endif
+        }
+
+        public bool RequiresVertexID(ShaderStageCapability stageCapability = ShaderStageCapability.All)
+        {
+            return true;
+        }
+
+        public NeededCoordinateSpace RequiresPosition(ShaderStageCapability stageCapability = ShaderStageCapability.All)
+        {
+            if (stageCapability == ShaderStageCapability.Vertex || stageCapability == ShaderStageCapability.All)
+                return NeededCoordinateSpace.Object;
+            else
+                return NeededCoordinateSpace.None;
+        }
+
+        public NeededCoordinateSpace RequiresNormal(ShaderStageCapability stageCapability = ShaderStageCapability.All)
+        {
+            if (stageCapability == ShaderStageCapability.Vertex || stageCapability == ShaderStageCapability.All)
+                return NeededCoordinateSpace.Object;
+            else
+                return NeededCoordinateSpace.None;
+        }
+
+        public NeededCoordinateSpace RequiresTangent(ShaderStageCapability stageCapability = ShaderStageCapability.All)
+        {
+            if (stageCapability == ShaderStageCapability.Vertex || stageCapability == ShaderStageCapability.All)
+                return NeededCoordinateSpace.Object;
+            else
+                return NeededCoordinateSpace.None;
+        }
+
+        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
+        {
+            properties.AddShaderProperty(new Vector1ShaderProperty()
+            {
+                overrideReferenceName = "_ComputeMeshIndex",
+                gpuInstanced = true,
+                hidden = true,
+                value = 0
+            });
+
+            base.CollectShaderProperties(properties, generationMode);
+        }
+
+        public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
+        {
+            sb.AppendLine("#if defined(UNITY_DOTS_INSTANCING_ENABLED)");
+            sb.AppendLine("$precision3 {0} = 0;", GetVariableNameForSlot(kPositionOutputSlotId));
+            sb.AppendLine("$precision3 {0} = 0;", GetVariableNameForSlot(kNormalOutputSlotId));
+            sb.AppendLine("$precision3 {0} = 0;", GetVariableNameForSlot(kTangentOutputSlotId));
+            if (generationMode == GenerationMode.ForReals)
+            {
+                sb.AppendLine($"{GetFunctionName()}(" +
+                           $"IN.VertexID, " +
+                           $"{GetVariableNameForSlot(kPositionOutputSlotId)}, " +
+                           $"{GetVariableNameForSlot(kNormalOutputSlotId)}, " +
+                           $"{GetVariableNameForSlot(kTangentOutputSlotId)});");
+            }
+            sb.AppendLine("#else");
+            sb.AppendLine("$precision3 {0} = IN.ObjectSpacePosition;", GetVariableNameForSlot(kPositionOutputSlotId));
+            sb.AppendLine("$precision3 {0} = IN.ObjectSpaceNormal;", GetVariableNameForSlot(kNormalOutputSlotId));
+            sb.AppendLine("$precision3 {0} = IN.ObjectSpaceTangent;", GetVariableNameForSlot(kTangentOutputSlotId));
+            sb.AppendLine("#endif");
+        }
+
+        public void GenerateNodeFunction(FunctionRegistry registry, GenerationMode generationMode)
+        {
+            registry.ProvideFunction("DeformedMeshData", sb =>
+            {
+                sb.AppendLine("struct DeformedVertexData");
+                sb.AppendLine("{");
+                using (sb.IndentScope())
+                {
+                    sb.AppendLine("float3 Position;");
+                    sb.AppendLine("float3 Normal;");
+                    sb.AppendLine("float4 Tangent;");
+                }
+                sb.AppendLine("};");
+                sb.AppendLine("uniform StructuredBuffer<DeformedVertexData> _DeformedMeshData : register(t1);");
+            });
+
+            registry.ProvideFunction(GetFunctionName(), sb =>
+            {
+                sb.AppendLine($"void {GetFunctionName()}(" +
+                            "uint vertexID, " +
+                            "out $precision3 positionOut, " +
+                            "out $precision3 normalOut, " +
+                            "out $precision3 tangentOut)");
+
+                sb.AppendLine("{");
+                using (sb.IndentScope())
+                {
+                    sb.AppendLine("const DeformedVertexData vertexData = _DeformedMeshData[asuint(_ComputeMeshIndex) + vertexID];");
+                    sb.AppendLine("positionOut = vertexData.Position;");
+                    sb.AppendLine("normalOut = vertexData.Normal;");
+                    sb.AppendLine("tangentOut = vertexData.Tangent.xyz;");
+                }
+                sb.AppendLine("}");
+            });
+        }
+
+        string GetFunctionName()
+        {
+            return $"Unity_ComputeDeformedVertex_{concretePrecision.ToShaderString()}";
+        }
+    }
+}