[hotfix] Simplified bpm data structure.

RhythmGameUtilities.Tests/UtilitiesTest.cs

@@ -22,15 +22,12 @@ public void TestConvertSecondsToTicks()
             const int seconds = 5;
             const int resolution = 192;
 
-            var bpmChanges = new Dictionary<int, int>
+            var bpmChanges = new[]
             {
-                { 0, 88000 },
-                { 3840, 112000 },
-                { 9984, 89600 },
-                { 22272, 112000 },
-                { 33792, 111500 },
-                { 34560, 112000 },
-                { 42240, 111980 }
+                new Tempo { Position = 0, BPM = 88000 }, new Tempo { Position = 3840, BPM = 112000 },
+                new Tempo { Position = 9984, BPM = 89600 }, new Tempo { Position = 22272, BPM = 112000 },
+                new Tempo { Position = 33792, BPM = 111500 }, new Tempo { Position = 34560, BPM = 112000 },
+                new Tempo { Position = 42240, BPM = 111980 }
             };
 
             var timeSignatureChanges = new[] { new TimeSignature { Position = 0, Numerator = 4, Denominator = 2 } };
@@ -60,15 +57,12 @@ public void TestCalculateBeatBars()
             const int resolution = 192;
             const int timeSignature = 4;
 
-            var bpmChanges = new Dictionary<int, int>
+            var bpmChanges = new Tempo[]
             {
-                { 0, 88000 },
-                { 3840, 112000 },
-                { 9984, 89600 },
-                { 22272, 112000 },
-                { 33792, 111500 },
-                { 34560, 112000 },
-                { 42240, 111980 }
+                new() { Position = 0, BPM = 88000 }, new() { Position = 3840, BPM = 112000 },
+                new() { Position = 9984, BPM = 89600 }, new() { Position = 22272, BPM = 112000 },
+                new() { Position = 33792, BPM = 111500 }, new() { Position = 34560, BPM = 112000 },
+                new() { Position = 42240, BPM = 111980 }
             };
 
             var beatBars = Utilities.CalculateBeatBars(bpmChanges, resolution, timeSignature, true);

RhythmGameUtilities/Scripts/Utilities.cs

@@ -13,8 +13,8 @@ internal static class UtilitiesInternal
         public static extern float ConvertTickToPosition(int tick, int resolution);
 
         [DllImport("libRhythmGameUtilities", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int ConvertSecondsToTicksInternal(float seconds, int resolution, int[] bpmChangesKeys,
-            int[] bpmChangesValues, int bpmChangesSize, TimeSignature[] timeSignatures, int timeSignaturesSize);
+        public static extern int ConvertSecondsToTicksInternal(float seconds, int resolution, Tempo[] bpmChanges,
+            int bpmChangesSize, TimeSignature[] timeSignatures, int timeSignaturesSize);
 
         [DllImport("libRhythmGameUtilities", CallingConvention = CallingConvention.Cdecl)]
         public static extern bool IsOnTheBeat(int bpm, float currentTime, float delta);
@@ -26,8 +26,8 @@ public static extern int ConvertSecondsToTicksInternal(float seconds, int resolu
         public static extern float CalculateAccuracyRatio(int position, int currentPosition, int delta);
 
         [DllImport("libRhythmGameUtilities", CallingConvention = CallingConvention.Cdecl)]
-        public static extern IntPtr CalculateBeatBarsInternal(int[] bpmChangesKeys,
-            int[] bpmChangesValues, int bpmChangesSize, int resolution, int ts,
+        public static extern IntPtr CalculateBeatBarsInternal(Tempo[] bpmChanges, int bpmChangesSize, int resolution,
+            int ts,
             bool includeHalfNotes, out int size);
 
     }
@@ -56,11 +56,11 @@ public static float ConvertTickToPosition(int tick, int resolution)
         /// <param name="resolution">The resolution of the song.</param>
         /// <param name="bpmChanges">All BPM changes within the song.</param>
         /// <param name="timeSignatureChanges">All time signature changes within the song.</param>
-        public static int ConvertSecondsToTicks(float seconds, int resolution, Dictionary<int, int> bpmChanges,
+        public static int ConvertSecondsToTicks(float seconds, int resolution, Tempo[] bpmChanges,
             TimeSignature[] timeSignatureChanges)
         {
-            return UtilitiesInternal.ConvertSecondsToTicksInternal(seconds, resolution, bpmChanges.Keys.ToArray(),
-                bpmChanges.Values.ToArray(), bpmChanges.Count, timeSignatureChanges, timeSignatureChanges.Length);
+            return UtilitiesInternal.ConvertSecondsToTicksInternal(seconds, resolution, bpmChanges, bpmChanges.Length,
+                timeSignatureChanges, timeSignatureChanges.Length);
         }
 
         /// <summary>
@@ -86,12 +86,11 @@ public static int RoundUpToTheNearestMultiplier(int value, int multiplier)
             return UtilitiesInternal.RoundUpToTheNearestMultiplier(value, multiplier);
         }
 
-        public static BeatBar[] CalculateBeatBars(Dictionary<int, int> bpmChanges, int resolution = 192, int ts = 4,
+        public static BeatBar[] CalculateBeatBars(Tempo[] bpmChanges, int resolution = 192, int ts = 4,
             bool includeHalfNotes = true)
         {
-
-            var ptrArray = UtilitiesInternal.CalculateBeatBarsInternal(bpmChanges.Keys.ToArray(),
-                bpmChanges.Values.ToArray(), bpmChanges.Count, resolution, ts, includeHalfNotes,
+            var ptrArray = UtilitiesInternal.CalculateBeatBarsInternal(bpmChanges, bpmChanges.Length, resolution, ts,
+                includeHalfNotes,
                 out var size);
 
             var beatBarSize = Marshal.SizeOf(typeof(BeatBar));

RhythmGameUtilities/Structs/Tempo.cs

@@ -0,0 +1,16 @@
+using System.Runtime.InteropServices;
+
+namespace RhythmGameUtilities
+{
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct Tempo
+    {
+
+        public int Position;
+
+        public int BPM;
+
+    }
+
+}

UnityPackage/Editor/Tests/UtilitiesTest.cs

@@ -22,15 +22,12 @@ public void TestConvertSecondsToTicks()
             const int seconds = 5;
             const int resolution = 192;
 
-            var bpmChanges = new Dictionary<int, int>
+            var bpmChanges = new[]
             {
-                { 0, 88000 },
-                { 3840, 112000 },
-                { 9984, 89600 },
-                { 22272, 112000 },
-                { 33792, 111500 },
-                { 34560, 112000 },
-                { 42240, 111980 }
+                new Tempo { Position = 0, BPM = 88000 }, new Tempo { Position = 3840, BPM = 112000 },
+                new Tempo { Position = 9984, BPM = 89600 }, new Tempo { Position = 22272, BPM = 112000 },
+                new Tempo { Position = 33792, BPM = 111500 }, new Tempo { Position = 34560, BPM = 112000 },
+                new Tempo { Position = 42240, BPM = 111980 }
             };
 
             var timeSignatureChanges = new[] { new TimeSignature { Position = 0, Numerator = 4, Denominator = 2 } };
@@ -60,15 +57,12 @@ public void TestCalculateBeatBars()
             const int resolution = 192;
             const int timeSignature = 4;
 
-            var bpmChanges = new Dictionary<int, int>
+            var bpmChanges = new Tempo[]
             {
-                { 0, 88000 },
-                { 3840, 112000 },
-                { 9984, 89600 },
-                { 22272, 112000 },
-                { 33792, 111500 },
-                { 34560, 112000 },
-                { 42240, 111980 }
+                new() { Position = 0, BPM = 88000 }, new() { Position = 3840, BPM = 112000 },
+                new() { Position = 9984, BPM = 89600 }, new() { Position = 22272, BPM = 112000 },
+                new() { Position = 33792, BPM = 111500 }, new() { Position = 34560, BPM = 112000 },
+                new() { Position = 42240, BPM = 111980 }
             };
 
             var beatBars = Utilities.CalculateBeatBars(bpmChanges, resolution, timeSignature, true);

UnityPackage/Scripts/Utilities.cs

@@ -13,8 +13,8 @@ internal static class UtilitiesInternal
         public static extern float ConvertTickToPosition(int tick, int resolution);
 
         [DllImport("libRhythmGameUtilities", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int ConvertSecondsToTicksInternal(float seconds, int resolution, int[] bpmChangesKeys,
-            int[] bpmChangesValues, int bpmChangesSize, TimeSignature[] timeSignatures, int timeSignaturesSize);
+        public static extern int ConvertSecondsToTicksInternal(float seconds, int resolution, Tempo[] bpmChanges,
+            int bpmChangesSize, TimeSignature[] timeSignatures, int timeSignaturesSize);
 
         [DllImport("libRhythmGameUtilities", CallingConvention = CallingConvention.Cdecl)]
         public static extern bool IsOnTheBeat(int bpm, float currentTime, float delta);
@@ -26,8 +26,8 @@ public static extern int ConvertSecondsToTicksInternal(float seconds, int resolu
         public static extern float CalculateAccuracyRatio(int position, int currentPosition, int delta);
 
         [DllImport("libRhythmGameUtilities", CallingConvention = CallingConvention.Cdecl)]
-        public static extern IntPtr CalculateBeatBarsInternal(int[] bpmChangesKeys,
-            int[] bpmChangesValues, int bpmChangesSize, int resolution, int ts,
+        public static extern IntPtr CalculateBeatBarsInternal(Tempo[] bpmChanges, int bpmChangesSize, int resolution,
+            int ts,
             bool includeHalfNotes, out int size);
 
     }
@@ -56,11 +56,11 @@ public static float ConvertTickToPosition(int tick, int resolution)
         /// <param name="resolution">The resolution of the song.</param>
         /// <param name="bpmChanges">All BPM changes within the song.</param>
         /// <param name="timeSignatureChanges">All time signature changes within the song.</param>
-        public static int ConvertSecondsToTicks(float seconds, int resolution, Dictionary<int, int> bpmChanges,
+        public static int ConvertSecondsToTicks(float seconds, int resolution, Tempo[] bpmChanges,
             TimeSignature[] timeSignatureChanges)
         {
-            return UtilitiesInternal.ConvertSecondsToTicksInternal(seconds, resolution, bpmChanges.Keys.ToArray(),
-                bpmChanges.Values.ToArray(), bpmChanges.Count, timeSignatureChanges, timeSignatureChanges.Length);
+            return UtilitiesInternal.ConvertSecondsToTicksInternal(seconds, resolution, bpmChanges, bpmChanges.Length,
+                timeSignatureChanges, timeSignatureChanges.Length);
         }
 
         /// <summary>
@@ -86,12 +86,11 @@ public static int RoundUpToTheNearestMultiplier(int value, int multiplier)
             return UtilitiesInternal.RoundUpToTheNearestMultiplier(value, multiplier);
         }
 
-        public static BeatBar[] CalculateBeatBars(Dictionary<int, int> bpmChanges, int resolution = 192, int ts = 4,
+        public static BeatBar[] CalculateBeatBars(Tempo[] bpmChanges, int resolution = 192, int ts = 4,
             bool includeHalfNotes = true)
         {
-
-            var ptrArray = UtilitiesInternal.CalculateBeatBarsInternal(bpmChanges.Keys.ToArray(),
-                bpmChanges.Values.ToArray(), bpmChanges.Count, resolution, ts, includeHalfNotes,
+            var ptrArray = UtilitiesInternal.CalculateBeatBarsInternal(bpmChanges, bpmChanges.Length, resolution, ts,
+                includeHalfNotes,
                 out var size);
 
             var beatBarSize = Marshal.SizeOf(typeof(BeatBar));

UnityPackage/Structs/Tempo.cs

@@ -0,0 +1,16 @@
+using System.Runtime.InteropServices;
+
+namespace RhythmGameUtilities
+{
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct Tempo
+    {
+
+        public int Position;
+
+        public int BPM;
+
+    }
+
+}

include/RhythmGameUtilities/Parsers.hpp

@@ -10,6 +10,7 @@
 #include "Enums/TypeCode.h"
 
 #include "Structs/Note.h"
+#include "Structs/Tempo.h"
 #include "Structs/TimeSignature.h"
 
 #include "Common.hpp"
@@ -108,7 +109,7 @@ std::map<std::string, std::string> ParseMetaDataFromChartSection(
 std::vector<TimeSignature> ParseTimeSignaturesFromChartSection(
     std::vector<std::pair<std::string, std::vector<std::string>>> section)
 {
-    auto timeSignatures = std::vector<TimeSignature>();
+    auto timeSignaturesChanges = std::vector<TimeSignature>();
 
     for (auto &line : section)
     {
@@ -119,27 +120,30 @@ std::vector<TimeSignature> ParseTimeSignaturesFromChartSection(
             auto denominator =
                 line.second.size() > 2 ? std::stoi(line.second.at(2)) : 2;
 
-            timeSignatures.push_back({position, numerator, denominator});
+            timeSignaturesChanges.push_back({position, numerator, denominator});
         }
     }
 
-    return timeSignatures;
+    return timeSignaturesChanges;
 }
 
-std::map<int, int> ParseBpmFromChartSection(
+std::vector<Tempo> ParseBpmFromChartSection(
     std::vector<std::pair<std::string, std::vector<std::string>>> section)
 {
-    auto bpm = std::map<int, int>();
+    auto bpmChanges = std::vector<Tempo>();
 
     for (auto &line : section)
     {
         if (line.second.front() == ToString(TypeCode::BPM_Marker))
         {
-            bpm.insert({std::stoi(line.first), std::stoi(line.second.at(1))});
+            auto position = std::stoi(line.first);
+            auto bpm = std::stoi(line.second.at(1));
+
+            bpmChanges.push_back({position, bpm});
         }
     }
 
-    return bpm;
+    return bpmChanges;
 }
 
 std::vector<Note> ParseNotesFromChartSection(

include/RhythmGameUtilities/Structs/Tempo.h

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace RhythmGameUtilities
+{
+
+struct Tempo
+{
+    int Position;
+
+    int BPM;
+};
+
+} // namespace RhythmGameUtilities

include/RhythmGameUtilities/Utilities.hpp

@@ -8,6 +8,7 @@
 
 #include "Structs/BeatBar.h"
 #include "Structs/Note.h"
+#include "Structs/Tempo.h"
 #include "Structs/TimeSignature.h"
 
 #include "Common.hpp"
@@ -34,7 +35,7 @@ const float SECONDS_PER_MINUTE = 60.0f;
  */
 
 int ConvertSecondsToTicks(float seconds, int resolution,
-                          std::map<int, int> bpmChanges,
+                          std::vector<Tempo> bpmChanges,
                           std::vector<TimeSignature> timeSignatureChanges)
 {
     auto bpmIterator = bpmChanges.begin();
@@ -43,13 +44,13 @@ int ConvertSecondsToTicks(float seconds, int resolution,
     auto totalTicks = 0;
     auto remainingSeconds = seconds;
     auto previousTick = 0;
-    auto previousBPM = bpmIterator->second / 1000.0;
+    auto previousBPM = bpmIterator->BPM / 1000.0;
     auto previousTimeSignature = timeSignatureIterator->Numerator;
 
     while (remainingSeconds > 0)
     {
         int nextBPMChange =
-            bpmIterator != bpmChanges.end() ? bpmIterator->first : INT_MAX;
+            bpmIterator != bpmChanges.end() ? bpmIterator->Position : INT_MAX;
 
         int nextTimeSignatureChange =
             timeSignatureIterator != timeSignatureChanges.end()
@@ -74,7 +75,7 @@ int ConvertSecondsToTicks(float seconds, int resolution,
 
         if (nextChangeTick == nextBPMChange)
         {
-            previousBPM = bpmIterator->second / 1000.0;
+            previousBPM = bpmIterator->BPM / 1000.0;
             ++bpmIterator;
         }
 
@@ -122,13 +123,20 @@ GenerateAdjacentKeyPairs(std::map<int, int> keyValuePairs)
     return adjacentKeyPairs;
 }
 
-std::vector<BeatBar> CalculateBeatBars(std::map<int, int> bpmChanges,
+std::vector<BeatBar> CalculateBeatBars(std::vector<Tempo> bpmChanges,
                                        int resolution, int ts,
                                        bool includeHalfNotes)
 {
     std::vector<BeatBar> beatBars;
 
-    auto keyValuePairs = GenerateAdjacentKeyPairs(bpmChanges);
+    std::map<int, int> bpmChangePositions;
+
+    for (const auto &bpmChange : bpmChanges)
+    {
+        bpmChangePositions[bpmChange.Position] = bpmChange.BPM;
+    }
+
+    auto keyValuePairs = GenerateAdjacentKeyPairs(bpmChangePositions);
 
     for (const auto &keyValuePair : keyValuePairs)
     {
@@ -137,12 +145,15 @@ std::vector<BeatBar> CalculateBeatBars(std::map<int, int> bpmChanges,
 
         for (auto tick = startTick; tick < endTick; tick += resolution)
         {
-            beatBars.push_back({tick, bpmChanges[startTick]});
+
+            auto position = tick;
+            auto bpm = bpmChangePositions[startTick];
+
+            beatBars.push_back({tick, bpm});
 
             if (includeHalfNotes && tick != endTick)
             {
-                beatBars.push_back(
-                    {tick + resolution / 2, bpmChanges[startTick]});
+                beatBars.push_back({tick + resolution / 2, bpm});
             }
         }
     }