Reverted r453804 while resolving Unity package compilation errors on Unity versions < 2022.1.

Author: rajatg-sidefx

Plugins/HoudiniEngineUnity/Editor/UI/HEU_SplinesPackageManager.cs

@@ -48,7 +48,7 @@ public static bool IsInstalled()
         public static void Add()
         {
             // Add the Untiy.Splines package to the project
-            Request = Client.Add("com.unity.splines");
+            Request = Client.Add("com.unity.splines@2.1.0");
             EditorApplication.update += Progress;
         }
 

Plugins/HoudiniEngineUnity/Scripts/Asset/HEU_Curve.cs

@@ -1050,7 +1050,7 @@ internal bool UpdateCurveInputForCurveParts(HEU_SessionBase session, HEU_Houdini
 
 	    // Probably not necessary, but just in case
 	    hasRotations &= rotations.Count == positions.Count;
-	    hasScales &= scales.Count == positions.Count;
+	    hasScales &= scales.Count == scales.Count;
 
 	    float [] posArr = new float[positions.Count * 3];
 	    float [] rotArr = new float[positions.Count * 4];

Plugins/HoudiniEngineUnity/Scripts/Utility/HEU_InputInterfaceSpline.cs

@@ -28,7 +28,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using UnityEngine;
-using UnityEngine.UIElements;
 
 #if UNITY_SPLINES_INSTALLED
 
@@ -127,7 +126,7 @@ public override bool CreateInputNodeWithDataUpload(HEU_SessionBase session, HAPI
             }
 
             // Get spline data from the input object
-            HEU_InputDataSplineContainer inputSplines = GenerateSplineDataFromGameObject(inputObject);
+            HEU_InputDataSplines inputSplines = GenerateSplineDataFromGameObject(inputObject);
             if (inputSplines == null || inputSplines._inputSplines == null || inputSplines._inputSplines.Count() == 0)
             {
                 HEU_Logger.LogError("No valid splines found on input objects.");
@@ -145,7 +144,7 @@ public override bool CreateInputNodeWithDataUpload(HEU_SessionBase session, HAPI
             inputNodeID = newNodeID;
 
             HEU_InputDataSpline inputSpline = inputSplines._inputSplines[0];
-            if (!UploadData(session, inputNodeID, inputSpline, Matrix4x4.identity))
+            if (!UploadData(session, inputNodeID, inputSpline))
             {
                 if (!session.CookNode(inputNodeID, false))
                 {
@@ -156,16 +155,21 @@ public override bool CreateInputNodeWithDataUpload(HEU_SessionBase session, HAPI
                 return false;
             }
 
-            // The spline is made up of branching sub-splines.
-            // Create an input node for each branching spline and object-merge it to the root spline.
+            if (!session.CookNode(inputNodeID, false))
+            {
+                HEU_Logger.LogError("New input node failed to cook!");
+                return false;
+            }
+
             bool createMergeNode = inputSplines._inputSplines.Count() > 1;
             if (!createMergeNode)
                 return true;
 
+            // Create merge node to merge branching splines
             HAPI_NodeId mergeNodeId = HEU_Defines.HEU_INVALID_NODE_ID;
             HAPI_NodeId parentId = HEU_HAPIUtility.GetParentNodeID(session, inputNodeID);
 
-            if (!session.CreateNode(parentId, "merge", null, false, out mergeNodeId))
+            if (!session.CreateNode(parentId, "merge", "rajat-merge", false, out mergeNodeId))
             {
                 HEU_Logger.LogErrorFormat("Unable to create merge SOP node for connecting input assets.");
                 return false;
@@ -183,20 +187,21 @@ public override bool CreateInputNodeWithDataUpload(HEU_SessionBase session, HAPI
             }
             inputNodeID = mergeNodeId;
 
-            Matrix4x4 localToWorld = inputSplines._transform.localToWorldMatrix;
             HAPI_NodeId branchNodeID;
+            string branchName = inputObject.name;
             HEU_InputDataSpline branchSpline;
+            int inputNodeIndex = 1;
             for (int i = 1; i < inputSplines._inputSplines.Count(); i++)
             {
-                session.CreateInputCurveNode(out branchNodeID, inputObject.name + "_" + i);
+                session.CreateInputCurveNode(out branchNodeID, branchName + "_" + i);
                 if (branchNodeID == HEU_Defines.HEU_INVALID_NODE_ID || !HEU_HAPIUtility.IsNodeValidInHoudini(session, branchNodeID))
                 {
                     HEU_Logger.LogError("Failed to create new input cruve node in Houdini session!");
                     return false;
                 }
 
                 branchSpline = inputSplines._inputSplines[i];
-                if (!UploadData(session, branchNodeID, branchSpline, localToWorld))
+                if (!UploadData(session, branchNodeID, branchSpline, true))
                 {
                     if (!session.CookNode(branchNodeID, false))
                     {
@@ -211,6 +216,7 @@ public override bool CreateInputNodeWithDataUpload(HEU_SessionBase session, HAPI
                     HEU_Logger.LogErrorFormat("Unable to connect to input node!");
                     return false;
                 }
+                inputNodeIndex++;
             }
 
             if (!session.CookNode(inputNodeID, false))
@@ -228,6 +234,7 @@ public override bool CreateInputNodeWithDataUpload(HEU_SessionBase session, HAPI
         public class HEU_InputDataSpline
         {
             public Spline _spline;
+            public Transform _transform;
             public bool _closed;
             public int _count;
             public float _length;
@@ -237,10 +244,9 @@ public class HEU_InputDataSpline
         /// <summary>
         /// Contains input geometry for multiple splines.
         /// </summary>
-        public class HEU_InputDataSplineContainer : HEU_InputData
+        public class HEU_InputDataSplines : HEU_InputData
         {
             public List<HEU_InputDataSpline> _inputSplines = new List<HEU_InputDataSpline>();
-            public Transform _transform;
         }
 
         /// <summary>
@@ -249,26 +255,25 @@ public class HEU_InputDataSplineContainer : HEU_InputData
         /// </summary>
         /// <param name="inputObject">GameObject containing a Spline component</param>
         /// <returns>A valid input data strcuture containing spline data</returns>
-        public HEU_InputDataSplineContainer GenerateSplineDataFromGameObject(GameObject inputObject)
+        public HEU_InputDataSplines GenerateSplineDataFromGameObject(GameObject inputObject)
         {
             SplineContainer splineContainer = inputObject.GetComponent<SplineContainer>();
             IReadOnlyList<Spline> splines = splineContainer.Splines;
 
-            HEU_InputDataSplineContainer splineContainerData = new HEU_InputDataSplineContainer();
+            HEU_InputDataSplines splineData = new HEU_InputDataSplines();
             foreach (Spline spline in splines)
             {
-                HEU_InputDataSpline splineData = new HEU_InputDataSpline();
-                splineData._spline = spline;
-                splineData._closed = spline.Closed;
-                splineData._count = spline.Count;
-                splineData._length = spline.GetLength();
-                splineData._knots = spline.Knots.ToArray<BezierKnot>();
-
-                splineContainerData._inputSplines.Add(splineData);
+                HEU_InputDataSpline inputSpline = new HEU_InputDataSpline();
+                inputSpline._spline = spline;
+                inputSpline._transform = inputObject.transform;
+                inputSpline._closed = spline.Closed;
+                inputSpline._count = spline.Count;
+                inputSpline._length = spline.GetLength();
+                inputSpline._knots = spline.Knots.ToArray<BezierKnot>();
+
+                splineData._inputSplines.Add(inputSpline);
             }
-            splineContainerData._transform = inputObject.transform;
-
-            return splineContainerData;
+            return splineData;
         }
 
         /// <summary>
@@ -278,14 +283,16 @@ public HEU_InputDataSplineContainer GenerateSplineDataFromGameObject(GameObject
         /// <param name="inputNodeID">ID of the input node</param>
         /// <param name="inputData">Container of the mesh geometry</param>
         /// <returns>True if successfully uploaded data</returns>
-        public bool UploadData(HEU_SessionBase session, HAPI_NodeId inputNodeID, HEU_InputDataSpline inputSpline, Matrix4x4 localToWorld)
+        public bool UploadData(HEU_SessionBase session, HAPI_NodeId inputNodeID, HEU_InputDataSpline inputSpline, bool toWorld = false)
         {
             // Set the input curve info of the newly created input curve
             HAPI_InputCurveInfo inputCurveInfo = new HAPI_InputCurveInfo();
             inputCurveInfo.curveType = HAPI_CurveType.HAPI_CURVETYPE_BEZIER;
-            inputCurveInfo.order = 4;
+            inputCurveInfo.order = 4; // Recommended default
             inputCurveInfo.closed = inputSpline._closed;
             inputCurveInfo.reverse = false;
+
+            // Curve always goes through the specified points
             inputCurveInfo.inputMethod = HAPI_InputCurveMethod.HAPI_CURVEMETHOD_BREAKPOINTS;
             inputCurveInfo.breakpointParameterization = HAPI_InputCurveParameterization.HAPI_CURVEPARAMETERIZATION_UNIFORM;
             if (!session.SetInputCurveInfo(inputNodeID, 0, ref inputCurveInfo))
@@ -294,16 +301,18 @@ public bool UploadData(HEU_SessionBase session, HAPI_NodeId inputNodeID, HEU_Inp
                 return false;
             }
 
-            // Calculate the number of refined points we want
+            // Calculate the number of refined point we want
             int numControlPoints = inputSpline._knots.Count();
             float splineLength = inputSpline._length;
-            float splineResolution = settings != null ? settings.SamplingResolution : 0.0f;
+            float splineResolution = settings != null ? settings.SamplingResolution : 0.5f;
+
             int numRefinedSplinePoints = splineResolution > 0.0f ? Mathf.CeilToInt(splineLength / splineResolution) + 1 : numControlPoints;
+            Matrix4x4 localToWorld = inputSpline._transform.localToWorldMatrix;
 
             float[] posArr;
             float[] rotArr;
             float[] scaleArr;
-            if (numRefinedSplinePoints <= numControlPoints)
+            if (numRefinedSplinePoints < numControlPoints)
             {
                 // There's not enough refined points, so we'll use the control points instead
                 posArr = new float[numControlPoints * 3];
@@ -312,10 +321,7 @@ public bool UploadData(HEU_SessionBase session, HAPI_NodeId inputNodeID, HEU_Inp
                 for (int i = 0; i < numControlPoints; i++)
                 {
                     BezierKnot knot = inputSpline._knots[i];
-
-                    // For branching sub-splines, apply local transform on vertices to get the merged spline
-                    float3 pos = localToWorld.MultiplyPoint(knot.Position);
-                    
+                    float3 pos = toWorld ? localToWorld.MultiplyPoint(knot.Position) : knot.Position;
                     HEU_HAPIUtility.ConvertPositionUnityToHoudini(pos, out posArr[i * 3 + 0], out posArr[i * 3 + 1], out posArr[i * 3 + 2]);
                     HEU_HAPIUtility.ConvertRotationUnityToHoudini(knot.Rotation, out rotArr[i * 4 + 0], out rotArr[i * 4 + 1], out rotArr[i * 4 + 2], out rotArr[i * 4 + 3]);
                 }
@@ -330,32 +336,22 @@ public bool UploadData(HEU_SessionBase session, HAPI_NodeId inputNodeID, HEU_Inp
                 for (int i = 0; i < numRefinedSplinePoints; i++)
                 {
                     float3 pos = SplineUtility.EvaluatePosition<Spline>(inputSpline._spline, currentDistance / splineLength);
-
-                    // For branching sub-splines, apply local transform on vertices to get the merged spline
-                    pos = localToWorld.MultiplyPoint(pos);
-                    
+                    if (toWorld)
+                    {
+                        pos = localToWorld.MultiplyPoint(pos);
+                    }
                     HEU_HAPIUtility.ConvertPositionUnityToHoudini(pos, out posArr[i * 3 + 0], out posArr[i * 3 + 1], out posArr[i * 3 + 2]);
+                    
                     currentDistance += splineResolution;
                 }
             }
 
-            bool hasRotations = rotArr.Length == posArr.Length;
-            bool hasScales = scaleArr.Length == posArr.Length;
-            bool hapi_result = false;
-            if (!hasRotations && !hasScales)
-            {
-                hapi_result = session.SetInputCurvePositions(inputNodeID, 0, posArr, 0, posArr.Length);
-            }
-            else
-            {
-                hapi_result = session.SetInputCurvePositionsRotationsScales(
-                    inputNodeID, 0,
-                    posArr, 0, posArr.Length,
-                    rotArr, 0, rotArr.Length,
-                    scaleArr, 0, 0
-                );
-            }
-
+            bool hapi_result = session.SetInputCurvePositionsRotationsScales(
+                inputNodeID, 0,
+                posArr, 0, posArr.Length,
+                rotArr, 0, rotArr.Length,
+                scaleArr, 0, 0
+            );
             if (!hapi_result)
             {
                 HEU_Logger.LogError("Failed to set input curve positions.");