Fix/avoid strip roots when animated

Editor/Scripts/GLTFImporter.cs

@@ -317,65 +317,95 @@ string GetUniqueName(string desiredName)
                 // Remove empty roots
                 if (gltfScene && _removeEmptyRootObjects)
                 {
+	                // To avoid removing a Root object which is animated, we collect from all animation clips the paths that are animated.
+	                var pathBindings = new List<string>();
+	                foreach (var aniClip in animations)
+	                {
+		                var bindings = AnimationUtility.GetCurveBindings(aniClip);
+		                var distinctPaths = bindings.Select( x => x.path).Distinct();
+						pathBindings.AddRange(distinctPaths);
+	                }
+	                pathBindings = pathBindings.Distinct().ToList();
+
                     var t = gltfScene.transform;
                     var existingAnimator = t.GetComponent<Animator>();
                     var hadAnimator = (bool)existingAnimator;
                     var existingAvatar = existingAnimator ? existingAnimator.avatar : default;
+                    var rootIsAnimated = false;
                     if (existingAnimator)
-	                    DestroyImmediate(existingAnimator);
+                    {
+	                    var firstChildName = t.childCount > 0 ? t.GetChild(0).gameObject.name : "";
+	                    // check if the object is animated, when true, cancel here
+						rootIsAnimated = firstChildName != "" && pathBindings.Contains(firstChildName);
+
+						if (!rootIsAnimated)
+							DestroyImmediate(existingAnimator);
+                    }
 
                     var animationPathPrefix = "";
                     var originalImportName = gltfScene.name;
-                    while (
-                        gltfScene.transform.childCount == 1 &&
-                        gltfScene.GetComponents<Component>().Length == 1) // Transform component
+                    if (!rootIsAnimated)
                     {
-                        var parent = gltfScene;
-                        gltfScene = gltfScene.transform.GetChild(0).gameObject;
-                        var importName = gltfScene.name;
-                        t = gltfScene.transform;
-                        t.parent = null; // To keep transform information in the new parent
-                        DestroyImmediate(parent); // Get rid of the parent
-                        if (animationPathPrefix != "")
-	                        animationPathPrefix += "/";
-                        animationPathPrefix += importName;
-                    }
-                    animationPathPrefix += "/";
+	                    while (
+		                    gltfScene.transform.childCount == 1 &&
+		                    gltfScene.GetComponents<Component>().Length == 1) // Transform component
+	                    {
+		                    // check if the object is animated, when true, cancel here
+		                    if (pathBindings.Contains(animationPathPrefix != ""
+			                        ? $"{animationPathPrefix}/{gltfScene.transform.GetChild(0).gameObject.name}"
+			                        : gltfScene.transform.GetChild(0).gameObject.name))
+			                    break;
+
+		                    var parent = gltfScene;
+		                    gltfScene = gltfScene.transform.GetChild(0).gameObject;
+		                    var importName = gltfScene.name;
 
-                    // Re-add animator if it was removed
-                    if (hadAnimator)
-					{
-	                    var newAnimator = gltfScene.AddComponent<Animator>();
-	                    newAnimator.avatar = existingAvatar;
-					}
 
-                    // Re-target animation clips - when we strip the root, all animations also change and have a different path now.
-                    if (animations != null)
-					{
-						foreach (var clip in animations)
-						{
-							if (clip == null) continue;
-
-							// change all animation clip targets
-							var bindings = AnimationUtility.GetCurveBindings(clip);
-							var curves = new AnimationCurve[bindings.Length];
-							var newBindings = new EditorCurveBinding[bindings.Length];
-							for (var index = 0; index < bindings.Length; index++)
-							{
-								var binding = bindings[index];
-								curves[index] = AnimationUtility.GetEditorCurve(clip, binding);
-
-								var newBinding = bindings[index];
-								if (binding.path.StartsWith(animationPathPrefix, StringComparison.Ordinal))
-									newBinding.path = binding.path.Substring(animationPathPrefix.Length);
-								newBindings[index] = newBinding;
-							}
-
-							var emptyCurves = new AnimationCurve[curves.Length];
-							AnimationUtility.SetEditorCurves(clip, bindings, emptyCurves);
-							AnimationUtility.SetEditorCurves(clip, newBindings, curves);
-						}
-					}
+		                    t = gltfScene.transform;
+		                    t.parent = null; // To keep transform information in the new parent
+		                    DestroyImmediate(parent); // Get rid of the parent
+		                    if (animationPathPrefix != "")
+			                    animationPathPrefix += "/";
+		                    animationPathPrefix += importName;
+	                    }
+
+	                    animationPathPrefix += "/";
+
+	                    // Re-add animator if it was removed
+	                    if (hadAnimator)
+	                    {
+		                    var newAnimator = gltfScene.AddComponent<Animator>();
+		                    newAnimator.avatar = existingAvatar;
+	                    }
+
+	                    // Re-target animation clips - when we strip the root, all animations also change and have a different path now.
+	                    if (animations != null)
+	                    {
+		                    foreach (var clip in animations)
+		                    {
+			                    if (clip == null) continue;
+
+			                    // change all animation clip targets
+			                    var bindings = AnimationUtility.GetCurveBindings(clip);
+			                    var curves = new AnimationCurve[bindings.Length];
+			                    var newBindings = new EditorCurveBinding[bindings.Length];
+			                    for (var index = 0; index < bindings.Length; index++)
+			                    {
+				                    var binding = bindings[index];
+				                    curves[index] = AnimationUtility.GetEditorCurve(clip, binding);
+
+				                    var newBinding = bindings[index];
+				                    if (binding.path.StartsWith(animationPathPrefix, StringComparison.Ordinal))
+					                    newBinding.path = binding.path.Substring(animationPathPrefix.Length);
+				                    newBindings[index] = newBinding;
+			                    }
+
+			                    var emptyCurves = new AnimationCurve[curves.Length];
+			                    AnimationUtility.SetEditorCurves(clip, bindings, emptyCurves);
+			                    AnimationUtility.SetEditorCurves(clip, newBindings, curves);
+		                    }
+	                    }
+                    } // (!rootIsAnimated)
 
                     gltfScene.name = originalImportName;
                 }

Runtime/Plugins/GLTFSerialization/Extensions/KHR_LightsPunctualExtension.cs

@@ -1,9 +1,12 @@
 using System;
 using System.Collections.Generic;
-using GLTF.Math;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using GLTF.Extensions;
+using GLTF.Utilities;
+using UnityEngine;
+using UnityGLTF.Extensions;
+using Color = GLTF.Math.Color;
 
 namespace GLTF.Schema.KHR_lights_punctual
 {
@@ -287,7 +290,7 @@ public IExtension Clone(GLTFRoot root)
 		}
 	}
 
-	public class KHR_LightsPunctualExtension : IExtension
+	public class KHR_LightsPunctualExtension : IExtension, IImportAnimationPointerRootExtension
 	{
 		public List<PunctualLight> Lights;
 
@@ -314,6 +317,95 @@ public JProperty Serialize()
 				)
 			);
 		}
+
+		private static string[] GltfLightPropertyToUnityPropertyName(string gltfPropertyName)
+		{
+			switch (gltfPropertyName)
+			{
+				case "color":
+					return new string[] { "m_Color.r", "m_Color.g", "m_Color.b"};
+				case "intensity":
+					return new string[] { "m_Intensity"};
+				case "range":
+					return new string[]  {"m_Range"};
+				case "spot/innerConeAngle":
+					return new string[]  {"m_InnerConeAngle"};
+				case "spot/outerConeAngle":
+					return new string[]  {"m_OuterConeAngle"};
+				default:
+					return new string[] {gltfPropertyName};
+			}
+		}
+
+		private static AnimationPointerData.ImportValuesConversion GetConversion(string gltfPropertyName)
+		{
+			switch (gltfPropertyName)
+			{
+				case "color":
+					return (data, index) =>
+					{
+						var col = data.primaryData.AccessorContent.AsFloat3s[index];
+						var color = new Color(col[0], col[1], col[2], 1f).ToUnityColorRaw();
+						return new float[] { color.r, color.g, color.b };
+						//return new float[] { col.x, col.y, col.z };
+					};
+				case "intensity":
+					return (data, index) => new float[1] { data.primaryData.AccessorContent.AsFloats[index] / Mathf.PI }; 
+				case "range":
+					return (data, index) => new float[1] { data.primaryData.AccessorContent.AsFloats[index] };
+				case "spot/innerConeAngle":
+					return (data, index) => new float[] { data.primaryData.AccessorContent.AsFloats[index] * 2 / (Mathf.Deg2Rad * 0.8f)}; 
+				case "spot/outerConeAngle":
+					return (data, index) => new float[] { data.primaryData.AccessorContent.AsFloats[index] * 2 / Mathf.Deg2Rad};
+				default:
+					return null;
+			}
+		}
+
+		public bool TryGetImportAnimationPointerData(GLTFRoot root, PointerPath pointerPath, out AnimationPointerData pointerData)
+		{
+			pointerData = new AnimationPointerData();
+			pointerData.targetNodeIds = new int[0];
+			pointerData.targetType = typeof(UnityEngine.Light);
+
+			if (root.Nodes == null)
+				return false;
+
+			var pointId = pointerPath.FindNext(PointerPath.PathElement.Index);
+			if (pointId == null)
+				return false;
+
+			var property = pointerPath.FindNext(PointerPath.PathElement.Property);
+			if (property == null)
+				return false;
+
+			pointerData.unityPropertyNames = GltfLightPropertyToUnityPropertyName(property.elementName);
+			pointerData.importAccessorContentConversion = GetConversion(property.elementName);
+
+			List<int> targetNodes = new List<int>();
+			for (int i = 0; i < root.Nodes.Count; i++)
+			{
+				var n = root.Nodes[i];
+				if (n.Extensions != null && n.Extensions.TryGetValue(KHR_lights_punctualExtensionFactory.EXTENSION_NAME, out IExtension extension))
+				{
+					if (!(extension is KHR_LightsPunctualNodeExtension lightExtension))
+						continue;
+
+					if (lightExtension.LightId.Id == pointId.index)
+					{
+						targetNodes.Add(i);
+					}
+				}
+			}
+
+			if (targetNodes.Count > 0)
+			{
+				pointerData.targetNodeIds = targetNodes.ToArray();
+				return true;
+			}
+
+			return false;
+		}
 	}
 
 	public class PunctualLightId : GLTFId<PunctualLight>

Runtime/Plugins/GLTFSerialization/Extensions/KHR_animation_pointer.cs

@@ -22,6 +22,12 @@ public JProperty Serialize()
 			if (path == null && clonedFrom != null) path = clonedFrom.path;
 			return new JProperty(EXTENSION_NAME, new JObject(new JProperty("pointer", path)));
 		}
+
+		public void Deserialize(GLTFRoot root, JProperty extensionToken)
+		{
+			var extensionObject = (JObject) extensionToken.Value;
+			path = (string) extensionObject["pointer"];
+		}
 
 		public IExtension Clone(GLTFRoot root)
 		{

Runtime/Plugins/GLTFSerialization/Extensions/KHR_animation_pointerExtensionFactory.cs

@@ -0,0 +1,31 @@
+using Newtonsoft.Json.Linq;
+using UnityGLTF.Extensions;
+
+namespace GLTF.Schema
+{
+    public class KHR_animation_pointerExtensionFactory : ExtensionFactory
+    {
+        public const string EXTENSION_NAME = "KHR_animation_pointer";
+
+
+        public KHR_animation_pointerExtensionFactory()
+        {
+            ExtensionName = EXTENSION_NAME;
+        }
+
+        public override IExtension Deserialize(GLTFRoot root, JProperty extensionToken)
+        {
+            if (extensionToken != null)
+            {
+                var extensionObject = (JObject) extensionToken.Value;
+                string path = (string) extensionObject["pointer"];
+                return new KHR_animation_pointer
+                {
+                    path = path
+                };
+            }
+
+            return null;
+        }
+    }
+}

Runtime/Plugins/GLTFSerialization/GLTFHelpers.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Text.RegularExpressions;
 using GLTF.Schema;
@@ -408,20 +409,28 @@ public static void BuildAnimationSamplers(ref Dictionary<string, List<AttributeA
 					NumericArray resultArray = attributeAccessor.AccessorContent;
 					LoadBufferView(attributeAccessor, out NativeArray<byte> bufferViewCache);
 
-					switch (samplerSet.Key)
+					switch (attributeAccessor.AccessorId.Value.Type)
 					{
-						case "time":
-							attributeAccessor.AccessorId.Value.AsFloatArray(ref resultArray, bufferViewCache, 0, attributeAccessor.AccessorId.Value.Normalized);
+						case GLTFAccessorAttributeType.SCALAR:
+							attributeAccessor.AccessorId.Value.AsFloatArray(ref resultArray, bufferViewCache);
 							break;
-						case "translation":
-						case "scale":
-							attributeAccessor.AccessorId.Value.AsFloat3Array(ref resultArray, bufferViewCache, 0, attributeAccessor.AccessorId.Value.Normalized);
+						case GLTFAccessorAttributeType.VEC2:
+							attributeAccessor.AccessorId.Value.AsFloat2Array(ref resultArray, bufferViewCache);
 							break;
-						case "rotation":
-							attributeAccessor.AccessorId.Value.AsFloat4Array(ref resultArray, bufferViewCache, 0, attributeAccessor.AccessorId.Value.Normalized);
+						case GLTFAccessorAttributeType.VEC3:
+							attributeAccessor.AccessorId.Value.AsFloat3Array(ref resultArray, bufferViewCache);
 							break;
-						case "weights":
-							attributeAccessor.AccessorId.Value.AsFloatArray(ref resultArray, bufferViewCache, 0, attributeAccessor.AccessorId.Value.Normalized);
+						case GLTFAccessorAttributeType.VEC4:
+							attributeAccessor.AccessorId.Value.AsFloat4Array(ref resultArray, bufferViewCache);
+							break;
+						case GLTFAccessorAttributeType.MAT2:
+							Debug.LogWarning("Unsupported MAT2 animation sampler type");
+							break;
+						case GLTFAccessorAttributeType.MAT3:
+							Debug.LogWarning("Unsupported MAT3 animation sampler type");
+							break;
+						case GLTFAccessorAttributeType.MAT4:
+							attributeAccessor.AccessorId.Value.AsMatrix4x4Array(ref resultArray, bufferViewCache);
 							break;
 					}
 

Runtime/Plugins/GLTFSerialization/Schema/Accessor.cs

@@ -1390,6 +1390,32 @@ public enum GLTFAccessorAttributeType
 		MAT4
 	}
 
+	public static class GLTFAccessorAttributeTypeExtensions
+	{
+		public static int ComponentCount(this GLTFAccessorAttributeType attrType)
+		{
+			switch (attrType)
+			{
+				case GLTFAccessorAttributeType.SCALAR:
+					return 1;
+				case GLTFAccessorAttributeType.VEC2:
+					return 2;
+				case GLTFAccessorAttributeType.VEC3:
+					return 3;
+				case GLTFAccessorAttributeType.VEC4:
+					return 4;
+				case GLTFAccessorAttributeType.MAT2:
+					return 4;
+				case GLTFAccessorAttributeType.MAT3:
+					return 9;
+				case GLTFAccessorAttributeType.MAT4:
+					return 16;
+			}
+
+			return 0;
+		}
+	}
+
     /// <summary>
 	[StructLayout(LayoutKind.Explicit)]
 	public struct NumericArray