Merge pull request #93 from neogeek/feature/calculate-ticks-with-time-signatures

neogeek · web-flow · commit 545cbaebc176 · 2025-01-20T13:57:56.000-05:00
[feat] Added TimeSignature calculation.
diff --git a/RhythmGameUtilities.Tests/ParsersTest.cs b/RhythmGameUtilities.Tests/ParsersTest.cs
@@ -54,7 +54,7 @@ public void TestParseTimeSignaturesFromChartSection()
 
             var timeSignatures = Parsers.ParseTimeSignaturesFromChartSection(sections[NamedSection.SyncTrack]);
 
-            Assert.That(timeSignatures.Count, Is.EqualTo(4));
+            Assert.That(timeSignatures.Length, Is.EqualTo(4));
         }
 
         [Test]
diff --git a/RhythmGameUtilities.Tests/UtilitiesTest.cs b/RhythmGameUtilities.Tests/UtilitiesTest.cs
@@ -33,8 +33,11 @@ public void TestConvertSecondsToTicks()
                 { 42240, 111980 }
             };
 
+            var timeSignatureChanges = new[] { new TimeSignature { Position = 0, Numerator = 4, Denominator = 2 } };
+
             Assert.That(
-                Utilities.ConvertSecondsToTicks(seconds, resolution, bpmChanges), Is.EqualTo(1408));
+                Utilities.ConvertSecondsToTicks(seconds, resolution, bpmChanges, timeSignatureChanges),
+                Is.EqualTo(1408));
         }
 
         [Test]
diff --git a/RhythmGameUtilities/Scripts/Parsers.cs b/RhythmGameUtilities/Scripts/Parsers.cs
@@ -109,14 +109,17 @@ public static Dictionary<string, string> ParseMetaDataFromChartSection(
             return section.ToDictionary(item => item.Key, x => x.Value.First());
         }
 
-        public static Dictionary<int, int[]> ParseTimeSignaturesFromChartSection(
+        public static TimeSignature[] ParseTimeSignaturesFromChartSection(
             KeyValuePair<string, string[]>[] section)
         {
             return section
-                .Where(item => item.Value[0] == TypeCode.TimeSignatureMarker)
-                .Select(item =>
-                    new KeyValuePair<int, int[]>(int.Parse(item.Key), item.Value.Skip(1).Select(int.Parse).ToArray()))
-                .ToDictionary(item => item.Key, x => x.Value);
+                .Where(item => item.Value.Length >= 2 && item.Value.First() == TypeCode.TimeSignatureMarker).Select(
+                    item => new TimeSignature
+                    {
+                        Position = int.Parse(item.Key),
+                        Numerator = int.Parse(item.Value.Skip(1).First()),
+                        Denominator = item.Value.Length > 2 ? int.Parse(item.Value.Skip(2).First()) : 2
+                    }).ToArray();
         }
 
         public static Dictionary<int, int> ParseBpmFromChartSection(
diff --git a/RhythmGameUtilities/Scripts/Utilities.cs b/RhythmGameUtilities/Scripts/Utilities.cs
@@ -14,7 +14,7 @@ internal static class UtilitiesInternal
 
         [DllImport("libRhythmGameUtilities", CallingConvention = CallingConvention.Cdecl)]
         public static extern int ConvertSecondsToTicksInternal(float seconds, int resolution, int[] bpmChangesKeys,
-            int[] bpmChangesValues, int bpmChangesSize);
+            int[] bpmChangesValues, int bpmChangesSize, TimeSignature[] timeSignatures, int timeSignaturesSize);
 
         [DllImport("libRhythmGameUtilities", CallingConvention = CallingConvention.Cdecl)]
         public static extern bool IsOnTheBeat(int bpm, float currentTime, float delta);
@@ -55,10 +55,12 @@ public static float ConvertTickToPosition(int tick, int resolution)
         /// <param name="seconds">The seconds to generate ticks with.</param>
         /// <param name="resolution">The resolution of the song.</param>
         /// <param name="bpmChanges">All BPM changes within the song.</param>
-        public static int ConvertSecondsToTicks(float seconds, int resolution, Dictionary<int, int> bpmChanges)
+        /// <param name="timeSignatureChanges">All time signature changes within the song.</param>
+        public static int ConvertSecondsToTicks(float seconds, int resolution, Dictionary<int, int> bpmChanges,
+            TimeSignature[] timeSignatureChanges)
         {
             return UtilitiesInternal.ConvertSecondsToTicksInternal(seconds, resolution, bpmChanges.Keys.ToArray(),
-                bpmChanges.Values.ToArray(), bpmChanges.Count);
+                bpmChanges.Values.ToArray(), bpmChanges.Count, timeSignatureChanges, timeSignatureChanges.Length);
         }
 
         /// <summary>
diff --git a/RhythmGameUtilities/Structs/TimeSignature.cs b/RhythmGameUtilities/Structs/TimeSignature.cs
@@ -0,0 +1,18 @@
+using System.Runtime.InteropServices;
+
+namespace RhythmGameUtilities
+{
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct TimeSignature
+    {
+
+        public int Position;
+
+        public int Numerator;
+
+        public int Denominator;
+
+    }
+
+}
diff --git a/UnityPackage/Editor/Tests/ParsersTest.cs b/UnityPackage/Editor/Tests/ParsersTest.cs
@@ -54,7 +54,7 @@ public void TestParseTimeSignaturesFromChartSection()
 
             var timeSignatures = Parsers.ParseTimeSignaturesFromChartSection(sections[NamedSection.SyncTrack]);
 
-            Assert.That(timeSignatures.Count, Is.EqualTo(4));
+            Assert.That(timeSignatures.Length, Is.EqualTo(4));
         }
 
         [Test]
diff --git a/UnityPackage/Editor/Tests/UtilitiesTest.cs b/UnityPackage/Editor/Tests/UtilitiesTest.cs
@@ -33,8 +33,11 @@ public void TestConvertSecondsToTicks()
                 { 42240, 111980 }
             };
 
+            var timeSignatureChanges = new[] { new TimeSignature { Position = 0, Numerator = 4, Denominator = 2 } };
+
             Assert.That(
-                Utilities.ConvertSecondsToTicks(seconds, resolution, bpmChanges), Is.EqualTo(1408));
+                Utilities.ConvertSecondsToTicks(seconds, resolution, bpmChanges, timeSignatureChanges),
+                Is.EqualTo(1408));
         }
 
         [Test]
diff --git a/UnityPackage/Scripts/Parsers.cs b/UnityPackage/Scripts/Parsers.cs
@@ -109,14 +109,17 @@ public static Dictionary<string, string> ParseMetaDataFromChartSection(
             return section.ToDictionary(item => item.Key, x => x.Value.First());
         }
 
-        public static Dictionary<int, int[]> ParseTimeSignaturesFromChartSection(
+        public static TimeSignature[] ParseTimeSignaturesFromChartSection(
             KeyValuePair<string, string[]>[] section)
         {
             return section
-                .Where(item => item.Value[0] == TypeCode.TimeSignatureMarker)
-                .Select(item =>
-                    new KeyValuePair<int, int[]>(int.Parse(item.Key), item.Value.Skip(1).Select(int.Parse).ToArray()))
-                .ToDictionary(item => item.Key, x => x.Value);
+                .Where(item => item.Value.Length >= 2 && item.Value.First() == TypeCode.TimeSignatureMarker).Select(
+                    item => new TimeSignature
+                    {
+                        Position = int.Parse(item.Key),
+                        Numerator = int.Parse(item.Value.Skip(1).First()),
+                        Denominator = item.Value.Length > 2 ? int.Parse(item.Value.Skip(2).First()) : 2
+                    }).ToArray();
         }
 
         public static Dictionary<int, int> ParseBpmFromChartSection(
diff --git a/UnityPackage/Scripts/Utilities.cs b/UnityPackage/Scripts/Utilities.cs
@@ -14,7 +14,7 @@ internal static class UtilitiesInternal
 
         [DllImport("libRhythmGameUtilities", CallingConvention = CallingConvention.Cdecl)]
         public static extern int ConvertSecondsToTicksInternal(float seconds, int resolution, int[] bpmChangesKeys,
-            int[] bpmChangesValues, int bpmChangesSize);
+            int[] bpmChangesValues, int bpmChangesSize, TimeSignature[] timeSignatures, int timeSignaturesSize);
 
         [DllImport("libRhythmGameUtilities", CallingConvention = CallingConvention.Cdecl)]
         public static extern bool IsOnTheBeat(int bpm, float currentTime, float delta);
@@ -55,10 +55,12 @@ public static float ConvertTickToPosition(int tick, int resolution)
         /// <param name="seconds">The seconds to generate ticks with.</param>
         /// <param name="resolution">The resolution of the song.</param>
         /// <param name="bpmChanges">All BPM changes within the song.</param>
-        public static int ConvertSecondsToTicks(float seconds, int resolution, Dictionary<int, int> bpmChanges)
+        /// <param name="timeSignatureChanges">All time signature changes within the song.</param>
+        public static int ConvertSecondsToTicks(float seconds, int resolution, Dictionary<int, int> bpmChanges,
+            TimeSignature[] timeSignatureChanges)
         {
             return UtilitiesInternal.ConvertSecondsToTicksInternal(seconds, resolution, bpmChanges.Keys.ToArray(),
-                bpmChanges.Values.ToArray(), bpmChanges.Count);
+                bpmChanges.Values.ToArray(), bpmChanges.Count, timeSignatureChanges, timeSignatureChanges.Length);
         }
 
         /// <summary>
diff --git a/UnityPackage/Structs/TimeSignature.cs b/UnityPackage/Structs/TimeSignature.cs
@@ -0,0 +1,18 @@
+using System.Runtime.InteropServices;
+
+namespace RhythmGameUtilities
+{
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct TimeSignature
+    {
+
+        public int Position;
+
+        public int Numerator;
+
+        public int Denominator;
+
+    }
+
+}
diff --git a/UnityPackage/Structs/TimeSignature.cs.meta b/UnityPackage/Structs/TimeSignature.cs.meta
diff --git a/include/RhythmGameUtilities/Parsers.hpp b/include/RhythmGameUtilities/Parsers.hpp
@@ -10,6 +10,7 @@
 #include "Enums/TypeCode.h"
 
 #include "Structs/Note.h"
+#include "Structs/TimeSignature.h"
 
 #include "Common.hpp"
 
@@ -104,17 +105,21 @@ std::map<std::string, std::string> ParseMetaDataFromChartSection(
     return data;
 }
 
-std::map<int, int> ParseTimeSignaturesFromChartSection(
+std::vector<TimeSignature> ParseTimeSignaturesFromChartSection(
     std::vector<std::pair<std::string, std::vector<std::string>>> section)
 {
-    auto timeSignatures = std::map<int, int>();
+    auto timeSignatures = std::vector<TimeSignature>();
 
     for (auto &line : section)
     {
         if (line.second.front() == ToString(TypeCode::TimeSignatureMarker))
         {
-            timeSignatures.insert(
-                {std::stoi(line.first), std::stoi(line.second.at(1))});
+            auto position = std::stoi(line.first);
+            auto numerator = std::stoi(line.second.at(1));
+            auto denominator =
+                line.second.size() > 2 ? std::stoi(line.second.at(2)) : 2;
+
+            timeSignatures.push_back({position, numerator, denominator});
         }
     }
 
diff --git a/include/RhythmGameUtilities/Structs/TimeSignature.h b/include/RhythmGameUtilities/Structs/TimeSignature.h
@@ -0,0 +1,15 @@
+#pragma once
+
+namespace RhythmGameUtilities
+{
+
+struct TimeSignature
+{
+    int Position;
+
+    int Numerator;
+
+    int Denominator;
+};
+
+} // namespace RhythmGameUtilities
diff --git a/include/RhythmGameUtilities/Utilities.hpp b/include/RhythmGameUtilities/Utilities.hpp
@@ -1,13 +1,16 @@
 #pragma once
 
+#include <climits>
 #include <cmath>
 #include <map>
 #include <optional>
 #include <vector>
 
-#include "Common.hpp"
 #include "Structs/BeatBar.h"
 #include "Structs/Note.h"
+#include "Structs/TimeSignature.h"
+
+#include "Common.hpp"
 
 #ifdef _WIN32
 #define PACKAGE_API __declspec(dllexport)
@@ -26,38 +29,65 @@ const float SECONDS_PER_MINUTE = 60.0f;
  * @param seconds The seconds to generate ticks with.
  * @param resolution The resolution of the song.
  * @param bpmChanges All BPM changes within the song.
+ * @param timeSignatureChanges All time signature changes within the song.
  * @public
  */
 
 int ConvertSecondsToTicks(float seconds, int resolution,
-                          std::map<int, int> bpmChanges)
+                          std::map<int, int> bpmChanges,
+                          std::vector<TimeSignature> timeSignatureChanges)
 {
+    auto bpmIterator = bpmChanges.begin();
+    auto timeSignatureIterator = timeSignatureChanges.begin();
+
     auto totalTicks = 0;
     auto remainingSeconds = seconds;
     auto previousTick = 0;
-    auto previousBPM = bpmChanges.begin()->second / 1000;
+    auto previousBPM = bpmIterator->second / 1000.0;
+    auto previousTimeSignature = timeSignatureIterator->Numerator;
 
-    for (auto const &[currentTick, value] : bpmChanges)
+    while (remainingSeconds > 0)
     {
-        auto timeForSegment = (currentTick - previousTick) /
-                              (resolution * previousBPM / SECONDS_PER_MINUTE);
+        int nextBPMChange =
+            bpmIterator != bpmChanges.end() ? bpmIterator->first : INT_MAX;
+
+        int nextTimeSignatureChange =
+            timeSignatureIterator != timeSignatureChanges.end()
+                ? timeSignatureIterator->Position
+                : INT_MAX;
+
+        int nextChangeTick = std::min(nextBPMChange, nextTimeSignatureChange);
+
+        float ticksPerSecond = resolution * previousBPM / SECONDS_PER_MINUTE;
+        float timeForSegment = (nextChangeTick - previousTick) / ticksPerSecond;
 
         if (remainingSeconds <= timeForSegment)
         {
-            totalTicks += static_cast<int>(remainingSeconds * previousBPM /
-                                           SECONDS_PER_MINUTE * resolution);
+            totalTicks += static_cast<int>(remainingSeconds * ticksPerSecond);
 
             return totalTicks;
         }
 
-        totalTicks += currentTick - previousTick;
+        totalTicks += nextChangeTick - previousTick;
         remainingSeconds -= timeForSegment;
-        previousTick = currentTick;
-        previousBPM = value / 1000;
+        previousTick = nextChangeTick;
+
+        if (nextChangeTick == nextBPMChange)
+        {
+            previousBPM = bpmIterator->second / 1000.0;
+            ++bpmIterator;
+        }
+
+        if (nextChangeTick == nextTimeSignatureChange)
+        {
+            previousTimeSignature = timeSignatureIterator->Numerator;
+            ++timeSignatureIterator;
+        }
     }
 
-    totalTicks += static_cast<int>(remainingSeconds * previousBPM /
-                                   SECONDS_PER_MINUTE * resolution);
+    float ticksPerSecond = resolution * previousBPM / SECONDS_PER_MINUTE;
+
+    totalTicks += static_cast<int>(remainingSeconds * ticksPerSecond);
 
     return totalTicks;
 }
diff --git a/include/RhythmGameUtilities/UtilitiesInternal.hpp b/include/RhythmGameUtilities/UtilitiesInternal.hpp
@@ -3,6 +3,7 @@
 #include <map>
 
 #include "Structs/BeatBar.h"
+#include "Structs/TimeSignature.h"
 
 #include "Utilities.hpp"
 
@@ -20,7 +21,9 @@ extern "C"
     PACKAGE_API int ConvertSecondsToTicksInternal(float seconds, int resolution,
                                                   int *bpmChangesKeys,
                                                   int *bpmChangesValues,
-                                                  int bpmChangesSize)
+                                                  int bpmChangesSize,
+                                                  TimeSignature *timeSignatures,
+                                                  int timeSignaturesSize)
     {
         std::map<int, int> bpmChanges;
 
@@ -29,7 +32,15 @@ extern "C"
             bpmChanges[bpmChangesKeys[i]] = bpmChangesValues[i];
         }
 
-        return ConvertSecondsToTicks(seconds, resolution, bpmChanges);
+        std::vector<TimeSignature> timeSignatureChanges;
+
+        for (auto i = 0; i < timeSignaturesSize; i += 1)
+        {
+            timeSignatureChanges.push_back(timeSignatures[i]);
+        }
+
+        return ConvertSecondsToTicks(seconds, resolution, bpmChanges,
+                                     timeSignatureChanges);
     }
 
     PACKAGE_API BeatBar *
diff --git a/tests/RhythmGameUtilities/Utilities.cpp b/tests/RhythmGameUtilities/Utilities.cpp
@@ -3,6 +3,8 @@
 #include <iostream>
 #include <tuple>
 
+#include "RhythmGameUtilities/Structs/TimeSignature.h"
+
 #include "RhythmGameUtilities/Utilities.hpp"
 
 using namespace RhythmGameUtilities;
@@ -20,7 +22,10 @@ void testConvertSecondsToTicks()
         {0, 88000},      {3840, 112000},  {9984, 89600},  {22272, 112000},
         {33792, 111500}, {34560, 112000}, {42240, 111980}};
 
-    assert(1408 == ConvertSecondsToTicks(5, 192, bpmChanges));
+    std::vector<TimeSignature> timeSignatureChanges = {{0, 4, 2}};
+
+    assert(1408 ==
+           ConvertSecondsToTicks(5, 192, bpmChanges, timeSignatureChanges));
 
     std::cout << ".";
 }
diff --git a/tests/RhythmGameUtilities/UtilitiesInternal.cpp b/tests/RhythmGameUtilities/UtilitiesInternal.cpp

Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ public void TestParseTimeSignaturesFromChartSection()`
`54`	`54`
`55`	`55`	`var timeSignatures = Parsers.ParseTimeSignaturesFromChartSection(sections[NamedSection.SyncTrack]);`
`56`	`56`
`57`		`- Assert.That(timeSignatures.Count, Is.EqualTo(4));`
	`57`	`+ Assert.That(timeSignatures.Length, Is.EqualTo(4));`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`[Test]`