AnimationClip から TimelineUniverse を作れるようにする

Author: nasshu2916

Assets/ArtNet/Editor/DmxRecorder/TimelineConverter.cs

@@ -21,6 +21,14 @@ public TimelineConverter(IReadOnlyCollection<(int time, DmxPacket packet)> packe
             }
         }
 
+        public TimelineConverter(DmxTimelineSetting dmxTimelineSetting)
+        {
+            foreach (var timelineElement in dmxTimelineSetting.DmxTimelines)
+            {
+                Timelines.Add(new TimelineUniverse(timelineElement.Universe, timelineElement.DmxTimelineClip));
+            }
+        }
+
         public void SaveDmxTimelineClips(string directory)
         {
             if (System.IO.Directory.Exists(directory) == false)
@@ -51,6 +59,11 @@ public void SaveDmxTimelineClips(string directory)
             AssetDatabase.Refresh();
         }
 
+        public List<(int time, DmxPacket packet)> ToDmxPackets()
+        {
+            return Timelines.SelectMany(x => x.ToDmxPackets()).OrderBy(x => x.time).ToList();
+        }
+
         private static void SaveAsset<T>(T asset, string directory, string fileName) where T : UnityEngine.Object
         {
             var path = $"{directory}/{fileName}";
@@ -77,6 +90,71 @@ public TimelineUniverse(int universe, IReadOnlyCollection<(int time, DmxPacket p
             }
         }
 
+        public TimelineUniverse(int universe, AnimationClip clip)
+        {
+            Universe = universe;
+            var curveBindings = AnimationUtility.GetCurveBindings(clip);
+            ChannelDmxFrameData = new List<DmxFrameData>[512];
+            for (var i = 0; i < ChannelDmxFrameData.Length; i++)
+            {
+                var propertyName = $"Ch{i + 1:D3}";
+
+                var curve = curveBindings
+                    .Where(binding => binding.propertyName == propertyName)
+                    .Select(binding => AnimationUtility.GetEditorCurve(clip, binding))
+                    .FirstOrDefault();
+
+                if (curve is null) continue;
+
+                ChannelDmxFrameData[i] = curve.keys.Select(x => new DmxFrameData((int) (x.time * 1000), (byte) x.value)).ToList();
+            }
+        }
+
+        public IEnumerable<int> AllFrameTimes()
+        {
+            return ChannelDmxFrameData.SelectMany(x => x.Select(frameData => frameData.Millisecond)).Distinct();
+        }
+
+        public byte FrameValue(int channel, int time)
+        {
+            var dmxFrameData = ChannelDmxFrameData[channel];
+
+            // If there is a frame data at the exact time, return it
+            foreach (var frameData in dmxFrameData.Where(frameData => frameData.Millisecond == time))
+            {
+                return frameData.Value;
+            }
+
+            // if there is no frame data, return 0
+            if (dmxFrameData.Count == 0) return 0;
+
+            // if time is out of range, return the first or last value
+            if (time < dmxFrameData[0].Millisecond) return dmxFrameData[0].Value;
+            if (time > dmxFrameData[^1].Millisecond) return dmxFrameData[^1].Value;
+
+            // return the estimated value from frames around the specified time.
+
+            // Find the frame data before and after the specified time
+            var prev = dmxFrameData[0];
+            var next = dmxFrameData[0];
+            foreach (var frameData in dmxFrameData)
+            {
+                if (frameData.Millisecond > time)
+                {
+                    next = frameData;
+                    break;
+                }
+
+                prev = frameData;
+            }
+
+            // Calculate the estimated value
+            var prevDiff = next.Value - prev.Value;
+            var prevDiffTime = next.Millisecond - prev.Millisecond;
+            var timeDiff = time - prev.Millisecond;
+            return (byte) (prev.Value + (prevDiff * timeDiff / prevDiffTime));
+        }
+
         public AnimationClip ToAnimationClip()
         {
             var curves = ConvertAnimationCurves();
@@ -144,6 +222,35 @@ private static bool IsOmittedFrame(
 
             return Math.Abs((float) prevDiff / prevDiffTime - (float) nextDiff / nextDiffTime) <= tolerance;
         }
+
+        public IEnumerable<(int time, DmxPacket packet)> ToDmxPackets()
+        {
+            byte sequence = 0;
+            var packets = new List<(int time, DmxPacket packet)>();
+            var allFrameTimes = AllFrameTimes().OrderBy(x => x).ToList();
+
+            foreach (var time in allFrameTimes)
+            {
+                var dmx = new byte[512];
+                for (var i = 0; i < ChannelDmxFrameData.Length; i++)
+                {
+                    dmx[i] = FrameValue(i, time);
+                }
+
+                var packet = new DmxPacket { Sequence = sequence, Universe = (ushort) Universe, Dmx = dmx };
+                packets.Add((time, packet));
+                if (sequence >= 255)
+                {
+                    sequence = 0;
+                }
+                else
+                {
+                    sequence++;
+                }
+            }
+
+            return packets;
+        }
     }
 
     public struct DmxFrameData