Simplified bpm data structure.

neogeek · neogeek · commit 4aa6b0e97a3a · 2025-01-21T14:01:38.000-05:00
diff --git a/RhythmGameUtilities.Tests/UtilitiesTest.cs b/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);
diff --git a/RhythmGameUtilities/Scripts/Utilities.cs b/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));
diff --git a/RhythmGameUtilities/Structs/Tempo.cs b/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;
+
+    }
+
+}
diff --git a/UnityPackage/Editor/Tests/UtilitiesTest.cs b/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);
diff --git a/UnityPackage/Scripts/Utilities.cs b/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));
diff --git a/UnityPackage/Structs/Tempo.cs b/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;
+
+    }
+
+}
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/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(
diff --git a/include/RhythmGameUtilities/Structs/Tempo.h b/include/RhythmGameUtilities/Structs/Tempo.h
@@ -0,0 +1,13 @@
+#pragma once
+
+namespace RhythmGameUtilities
+{
+
+struct Tempo
+{
+    int Position;
+
+    int BPM;
+};
+
+} // namespace RhythmGameUtilities
diff --git a/include/RhythmGameUtilities/Utilities.hpp b/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});
             }
         }
     }
diff --git a/include/RhythmGameUtilities/UtilitiesInternal.hpp b/include/RhythmGameUtilities/UtilitiesInternal.hpp
diff --git a/tests/RhythmGameUtilities/Utilities.cpp b/tests/RhythmGameUtilities/Utilities.cpp
diff --git a/tests/RhythmGameUtilities/UtilitiesInternal.cpp b/tests/RhythmGameUtilities/UtilitiesInternal.cpp

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@`
`10`	`10`	`#include "Enums/TypeCode.h"`
`11`	`11`
`12`	`12`	`#include "Structs/Note.h"`
	`13`	`+#include "Structs/Tempo.h"`
`13`	`14`	`#include "Structs/TimeSignature.h"`
`14`	`15`
`15`	`16`	`#include "Common.hpp"`
`@@ -108,7 +109,7 @@ std::map<std::string, std::string> ParseMetaDataFromChartSection(`
`108`	`109`	`std::vector<TimeSignature> ParseTimeSignaturesFromChartSection(`
`109`	`110`	`std::vector<std::pair<std::string, std::vector<std::string>>> section)`
`110`	`111`	`{`
`111`		`- auto timeSignatures = std::vector<TimeSignature>();`
	`112`	`+ auto timeSignaturesChanges = std::vector<TimeSignature>();`
`112`	`113`
`113`	`114`	`for (auto &line : section)`
`114`	`115`	`{`
`@@ -119,27 +120,30 @@ std::vector<TimeSignature> ParseTimeSignaturesFromChartSection(`
`119`	`120`	`auto denominator =`
`120`	`121`	`line.second.size() > 2 ? std::stoi(line.second.at(2)) : 2;`
`121`	`122`
`122`		`- timeSignatures.push_back({position, numerator, denominator});`
	`123`	`+ timeSignaturesChanges.push_back({position, numerator, denominator});`
`123`	`124`	`}`
`124`	`125`	`}`
`125`	`126`
`126`		`- return timeSignatures;`
	`127`	`+ return timeSignaturesChanges;`
`127`	`128`	`}`
`128`	`129`
`129`		`-std::map<int, int> ParseBpmFromChartSection(`
	`130`	`+std::vector<Tempo> ParseBpmFromChartSection(`
`130`	`131`	`std::vector<std::pair<std::string, std::vector<std::string>>> section)`
`131`	`132`	`{`
`132`		`- auto bpm = std::map<int, int>();`
	`133`	`+ auto bpmChanges = std::vector<Tempo>();`
`133`	`134`
`134`	`135`	`for (auto &line : section)`
`135`	`136`	`{`
`136`	`137`	`if (line.second.front() == ToString(TypeCode::BPM_Marker))`
`137`	`138`	`{`
`138`		`- bpm.insert({std::stoi(line.first), std::stoi(line.second.at(1))});`
	`139`	`+ auto position = std::stoi(line.first);`
	`140`	`+ auto bpm = std::stoi(line.second.at(1));`
	`141`	`+`
	`142`	`+ bpmChanges.push_back({position, bpm});`
`139`	`143`	`}`
`140`	`144`	`}`
`141`	`145`
`142`		`- return bpm;`
	`146`	`+ return bpmChanges;`
`143`	`147`	`}`
`144`	`148`
`145`	`149`	`std::vector<Note> ParseNotesFromChartSection(`