fix(rendering): Correct cursor movement on repeats

Author: Danielku15

src/AlphaTabApiBase.ts

@@ -2,7 +2,11 @@ import { AlphaSynthMidiFileHandler } from '@src/midi/AlphaSynthMidiFileHandler';
 import { MidiFileGenerator } from '@src/midi/MidiFileGenerator';
 
 import { MidiFile } from '@src/midi/MidiFile';
-import { MidiTickLookup, MidiTickLookupFindBeatResult } from '@src/midi/MidiTickLookup';
+import {
+    MidiTickLookup,
+    MidiTickLookupFindBeatResult,
+    MidiTickLookupFindBeatResultCursorMode
+} from '@src/midi/MidiTickLookup';
 import { IAlphaSynth } from '@src/synth/IAlphaSynth';
 import { PlaybackRange } from '@src/synth/PlaybackRange';
 import { PlayerState } from '@src/synth/PlayerState';
@@ -837,7 +841,7 @@ export class AlphaTabApiBase<TSettings> {
             this.player.positionChanged.on(e => {
                 this._previousTick = e.currentTick;
                 this.uiFacade.beginInvoke(() => {
-                    this.cursorUpdateTick(e.currentTick, false);
+                    this.cursorUpdateTick(e.currentTick, false, false, e.isSeek);
                 });
             });
             this.player.stateChanged.on(e => {
@@ -859,14 +863,14 @@ export class AlphaTabApiBase<TSettings> {
      * @param stop
      * @param shouldScroll whether we should scroll to the bar (if scrolling is active)
      */
-    private cursorUpdateTick(tick: number, stop: boolean, shouldScroll: boolean = false): void {
+    private cursorUpdateTick(tick: number, stop: boolean, shouldScroll: boolean = false, forceUpdate:boolean = false): void {
         let cache: MidiTickLookup | null = this._tickCache;
         if (cache) {
             let tracks = this._trackIndexLookup;
             if (tracks != null && tracks.size > 0) {
                 let beat: MidiTickLookupFindBeatResult | null = cache.findBeat(tracks, tick, this._currentBeat);
                 if (beat) {
-                    this.cursorUpdateBeat(beat, stop, shouldScroll);
+                    this.cursorUpdateBeat(beat, stop, shouldScroll, forceUpdate || this.playerState === PlayerState.Paused);
                 }
             }
         }
@@ -900,7 +904,8 @@ export class AlphaTabApiBase<TSettings> {
             !forceUpdate &&
             beat === previousBeat?.beat &&
             cache === previousCache &&
-            previousState === this._playerState
+            previousState === this._playerState && 
+            previousBeat?.start === lookupResult.start
         ) {
             return;
         }
@@ -924,7 +929,8 @@ export class AlphaTabApiBase<TSettings> {
                 beatsToHighlight,
                 cache!,
                 beatBoundings!,
-                shouldScroll
+                shouldScroll,
+                lookupResult.cursorMode
             );
         });
     }
@@ -1010,7 +1016,8 @@ export class AlphaTabApiBase<TSettings> {
         beatsToHighlight: BeatTickLookupItem[],
         cache: BoundsLookup,
         beatBoundings: BeatBounds,
-        shouldScroll: boolean
+        shouldScroll: boolean,
+        cursorMode: MidiTickLookupFindBeatResultCursorMode
     ) {
         const barCursor = this._barCursor;
         const beatCursor = this._beatCursor;
@@ -1050,7 +1057,7 @@ export class AlphaTabApiBase<TSettings> {
             if (this.settings.player.enableAnimatedBeatCursor) {
                 let nextBeatX: number = barBoundings.visualBounds.x + barBoundings.visualBounds.w;
                 // get position of next beat on same system
-                if (nextBeat) {
+                if (nextBeat && cursorMode == MidiTickLookupFindBeatResultCursorMode.ToNextBext) {
                     // if we are moving within the same bar or to the next bar
                     // transition to the next beat, otherwise transition to the end of the bar.
                     let nextBeatBoundings: BeatBounds | null = cache.findBeat(nextBeat);

src/midi/MidiTickLookup.ts

@@ -4,6 +4,26 @@ import { MidiUtils } from '@src/midi/MidiUtils';
 import { Beat } from '@src/model/Beat';
 import { MasterBar } from '@src/model/MasterBar';
 
+/**
+ * Describes how a cursor should be moving.
+ */
+export enum MidiTickLookupFindBeatResultCursorMode {
+    /**
+     * Unknown/Undetermined mode. Should not happen on user level.
+     */
+    Unknown,
+
+    /**
+     * The cursor should animate to the next beat.
+     */
+    ToNextBext,
+
+    /**
+     * The cursor should animate to the end of the bar (typically on repeats and jumps)
+     */
+    ToEndOfBar
+}
+
 /**
  * Represents the results of searching the currently played beat.
  * @see MidiTickLookup.FindBeat
@@ -40,6 +60,11 @@ export class MidiTickLookupFindBeatResult {
      */
     public duration: number = 0;
 
+    /**
+     * The mode how the cursor should be handled.
+     */
+    public cursorMode: MidiTickLookupFindBeatResultCursorMode = MidiTickLookupFindBeatResultCursorMode.Unknown;    
+
     public get start(): number {
         return this.masterBar.start + this.beatLookup.start;
     }
@@ -57,7 +82,7 @@ export class MidiTickLookupFindBeatResult {
         if (this.masterBar.tempoChanges.length === 1) {
             this.duration = MidiUtils.ticksToMillis(this.tickDuration, this.masterBar.tempoChanges[0].tempo);
         } else {
-            // Performance Note: I still wonder if we cannot calculate these slices efficiently ahead-of-time. 
+            // Performance Note: I still wonder if we cannot calculate these slices efficiently ahead-of-time.
             // the sub-slicing in the lookup across beats makes it a bit tricky to do on-the-fly
             // but maybe on finalizing the tick lookup?
 
@@ -77,7 +102,7 @@ export class MidiTickLookupFindBeatResult {
                 // next change is after beat, we can stop looking at changes
                 else if (change.tick > endTick) {
                     break;
-                } 
+                }
                 // change while beat is playing
                 else {
                     millis += MidiUtils.ticksToMillis(change.tick - currentTick, currentTempo);
@@ -87,7 +112,7 @@ export class MidiTickLookupFindBeatResult {
             }
 
             // last slice
-            if(endTick > currentTick) {
+            if (endTick > currentTick) {
                 millis += MidiUtils.ticksToMillis(endTick - currentTick, currentTempo);
             }
 
@@ -199,7 +224,6 @@ export class MidiTickLookup {
             current.beatLookup.nextBeat,
             current.end,
             trackLookup,
-            false,
             true
         );
 
@@ -210,14 +234,29 @@ export class MidiTickLookup {
         // if we have the next beat take the difference between the times as duration
         if (current.nextBeat) {
             current.tickDuration = current.nextBeat.start - current.start;
+            current.cursorMode = MidiTickLookupFindBeatResultCursorMode.ToNextBext;
             current.calculateDuration();
         }
 
         // no next beat, animate to the end of the bar (could be an incomplete bar)
         if (!current.nextBeat) {
             current.tickDuration = current.masterBar.end - current.start;
+            current.cursorMode = MidiTickLookupFindBeatResultCursorMode.ToEndOfBar;
             current.calculateDuration();
         }
+
+        // if the next beat is not directly the next master bar (e.g. jumping back or forth)
+        // we report no next beat and animate to the end
+        if (
+            current.nextBeat &&
+            current.nextBeat.masterBar.masterBar.index != current.masterBar.masterBar.index + 1 &&
+            (
+                current.nextBeat.masterBar.masterBar.index != current.masterBar.masterBar.index ||
+                current.nextBeat.beat.playbackStart <= current.beat.playbackStart
+            )
+        ) {
+            current.cursorMode = MidiTickLookupFindBeatResultCursorMode.ToEndOfBar;
+        }        
     }
 
     private findBeatSlow(
@@ -261,7 +300,6 @@ export class MidiTickLookup {
                     masterBar.firstBeat,
                     tick,
                     trackLookup,
-                    true,
                     isNextSearch
                 );
 
@@ -282,16 +320,15 @@ export class MidiTickLookup {
      * @param currentStartLookup
      * @param tick
      * @param visibleTracks
-     * @param fillNext
+     * @param isNextSearch
      * @returns
      */
     private findBeatInMasterBar(
         masterBar: MasterBarTickLookup,
         currentStartLookup: BeatTickLookup | null,
         tick: number,
         visibleTracks: Set<number>,
-        fillNext: boolean,
-        isNextSeach: boolean
+        isNextSearch: boolean
     ): MidiTickLookupFindBeatResult | null {
         if (!currentStartLookup) {
             return null;
@@ -310,7 +347,7 @@ export class MidiTickLookup {
                 // found the matching beat lookup but none of the beats are visible
                 // in this case scan further to the next lookup which has any visible beat
                 if (!startBeat) {
-                    if (isNextSeach) {
+                    if (isNextSearch) {
                         let currentMasterBar: MasterBarTickLookup | null = masterBar;
                         while (currentMasterBar != null && startBeat == null) {
                             while (currentStartLookup != null) {
@@ -363,7 +400,7 @@ export class MidiTickLookup {
             return null;
         }
 
-        const result = this.createResult(masterBar, startBeatLookup!, startBeat, fillNext, visibleTracks);
+        const result = this.createResult(masterBar, startBeatLookup!, startBeat, isNextSearch, visibleTracks);
 
         return result;
     }
@@ -372,7 +409,7 @@ export class MidiTickLookup {
         masterBar: MasterBarTickLookup,
         beatLookup: BeatTickLookup,
         beat: Beat,
-        fillNext: boolean,
+        isNextSearch: boolean,
         visibleTracks: Set<number>
     ) {
         const result = new MidiTickLookupFindBeatResult(masterBar);
@@ -382,7 +419,7 @@ export class MidiTickLookup {
 
         result.tickDuration = beatLookup!.end - beatLookup!.start;
 
-        if (fillNext) {
+        if (!isNextSearch) {
             this.fillNextBeat(result, visibleTracks);
         }