Added new song class to C# libraries.

Author: neogeek

RhythmGameUtilities/Structs/Song.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace RhythmGameUtilities
+{
+
+    public class Song
+    {
+
+        private readonly Dictionary<string, KeyValuePair<string, string[]>[]> _sections;
+
+        public Dictionary<string, string> metaData { get; }
+
+        public int resolution { get; }
+
+        public Tempo[] tempoChanges { get; private set; }
+
+        public TimeSignature[] timeSignatureChanges { get; }
+
+        public Dictionary<Difficulty, Note[]> difficulties { get; private set; }
+
+        public BeatBar[] beatBars { get; private set; }
+
+        public Song(string contents)
+        {
+            _sections = Parsers.ParseSectionsFromChart(contents);
+
+            metaData = Parsers.ParseMetaDataFromChartSection(_sections
+                .First(section => section.Key == NamedSection.Song)
+                .Value);
+
+            resolution = int.Parse(metaData["Resolution"]);
+
+            tempoChanges = Parsers.ParseTempoChangesFromChartSection(_sections
+                .First(section => section.Key == NamedSection.SyncTrack)
+                .Value);
+
+            timeSignatureChanges = Parsers.ParseTimeSignatureChangesFromChartSection(_sections[NamedSection.SyncTrack]);
+
+            difficulties = Enum.GetValues(typeof(Difficulty))
+                .Cast<Difficulty>()
+                .Where(difficulty => _sections.ToDictionary(item => item.Key, x => x.Value)
+                    .ContainsKey($"{difficulty}Single"))
+                .ToDictionary(difficulty => difficulty,
+                    difficulty => Parsers.ParseNotesFromChartSection(_sections[$"{difficulty}Single"]));
+
+            beatBars = Utilities.CalculateBeatBars(tempoChanges, includeHalfNotes : true);
+        }
+
+        public void RecalculateBeatBarsWithSongLength(float songLength)
+        {
+            var lastTick = Utilities.ConvertSecondsToTicks(songLength, resolution, tempoChanges, timeSignatureChanges);
+
+            tempoChanges = Parsers.ParseTempoChangesFromChartSection(_sections
+                .First(section => section.Key == NamedSection.SyncTrack)
+                .Value);
+
+            tempoChanges = tempoChanges.Concat(new Tempo[]
+                {
+                    new()
+                    {
+                        Position = Utilities.RoundUpToTheNearestMultiplier(lastTick, resolution),
+                        BPM = tempoChanges.Last().BPM
+                    }
+                })
+                .ToArray();
+
+            beatBars = Utilities.CalculateBeatBars(tempoChanges, includeHalfNotes : true);
+        }
+
+    }
+
+}

UnityPackage/Samples~/SampleSong (URP)/Scripts/RenderSong.cs

@@ -1,7 +1,5 @@
-using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Threading.Tasks;
 using System.Web;
 using RhythmGameUtilities;
@@ -51,67 +49,21 @@ public class RenderSong : MonoBehaviour
 
     private readonly Vector3 _beatBarScaleQuarter = new(5, 0.03f, 0.01f);
 
-    public int resolution { get; set; } = 192;
-
-    public Tempo[] tempoChanges { get; set; }
-
-    public TimeSignature[] timeSignatureChanges { get; set; }
-
-    public Dictionary<Difficulty, Note[]> difficulties { get; set; }
-
-    public Dictionary<int, List<Note>> notesGroupedByHandPosition { get; set; }
-
-    public BeatBar[] beatBars { get; set; }
+    private Song _song;
 
     private async void Start()
     {
         var path = Path.Join(Application.dataPath, _songPath, "notes.chart");
 
         var contents = await LoadTextFileFromPath($"file://{HttpUtility.UrlPathEncode(path)}");
 
-        var sections = Parsers.ParseSectionsFromChart(contents);
-
-        var metadata = Parsers.ParseMetaDataFromChartSection(sections
-            .First(section => section.Key == NamedSection.Song)
-            .Value);
+        _song = new Song(contents);
 
         _audioSource.clip =
             await LoadAudioFileFromPath(
-                $"file://{HttpUtility.UrlPathEncode(Path.Join(Path.GetDirectoryName(path), metadata["MusicStream"]))}");
-
-        resolution = int.Parse(metadata["Resolution"]);
-
-        tempoChanges = Parsers.ParseTempoChangesFromChartSection(sections.First(section => section.Key == NamedSection.SyncTrack)
-            .Value);
-
-        timeSignatureChanges = Parsers.ParseTimeSignatureChangesFromChartSection(sections[NamedSection.SyncTrack]);
-
-        var lastTick =
-            Utilities.ConvertSecondsToTicks(_audioSource.clip.length, resolution, tempoChanges, timeSignatureChanges);
-
-        tempoChanges = tempoChanges.Concat(new Tempo[]
-            {
-                new()
-                {
-                    Position = Utilities.RoundUpToTheNearestMultiplier(lastTick, resolution),
-                    BPM = tempoChanges.Last().BPM
-                }
-            })
-            .ToArray();
-
-        difficulties = Enum.GetValues(typeof(Difficulty))
-            .Cast<Difficulty>()
-            .Where(difficulty => sections.ToDictionary(item => item.Key, x => x.Value)
-                .ContainsKey($"{difficulty}Single"))
-            .ToDictionary(difficulty => difficulty,
-                difficulty => Parsers.ParseNotesFromChartSection(sections[$"{difficulty}Single"]));
+                $"file://{HttpUtility.UrlPathEncode(Path.Join(Path.GetDirectoryName(path), _song.metaData["MusicStream"]))}");
 
-        notesGroupedByHandPosition = difficulties[Difficulty.Expert]
-            .Where(note => note.HandPosition < 5)
-            .GroupBy(note => note.HandPosition)
-            .ToDictionary(group => group.Key, group => group.ToList());
-
-        beatBars = Utilities.CalculateBeatBars(tempoChanges, includeHalfNotes : true);
+        _song.RecalculateBeatBarsWithSongLength(_audioSource.clip.length);
 
         _audioSource.Play();
     }
@@ -161,18 +113,19 @@ private void Update()
     {
         RenderTrack();
 
-        if (notesGroupedByHandPosition == null)
+        if (_song?.difficulties?[Difficulty.Easy] == null)
         {
             return;
         }
 
         var tickOffset =
-            Utilities.ConvertSecondsToTicks(_audioSource.time, resolution, tempoChanges, timeSignatureChanges);
+            Utilities.ConvertSecondsToTicks(_audioSource.time, _song.resolution, _song.tempoChanges,
+                _song.timeSignatureChanges);
 
-        RenderHitNotes(notesGroupedByHandPosition);
+        RenderHitNotes();
 
-        RenderNotes(notesGroupedByHandPosition, resolution, tickOffset);
-        RenderBeatBars(beatBars, resolution, tickOffset);
+        RenderNotes(_song.difficulties[Difficulty.Easy], _song.resolution, tickOffset);
+        RenderBeatBars(_song.beatBars, _song.resolution, tickOffset);
     }
 
     private void RenderTrack()
@@ -183,51 +136,43 @@ private void RenderTrack()
             _trackMaterial, 0);
     }
 
-    private void RenderHitNotes(Dictionary<int, List<Note>> notesGroupedByHandPosition)
+    private void RenderHitNotes()
     {
-        for (var x = 0; x < notesGroupedByHandPosition.Count; x += 1)
+        for (var x = 0; x < 5; x += 1)
         {
             Graphics.DrawMesh(_mesh,
                 Matrix4x4.TRS(new Vector3(x + 0.5f, 0, 0), Quaternion.identity, _noteScaleFlat),
                 _materials[x], 0);
         }
     }
 
-    private void RenderNotes(Dictionary<int, List<Note>> notesGroupedByHandPosition, int resolution, int tickOffset)
+    private void RenderNotes(Note[] notes, int resolution, int tickOffset)
     {
-        for (var x = 0; x < notesGroupedByHandPosition.Count; x += 1)
-        {
-            if (!notesGroupedByHandPosition.ContainsKey(x))
-            {
-                continue;
-            }
-
-            var noteMatrix = new List<Matrix4x4>
-            {
-                Matrix4x4.TRS(new Vector3(x + 0.5f, 0, 0), Quaternion.identity, _noteScaleFlat)
-            };
+        var laneArray = new Dictionary<int, List<Matrix4x4>>();
 
-            for (var y = 0; y < notesGroupedByHandPosition[x].Count; y += 1)
-            {
-                var position = Utilities.ConvertTickToPosition(notesGroupedByHandPosition[x][y].Position - tickOffset,
-                    resolution) * _scale;
+        for (var x = 0; x < 5; x += 1)
+        {
+            laneArray.Add(x, new List<Matrix4x4>());
+        }
 
-                if (position > _distance)
-                {
-                    break;
-                }
+        for (var i = 0; i < notes.Length; i += 1)
+        {
+            if (notes[i].HandPosition > 5) continue;
 
-                if (position < 0)
-                {
-                    continue;
-                }
+            var position = Utilities.ConvertTickToPosition(notes[i].Position - tickOffset,
+                resolution) * _scale;
 
-                noteMatrix.Add(Matrix4x4.TRS(
-                    new Vector3(notesGroupedByHandPosition[x][y].HandPosition + 0.5f, 0, position),
+            if (position > 0 && position < _distance)
+            {
+                laneArray[notes[i].HandPosition].Add(Matrix4x4.TRS(
+                    new Vector3(notes[i].HandPosition + 0.5f, 0, position),
                     Quaternion.identity, _noteScale));
             }
+        }
 
-            Graphics.DrawMeshInstanced(_mesh, 0, _materials[x], noteMatrix);
+        for (var x = 0; x < 5; x += 1)
+        {
+            Graphics.DrawMeshInstanced(_mesh, 0, _materials[x], laneArray[x]);
         }
     }
 
@@ -242,30 +187,23 @@ private void RenderBeatBars(BeatBar[] beatBars, int resolution, int tickOffset)
             var position = Utilities.ConvertTickToPosition(beatBars[x].Position - tickOffset, resolution) *
                            _scale;
 
-            if (position > _distance)
-            {
-                break;
-            }
-
-            if (position < 0)
-            {
-                continue;
-            }
-
-            if (x % 8 == 0)
-            {
-                beatBarMatrix.Add(Matrix4x4.TRS(new Vector3(2.5f, 0, position), Quaternion.identity,
-                    _beatBarScaleFull));
-            }
-            else if (x % 2 == 0)
-            {
-                beatBarHalfMatrix.Add(Matrix4x4.TRS(new Vector3(2.5f, 0, position), Quaternion.identity,
-                    _beatBarScaleHalf));
-            }
-            else
+            if (position > 0 && position < _distance)
             {
-                beatBarQuarterMatrix.Add(Matrix4x4.TRS(new Vector3(2.5f, 0, position), Quaternion.identity,
-                    _beatBarScaleQuarter));
+                if (x % 8 == 0)
+                {
+                    beatBarMatrix.Add(Matrix4x4.TRS(new Vector3(2.5f, 0, position), Quaternion.identity,
+                        _beatBarScaleFull));
+                }
+                else if (x % 2 == 0)
+                {
+                    beatBarHalfMatrix.Add(Matrix4x4.TRS(new Vector3(2.5f, 0, position), Quaternion.identity,
+                        _beatBarScaleHalf));
+                }
+                else
+                {
+                    beatBarQuarterMatrix.Add(Matrix4x4.TRS(new Vector3(2.5f, 0, position), Quaternion.identity,
+                        _beatBarScaleQuarter));
+                }
             }
         }