Compute Skinning is applied in VertMesh through defines

 - Add separate shader for skinning
 - Set DOTS_SKINNING define for all passes when hybrid v2 is enabled
 - Add new builtin property that determines if skinning should be applied

Add front buffer index to access deformed vertices of current/previous frame.

Actually get the the vertex position of the current frame when rendering the object itself.

d3d debug pragma for HDTarget

Remove skin setting component

Apply skinning in motion vec pass, rename function

Add motion vectors to unity instancing properties

Remove compute deformation node

Enable vertexID when DOTS_INSTANCING_ON is defined

Remove manual adding of vertex id and defines in HD shader passes

Remove skinning include and define

Remove compute mesh index property when dots instancing is not defined

Shader cleanup for dots deformations

Rename shader file for dots skinning functions

Remove changes from HDShaderPasses

Remove formatting issues

Remove include define

Remove all changes from HDShaderPasses

Remove debug pragma

Update some comments
Also skin vertices even if motion vectors are not skinned

Remove duplicated define

Add compute mesh index to URP shader variables. Add function to fetch vertices from compute buffer in ShaderVariablesFunctions

Rename some functions, move fetching to different file

Rename deformation function for HDRP

Keep vertex ID as optional when hybrid v2 is not used

Remove formatting from HDTarget

Updated changelogs to be more descriptive.

Rename material property

Add dots skinning function to URP passes PBR-Forward/GBuffer, Lit-Forward/GBuffer, Depth/DepthNormal, ShadowCaster, Unlit, PostProcessing, ScreenSpaceShadows, SimpleLit-Forward/GBiffer, PreviewPass

Remove modulus from deform vertex function

Remove modulus, change to uints

Remove documentation for Compute Deformation Node

Author: hedvig

com.unity.render-pipelines.core/ShaderLibrary/DotsDeformation.hlsl

@@ -0,0 +1,81 @@
+#if defined(DOTS_INSTANCING_ON)
+struct DeformedVertexData
+{
+    float3 Position;
+    float3 Normal;
+    float3 Tangent;
+};
+
+int _HybridDeformedVertexStreamIndex;
+uniform StructuredBuffer<DeformedVertexData> _DeformedMeshData;
+uniform StructuredBuffer<DeformedVertexData> _PreviousFrameDeformedMeshData;
+
+// Reads vertex data for compute skinned meshes in Hybdrid Renderer
+void FetchComputeVertexData(inout float3 pos, inout float3 nrm, inout float4 tan, in uint vertexID)
+{
+    // x,y = current and previous frame indices
+    // z = deformation check (0 = no deformation, 1 = has deformation)
+    // w = skinned motion vectors
+    const int4 deformProperty = asint(unity_DOTSDeformationParams);
+    const int doSkinning = deformProperty.z;
+    if (doSkinning == 1)
+    {
+        const int streamIndex = _HybridDeformedVertexStreamIndex;
+        const int startIndex = deformProperty[streamIndex];
+        const DeformedVertexData vertexData = _DeformedMeshData[startIndex + vertexID];
+
+        pos = vertexData.Position;
+        nrm = vertexData.Normal;
+        tan = float4(vertexData.Tangent, 0);
+    }
+}
+
+void FetchComputeVertexPosNrm(inout float3 pos, inout float3 nrm, in uint vertexID)
+{
+    // x,y = current and previous frame indices
+    // z = deformation check (0 = no deformation, 1 = has deformation)
+    // w = skinned motion vectors
+    const int4 deformProperty = asint(unity_DOTSDeformationParams);
+    const int doSkinning = deformProperty.z;
+    if (doSkinning == 1)
+    {
+        const int streamIndex = _HybridDeformedVertexStreamIndex;
+        const int startIndex = deformProperty[streamIndex];
+        const DeformedVertexData vertexData = _DeformedMeshData[startIndex + vertexID];
+
+        pos = vertexData.Position;
+        nrm = vertexData.Normal;
+    }
+}
+
+void FetchComputeVertexNormal(inout float3 normal, in uint vertexID)
+{
+    const int4 deformProperty = asint(unity_DOTSDeformationParams);
+    const int doSkinning = deformProperty.z;
+    if (doSkinning == 1)
+    {
+        const int streamIndex = _HybridDeformedVertexStreamIndex;
+        const int startIndex = deformProperty[streamIndex];
+    
+        normal = _DeformedMeshData[startIndex + vertexID].Normal;
+    }
+}
+
+void FetchComputeVertexPosition(inout float3 position, in uint vertexID)
+{
+    const int4 deformProperty = asint(unity_DOTSDeformationParams);
+    const int doSkinning = deformProperty.z;
+    if (doSkinning == 1)
+    {
+        const int streamIndex = _HybridDeformedVertexStreamIndex;
+        const int startIndex = deformProperty[streamIndex];
+
+        position = _DeformedMeshData[startIndex + vertexID].Position;
+    }
+}
+
+void FetchComputeVertexPosition(inout float4 position, in uint vertexID)
+{
+    FetchComputeVertexPosition(position.xyz, vertexID);
+}
+#endif

com.unity.render-pipelines.core/ShaderLibrary/DotsDeformation.hlsl.meta

@@ -16,6 +16,7 @@ The version number for this package has increased due to a version update of a r
 - Added light unit slider for automatic and automatic histrogram exposure limits.
 - Added View Bias for mesh decals.
 - Added support for the PlayStation 5 platform.
+- Added support for skinned motionvectors when using Hybrid Renderer
 
 ### Fixed
 - Fixed computation of geometric normal in path tracing (case 1293029).
@@ -108,6 +109,7 @@ The version number for this package has increased due to a version update of a r
 - Transparent materials created by the Model Importer are set to not cast shadows. ( case 1295747)
 - Change some light unit slider value ranges to better reflect the lighting scenario.
 - Change the tooltip for color shadows and semi-transparent shadows (case 1307704).
+- Compute Deformation Node no longer needs to be added manually in Shader Graph for skinning to work with Hybrid Renderer V2.
 
 ## [10.2.1] - 2020-11-30
 

com.unity.render-pipelines.high-definition/CHANGELOG.md

@@ -357,6 +357,7 @@ RenderStateCollection GenerateRenderState()
             {
                 var renderState = new RenderStateCollection();
                 renderState.Add(CoreRenderStates.MotionVectors);
+
                 return renderState;
             }
 

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

@@ -28,8 +28,13 @@ public struct AttributesMesh
                 "COLOR", subscriptOptions : StructFieldOptions.Optional);
             public static FieldDescriptor instanceID = new FieldDescriptor(AttributesMesh.name, "instanceID", "", ShaderValueType.Uint,
                 "INSTANCEID_SEMANTIC", "UNITY_ANY_INSTANCING_ENABLED");
+#if ENABLE_HYBRID_RENDERER_V2
+            public static FieldDescriptor vertexID = new FieldDescriptor(AttributesMesh.name, "vertexID", "", ShaderValueType.Uint,
+                "SV_VertexID", "DOTS_INSTANCING_ON");
+#else
             public static FieldDescriptor vertexID = new FieldDescriptor(AttributesMesh.name, "vertexID", "ATTRIBUTES_NEED_VERTEXID", ShaderValueType.Uint,
                 "SV_VertexID", subscriptOptions: StructFieldOptions.Optional);
+#endif
         }
 
         public struct VaryingsMeshToPS

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

@@ -1339,6 +1339,8 @@ void UpdateShaderVariablesGlobalCB(HDCamera hdCamera, CommandBuffer cmd)
                 m_ShaderVariablesGlobalCB._EnableRecursiveRayTracing = 0;
                 m_ShaderVariablesGlobalCB._SpecularOcclusionBlend = 1.0f;
             }
+            
+            m_ShaderVariablesGlobalCB._HybridDeformedVertexStreamIndex = UnityEngine.Time.frameCount & 1;
 
             ConstantBuffer.PushGlobal(cmd, m_ShaderVariablesGlobalCB, HDShaderIDs._ShaderVariablesGlobal);
         }

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/HDRenderPipeline.cs

@@ -0,0 +1,66 @@
+#if defined(DOTS_INSTANCING_ON)
+struct DeformedVertexData
+{
+    float3 Position;
+    float3 Normal;
+    float3 Tangent;
+};
+
+uniform StructuredBuffer<DeformedVertexData> _DeformedMeshData;
+uniform StructuredBuffer<DeformedVertexData> _PreviousFrameDeformedMeshData;
+
+// Reads vertex data for compute skinned meshes in Hybdrid Renderer
+void FetchComputeVertexData(inout AttributesMesh input)
+{
+    // x,y = current and previous frame indices
+    // z = deformation check (0 = no deformation, 1 = has deformation)
+    // w = skinned motion vectors
+    const int4 deformProperty = asint(unity_DOTSDeformationParams);
+    const int doSkinning = deformProperty.z;
+    if (doSkinning == 1)
+    {
+        const uint streamIndex = _HybridDeformedVertexStreamIndex;
+        const uint startIndex = deformProperty[streamIndex];
+        const DeformedVertexData vertexData = _DeformedMeshData[startIndex + input.vertexID];
+
+        input.positionOS = vertexData.Position;
+#ifdef ATTRIBUTES_NEED_NORMAL
+        input.normalOS = vertexData.Normal;
+#endif
+#ifdef ATTRIBUTES_NEED_TANGENT
+        input.tangentOS = float4(vertexData.Tangent, 0);
+#endif
+    }
+}
+
+// Reads vertex position for compute skinned meshes in Hybdrid Renderer
+// and also previous frame position if skinned motion vectors are used
+void FetchComputeVertexPosition(inout float3 currPos, inout float3 prevPos, uint vertexID)
+{
+    // x,y = current and previous frame indices
+    // z = deformation check (0 = no deformation, 1 = has deformation)
+    // w = skinned motion vectors
+    const int4 deformProperty = asint(unity_DOTSDeformationParams);
+    const int computeSkin = deformProperty.z;
+    const uint streamIndex = _HybridDeformedVertexStreamIndex;
+    if (computeSkin == 1)
+    {
+        const uint currMeshStart = deformProperty[streamIndex]; 
+        const uint currStreamIndex = _HybridDeformedVertexStreamIndex;
+        currPos = _DeformedMeshData[currMeshStart + vertexID].Position;
+    }
+
+    const int skinMotionVec = deformProperty.w;
+    if (skinMotionVec == 1)
+    {
+        const uint prevStreamIndex = streamIndex ^ 1;
+        const int prevMeshStart = deformProperty[prevStreamIndex];
+
+        if(prevMeshStart == -1)
+            prevPos = _DeformedMeshData[prevMeshStart + vertexID].Position;
+        else
+            prevPos = _PreviousFrameDeformedMeshData[prevMeshStart + vertexID].Position;
+
+    }
+}
+#endif

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/DotsDeformation.hlsl

@@ -87,7 +87,6 @@ void MotionVectorPositionZBias(VaryingsToPS input)
 
 PackedVaryingsType MotionVectorVS(inout VaryingsType varyingsType, AttributesMesh inputMesh, AttributesPass inputPass)
 {
-
 #if !defined(TESSELLATION_ON)
     MotionVectorPositionZBias(varyingsType);
 #endif
@@ -107,15 +106,21 @@ PackedVaryingsType MotionVectorVS(inout VaryingsType varyingsType, AttributesMes
     {
         bool hasDeformation = unity_MotionVectorsParams.x > 0.0; // Skin or morph target
 
-        float3 effectivePositionOS = (hasDeformation ? inputPass.previousPositionOS : inputMesh.positionOS);
+        float3 deformedPrevPos = inputPass.previousPositionOS;
+
+#if defined(DOTS_INSTANCING_ON)
+        FetchComputeVertexPosition(inputMesh.positionOS, deformedPrevPos, inputMesh.vertexID);
+#endif
+        float3 effectivePositionOS = (hasDeformation) ? deformedPrevPos : inputMesh.positionOS;
+
 #if defined(_ADD_PRECOMPUTED_VELOCITY)
         effectivePositionOS -= inputPass.precomputedVelocity;
 #endif
 
     // Need to apply any vertex animation to the previous worldspace position, if we want it to show up in the motion vector buffer
 #if defined(HAVE_MESH_MODIFICATION)
         AttributesMesh previousMesh = inputMesh;
-        previousMesh.positionOS = effectivePositionOS ;
+        previousMesh.positionOS = effectivePositionOS;
 
         previousMesh = ApplyMeshModification(previousMesh, _LastTimeParameters.xyz);
         float3 previousPositionRWS = TransformPreviousObjectToWorld(previousMesh.positionOS);

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/DotsDeformation.hlsl.meta

@@ -22,7 +22,9 @@ struct AttributesMesh
 #ifdef ATTRIBUTES_NEED_COLOR
     float4 color        : COLOR;
 #endif
-
+#ifdef DOTS_INSTANCING_ON
+    uint vertexID        : SV_VertexID;
+#endif
     UNITY_VERTEX_INPUT_INSTANCE_ID
 };