Plugins + Scripts Animatis

Animatis – Update Version 2.1​

UI Overhaul: Collapsible Sections + Cleaner Workflow​

Animatis has received a major UI upgrade focused on clarity and speed. The interface is now easier to navigate, with advanced options tucked away until you need them.

What’s New​

Collapsible Sections (Cleaner Tabs)​

• Added collapsible UI blocks to keep the layout clean and beginner-friendly
• Advanced features like SEQUENCING can now be expanded/collapsed on demand
• Helps reduce scrolling and makes the main workflow faster

Improved Tab Experience​

• Refined the tab layout to feel more consistent and “tool-like”
• Clearer separation between basic workflow and advanced features

Enhancements / Improvements​

Sequencing UI (Better Flow Control)​

• Sequencing controls are now grouped in a dedicated collapsible section:
  • Next Animation selection
  • Transition Time (crossfade)
  • Rename Animation

Keyframe & Editing Stability Improvements​

• Improved keyframe time handling (more consistent behavior when adding/removing keys)
• Safer delete logic to prevent accidental removal of nearby keyframes

Quality-of-Life & External Control​

• Expanded trigger actions / external control options (play/stop, navigation, etc.)
• General safety and performance polish in the update loop

& Rename your animation!​

---

Changelog Summary​

Added

• Collapsible UI sections (example: SEQUENCING block)

Improved

• Overall UI structure and workflow clarity
• Keyframe editing stability and deletion accuracy
• Sequencing controls grouped and easier to manage
  
  
  
  
  

Small fix this time for the Segmental speed not working correctly

Issue: RequestUIRefresh() calls expected immediate UI updates, but only set a flag checked when the Targets tab opened

Fix: Replaced with SelectTab(6) for immediate Keyframes tab rebuilds

Status: Testet and FIXED

Update v1.9-serious bug fixes.

So last update had critical issues i had overlooked which i hope now should be fixed.

Critical Bugs Fixed:

1. Timeline Scrubber Not Updating Current Time CRITICAL

File: TimelineUI.cs line 66
Problem: Timeline scrubber had no callback - dragging it didn't update currentAnimation.currentTime
Fix: Added timeStorable.setCallbackFunction = OnTimeChanged;
Result: Scrubber now properly updates time, "Add Keyframe at Current Time" works correctly

---
2. Keyframe Tangent Corruption CRITICAL

Files: SimpleAnimation.cs lines 610-655, MorphAnimation.cs lines 32-77
Problem: Adding a keyframe at time X would alter the curve tangents at neighboring keyframes, permanently changing the animation shape even after deleting the keyframe
Fix: Save all existing keyframes before adding new one, restore original tangents after insertion
Result: Adding/deleting keyframes no longer corrupts the existing animation curve

---
3. Delete Keyframe Time Mismatch HIGH

File: TimelineUI.cs lines 377-396
Problem: Delete used currentAnimation.currentTime which might be slightly off from actual keyframe times
Fix: Snap to closest canonical keyframe time before deleting
Result: Delete now reliably removes the keyframe you clicked on

---
Performance Optimizations:

4. Playing Animations Cache PERFORMANCE

File: SimpleTimeline.cs lines 18, 100, 2763-2777, 2986-2998, 3034
Added: playingAnimations list cache + SetAnimationPlaying() helper
Benefit: With 50 animations and only 1 playing = 50x performance improvement in Update/LateUpdate loops

---
Data Integrity Fixes:

5. Culture-Invariant Float Serialization HIGH

Files: SimpleTimeline.cs (multiple locations), TriggerTrack.cs lines 154-155
Problem: Used culture-dependent ToString() - German users got commas (1,5) instead of periods (1.5)
Fix: All ToString() → ToString(CultureInfo.InvariantCulture)
Result: Presets now work internationally, no more decimal separator issues

6. Safe Deserialization with TryParse HIGH

Files: SimpleTimeline.cs (lines 3740, 3745, 3762, 3784-3786, 4007-4010), TriggerTrack.cs lines 176-180
Problem: Used float.Parse() which crashes on corrupted data
Fix: All Parse() → TryParse(..., NumberStyles.Float, CultureInfo.InvariantCulture, out ...)
Result: Corrupted presets fail gracefully with default values instead of crashing

---
User Experience Improvements:

7. Timeline Click Snapping UX

File: SimpleTimeline.cs lines 2133-2148
Problem: Clicking timeline jumped to any arbitrary time
Fix: Snap to nearest canonical keyframe time
Result: Timeline clicks are now optimal - always land on exact keyframe positions

8. Delete Keyframe Logging DEBUG

File: TimelineUI.cs lines 378-454
Added: Detailed logging showing which controllers/morphs had keyframes deleted
Result: Clear feedback about what was deleted and at what exact time

---
Code Consistency:

9. TriggerTrack RemoveKeyframe Consistency API

File: TriggerTrack.cs lines 42-68
Problem: Removed ALL keyframes within tolerance (different from controller/morph behavior)
Fix: Now removes only CLOSEST keyframe within tolerance
Result: Consistent API behavior across all keyframe types

10. Playing Animations Cache Rebuild SAFETY

File: SimpleTimeline.cs lines 3584-3597, 2986-2998
Added: Rebuild playingAnimations cache after loading from JSON and safety check in Update()
Result: Animations resume correctly when loading scenes/presets

---
Files Modified:

1. SimpleTimeline.cs - Culture fixes, TryParse, performance cache, timeline snapping
2. TimelineUI.cs - Scrubber callback, delete snapping, detailed logging
3. SimpleAnimation.cs - Tangent preservation in AddKeyWithLinearTangents
4. MorphAnimation.cs - Tangent preservation in AddKeyframe
5. TriggerTrack.cs - Culture-invariant serialization, safe TryParse, consistent RemoveKeyframe

---
Before vs After:
┌──────────────────────────┬─────────────────────────┬───────────────────────────────────┐
│ Issue │ Before │ After │
├──────────────────────────┼─────────────────────────┼───────────────────────────────────┤
│ Scrubber drag │ Time stuck at 0 │ Updates correctly │
├──────────────────────────┼─────────────────────────┼───────────────────────────────────┤
│ Add/Delete keyframes │ Corrupts curve shape │ Preserves original shape │
├──────────────────────────┼─────────────────────────┼───────────────────────────────────┤
│ Delete keyframe │ Often fails silently │ Reliably deletes with feedback │
├──────────────────────────┼─────────────────────────┼───────────────────────────────────┤
│ Timeline click │ Jumps to random time │ Snaps to keyframe │
├──────────────────────────┼─────────────────────────┼───────────────────────────────────┤
│ 50 animations playing │ Slow (checks all 50) │ Fast (checks only playing) │
├──────────────────────────┼─────────────────────────┼───────────────────────────────────┤
│ German user loads preset │ Crashes on "1,5" │ Works perfectly │
├──────────────────────────┼─────────────────────────┼───────────────────────────────────┤
│ Corrupted preset │ Plugin crash │ Graceful fallback │
└──────────────────────────┴─────────────────────────┴───────────────────────────────────┘

Guys if you still find issues please let me know and il try to fix as soon as i can!

Animatis v1.8 – Stability & Performance Update


This update focuses on preventing freezes/crashes and making playback more reliable in long sessions.

Major Bug Fixes & Improvements​

Critical Stability Fixes​

• Fixed division by zero crashes in timeline UI and duration calculations
• Fixed NaN propagation in segment speed calculations that could freeze animations
• Fixed array index out of bounds errors during keyframe operations
• Fixed race conditions in animation list that caused unpredictable behavior
• Added comprehensive validation to prevent infinity/NaN values in math operations

Performance & Memory​

• Fixed memory leak in morph animation curve type dictionary (added 10K entry cleanup)
• Optimized dictionary lookups using TryGetValue pattern
• Fixed quaternion denormalization drift with improved normalization threshold
• Prevented infinite loops with NaN detection in animation update cycles
• Reduced object creation overhead in UI refresh cycles

Robustness Improvements​

• Added null checks after Unity Instantiate() calls to prevent UI errors
• Added Unity object lifetime validation for destroyed references
• Fixed potential stack overflow from recursive UI refresh calls
• Added bounds checking before substring operations
• Improved event handler cleanup to prevent memory leaks

Code Quality​

• Replaced magic numbers with named constants for consistency
• Created UI color constants for maintainable styling
• Improved null safety throughout codebase
• Better error handling and validation patterns
• Standardized floating-point comparisons using TIME_TOLERANCE

Animatis v1.7 Segment Speed & Loop Fixes

Overview

This update fixes 2 critical bugs related to the segment speed system and looping animations. If you use segment speeds (variable animation speed per segment), this update is essential.

---
What's Fixed

Major Fixes:

1. Segment Speed Now Works for Short Intervals CRITICAL FIX
- Problem: Segment speeds weren't working for short time intervals (0.2s or less)
- Cause: When frame deltaTime was larger than the segment duration, the animation would skip right through the segment without applying the speed modifier
- Fixed: Implemented segment-aware time advancement that properly splits frame time across segment boundaries
- You'll notice: Slow-motion and speed-up effects now work perfectly even on very short segments (0.1s, 0.2s, etc.)

Example that now works:
Create animation with 3 keyframes:
- 0.0s: Start pose
- 0.2s: Middle pose
- 0.4s: End pose

Set segment [0.0s → 0.2s] to 0.1x speed (slow motion)
Result: Segment now properly slows down, even though it's only 0.2 seconds!

2. Looping Animations with Segment Speeds HIGH PRIORITY
- Problem: When looping animations crossed the duration boundary during segment speed advancement, segment lookups could fail
- Fixed: Added proper loop wrapping during segment advancement to ensure correct segment detection after wrapping
- You'll notice: Looping animations with segment speeds work smoothly across the loop boundary

---
Technical Details (For Plugin Developers)

Bug #1: Segment Speed Skipping

Location: SimpleTimeline.cs:2921-2997 (UpdateAnimation method)

Old Behavior:
// Sample speed once at frame start
effectiveSpeed = anim.GetSegmentSpeedAtTime(anim.currentTime);
anim.currentTime += deltaTime * effectiveSpeed;

Problem: If deltaTime > segment duration, the segment is jumped over entirely.

New Behavior:
// Split deltaTime across segment boundaries
float remainingDelta = deltaTime;
while (remainingDelta > 0)
{
float currentSegmentSpeed = anim.GetSegmentSpeedAtTime(anim.currentTime);
float segmentEndTime = FindCurrentSegmentEnd();
float timeToSegmentEnd = segmentEndTime - anim.currentTime;
float deltaToReachBoundary = timeToSegmentEnd / currentSegmentSpeed;

if (remainingDelta <= deltaToReachBoundary)
{
// Stay in segment
anim.currentTime += remainingDelta * currentSegmentSpeed;
remainingDelta = 0;
}
else
{
// Cross to next segment
anim.currentTime = segmentEndTime;
remainingDelta -= deltaToReachBoundary;
}
}

Bug #2: Loop Wrapping

Location: SimpleTimeline.cs:2978-2996

Added loop wrapping inside segment advancement loop to ensure correct segment lookups after crossing duration boundary.

---
Important Notes

- No breaking changes - All existing animations load normally
- Segment speeds are more accurate now, especially for short segments
- Looping animations with segment speeds work correctly
- All previous v1.2 bug fixes still included (rotation interpolation, curve type persistence, etc.)

Animatis v1.6 - Critical Bug Fixes Update

Overview

This update fixes 6 critical bugs that were affecting animation quality and stability. All fixes focus on improving reliability and user experience.

---
What's Fixed

Major Fixes:

1. Rotation Animation Bug HIGH IMPACT
- Problem: Controllers would sometimes rotate "the long way around" when updating keyframes in the middle of animations
- Fixed: Rotation interpolation now correctly chooses the shortest path between keyframes
- You'll notice: Much smoother rotation transitions, especially with large angle changes (180°+)

2. Curve Types Resetting HIGH IMPACT
- Problem: When updating a keyframe, Smooth/Bezier curve settings would randomly reset to Linear
- Fixed: Curve types now properly persist when modifying keyframes
- You'll notice: No more constantly re-applying "Smooth" settings after tweaking poses!

3. Accidental Keyframe Deletion HIGH IMPACT
- Problem: Deleting a keyframe could sometimes delete nearby keyframes too (if they were within 10ms)
- Fixed: Delete now removes ONLY the closest keyframe (5ms tolerance)
- You'll notice: More precise control - no more losing work to accidental deletions

---
Performance & Stability Fixes:

4. Memory Leak (Curve Type Data)
- Fixed orphaned curve type data accumulating over time
- Animations with lots of keyframe edits will run more efficiently

5. Memory Leak (Clear All Keyframes)
- Fixed curve type data not being cleared when using "Clear All Keyframes" button
- Cleaner memory usage overall

6. Division by Zero Protection
- Added safety checks for corrupted save files with invalid animation durations
- More crash-resistant when loading older/corrupted scenes

---
Technical Details (For Plugin Developers)

Changed Files:

- SimpleAnimation.cs - 5 bug fixes (quaternion logic, curve type preservation, memory leaks)
- MorphAnimation.cs - 4 bug fixes (curve type preservation, memory leaks)
- SimpleTimeline.cs - 1 safety fix (division by zero)

Specific Changes:

1. Quaternion flip logic: Now finds keyframe BEFORE insertion point instead of last keyframe
2. SetKeyframe(): Preserves curve types and custom tangents across time tolerance
3. RemoveKeyAtTime(): Finds CLOSEST match instead of removing ALL within tolerance
4. RemoveKeyframe(): Cleans up curveTypes and customTangents dictionaries
5. ClearAllKeyframes(): Clears curve type dictionaries to prevent memory leaks
6. RefreshKeyframeMarkers(): Added zero-duration safety check

---
Important Notes

- No breaking changes - All existing animations load normally
- Recommended: Re-save your animations after updating to ensure curve types are properly stored
- Tested: Thoroughly tested with complex multi-controller animations and duration changes


Credits

Special thanks to the community testers who reported these issues and helped identify the bugs!

Animatis – Update v1.6​

Visual Timeline Upgrade (Click-to-Jump + Keyframe Markers)​

Animatis now has an improved Visual Timeline to make scrubbing and editing much faster—without adding Timeline-level complexity.

Added​

• Keyframe markers: All keyframes are displayed as vertical markers on the timeline bar
• Click-to-jump: Click anywhere on the timeline bar to instantly jump to that time
• Auto-refresh markers: Markers refresh when keyframes change

Improved​

• Play resumes from current time: Play starts from your scrubbed position (not always from 0s)
• More predictable playback: Only resets when the animation has actually finished

Why this matters​

You can now see where keyframes are at a glance, jump around instantly, and keep working from your current position. This gives you Timeline-style visual feedback with a fraction of the UI complexity—staying true to Animatis: more powerful, yet simpler.

Animatis Update 1.5 : Segment Speed & Keyframe Workflow Improvements (thnx Moleculo for the feedbacks )​

This update focuses on improving timing control, stability, and usability, especially when working with segment-based animation speed.

Two Speed Modes (Now Fully Separated)​

Animatis now uses two clearly defined speed modes:

• Global Speed – one speed value for the entire animation
• Segment Speed – individual speed control between keyframes

Only one mode is active at a time, ensuring predictable playback and removing timing conflicts.

---

Reliable Segment Speed System​

Segment speed has been reworked internally to be time-based and stable:

• Segment boundaries are derived from a unified set of keyframe times
• Speed is applied consistently regardless of controller or morph order
• Editing, adding, or removing keyframes no longer breaks segment timing
• Save/Load preserves segment speeds correctly

This makes segment speed reliable and suitable for real animation work, not just experimentation.

---

🗂 New Keyframes Tab (Cleaner & Easier to Use)​

Keyframe editing now has its own dedicated UI tab, designed for clarity:

• Clear Global / Segment speed mode selection
• Scrollable list of animation segments
• Edit one segment at a time (no UI clutter)
• Simple controls to reset or copy speed values

The goal is to make timing edits fast, readable, and intuitive.

---

Design Philosophy​

Animatis is not trying to replace Timeline.


Timeline excels at precision key editing.
Animatis focuses on motion flow, rhythm, and experimentation , with segment-level timing control.

---

Result​

• More predictable playback
• Better timing control than before
• Cleaner UI
• Segment speed now feels intentional, not experimental

As always, thanks for the feedback, it directly helps shape Animatis.

Animatis 1.4.9 Update Summary​

This update focuses on stability, cleanup, and correctness.
No new features were added.

---

Bug Fixes​

1. Fixed critical compilation error (CS1061)

• Issue: ControllerAnimation.keyframeSpeeds and MorphAnimation.keyframeSpeeds did not exist
• Fix: Updated references to use SimpleAnimation.segmentSpeeds
• Files: TimelineUI.cs (lines 364, 376, 729)

2. Fixed tab index bugs – Targets tab

• Issue: “Open Target Manager” and “Back” buttons jumped to the wrong tab
• Fix: SelectTab(1) → SelectTab(2)
• Files: SimpleTimeline.cs (lines 680, 777)

3. Fixed tab index bug – Visual tab

• Issue: “Refresh Timeline View” button switched to Targets tab
• Fix: SelectTab(2) → SelectTab(3)
• Files: SimpleTimeline.cs (line 867)

4. Fixed storable cleanup leak

• Issue: segmentSpeedStorable was not deregistered during cleanup
• Fix: Proper deregistration added alongside timeStorable
• Files: TimelineUI.cs (line 600)

---

Feature Removal – Segment Speed System​

The segment speed system has been fully removed due to instability and incorrect behavior.


Removed components:

• KeyframeSpeed class (step-based lookup, not curve-based)
• segmentSpeeds list and segmentSpeedCurve from SimpleAnimation
• All segment speed UI (sliders, labels, callbacks)
• All segment speed–related methods in TimelineUI (6 methods)
• Segment speed save/load logic
• Segment speed playback logic in SimpleTimeline

Result:
Animation playback now relies solely on the simple and reliable global speed slider.

---

Architecture Notes​

• Segment speeds were briefly refactored to use Unity’s AnimationCurve
• Linear tangents and proper interpolation were implemented
• Behavior was changed from multiplying global speed to overriding it
• Despite improvements, the system remained unreliable and was fully removed

---

Code Quality & Cleanup​

• ~400+ lines of problematic code removed
• Cleaned files:
  • SimpleAnimation.cs
  • SimpleTimeline.cs
  • TimelineUI.cs
• Fixed 1 critical compile-blocking error
• Fixed 3 tab navigation issues
• Removed unused validation logic

---

Current State​

• Compiles successfully
• All tabs navigate correctly
• No storable leaks
• Clean, maintainable codebase
• Uses standard VaM patterns
• Animation playback uses global speed only

Animatis Update 1.4.8 - MULTI-PLAY Tab + Controller Exclusions (Layered Playback)​

This update introduces multi-animation playback clean, predictable, and easy to manage.

What’s new​

• Added a dedicated “MULTI-PLAY” tab
• New CreateMultiPlayTab() UI:
  • Clear header + master/slave explanation
  • Per-animation controls (Play / Stop / Follow Master Time / Exclusions)
• Removed the old multi-play section from the Animation tab
• Updated all currentTab == checks across the UI code
• RefreshMultiAnimationControls() now correctly runs on currentTab == 1

MULTI-PLAY rule (important)​

MULTI-PLAY works by layering animations — but:


A controller (or morph) can only be driven by ONE animation at a time.
If two animations both have the same controller enabled, they will conflict (fight each other / jitter / overwrite).

Solution: Exclusions​

Each animation now has Exclusions, so you can decide exactly what it controls.


Example workflow:

• Animation A: Body + Legs
• Animation B: Arms + Head
• Disable overlapping controllers in one of them, and the two animations can play together cleanly.