Use AnimationSet to group animations with appeals

Author: hozuki

src/MillionDance/Entities/Extensions/AnimationSetExtensions.cs

@@ -0,0 +1,14 @@
+using JetBrains.Annotations;
+using OpenMLTD.MillionDance.Entities.Internal;
+
+namespace OpenMLTD.MillionDance.Entities.Extensions {
+    internal static class AnimationSetExtensions {
+
+        public static void Deconstruct<T>([NotNull] this AnimationSet<T> animationSet, [CanBeNull] out T @default, [CanBeNull] out T another, [CanBeNull] out T special) {
+            @default = animationSet.Default;
+            another = animationSet.Another;
+            special = animationSet.Special;
+        }
+
+    }
+}

src/MillionDance/Entities/Internal/AnimationSet.cs

@@ -0,0 +1,12 @@
+using JetBrains.Annotations;
+
+namespace OpenMLTD.MillionDance.Entities.Internal {
+    internal static class AnimationSet {
+
+        [NotNull]
+        public static AnimationSet<T> Create<T>([CanBeNull] T @default, [CanBeNull] T another, [CanBeNull] T special) {
+            return new AnimationSet<T>(@default, another, special);
+        }
+
+    }
+}

src/MillionDance/Entities/Internal/AnimationSet`1.cs

@@ -0,0 +1,45 @@
+using System.Diagnostics;
+using JetBrains.Annotations;
+
+namespace OpenMLTD.MillionDance.Entities.Internal {
+    /// <summary>
+    /// A set of animations
+    /// </summary>
+    /// <typeparam name="T">The type containing animation data</typeparam>
+    internal sealed class AnimationSet<T> {
+
+        public AnimationSet([CanBeNull] T @default, [CanBeNull] T another, [CanBeNull] T special) {
+            Default = @default;
+            Special = special;
+            Another = another;
+        }
+
+        /// <summary>
+        /// Default animations
+        /// </summary>
+        [CanBeNull]
+        public T Default {
+            [DebuggerStepThrough]
+            get;
+        }
+
+        /// <summary>
+        /// Animations for another appeal (apa)
+        /// </summary>
+        [CanBeNull]
+        public T Another {
+            [DebuggerStepThrough]
+            get;
+        }
+
+        /// <summary>
+        /// Animations for special appeal (apg)
+        /// </summary>
+        [CanBeNull]
+        public T Special {
+            [DebuggerStepThrough]
+            get;
+        }
+
+    }
+}

src/MillionDance/FMain.Working.cs

@@ -225,7 +225,7 @@ ConversionConfig PrepareConversionConfig(InputParams ip) {
 
                     if (p.GenerateCameraMotion) {
                         Log("Loading camera motion...");
-                        camera = ResourceLoader.LoadCamera(p.InputCamera);
+                        (camera, _, _) = ResourceLoader.LoadCamera(p.InputCamera);
                         if (camera == null) {
                             Log("Failed to load camera data.");
                             break;

src/MillionDance/MillionDance.csproj

@@ -77,9 +77,12 @@
     <Compile Include="Core\VmdCreator.FacialExpressions.cs" />
     <Compile Include="Core\VmdCreator.FacialExpressionTable.cs" />
     <Compile Include="Core\VmdCreator.Light.cs" />
+    <Compile Include="Entities\Extensions\AnimationSetExtensions.cs" />
     <Compile Include="Entities\Extensions\KeyTypeExtension.cs" />
     <Compile Include="Entities\Extensions\PropertyTypeExtension.cs" />
     <Compile Include="Entities\Extensions\ScenarioObjectExtensions.cs" />
+    <Compile Include="Entities\Internal\AnimationSet.cs" />
+    <Compile Include="Entities\Internal\AnimationSet`1.cs" />
     <Compile Include="Entities\Internal\CameraAnimation.cs" />
     <Compile Include="Entities\Internal\CameraFrame.cs" />
     <Compile Include="Entities\Mltd\CompiledBodyAnimationSource.cs" />

src/MillionDance/ResourceLoader.cs

@@ -9,6 +9,8 @@
 using Imas.Data.Serialized.Sway;
 using JetBrains.Annotations;
 using OpenMLTD.MillionDance.Core;
+using OpenMLTD.MillionDance.Entities.Extensions;
+using OpenMLTD.MillionDance.Entities.Internal;
 using OpenMLTD.MillionDance.Entities.Mltd;
 
 namespace OpenMLTD.MillionDance {
@@ -127,15 +129,21 @@ public static AvatarWrapper LoadHeadAvatar([NotNull] string filePath) {
             return result;
         }
 
-        [CanBeNull]
-        public static CharacterImasMotionAsset LoadCamera([NotNull] string filePath) {
-            CharacterImasMotionAsset cam = null;
+        [NotNull]
+        public static AnimationSet<CharacterImasMotionAsset> LoadCamera([NotNull] string filePath) {
+            CharacterImasMotionAsset cam = null, apa = null, apg = null;
 
-            const string camEnds = "_cam.imo";
+            const string defCamEnds = "_cam.imo";
+            const string apaCamEnds = "_apa.imo";
+            const string apgCamEnds = "_apg.imo";
+            const string apaPortraitCamEnds = "_tate_apa.imo";
+            const string apgPortraitCamEnds = "_tate_apg.imo";
 
             var manager = new AssetsManager();
             manager.LoadFiles(filePath);
 
+            var ser = new ScriptableObjectSerializer();
+
             foreach (var assetFile in manager.assetsFileList) {
                 foreach (var obj in assetFile.Objects) {
                     if (obj.type != ClassIDType.MonoBehaviour) {
@@ -148,22 +156,25 @@ public static CharacterImasMotionAsset LoadCamera([NotNull] string filePath) {
                         throw new ArgumentException("An object serialized as MonoBehaviour is actually not a MonoBehaviour.");
                     }
 
-                    if (!behaviour.m_Name.EndsWith(camEnds)) {
-                        continue;
+                    if (behaviour.m_Name.EndsWith(defCamEnds)) {
+                        cam = ser.Deserialize<CharacterImasMotionAsset>(behaviour);
+                    } else if (behaviour.m_Name.EndsWith(apaCamEnds) && !behaviour.m_Name.EndsWith(apaPortraitCamEnds)) {
+                        apa = ser.Deserialize<CharacterImasMotionAsset>(behaviour);
+                    } else if (behaviour.m_Name.EndsWith(apgCamEnds) && !behaviour.m_Name.EndsWith(apgPortraitCamEnds)) {
+                        apg = ser.Deserialize<CharacterImasMotionAsset>(behaviour);
                     }
 
-                    var ser = new ScriptableObjectSerializer();
-
-                    cam = ser.Deserialize<CharacterImasMotionAsset>(behaviour);
-
-                    break;
+                    if (cam != null && apa != null && apg != null) {
+                        break;
+                    }
                 }
             }
 
-            return cam;
+            return AnimationSet.Create(cam, apa, apg);
         }
 
-        public static (IBodyAnimationSource, IBodyAnimationSource, IBodyAnimationSource) LoadDance([NotNull] string filePath, int songPosition) {
+        [NotNull]
+        public static AnimationSet<IBodyAnimationSource> LoadDance([NotNull] string filePath, int songPosition) {
             IBodyAnimationSource danSource = null, apaSource = null, apgSource = null;
             var danceAnimationLoaded = false;
 
@@ -211,7 +222,7 @@ public static (IBodyAnimationSource, IBodyAnimationSource, IBodyAnimationSource)
                 }
             }
 
-            return (danSource, apaSource, apgSource);
+            return AnimationSet.Create(danSource, apaSource, apgSource);
         }
 
         public static (ScenarioObject, ScenarioObject, ScenarioObject) LoadScenario([NotNull] string filePath) {
@@ -255,7 +266,8 @@ public static (ScenarioObject, ScenarioObject, ScenarioObject) LoadScenario([Not
             return (main, landscape, portrait);
         }
 
-        private static (CharacterImasMotionAsset, CharacterImasMotionAsset, CharacterImasMotionAsset) LoadDanceLegacy([NotNull] string filePath, int songPosition) {
+        [NotNull]
+        private static AnimationSet<CharacterImasMotionAsset> LoadDanceLegacy([NotNull] string filePath, int songPosition) {
             CharacterImasMotionAsset dan = null, apa = null, apg = null;
 
             var danComp = $"{songPosition:00}_dan.imo";
@@ -294,10 +306,11 @@ private static (CharacterImasMotionAsset, CharacterImasMotionAsset, CharacterIma
                 }
             }
 
-            return (dan, apa, apg);
+            return AnimationSet.Create(dan, apa, apg);
         }
 
-        private static (AnimationClip, AnimationClip, AnimationClip) LoadDanceCompiled([NotNull] string filePath, int songPosition) {
+        [NotNull]
+        private static AnimationSet<AnimationClip> LoadDanceCompiled([NotNull] string filePath, int songPosition) {
             AnimationClip dan = null, apa = null, apg = null;
 
             var danComp = $"{songPosition:00}_dan";
@@ -333,13 +346,22 @@ private static (AnimationClip, AnimationClip, AnimationClip) LoadDanceCompiled([
                 }
             }
 
-            return (dan, apa, apg);
+            return AnimationSet.Create(dan, apa, apg);
         }
 
         public static (SwayController Body, SwayController Head) LoadSwayControllers([NotNull] string bodyFilePath, [NotNull] string headFilePath) {
             var body = LoadSwayController(bodyFilePath);
+
+            if (body == null) {
+                throw new ArgumentNullException(nameof(body), "Body sway is null.");
+            }
+
             var head = LoadSwayController(headFilePath);
 
+            if (head == null) {
+                throw new ArgumentNullException(nameof(head), "Head sway is null.");
+            }
+
             SwayController.FixSwayReferences(body, head);
 
             return (Body: body, Head: head);