It sounds like you're trying to create a seamless loop within an animation by manipulating the track time and animation start/end times. Here are some suggestions based on the information provided:

1. Using Track Time:

   • When you capture the loop-begin event time, ensure you are correctly setting the track time when the loop-end event hits. This should look something like:

          trackEntry->setTrackTime(loopBeginEventTime);

   • Make sure you are not inadvertently resetting or clearing the track, which could cause the animation to stop or jump.

2. Using Animation Start/End:

   • When setting the animation start and end times, ensure you are correctly setting the loop flag and updating the track entry. This should look something like:

          trackEntry->setAnimationStart(loopBeginEventTime);
          trackEntry->setAnimationEnd(loopEndEventTime);
          trackEntry->setLoop(true);

   • Ensure that the loop flag is set appropriately to avoid unexpected behavior.

3. Internal Data Updates:

   • You mentioned _trackLast and _nextTrackLast. These are internal variables that help manage the state of the animation. If you are manually manipulating the track time or animation start/end times, you may need to update these variables to reflect the new state.
   • After making changes, ensure you are calling the necessary update methods to apply the changes:

          animationState->update(deltaTime);
          animationState->apply(skeleton);
          skeleton->updateWorldTransform();

4. Debugging:

   • Add logging to track the values of trackTime, animationStart, and animationEnd before and after you make changes. This can help you identify if the values are being set correctly.
   • Ensure that the events are being triggered at the correct times and that there are no race conditions causing unexpected behavior.

If these suggestions do not resolve the issue, you may need to create a minimal reproducible example to isolate the problem. This can help identify if there is an issue with the runtime or if additional steps are needed to achieve the desired behavior.

Manipulating animationStart and animationEnd mid-playback is interesting, though I've not tried it and I'm not sure what else it may affect. You don't generally want to set private fields (starting with _).

It's likely easiest to use 3 track entries instead of manipulating a single entry. Eg:

intro = state.setAnimation(0, "animation", false);
intro.animationEnd = 0.25; // intro end time

loop = state.addAnimation(0, "animation", true, 0);
loop.animationStart = 0.25; // intro end time
loop.animationEnd = 0.75; // loop end time

outro = state.addAnimation(0, "animation", false, 6); // 6 is duration to play loop
outro.animationStart = 0.75; // loop end time

You could postpone adding the outro if you want to play the looping part for an indefinite amount of time. In that case you'd probably set the addAnimation delay to 0, so the outro starts at the end of the next loop.

You can do this part to play the intro and then loop indefinitely:

intro = state.setAnimation(0, "animation", false);
intro.animationEnd = 0.25; // intro end time

loop = state.addAnimation(0, "animation", true, 0);
loop.animationStart = 0.25; // intro end time
loop.animationEnd = 0.75; // loop end time

It will continue to loop. When you want to stop it:

outro = state.addAnimation(0, "animation", false, 0);
outro.animationStart = 0.75; // loop end time

The 0 delay passed to addAnimation will cause the outro entry to play the next time the loop completes.

eglynum I don't know those values before playing the animation and hitting the loop start/end events. If I had that data before-hand, then I think you're approach would work.

You could query the Animation for the vector of EventTimeline and then get the timepoints from the events of those timelines. Untested pseudo-code:

Vector<Timeline*> timelines = animation->getTimelines();
for (auto *timeline : timelines) {
    if (timeline->getRTTI().isExactly(EventTimeline::rtti)) {
        EventTimeline *eventTimeline = static_cast<EventTimeline*>(timeline);
        Vector<Event *> &events = eventTimeline->getEvents();
         // now get event time and data from each event and compare it to your loop start/end event names
    }
}