Add ImAnim bindings

imgui/Dalamud.Bindings.ImAnim/Dalamud.Bindings.ImAnim.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+        <DisableRuntimeMarshalling>true</DisableRuntimeMarshalling>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Dalamud.Bindings.ImGui\Dalamud.Bindings.ImGui.csproj" />
+    </ItemGroup>
+</Project>

imgui/Dalamud.Bindings.ImAnim/Enums/ImAnimAnchorSpace.cs

@@ -0,0 +1,24 @@
+namespace Dalamud.Bindings.ImAnim;
+
+public enum ImAnimAnchorSpace
+{
+    /// <summary>
+    /// ImGui::GetContentRegionAvail()
+    /// </summary>
+    WindowContent,
+
+    /// <summary>
+    /// ImGui::GetWindowSize()
+    /// </summary>
+    Window,
+
+    /// <summary>
+    /// ImGui::GetWindowViewport()->Size
+    /// </summary>
+    Viewport,
+
+    /// <summary>
+    /// ImGui::GetItemRectSize()
+    /// </summary>
+    LastItem,
+}

imgui/Dalamud.Bindings.ImAnim/Enums/ImAnimColorSpace.cs

@@ -0,0 +1,29 @@
+namespace Dalamud.Bindings.ImAnim;
+
+public enum ImAnimColorSpace
+{
+    /// <summary>
+    /// blend in sRGB (not physically linear)
+    /// </summary>
+    Srgb,
+
+    /// <summary>
+    /// sRGB<->linear, blend in linear, back to sRGB
+    /// </summary>
+    SrgbLinear,
+
+    /// <summary>
+    /// blend H/S/V (hue shortest arc), keep A linear
+    /// </summary>
+    Hsv,
+
+    /// <summary>
+    /// sRGB<->OKLAB, blend in OKLAB, back to sRGB
+    /// </summary>
+    Oklab,
+
+    /// <summary>
+    /// sRGB<->OKLCH (cylindrical OKLAB), blend in OKLCH, back to sRGB
+    /// </summary>
+    Oklch,
+}

imgui/Dalamud.Bindings.ImAnim/Enums/ImAnimDirection.cs

@@ -0,0 +1,19 @@
+namespace Dalamud.Bindings.ImAnim;
+
+public enum ImAnimDirection
+{
+    /// <summary>
+    /// play forward
+    /// </summary>
+    Normal,
+
+    /// <summary>
+    /// play backward
+    /// </summary>
+    Reverse,
+
+    /// <summary>
+    /// ping-pong
+    /// </summary>
+    Alternate,
+}

imgui/Dalamud.Bindings.ImAnim/Enums/ImAnimEaseStepsMode.cs

@@ -0,0 +1,8 @@
+namespace Dalamud.Bindings.ImAnim;
+
+public enum ImAnimEaseStepsMode
+{
+    End,
+    Start,
+    Both,
+}

imgui/Dalamud.Bindings.ImAnim/Enums/ImAnimEaseType.cs

@@ -0,0 +1,70 @@
+namespace Dalamud.Bindings.ImAnim;
+
+public enum ImAnimEaseType
+{
+    Linear,
+    InQuad,
+    OutQuad,
+    InOutQuad,
+    InCubic,
+    OutCubic,
+    InOutCubic,
+    InQuart,
+    OutQuart,
+    InOutQuart,
+    InQuint,
+    OutQuint,
+    InOutQuint,
+    InSine,
+    OutSine,
+    InOutSine,
+    InExpo,
+    OutExpo,
+    InOutExpo,
+    InCirc,
+    OutCirc,
+    InOutCirc,
+    /// <summary>
+    /// p0 = overshoot
+    /// </summary>
+    InBack,
+    /// <summary>
+    /// p0 = overshoot
+    /// </summary>
+    OutBack,
+    /// <summary>
+    /// p0 = overshoot
+    /// </summary>
+    InOutBack,
+    /// <summary>
+    /// p0 = amplitude, p1 = period
+    /// </summary>
+    InElastic,
+    /// <summary>
+    /// p0 = amplitude, p1 = period
+    /// </summary>
+    OutElastic,
+    /// <summary>
+    /// p0 = amplitude, p1 = period
+    /// </summary>
+    InOutElastic,
+    InBounce,
+    OutBounce,
+    InOutBounce,
+    /// <summary>
+    /// p0 = steps (>=1), p1 = 0:end 1:start 2:both
+    /// </summary>
+    Steps,
+    /// <summary>
+    /// p0=x1 p1=y1 p2=x2 p3=y2
+    /// </summary>
+    CubicBezier,
+    /// <summary>
+    /// p0=mass p1=stiffness p2=damping p3=v0
+    /// </summary>
+    Spring,
+    /// <summary>
+    /// User-defined easing function (use iam_ease_custom_fn)
+    /// </summary>
+    Custom,
+}

imgui/Dalamud.Bindings.ImAnim/Enums/ImAnimNoiseType.cs

@@ -0,0 +1,24 @@
+namespace Dalamud.Bindings.ImAnim;
+
+public enum ImAnimNoiseType
+{
+    /// <summary>
+    /// Classic Perlin noise
+    /// </summary>
+    Perlin,
+
+    /// <summary>
+    /// Simplex noise (faster, fewer artifacts)
+    /// </summary>
+    Simplex,
+
+    /// <summary>
+    /// Value noise (blocky)
+    /// </summary>
+    Value,
+
+    /// <summary>
+    /// Worley/cellular noise
+    /// </summary>
+    Worley,
+}

imgui/Dalamud.Bindings.ImAnim/Enums/ImAnimPolicy.cs

@@ -0,0 +1,19 @@
+namespace Dalamud.Bindings.ImAnim;
+
+public enum ImAnimPolicy
+{
+    /// <summary>
+    /// smooth into new target
+    /// </summary>
+    Crossfade,
+
+    /// <summary>
+    /// snap to target
+    /// </summary>
+    Cut,
+
+    /// <summary>
+    /// queue one pending target
+    /// </summary>
+    Queue,
+}

imgui/Dalamud.Bindings.ImAnim/Enums/ImAnimResult.cs

@@ -0,0 +1,9 @@
+namespace Dalamud.Bindings.ImAnim;
+
+public enum ImAnimResult
+{
+    Ok,
+    ErrNotFound,
+    ErrBadArg,
+    ErrNoMem,
+}

imgui/Dalamud.Bindings.ImAnim/Enums/ImAnimRotationMode.cs

@@ -0,0 +1,29 @@
+namespace Dalamud.Bindings.ImAnim;
+
+public enum ImAnimRotationMode
+{
+    /// <summary>
+    /// Shortest path (default) - never rotates more than 180 degrees
+    /// </summary>
+    Shortest,
+
+    /// <summary>
+    /// Longest path - always takes the long way around
+    /// </summary>
+    Longest,
+
+    /// <summary>
+    /// Clockwise - always rotates clockwise (positive direction)
+    /// </summary>
+    Cw,
+
+    /// <summary>
+    /// Counter-clockwise - always rotates counter-clockwise
+    /// </summary>
+    Ccw,
+
+    /// <summary>
+    /// Direct lerp - no angle unwrapping, can cause spinning for large deltas
+    /// </summary>
+    Direct,
+}

imgui/Dalamud.Bindings.ImAnim/Enums/ImAnimTextPathAlign.cs

@@ -0,0 +1,19 @@
+namespace Dalamud.Bindings.ImAnim;
+
+public enum ImAnimTextPathAlign
+{
+    /// <summary>
+    /// Text starts at path start (or offset)
+    /// </summary>
+    Start,
+
+    /// <summary>
+    /// Text centered on path
+    /// </summary>
+    Center,
+
+    /// <summary>
+    /// Text ends at path end
+    /// </summary>
+    End,
+}

imgui/Dalamud.Bindings.ImAnim/Enums/ImAnimTextStaggerEffect.cs

@@ -0,0 +1,59 @@
+namespace Dalamud.Bindings.ImAnim;
+
+public enum ImAnimTextStaggerEffect
+{
+    /// <summary>
+    /// No effect (instant appear)
+    /// </summary>
+    None,
+
+    /// <summary>
+    /// Fade in alpha
+    /// </summary>
+    Fade,
+
+    /// <summary>
+    /// Scale from center
+    /// </summary>
+    Scale,
+
+    /// <summary>
+    /// Slide up from below
+    /// </summary>
+    SlideUp,
+
+    /// <summary>
+    /// Slide down from above
+    /// </summary>
+    SlideDown,
+
+    /// <summary>
+    /// Slide in from right
+    /// </summary>
+    SlideLeft,
+
+    /// <summary>
+    /// Slide in from left
+    /// </summary>
+    SlideRight,
+
+    /// <summary>
+    /// Rotate in
+    /// </summary>
+    Rotate,
+
+    /// <summary>
+    /// Bounce in with overshoot
+    /// </summary>
+    Bounce,
+
+    /// <summary>
+    /// Wave motion (continuous)
+    /// </summary>
+    Wave,
+
+    /// <summary>
+    /// Typewriter style (instant per char)
+    /// </summary>
+    Typewriter,
+}

imgui/Dalamud.Bindings.ImAnim/Enums/ImAnimVariationMode.cs

@@ -0,0 +1,44 @@
+namespace Dalamud.Bindings.ImAnim;
+
+public enum ImAnimVariationMode
+{
+    /// <summary>
+    /// No variation
+    /// </summary>
+    None,
+
+    /// <summary>
+    /// Add amount each iteration
+    /// </summary>
+    Increment,
+
+    /// <summary>
+    /// Subtract amount each iteration
+    /// </summary>
+    Decrement,
+
+    /// <summary>
+    /// Multiply by factor each iteration
+    /// </summary>
+    Multiply,
+
+    /// <summary>
+    /// Random in range [-amount, +amount]
+    /// </summary>
+    Random,
+
+    /// <summary>
+    /// Random in range [0, amount]
+    /// </summary>
+    RandomAbs,
+
+    /// <summary>
+    /// Alternate +/- each iteration
+    /// </summary>
+    PingPong,
+
+    /// <summary>
+    /// Use custom callback
+    /// </summary>
+    Callback,
+}

imgui/Dalamud.Bindings.ImAnim/Enums/ImAnimWaveType.cs

@@ -0,0 +1,24 @@
+namespace Dalamud.Bindings.ImAnim;
+
+public enum ImAnimWaveType
+{
+    /// <summary>
+    /// Smooth sine wave
+    /// </summary>
+    Sine,
+
+    /// <summary>
+    /// Triangle wave (linear up/down)
+    /// </summary>
+    Triangle,
+
+    /// <summary>
+    /// Sawtooth wave (linear up, instant reset)
+    /// </summary>
+    Sawtooth,
+
+    /// <summary>
+    /// Square wave (on/off pulse)
+    /// </summary>
+    Square,
+}

imgui/Dalamud.Bindings.ImAnim/ImAnimNative.cs

@@ -0,0 +1,809 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+using Dalamud.Bindings.ImGui;
+
+namespace Dalamud.Bindings.ImAnim;
+
+public static unsafe partial class ImAnimNative
+{
+    private const string LibName = "cimanim";
+
+    // ----------------------------------------------------
+    // Public API declarations
+    // ----------------------------------------------------
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_set_imgui_context")]
+    public static partial void SetImGuiContext(ImGuiContext* context);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_demo_window")]
+    public static partial void DemoWindow();
+
+    // Frame management
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_update_begin_frame")]
+    public static partial void UpdateBeginFrame();
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_gc")]
+    public static partial void Gc(uint maxAgeFrames = 600);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_reserve")]
+    public static partial void Reserve(int capFloat, int capVec2, int capVec4, int capInt, int capColor);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_set_ease_lut_samples")]
+    public static partial void SetEaseLutSamples(int count);
+
+    // Global time scale (for slow-motion / fast-forward debugging)
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_set_global_time_scale")]
+    public static partial void SetGlobalTimeScale(float scale);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_get_global_time_scale")]
+    public static partial float GetGlobalTimeScale();
+
+    // Lazy Initialization - defer channel creation until animation is needed
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_set_lazy_init")]
+    public static partial void SetLazyInit(byte enable);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_is_lazy_init_enabled")]
+    public static partial byte IsLazyInitEnabled();
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_register_custom_ease")]
+    public static partial void RegisterCustomEase(int slot, delegate* unmanaged[Cdecl]<float, float> fn);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_get_custom_ease")]
+    public static partial void GetCustomEase(delegate* unmanaged[Cdecl]<float, float>* pOut, int slot);
+
+    // Debug UI
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_show_unified_inspector")]
+    public static partial void ShowUnifiedInspector(byte* pOpen = null);
+
+    // Performance Profiler
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_profiler_enable")]
+    public static partial void ProfilerEnable(byte enable);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_profiler_is_enabled")]
+    public static partial byte ProfilerIsEnabled();
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_profiler_begin_frame")]
+    public static partial void ProfilerBeginFrame();
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_profiler_end_frame")]
+    public static partial void ProfilerEndFrame();
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_profiler_begin")]
+    public static partial void ProfilerBegin(byte* name);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_profiler_end")]
+    public static partial void ProfilerEnd();
+
+    // Drag Feedback - animated feedback for drag operations
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_drag_begin")]
+    public static partial void DragBegin(ImAnimDragFeedback* pOut, uint id, Vector2* pos);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_drag_update")]
+    public static partial void DragUpdate(ImAnimDragFeedback* pOut, uint id, Vector2* pos, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_drag_release")]
+    public static partial void DragRelease(ImAnimDragFeedback* pOut, uint id, Vector2* pos, ImAnimDragOpts* opts, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_drag_cancel")]
+    public static partial void DragCancel(uint id);
+
+    // Oscillators - continuous periodic animations
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_oscillate")]
+    public static partial float Oscillate(uint id, float amplitude, float frequency, ImAnimWaveType waveType, float phase, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_oscillate_int")]
+    public static partial int OscillateInt(uint id, int amplitude, float frequency, ImAnimWaveType waveType, float phase, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_oscillate_vec2")]
+    public static partial void OscillateVec2(Vector2* pOut, uint id, Vector2* amplitude, Vector2* frequency, ImAnimWaveType waveType, Vector2* phase, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_oscillate_vec4")]
+    public static partial void OscillateVec4(Vector4* pOut, uint id, Vector4* amplitude, Vector4* frequency, ImAnimWaveType waveType, Vector4* phase, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_oscillate_color")]
+    public static partial void OscillateColor(Vector4* pOut, uint id, Vector4* baseColor, Vector4* amplitude, float frequency, ImAnimWaveType waveType, float phase, ImAnimColorSpace colorSpace, float dt);
+
+    // Shake/Wiggle - procedural noise animations
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_shake")]
+    public static partial float Shake(uint id, float intensity, float frequency, float decayTime, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_shake_int")]
+    public static partial int ShakeInt(uint id, int intensity, float frequency, float decayTime, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_shake_vec2")]
+    public static partial void ShakeVec2(Vector2* pOut, uint id, Vector2* intensity, float frequency, float decayTime, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_shake_vec4")]
+    public static partial void ShakeVec4(Vector4* pOut, uint id, Vector4* intensity, float frequency, float decayTime, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_shake_color")]
+    public static partial void ShakeColor(Vector4* pOut, uint id, Vector4* baseColor, Vector4* intensity, float frequency, float decayTime, ImAnimColorSpace colorSpace, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_wiggle")]
+    public static partial float Wiggle(uint id, float amplitude, float frequency, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_wiggle_int")]
+    public static partial int WiggleInt(uint id, int amplitude, float frequency, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_wiggle_vec2")]
+    public static partial void WiggleVec2(Vector2* pOut, uint id, Vector2* amplitude, float frequency, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_wiggle_vec4")]
+    public static partial void WiggleVec4(Vector4* pOut, uint id, Vector4* amplitude, float frequency, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_wiggle_color")]
+    public static partial void WiggleColor(Vector4* pOut, uint id, Vector4* baseColor, Vector4* amplitude, float frequency, ImAnimColorSpace colorSpace, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_trigger_shake")]
+    public static partial void TriggerShake(uint id);
+
+    // Easing evaluation
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_eval_preset")]
+    public static partial float EvalPreset(ImAnimEaseType type, float t);
+
+    // Tween API - smoothly interpolate values over time
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_float")]
+    public static partial float TweenFloat(uint id, uint channelId, float target, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_vec2")]
+    public static partial void TweenVec2(Vector2* pOut, uint id, uint channelId, Vector2* target, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_vec4")]
+    public static partial void TweenVec4(Vector4* pOut, uint id, uint channelId, Vector4* target, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_int")]
+    public static partial int TweenInt(uint id, uint channelId, int target, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_color")]
+    public static partial void TweenColor(Vector4* pOut, uint id, uint channelId, Vector4* targetSrgb, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, ImAnimColorSpace colorSpace, float dt);
+
+    // Resize-friendly helpers
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_anchor_size")]
+    public static partial void GetAnchorSize(Vector2* pOut, ImAnimAnchorSpace space);
+
+    // Relative target tweens (percent of anchor + pixel offset) - survive window resizes
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_float_rel")]
+    public static partial float TweenFloatRel(uint id, uint channelId, float percent, float pxBias, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, ImAnimAnchorSpace anchorSpace, int axis, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_vec2_rel")]
+    public static partial void TweenVec2Rel(Vector2* pOut, uint id, uint channelId, Vector2* percent, Vector2* pxBias, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, ImAnimAnchorSpace anchorSpace, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_vec4_rel")]
+    public static partial void TweenVec4Rel(Vector4* pOut, uint id, uint channelId, Vector4* percent, Vector4* pxBias, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, ImAnimAnchorSpace anchorSpace, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_color_rel")]
+    public static partial void TweenColorRel(Vector4* pOut, uint id, uint channelId, Vector4* percent, Vector4* pxBias, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, ImAnimColorSpace colorSpace, ImAnimAnchorSpace anchorSpace, float dt);
+
+    // Rebase functions - change target of in-progress animation without restarting
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_rebase_float")]
+    public static partial void RebaseFloat(uint id, uint channelId, float newTarget, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_rebase_vec2")]
+    public static partial void RebaseVec2(uint id, uint channelId, Vector2* newTarget, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_rebase_vec4")]
+    public static partial void RebaseVec4(uint id, uint channelId, Vector4* newTarget, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_rebase_int")]
+    public static partial void RebaseInt(uint id, uint channelId, int newTarget, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_rebase_color")]
+    public static partial void RebaseColor(uint id, uint channelId, Vector4* newTarget, float dt);
+
+    // Resolved tweens - target computed dynamically by callback each frame
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_float_resolved")]
+    public static partial float TweenFloatResolved(uint id, uint channelId, delegate* unmanaged[Cdecl]<void*, float> fn, void* userData, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_vec2_resolved")]
+    public static partial void TweenVec2Resolved(Vector2* pOut, uint id, uint channelId, delegate* unmanaged[Cdecl]<void*, Vector2> fn, void* userData, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_vec4_resolved")]
+    public static partial void TweenVec4Resolved(Vector4* pOut, uint id, uint channelId, delegate* unmanaged[Cdecl]<void*, Vector4> fn, void* userData, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_color_resolved")]
+    public static partial void TweenColorResolved(Vector4* pOut, uint id, uint channelId, delegate* unmanaged[Cdecl]<void*, Vector4> fn, void* userData, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, ImAnimColorSpace colorSpace, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_int_resolved")]
+    public static partial int TweenIntResolved(uint id, uint channelId, delegate* unmanaged[Cdecl]<void*, int> fn, void* userData, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, float dt);
+
+    // Color blending utility
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_get_blended_color")]
+    public static partial void GetBlendedColor(Vector4* pOut, Vector4* a, Vector4* b, float t, ImAnimColorSpace colorSpace);
+
+
+    // ----------------------------------------------------
+    // Convenience shorthands for common easings
+    // ----------------------------------------------------
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_ease_preset")]
+    public static partial void EasePreset(ImAnimEaseDesc* pOut, ImAnimEaseType type);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_ease_bezier")]
+    public static partial void EaseBezier(ImAnimEaseDesc* pOut, float x1, float y1, float x2, float y2);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_ease_steps_desc")]
+    public static partial void EaseStepsDesc(ImAnimEaseDesc* pOut, int steps, ImAnimEaseStepsMode mode);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_ease_back")]
+    public static partial void EaseBack(ImAnimEaseDesc* pOut, float overshoot);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_ease_elastic")]
+    public static partial void EaseElastic(ImAnimEaseDesc* pOut, float amplitude, float period);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_ease_spring_desc")]
+    public static partial void EaseSpring(ImAnimEaseDesc* pOut, float mass, float stiffness, float damping, float v0);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_ease_custom_fn")]
+    public static partial void EaseCustomFn(ImAnimEaseDesc* pOut, int slot);
+
+    // Scroll animation - smooth scrolling for ImGui windows
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_scroll_to_y")]
+    public static partial void ScrollToY(float targetY, float duration, ImAnimEaseDesc* ez = null);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_scroll_to_x")]
+    public static partial void ScrollToX(float targetX, float duration, ImAnimEaseDesc* ez = null);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_scroll_to_top")]
+    public static partial void ScrollToTop(float duration = 0.3f, ImAnimEaseDesc* ez = null);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_scroll_to_bottom")]
+    public static partial void ScrollToBottom(float duration = 0.3f, ImAnimEaseDesc* ez = null);
+
+
+    // ----------------------------------------------------
+    // Per-axis easing - different easing per component
+    // ----------------------------------------------------
+
+    // Tween with per-axis easing - each component uses its own easing curve
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_vec2_per_axis")]
+    public static partial void TweenVec2PerAxis(Vector2* pOut, uint id, uint channelId, Vector2* target, float dur, ImAnimEasePerAxis* ez, ImAnimPolicy policy, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_vec4_per_axis")]
+    public static partial void TweenVec4PerAxis(Vector4* pOut, uint id, uint channelId, Vector4* target, float dur, ImAnimEasePerAxis* ez, ImAnimPolicy policy, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_color_per_axis")]
+    public static partial void TweenColorPerAxis(Vector4* pOut, uint id, uint channelId, Vector4* targetSrgb, float dur, ImAnimEasePerAxis* ez, ImAnimPolicy policy, ImAnimColorSpace colorSpace, float dt);
+
+
+    // ----------------------------------------------------
+    // Motion Paths - animate along curves and splines
+    // ----------------------------------------------------
+
+    // Single-curve evaluation functions (stateless, for direct use)
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_bezier_quadratic")]
+    public static partial void BezierQuadratic(Vector2* pOut, Vector2* p0, Vector2* p1, Vector2* p2, float t);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_bezier_cubic")]
+    public static partial void BezierCubic(Vector2* pOut, Vector2* p0, Vector2* p1, Vector2* p2, Vector2* p3, float t);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_catmull_rom")]
+    public static partial void CatmullRom(Vector2* pOut, Vector2* p0, Vector2* p1, Vector2* p2, Vector2* p3, float t, float tension);
+
+    // Derivatives (for tangent/velocity)
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_bezier_quadratic_deriv")]
+    public static partial void BezierQuadraticDeriv(Vector2* pOut, Vector2* p0, Vector2* p1, Vector2* p2, float t);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_bezier_cubic_deriv")]
+    public static partial void BezierCubicDeriv(Vector2* pOut, Vector2* p0, Vector2* p1, Vector2* p2, Vector2* p3, float t);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_catmull_rom_deriv")]
+    public static partial void CatmullRomDeriv(Vector2* pOut, Vector2* p0, Vector2* p1, Vector2* p2, Vector2* p3, float t, float tension);
+
+    // Query path info
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_path_exists")]
+    public static partial byte PathExists(uint pathId);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_path_length")]
+    public static partial float PathLength(uint pathId);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_path_evaluate")]
+    public static partial void PathEvaluate(Vector2* pOut, uint pathId, float t);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_path_tangent")]
+    public static partial void PathTangent(Vector2* pOut, uint pathId, float t);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_path_angle")]
+    public static partial float PathAngle(uint pathId, float t);
+
+    // Tween along a path
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_path")]
+    public static partial void TweenPath(Vector2* pOut, uint id, uint channelId, uint pathId, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, float dt = -1f);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_path_angle")]
+    public static partial float TweenPathAngle(uint id, uint channelId, uint pathId, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, float dt = -1f);
+
+
+    // ----------------------------------------------------
+    // Arc-length parameterization (for constant-speed animation)
+    // ----------------------------------------------------
+
+    // Build arc-length lookup table for a path (call once per path, improves accuracy)
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_path_build_arc_lut")]
+    public static partial void PathBuildArcLut(uint pathId, int subdivisions);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_path_has_arc_lut")]
+    public static partial byte PathHasArcLut(uint pathId);
+
+    // Distance-based path evaluation (uses arc-length LUT for constant speed)
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_path_distance_to_t")]
+    public static partial float PathDistanceToT(uint pathId, float distance);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_path_evaluate_at_distance")]
+    public static partial void PathEvaluateAtDistance(Vector2* pOut, uint pathId, float distance);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_path_angle_at_distance")]
+    public static partial float PathAngleAtDistance(uint pathId, float distance);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_path_tangent_at_distance")]
+    public static partial void PathTangentAtDistance(Vector2* pOut, uint pathId, float distance);
+
+
+    // ----------------------------------------------------
+    // Path Morphing - interpolate between two paths
+    // ----------------------------------------------------
+
+    // Evaluate morphed path at parameter t [0,1] with blend factor [0,1]
+    // path_a at blend=0, path_b at blend=1
+    // Paths can have different numbers of segments - they are resampled to match
+    [LibraryImport(LibName, EntryPoint = "c_iam_path_morph")]
+    public static partial void PathMorph(Vector2* pOut, uint pathA, uint pathB, float t, float blend, ImAnimMorphOpts* opts = null);
+
+    // Get tangent of morphed path
+    [LibraryImport(LibName, EntryPoint = "c_iam_path_morph_tangent")]
+    public static partial void PathMorphTangent(Vector2* pOut, uint pathA, uint pathB, float t, float blend, ImAnimMorphOpts* opts = null);
+
+    // Get angle (radians) of morphed path
+    [LibraryImport(LibName, EntryPoint = "c_iam_path_morph_angle")]
+    public static partial float PathMorphAngle(uint pathA, uint pathB, float t, float blend, ImAnimMorphOpts* opts = null);
+
+    // Tween along a morphing path - animates both position along path AND the morph blend
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_path_morph")]
+    public static partial void TweenPathMorph(Vector2* pOut, uint id, uint channelId, uint pathA, uint pathB, float targetBlend, float dur, ImAnimEaseDesc* pathEase, ImAnimEaseDesc* morphEase, ImAnimPolicy policy, float dt, ImAnimMorphOpts* opts = null);
+
+    // Get current morph blend value from a tween (for querying state)
+    [LibraryImport(LibName, EntryPoint = "c_iam_get_morph_blend")]
+    public static partial float GetMorphBlend(uint id, uint channelId);
+
+
+    // ----------------------------------------------------
+    // Text along motion paths
+    // ----------------------------------------------------
+
+    // Render text along a path (static - no animation)
+    [LibraryImport(LibName, EntryPoint = "c_iam_text_path")]
+    public static partial void TextPath(uint pathId, byte* text, ImAnimTextPathOpts* opts = null);
+
+    // Animated text along path (characters appear progressively)
+    [LibraryImport(LibName, EntryPoint = "c_iam_text_path_animated")]
+    public static partial void TextPathAnimated(uint pathId, byte* text, float progress, ImAnimTextPathOpts* opts = null);
+
+    // Helper: Get text width for path layout calculations
+    [LibraryImport(LibName, EntryPoint = "c_iam_text_path_width")]
+    public static partial float TextPathWidth(byte* text, ImAnimTextPathOpts* opts = null);
+
+
+    // ----------------------------------------------------
+    // Quad transform helpers (for advanced custom rendering)
+    // ----------------------------------------------------
+
+    // Transform a quad (4 vertices) by rotation and translation
+    [LibraryImport(LibName, EntryPoint = "c_iam_transform_quad")]
+    public static partial void TransformQuad(Quaternion* quad, Vector2* center, float angleRad, Vector2* translation);
+
+    // Create a rotated quad for a glyph at a position on the path
+    [LibraryImport(LibName, EntryPoint = "c_iam_make_glyph_quad")]
+    public static partial void MakeGlyphQuad(Quaternion* quad, Vector2* pos, float angleRad, float glyphWidth, float glyphHeight, float baselineOffset);
+
+
+    // ----------------------------------------------------
+    // Text Stagger - per-character animation effects
+    // ----------------------------------------------------
+
+    // Render text with per-character stagger animation
+    [LibraryImport(LibName, EntryPoint = "c_iam_text_stagger")]
+    public static partial void TextStagger(uint id, byte* text, float progress, ImAnimTextStaggerOpts* opts = null);
+
+    // Get text width for layout calculations
+    [LibraryImport(LibName, EntryPoint = "c_iam_text_stagger_width")]
+    public static partial float TextStaggerWidth(byte* text, ImAnimTextStaggerOpts* opts = null);
+
+    // Get total animation duration for text (accounts for stagger delays)
+    [LibraryImport(LibName, EntryPoint = "c_iam_text_stagger_duration")]
+    public static partial float TextStaggerDuration(byte* text, ImAnimTextStaggerOpts* opts = null);
+
+
+    // ----------------------------------------------------
+    // Noise Channels - Perlin/Simplex noise for organic movement
+    // ----------------------------------------------------
+
+    // Sample noise at a point (returns value in [-1, 1])
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_noise_2d")]
+    public static partial float Noise2D(float x, float y, ImAnimNoiseOpts* opts = null);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_noise_3d")]
+    public static partial float Noise3D(float x, float y, float z, ImAnimNoiseOpts* opts = null);
+
+    // Animated noise channels - continuous noise that evolves over time
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_noise_channel_float")]
+    public static partial float NoiseChannelFloat(uint id, float frequency, float amplitude, ImAnimNoiseOpts* opts, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_noise_channel_vec2")]
+    public static partial void NoiseChannelVec2(Vector2* pOut, uint id, Vector2* frequency, Vector2* amplitude, ImAnimNoiseOpts* opts, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_noise_channel_vec4")]
+    public static partial void NoiseChannelVec4(Vector4* pOut, uint id, Vector4* frequency, Vector4* amplitude, ImAnimNoiseOpts* opts, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_noise_channel_color")]
+    public static partial void NoiseChannelColor(Vector4* pOut, uint id, Vector4* baseColor, Vector4* amplitude, float frequency, ImAnimNoiseOpts* opts, ImAnimColorSpace colorSpace, float dt);
+
+    // Convenience: smooth random movement (like wiggle but using noise)
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_smooth_noise_float")]
+    public static partial float SmoothNoiseFloat(uint id, float amplitude, float speed, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_smooth_noise_vec2")]
+    public static partial void SmoothNoiseVec2(Vector2* pOut, uint id, Vector2* amplitude, float speed, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_smooth_noise_vec4")]
+    public static partial void SmoothNoiseVec4(Vector4* pOut, uint id, Vector4* amplitude, float speed, float dt);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_smooth_noise_color")]
+    public static partial void SmoothNoiseColor(Vector4* pOut, uint id, Vector4* baseColor, Vector4* amplitude, float speed, ImAnimColorSpace colorSpace, float dt);
+
+
+    // ----------------------------------------------------
+    // Style Interpolation - animate between ImGuiStyle themes
+    // ----------------------------------------------------
+
+    // Register a named style for interpolation
+    [LibraryImport(LibName, EntryPoint = "c_iam_style_register")]
+    public static partial void StyleRegister(uint styleId, ImGuiStyle* style);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_style_register_current")]
+    public static partial void StyleRegisterCurrent(uint styleId);
+
+    // Blend between two registered styles (result applied to ImGui::GetStyle())
+    // Uses iam_color_space for color blending mode (iam_col_oklab recommended)
+    [LibraryImport(LibName, EntryPoint = "c_iam_style_blend")]
+    public static partial void StyleBlend(uint styleA, uint styleB, float t, ImAnimColorSpace colorSpace = ImAnimColorSpace.Oklab);
+
+    // Tween between styles over time
+    [LibraryImport(LibName, EntryPoint = "c_iam_style_tween")]
+    public static partial void StyleTween(uint id, uint targetStyle, float duration, ImAnimEaseDesc* ease, ImAnimColorSpace colorSpace, float dt);
+
+    // Get interpolated style without applying
+    [LibraryImport(LibName, EntryPoint = "c_iam_style_blend_to")]
+    public static partial void StyleBlendTo(uint styleA, uint styleB, float t, ImGuiStyle* outStyle, ImAnimColorSpace colorSpace = ImAnimColorSpace.Oklab);
+
+    // Check if a style is registered
+    [LibraryImport(LibName, EntryPoint = "c_iam_style_exists")]
+    public static partial byte StyleExists(uint styleId);
+
+    // Remove a registered style
+    [LibraryImport(LibName, EntryPoint = "c_iam_style_unregister")]
+    public static partial void StyleUnregister(uint styleId);
+
+
+    // ----------------------------------------------------
+    // Gradient Interpolation - animate between color gradients
+    // ----------------------------------------------------
+
+    // Blend between two gradients
+    [LibraryImport(LibName, EntryPoint = "c_iam_gradient_lerp")]
+    public static partial void GradientLerp(ImAnimGradient* pOut, ImAnimGradient* a, ImAnimGradient* b, float t, ImAnimColorSpace colorSpace = ImAnimColorSpace.Oklab);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_gradient")]
+    public static partial void TweenGradient(ImAnimGradient* pOut, uint id, uint channelId, ImAnimGradient* target, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, ImAnimColorSpace colorSpace, float dt);
+
+
+    // ----------------------------------------------------
+    // Transform Interpolation - animate 2D transforms
+    // ----------------------------------------------------
+
+    // Blend between two transforms with rotation interpolation
+    [LibraryImport(LibName, EntryPoint = "c_iam_transform_lerp")]
+    public static partial void TransformLerp(ImAnimTransform* pOut, ImAnimTransform* a, ImAnimTransform* b, float t, ImAnimRotationMode rotationMode = ImAnimRotationMode.Shortest);
+
+    // Tween between transforms over time
+    [LibraryImport(LibName, EntryPoint = "c_iam_tween_transform")]
+    public static partial void TweenTransform(ImAnimTransform* pOut, uint id, uint channelId, ImAnimTransform* target, float dur, ImAnimEaseDesc* ez, ImAnimPolicy policy, int rotationMode, float dt);
+
+    // Decompose a 3x2 matrix into transform components
+    [LibraryImport(LibName, EntryPoint = "c_iam_transform_from_matrix")]
+    public static partial void TransformFromMatrix(ImAnimTransform* pOut, float m00, float m01, float m10, float m11, float tx, float ty);
+
+    // Convert transform to 3x2 matrix (row-major: [m00 m01 tx; m10 m11 ty])
+    [LibraryImport(LibName, EntryPoint = "c_iam_transform_to_matrix")]
+    public static partial void TransformToMatrix(ImAnimTransform* t, Matrix3x2* outMatrix);
+
+
+    // ----------------------------------------------------
+    // iam_clip - fluent API for authoring animations
+    // ----------------------------------------------------
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_begin")]
+    public static partial void ClipBegin(ImAnimClip* pOut, uint clipId);
+
+    // Add keyframes for different channel types
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_key_float")]
+    public static partial void ClipKeyFloat(ImAnimClip* self, uint channel, float time, float value, ImAnimEaseType easeType, Vector4* bezier4);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_key_vec2")]
+    public static partial void ClipKeyVec2(ImAnimClip* self, uint channel, float time, Vector2* value, ImAnimEaseType easeType, Vector4* bezier4);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_key_vec4")]
+    public static partial void ClipKeyVec4(ImAnimClip* self, uint channel, float time, Vector4* value, ImAnimEaseType easeType, Vector4* bezier4);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_key_int")]
+    public static partial void ClipKeyInt(ImAnimClip* self, uint channel, float time, int value, ImAnimEaseType easeType);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_key_color")]
+    public static partial void ClipKeyColor(ImAnimClip* self, uint channel, float time, Vector4* value, ImAnimColorSpace colorSpace, ImAnimEaseType easeType, Vector4* bezier4);
+
+    // Keyframes with repeat variation (value changes per loop iteration)
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_key_float_var")]
+    public static partial void ClipKeyFloatVar(ImAnimClip* self, uint channel, float time, float value, ImAnimVariationFloat* var, ImAnimEaseType easeType, Vector4* bezier4);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_key_vec2_var")]
+    public static partial void ClipKeyVec2Var(ImAnimClip* self, uint channel, float time, Vector2* value, ImAnimVariationVec2* var, ImAnimEaseType easeType, Vector4* bezier4);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_key_vec4_var")]
+    public static partial void ClipKeyVec4Var(ImAnimClip* self, uint channel, float time, Vector4* value, ImAnimVariationVec4* var, ImAnimEaseType easeType, Vector4* bezier4);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_key_int_var")]
+    public static partial void ClipKeyIntVar(ImAnimClip* self, uint channel, float time, int value, ImAnimVariationInt* var, ImAnimEaseType easeType);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_key_color_var")]
+    public static partial void ClipKeyColorVar(ImAnimClip* self, uint channel, float time, Vector4* value, ImAnimVariationColor* var, ImAnimColorSpace colorSpace, ImAnimEaseType easeType, Vector4* bezier4);
+
+    // Spring-based keyframe (float only)
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_key_float_spring")]
+    public static partial void ClipKeyFloatSpring(ImAnimClip* self, uint channel, float time, float target, ImAnimSpringParams* spring);
+
+    // Anchor-relative keyframes (values resolved relative to window/viewport at get time)
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_key_float_rel")]
+    public static partial void ClipKeyFloatRel(ImAnimClip* self, uint channel, float time, float percent, float pxBias, ImAnimAnchorSpace anchorSpace, int axis, ImAnimEaseType easeType, Vector4* bezier4);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_key_vec2_rel")]
+    public static partial void ClipKeyVec2Rel(ImAnimClip* self, uint channel, float time, Vector2* percent, Vector2* pxBias, ImAnimAnchorSpace anchorSpace, ImAnimEaseType easeType, Vector4* bezier4);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_key_vec4_rel")]
+    public static partial void ClipKeyVec4Rel(ImAnimClip* self, uint channel, float time, Vector4* percent, Vector4* pxBias, ImAnimAnchorSpace anchorSpace, ImAnimEaseType easeType, Vector4* bezier4);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_key_color_rel")]
+    public static partial void ClipKeyColorRel(ImAnimClip* self, uint channel, float time, Vector4* percent, Vector4* pxBias, ImAnimColorSpace colorSpace, ImAnimAnchorSpace anchorSpace, ImAnimEaseType easeType, Vector4* bezier4);
+
+    // Timeline grouping - sequential and parallel keyframe blocks
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_seq_begin")]
+    public static partial void ClipSeqBegin(ImAnimClip* self);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_seq_end")]
+    public static partial void ClipSeqEnd(ImAnimClip* self);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_par_begin")]
+    public static partial void ClipParBegin(ImAnimClip* self);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_par_end")]
+    public static partial void ClipParEnd(ImAnimClip* self);
+
+    // Timeline markers - callbacks at specific times during playback
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_marker_id")]
+    public static partial void ClipMarkerId(ImAnimClip* self, float time, uint markerId, delegate* unmanaged[Cdecl]<uint, uint, float, void*, void> cb, void* userData);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_marker")]
+    public static partial void ClipMarker(ImAnimClip* self, float time, delegate* unmanaged[Cdecl]<uint, uint, float, void*, void> cb, void* userData);
+
+    // Clip options
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_set_loop")]
+    public static partial void ClipSetLoop(ImAnimClip* self, byte loop, ImAnimDirection direction, int loopCount);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_set_delay")]
+    public static partial void ClipSetDelay(ImAnimClip* self, float delaySeconds);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_set_stagger")]
+    public static partial void ClipSetStagger(ImAnimClip* self, int count, float eachDelay, float fromCenterBias);
+
+    // Timing variation per loop iteration
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_set_duration_var")]
+    public static partial void ClipSetDurationVar(ImAnimClip* self, ImAnimVariationFloat* var);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_set_delay_var")]
+    public static partial void ClipSetDelayVar(ImAnimClip* self, ImAnimVariationFloat* var);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_set_timescale_var")]
+    public static partial void ClipSetTimescaleVar(ImAnimClip* self, ImAnimVariationFloat* var);
+
+    // Callbacks
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_on_begin")]
+    public static partial void ClipOnBegin(ImAnimClip* self, delegate* unmanaged[Cdecl]<uint, void*, void> cb, void* userData);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_on_update")]
+    public static partial void ClipOnUpdate(ImAnimClip* self, delegate* unmanaged[Cdecl]<uint, void*, void> cb, void* userData);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_on_complete")]
+    public static partial void ClipOnComplete(ImAnimClip* self, delegate* unmanaged[Cdecl]<uint, void*, void> cb, void* userData);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_end")]
+    public static partial void ClipEnd(ImAnimClip* self);
+
+
+    // ----------------------------------------------------
+    // iam_instance - playback control for a clip
+    // ----------------------------------------------------
+
+    // Playback control
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_pause")]
+    public static partial void InstancePause(ImAnimInstance* self);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_resume")]
+    public static partial void InstanceResume(ImAnimInstance* self);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_stop")]
+    public static partial void InstanceStop(ImAnimInstance* self);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_destroy_playback")]
+    public static partial void InstanceDestroyPlayback(ImAnimInstance* self);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_seek")]
+    public static partial void InstanceSeek(ImAnimInstance* self, float time);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_set_time_scale")]
+    public static partial void InstanceSetTimeScale(ImAnimInstance* self, float scale);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_set_weight")]
+    public static partial void InstanceSetWeight(ImAnimInstance* self, float weight);
+
+    // Animation chaining - play another clip when this one completes
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_then")]
+    public static partial void InstanceThen(ImAnimInstance* pOut, ImAnimInstance* self, uint nextClipId);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_then_id")]
+    public static partial void InstanceThenId(ImAnimInstance* pOut, ImAnimInstance* self, uint nextClipId, uint nextInstanceId);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_then_delay")]
+    public static partial void InstanceThenDelay(ImAnimInstance* pOut, ImAnimInstance* self, float delay);
+
+    // Query state
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_time")]
+    public static partial float InstanceTime(ImAnimInstance* self);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_duration")]
+    public static partial float InstanceDuration(ImAnimInstance* self);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_is_playing")]
+    public static partial byte InstanceIsPlaying(ImAnimInstance* self);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_is_paused")]
+    public static partial byte InstanceIsPaused(ImAnimInstance* self);
+
+    // Get animated values
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_get_float")]
+    public static partial byte InstanceGetFloat(ImAnimInstance* self, uint channel, float* outVal);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_get_vec2")]
+    public static partial byte InstanceGetVec2(ImAnimInstance* self, uint channel, Vector2* outVal);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_get_vec4")]
+    public static partial byte InstanceGetVec4(ImAnimInstance* self, uint channel, Vector4* outVal);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_get_int")]
+    public static partial byte InstanceGetInt(ImAnimInstance* self, uint channel, int* outVal);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_get_color")]
+    public static partial byte InstanceGetColor(ImAnimInstance* self, uint channel, Vector4* outVal, ImAnimColorSpace colorSpace);
+
+    // Check validity
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_instance_valid")]
+    public static partial byte InstanceValid(ImAnimInstance* self);
+
+
+    // ----------------------------------------------------
+    // Clip System API
+    // ----------------------------------------------------
+
+    // Initialize/shutdown (optional - auto-init on first use)
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_init")]
+    public static partial void ClipInit(int initialClipCap, int initialInstCap);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_shutdown")]
+    public static partial void ClipShutdown();
+
+    // c_Per-frame update (call after iam_update_begin_frame)
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_update")]
+    public static partial void ClipUpdate(float dt);
+
+    // Garbage collection for instances
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_gc")]
+    public static partial void ClipGc(uint maxAgeFrames);
+
+    // Play a clip on an instance (creates or reuses instance)
+    [LibraryImport(LibName, EntryPoint = "c_iam_play")]
+    public static partial void Play(ImAnimInstance* pOut, uint clipId, uint instanceId);
+
+    // c_Get an existing instance (returns invalid iam_instance if not found)
+    [LibraryImport(LibName, EntryPoint = "c_iam_get_instance")]
+    public static partial void GetInstance(ImAnimInstance* pOut, uint instanceId);
+
+    // Query clip info
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_duration")]
+    public static partial float ClipDuration(uint clipId);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_exists")]
+    public static partial byte ClipExists(uint clipId);
+
+    // Stagger helpers - compute delay for indexed instances
+    [LibraryImport(LibName, EntryPoint = "c_iam_stagger_delay")]
+    public static partial float StaggerDelay(uint clipId, int index);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_play_stagger")]
+    public static partial void PlayStagger(ImAnimInstance* pOut, uint clipId, uint instanceId, int index);
+
+    // Layering support - blend multiple animation instances
+    [LibraryImport(LibName, EntryPoint = "c_iam_layer_begin")]
+    public static partial void LayerBegin(uint instanceId);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_layer_add")]
+    public static partial void LayerAdd(ImAnimInstance* inst, float weight);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_layer_end")]
+    public static partial void LayerEnd(uint instanceId);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_get_blended_float")]
+    public static partial byte GetBlendedFloat(uint instanceId, uint channel, float* outVal);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_get_blended_vec2")]
+    public static partial byte GetBlendedVec2(uint instanceId, uint channel, Vector2* outVal);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_get_blended_vec4")]
+    public static partial byte GetBlendedVec4(uint instanceId, uint channel, Vector4* outVal);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_get_blended_int")]
+    public static partial byte GetBlendedInt(uint instanceId, uint channel, int* outVal);
+
+    // Persistence (optional)
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_save")]
+    public static partial ImAnimResult ClipSave(uint clipId, byte* path);
+
+    [LibraryImport(LibName, EntryPoint = "c_iam_clip_load")]
+    public static partial ImAnimResult ClipLoad(byte* path, uint* outClipId);
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimClip.cs

@@ -0,0 +1,338 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+using Dalamud.Bindings.ImGui;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct ImAnimClip
+{
+    public uint ClipId;
+
+    public static ImAnimClip Begin(uint clipId)
+    {
+        return ImAnim.ClipBegin(clipId);
+    }
+
+    public ImAnimClip KeyFloat(uint channel, float time, float value, ImAnimEaseType easeType = ImAnimEaseType.Linear)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyFloat(@this, channel, time, value, easeType, null);
+        return this;
+    }
+
+    public ImAnimClip KeyFloat(uint channel, float time, float value, ImAnimEaseType easeType, Vector4 bezier4)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyFloat(@this, channel, time, value, easeType, &bezier4);
+        return this;
+    }
+
+    public ImAnimClip KeyVec2(uint channel, float time, Vector2 value, ImAnimEaseType easeType = ImAnimEaseType.Linear)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyVec2(@this, channel, time, &value, easeType, null);
+        return this;
+    }
+
+    public ImAnimClip KeyVec2(uint channel, float time, Vector2 value, ImAnimEaseType easeType, Vector4 bezier4)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyVec2(@this, channel, time, &value, easeType, &bezier4);
+        return this;
+    }
+
+    public ImAnimClip KeyVec4(uint channel, float time, Vector4 value, ImAnimEaseType easeType = ImAnimEaseType.Linear)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyVec4(@this, channel, time, &value, easeType, null);
+        return this;
+    }
+
+    public ImAnimClip KeyVec4(uint channel, float time, Vector4 value, ImAnimEaseType easeType, Vector4 bezier4)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyVec4(@this, channel, time, &value, easeType, &bezier4);
+        return this;
+    }
+
+    public ImAnimClip KeyInt(uint channel, float time, int value, ImAnimEaseType easeType = ImAnimEaseType.Linear)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyInt(@this, channel, time, value, easeType);
+        return this;
+    }
+
+    public ImAnimClip KeyColor(uint channel, float time, Vector4 value, ImAnimColorSpace colorSpace, ImAnimEaseType easeType = ImAnimEaseType.Linear)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyColor(@this, channel, time, &value, colorSpace, easeType, null);
+        return this;
+    }
+
+    public ImAnimClip KeyColor(uint channel, float time, Vector4 value, ImAnimColorSpace colorSpace, ImAnimEaseType easeType, Vector4 bezier4)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyColor(@this, channel, time, &value, colorSpace, easeType, &bezier4);
+        return this;
+    }
+
+    // Keyframes with repeat variation (value changes per loop iteration)
+
+    public ImAnimClip KeyFloatVar(uint channel, float time, float value, ImAnimVariationFloat var, ImAnimEaseType easeType = ImAnimEaseType.Linear)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyFloatVar(@this, channel, time, value, &var, easeType, null);
+        return this;
+    }
+
+    public ImAnimClip KeyFloatVar(uint channel, float time, float value, ImAnimVariationFloat var, ImAnimEaseType easeType, Vector4 bezier4)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyFloatVar(@this, channel, time, value, &var, easeType, &bezier4);
+        return this;
+    }
+
+    public ImAnimClip KeyVec2Var(uint channel, float time, Vector2 value, ImAnimVariationVec2 var, ImAnimEaseType easeType)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyVec2Var(@this, channel, time, &value, &var, easeType, null);
+        return this;
+    }
+
+    public ImAnimClip KeyVec2Var(uint channel, float time, Vector2 value, ImAnimVariationVec2 var, ImAnimEaseType easeType, Vector4 bezier4)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyVec2Var(@this, channel, time, &value, &var, easeType, &bezier4);
+        return this;
+    }
+
+    public ImAnimClip KeyVec4Var(uint channel, float time, Vector4 value, ImAnimVariationVec4 var, ImAnimEaseType easeType = ImAnimEaseType.Linear)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyVec4Var(@this, channel, time, &value, &var, easeType, null);
+        return this;
+    }
+
+    public ImAnimClip KeyVec4Var(uint channel, float time, Vector4 value, ImAnimVariationVec4 var, ImAnimEaseType easeType, Vector4 bezier4)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyVec4Var(@this, channel, time, &value, &var, easeType, &bezier4);
+        return this;
+    }
+
+    public ImAnimClip KeyIntVar(uint channel, float time, int value, ImAnimVariationInt var, ImAnimEaseType easeType = ImAnimEaseType.Linear)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyIntVar(@this, channel, time, value, &var, easeType);
+        return this;
+    }
+
+    public ImAnimClip KeyColorVar(uint channel, float time, Vector4 value, ImAnimVariationColor var, ImAnimColorSpace colorSpace, ImAnimEaseType easeType = ImAnimEaseType.Linear)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyColorVar(@this, channel, time, &value, &var, colorSpace, easeType, null);
+        return this;
+    }
+
+    public ImAnimClip KeyColorVar(uint channel, float time, Vector4 value, ImAnimVariationColor var, ImAnimColorSpace colorSpace, ImAnimEaseType easeType, Vector4 bezier4)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyColorVar(@this, channel, time, &value, &var, colorSpace, easeType, &bezier4);
+        return this;
+    }
+
+    // Spring-based keyframe (float only)
+
+    public ImAnimClip KeyFloatSpring(uint channel, float time, float target, ImAnimSpringParams spring)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyFloatSpring(@this, channel, time, target, &spring);
+        return this;
+    }
+
+    // Anchor-relative keyframes (values resolved relative to window/viewport at get time)
+
+    public ImAnimClip KeyFloatRel(uint channel, float time, float percent, float pxBias, ImAnimAnchorSpace anchorSpace, int axis, ImAnimEaseType easeType = ImAnimEaseType.Linear)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyFloatRel(@this, channel, time, percent, pxBias, anchorSpace, axis, easeType, null);
+        return this;
+    }
+
+    public ImAnimClip KeyFloatRel(uint channel, float time, float percent, float pxBias, ImAnimAnchorSpace anchorSpace, int axis, ImAnimEaseType easeType, Vector4 bezier4)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyFloatRel(@this, channel, time, percent, pxBias, anchorSpace, axis, easeType, &bezier4);
+        return this;
+    }
+
+    public ImAnimClip KeyVec2Rel(uint channel, float time, Vector2 percent, Vector2 pxBias, ImAnimAnchorSpace anchorSpace, ImAnimEaseType easeType = ImAnimEaseType.Linear)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyVec2Rel(@this, channel, time, &percent, &pxBias, anchorSpace, easeType, null);
+        return this;
+    }
+
+    public ImAnimClip KeyVec2Rel(uint channel, float time, Vector2 percent, Vector2 pxBias, ImAnimAnchorSpace anchorSpace, ImAnimEaseType easeType, Vector4 bezier4)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyVec2Rel(@this, channel, time, &percent, &pxBias, anchorSpace, easeType, &bezier4);
+        return this;
+    }
+
+    public ImAnimClip KeyVec4Rel(uint channel, float time, Vector4 percent, Vector4 pxBias, ImAnimAnchorSpace anchorSpace, ImAnimEaseType easeType = ImAnimEaseType.Linear)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyVec4Rel(@this, channel, time, &percent, &pxBias, anchorSpace, easeType, null);
+        return this;
+    }
+
+    public ImAnimClip KeyVec4Rel(uint channel, float time, Vector4 percent, Vector4 pxBias, ImAnimAnchorSpace anchorSpace, ImAnimEaseType easeType, Vector4 bezier4)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyVec4Rel(@this, channel, time, &percent, &pxBias, anchorSpace, easeType, &bezier4);
+        return this;
+    }
+
+    public ImAnimClip KeyColorRel(uint channel, float time, Vector4 percent, Vector4 pxBias, ImAnimColorSpace colorSpace, ImAnimAnchorSpace anchorSpace, ImAnimEaseType easeType = ImAnimEaseType.Linear)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyColorRel(@this, channel, time, &percent, &pxBias, colorSpace, anchorSpace, easeType, null);
+        return this;
+    }
+
+    public ImAnimClip KeyColorRel(uint channel, float time, Vector4 percent, Vector4 pxBias, ImAnimColorSpace colorSpace, ImAnimAnchorSpace anchorSpace, ImAnimEaseType easeType, Vector4 bezier4)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipKeyColorRel(@this, channel, time, &percent, &pxBias, colorSpace, anchorSpace, easeType, &bezier4);
+        return this;
+    }
+
+    // Timeline grouping - sequential and parallel keyframe blocks
+
+    public ImAnimClip SeqBegin()
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipSeqBegin(@this);
+        return this;
+    }
+
+    public ImAnimClip SeqEnd()
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipSeqEnd(@this);
+        return this;
+    }
+
+    public ImAnimClip ParBegin()
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipParBegin(@this);
+        return this;
+    }
+
+    public ImAnimClip ParEnd()
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipParEnd(@this);
+        return this;
+    }
+
+    // Timeline markers - callbacks at specific times during playback
+
+    public ImAnimClip MarkerId(float time, uint markerId, ImAnim.MarkerCallback cb, void* userData = null)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipMarkerId(@this, time, markerId, (delegate* unmanaged[Cdecl]<uint, uint, float, void*, void>)Marshal.GetFunctionPointerForDelegate(cb), userData);
+        return this;
+    }
+
+    public ImAnimClip Marker(float time, ImAnim.MarkerCallback cb, void* userData = null)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipMarker(@this, time, (delegate* unmanaged[Cdecl]<uint, uint, float, void*, void>)Marshal.GetFunctionPointerForDelegate(cb), userData);
+        return this;
+    }
+
+    // Clip options
+
+    public ImAnimClip SetLoop(bool loop, ImAnimDirection direction, int loopCount = -1)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipSetLoop(@this, (byte)(loop ? 1 : 0), direction, loopCount);
+        return this;
+    }
+
+    public ImAnimClip SetDelay(float delaySeconds)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipSetDelay(@this, delaySeconds);
+        return this;
+    }
+
+    public ImAnimClip SetStagger(int count, float eachDelay, float fromCenterBias)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipSetStagger(@this, count, eachDelay, fromCenterBias);
+        return this;
+    }
+
+    // Timing variation per loop iteration
+
+    public ImAnimClip SetDurationVar(ImAnimVariationFloat var)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipSetDurationVar(@this, &var);
+        return this;
+    }
+
+    public ImAnimClip SetDelayVar(ImAnimVariationFloat var)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipSetDelayVar(@this, &var);
+        return this;
+    }
+
+    public ImAnimClip SetTimescaleVar(ImAnimVariationFloat var)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipSetTimescaleVar(@this, &var);
+        return this;
+    }
+
+    // Callbacks
+
+    public ImAnimClip OnBegin(ImAnim.ClipCallback cb, void* userData = null)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipOnBegin(@this, (delegate* unmanaged[Cdecl]<uint, void*, void>)Marshal.GetFunctionPointerForDelegate(cb), userData);
+        return this;
+    }
+
+    public ImAnimClip OnUpdate(ImAnim.ClipCallback cb, void* userData = null)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipOnUpdate(@this, (delegate* unmanaged[Cdecl]<uint, void*, void>)Marshal.GetFunctionPointerForDelegate(cb), userData);
+        return this;
+    }
+
+    public ImAnimClip OnComplete(ImAnim.ClipCallback cb, void* userData = null)
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipOnComplete(@this, (delegate* unmanaged[Cdecl]<uint, void*, void>)Marshal.GetFunctionPointerForDelegate(cb), userData);
+        return this;
+    }
+
+    public void End()
+    {
+        fixed (ImAnimClip* @this = &this)
+            ImAnimNative.ClipEnd(@this);
+    }
+
+    public ImAnimResult Save(ImU8String path)
+    {
+        return ImAnim.ClipSave(this.ClipId, path);
+    }
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimDragFeedback.cs

@@ -0,0 +1,15 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public struct ImAnimDragFeedback
+{
+    public Vector2 Position;
+    public Vector2 Offset;
+    public Vector2 Velocity;
+    public bool IsDragging;
+    public bool IsSnapping;
+    public float SnapProgress;
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimDragOpts.cs

@@ -0,0 +1,17 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct ImAnimDragOpts
+{
+    public Vector2 SnapGrid;
+    public Vector2* SnapPoints;
+    public int SnapPointsCount;
+    public float SnapDuration;
+    public float Overshoot;
+    public ImAnimEaseType EaseType;
+
+    public static ImAnimDragOpts Default() => new() { SnapDuration = 0.2f, EaseType = ImAnimEaseType.OutCubic };
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimEaseDesc.cs

@@ -0,0 +1,13 @@
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public struct ImAnimEaseDesc
+{
+    public ImAnimEaseType Type;
+    public float P0;
+    public float P1;
+    public float P2;
+    public float P3;
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimEasePerAxis.cs

@@ -0,0 +1,28 @@
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public struct ImAnimEasePerAxis
+{
+    public ImAnimEaseDesc X;
+    public ImAnimEaseDesc Y;
+    public ImAnimEaseDesc Z;
+    public ImAnimEaseDesc W;
+
+    public static ImAnimEasePerAxis From(ImAnimEaseDesc all) => new()
+    {
+        X = all,
+        Y = all,
+        Z = all,
+        W = all
+    };
+
+    public static ImAnimEasePerAxis From(ImAnimEaseDesc ex, ImAnimEaseDesc ey) => new()
+    {
+        X = ex,
+        Y = ey,
+        Z = new ImAnimEaseDesc { Type = ImAnimEaseType.Linear },
+        W = new ImAnimEaseDesc { Type = ImAnimEaseType.Linear }
+    };
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimGradient.cs

@@ -0,0 +1,13 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+using Dalamud.Bindings.ImGui;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct ImAnimGradient
+{
+    public ImVector<Vector2> Positions;
+    public ImVector<Vector2> Colors;
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimInstance.cs

@@ -0,0 +1,155 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct ImAnimInstance
+{
+    public uint InstId;
+
+    // Playback control
+
+    public static ImAnimInstance Create()
+    {
+        return new ImAnimInstance();
+    }
+
+    public static ImAnimInstance Create(uint instId)
+    {
+        return new ImAnimInstance() { InstId = instId };
+    }
+
+    public void Pause()
+    {
+        fixed (ImAnimInstance* @this = &this)
+            ImAnimNative.InstancePause(@this);
+    }
+
+    public void Resume()
+    {
+        fixed (ImAnimInstance* @this = &this)
+            ImAnimNative.InstanceResume(@this);
+    }
+
+    public void Stop()
+    {
+        fixed (ImAnimInstance* @this = &this)
+            ImAnimNative.InstanceStop(@this);
+    }
+
+    public void Seek(float time)
+    {
+        fixed (ImAnimInstance* @this = &this)
+            ImAnimNative.InstanceSeek(@this, time);
+    }
+
+    public void SetTimeScale(float scale)
+    {
+        fixed (ImAnimInstance* @this = &this)
+            ImAnimNative.InstanceSetTimeScale(@this, scale);
+    }
+
+    public void SetWeight(float weight)
+    {
+        fixed (ImAnimInstance* @this = &this)
+            ImAnimNative.InstanceSetWeight(@this, weight);
+    }
+
+    // Animation chaining - play another clip when this one completes
+
+    public ImAnimInstance Then(uint nextClipId)
+    {
+        ImAnimInstance ret = default;
+        fixed (ImAnimInstance* @this = &this)
+            ImAnimNative.InstanceThen(&ret, @this, nextClipId);
+        return ret;
+    }
+
+    public ImAnimInstance Then(uint nextClipId, uint nextInstanceId)
+    {
+        ImAnimInstance ret = default;
+        fixed (ImAnimInstance* @this = &this)
+            ImAnimNative.InstanceThenId(&ret, @this, nextClipId, nextInstanceId);
+        return ret;
+    }
+
+    public ImAnimInstance ThenDelay(float delay)
+    {
+        ImAnimInstance ret = default;
+        fixed (ImAnimInstance* @this = &this)
+            ImAnimNative.InstanceThenDelay(&ret, @this, delay);
+        return ret;
+    }
+
+    // Query state
+
+    public float Time()
+    {
+        fixed (ImAnimInstance* @this = &this)
+            return ImAnimNative.InstanceTime(@this);
+    }
+
+    public float Duration()
+    {
+        fixed (ImAnimInstance* @this = &this)
+            return ImAnimNative.InstanceDuration(@this);
+    }
+
+    public bool IsPlaying()
+    {
+        fixed (ImAnimInstance* @this = &this)
+            return ImAnimNative.InstanceIsPlaying(@this) == 1;
+    }
+
+    public bool IsPaused()
+    {
+        fixed (ImAnimInstance* @this = &this)
+            return ImAnimNative.InstanceIsPaused(@this) == 1;
+    }
+
+    // Get animated values
+
+    public bool GetFloat(uint channel, out float value)
+    {
+        fixed (ImAnimInstance* @this = &this)
+        fixed (float* outVal = &value)
+            return ImAnimNative.InstanceGetFloat(@this, channel, outVal) == 1;
+    }
+
+    public bool GetVec2(uint channel, out Vector2 value)
+    {
+        fixed (ImAnimInstance* @this = &this)
+        fixed (Vector2* outVal = &value)
+            return ImAnimNative.InstanceGetVec2(@this, channel, outVal) == 1;
+    }
+
+    public bool GetVec4(uint channel, out Vector4 value)
+    {
+        fixed (ImAnimInstance* @this = &this)
+        fixed (Vector4* outVal = &value)
+            return ImAnimNative.InstanceGetVec4(@this, channel, outVal) == 1;
+    }
+
+    public bool GetInt(uint channel, out int value)
+    {
+        fixed (ImAnimInstance* @this = &this)
+        fixed (int* outVal = &value)
+            return ImAnimNative.InstanceGetInt(@this, channel, outVal) == 1;
+    }
+
+    public bool GetColor(uint channel, out Vector4 value, ImAnimColorSpace colorSpace = ImAnimColorSpace.Oklab)
+    {
+        fixed (ImAnimInstance* @this = &this)
+        fixed (Vector4* outVal = &value)
+            return ImAnimNative.InstanceGetColor(@this, channel, outVal, colorSpace) == 1;
+    }
+
+    // Check validity
+
+    public bool Valid()
+    {
+        fixed (ImAnimInstance* @this = &this)
+            return ImAnimNative.InstanceValid(@this) == 1;
+    }
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimMorphOpts.cs

@@ -0,0 +1,13 @@
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public struct ImAnimMorphOpts
+{
+    public int Samples;
+    public bool MatchEndpoints;
+    public bool UseArcLength;
+
+    public static ImAnimMorphOpts Default() => new() { Samples = 64, MatchEndpoints = true, UseArcLength = true };
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimNoiseOpts.cs

@@ -0,0 +1,28 @@
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct ImAnimNoiseOpts
+{
+    public ImAnimNoiseType Type;
+    /// <summary>
+    /// Number of octaves for fractal noise (1-8)
+    /// </summary>
+    public int Octaves;
+
+    /// <summary>
+    /// Amplitude multiplier per octave (0.0-1.0)
+    /// </summary>
+    public float Persistence;
+
+    /// <summary>
+    /// Frequency multiplier per octave (typically 2.0)
+    /// </summary>
+    public float Lacunarity;
+
+    /// <summary>
+    /// Random seed for noise generation
+    /// </summary>
+    public int Seed;
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimSpringParams.cs

@@ -0,0 +1,12 @@
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential, Pack = 4)]
+public struct ImAnimSpringParams
+{
+    public float Mass;
+    public float Stiffness;
+    public float Damping;
+    public float InitialVelocity;
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimTextPathOpts.cs

@@ -0,0 +1,21 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+using Dalamud.Bindings.ImGui;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public struct ImAnimTextPathOpts
+{
+    public Vector2 Origin;
+    public float Offset;
+    public float LetterSpacing;
+    public ImAnimTextPathAlign Align;
+    public bool FlipY;
+    public uint Color;
+    public ImFontPtr Font;
+    public float FontScale;
+
+    public static ImAnimTextPathOpts Default() => new() { Color = 0xFFFFFFFF, FontScale = 1.0f };
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimTextStaggerOpts.cs

@@ -0,0 +1,32 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+using Dalamud.Bindings.ImGui;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct ImAnimTextStaggerOpts
+{
+    public Vector2 Pos;
+    public ImAnimTextStaggerEffect Effect;
+    public float CharDelay;
+    public float CharDuration;
+    public float EffectIntensity;
+    public ImAnimEaseDesc Ease;
+    public uint Color;
+    public ImFontPtr Font;
+    public float FontScale;
+    public float LetterSpacing;
+
+    public static ImAnimTextStaggerOpts Default() => new()
+    {
+        Effect = ImAnimTextStaggerEffect.Fade,
+        CharDelay = 0.05f,
+        CharDuration = 0.3f,
+        EffectIntensity = 20.0f,
+        Ease = new ImAnimEaseDesc { Type = ImAnimEaseType.OutCubic },
+        Color = 0xFFFFFFFF,
+        FontScale = 1.0f
+    };
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimTransform.cs

@@ -0,0 +1,12 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct ImAnimTransform
+{
+    public Vector2 Position;
+    public Vector2 Scale;
+    public float Rotation;
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimVariationColor.cs

@@ -0,0 +1,170 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct ImAnimVariationColor
+{
+    public ImAnimVariationMode Mode;
+    public Vector4 Amount;
+    public Vector4 MinClamp;
+    public Vector4 MaxClamp;
+    public ImAnimColorSpace ColorSpace;
+    public delegate* unmanaged[Cdecl]<int, void*, Vector4> Callback;
+    public void* User;
+    public ImAnimVariationFloat R;
+    public ImAnimVariationFloat G;
+    public ImAnimVariationFloat B;
+    public ImAnimVariationFloat A;
+
+    public static ImAnimVariationColor None => new()
+    {
+        Mode = ImAnimVariationMode.None,
+        Amount = Vector4.Zero,
+        MinClamp = Vector4.Zero,
+        MaxClamp = Vector4.One,
+        ColorSpace = ImAnimColorSpace.Oklab,
+        Callback = null,
+        User = null,
+        R = ImAnimVariationFloat.None,
+        G = ImAnimVariationFloat.None,
+        B = ImAnimVariationFloat.None,
+        A = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationColor Inc(Vector4 color) => new()
+    {
+        Mode = ImAnimVariationMode.Increment,
+        Amount = color,
+        MinClamp = Vector4.Zero,
+        MaxClamp = Vector4.One,
+        ColorSpace = ImAnimColorSpace.Oklab,
+        Callback = null,
+        User = null,
+        R = ImAnimVariationFloat.None,
+        G = ImAnimVariationFloat.None,
+        B = ImAnimVariationFloat.None,
+        A = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationColor Inc(float r, float g, float b, float a) => new()
+    {
+        Mode = ImAnimVariationMode.Increment,
+        Amount = new Vector4(r, g, b, a),
+        MinClamp = Vector4.Zero,
+        MaxClamp = Vector4.One,
+        ColorSpace = ImAnimColorSpace.Oklab,
+        Callback = null,
+        User = null,
+        R = ImAnimVariationFloat.None,
+        G = ImAnimVariationFloat.None,
+        B = ImAnimVariationFloat.None,
+        A = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationColor Dec(Vector4 color) => new()
+    {
+        Mode = ImAnimVariationMode.Decrement,
+        Amount = color,
+        MinClamp = Vector4.Zero,
+        MaxClamp = Vector4.One,
+        ColorSpace = ImAnimColorSpace.Oklab,
+        Callback = null,
+        User = null,
+        R = ImAnimVariationFloat.None,
+        G = ImAnimVariationFloat.None,
+        B = ImAnimVariationFloat.None,
+        A = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationColor Dec(float r, float g, float b, float a) => new()
+    {
+        Mode = ImAnimVariationMode.Decrement,
+        Amount = new Vector4(r, g, b, a),
+        MinClamp = Vector4.Zero,
+        MaxClamp = Vector4.One,
+        ColorSpace = ImAnimColorSpace.Oklab,
+        Callback = null,
+        User = null,
+        R = ImAnimVariationFloat.None,
+        G = ImAnimVariationFloat.None,
+        B = ImAnimVariationFloat.None,
+        A = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationColor Mul(float f) => new()
+    {
+        Mode = ImAnimVariationMode.Multiply,
+        Amount = new Vector4(f, f, f, 1),
+        MinClamp = Vector4.Zero,
+        MaxClamp = Vector4.One,
+        ColorSpace = ImAnimColorSpace.Oklab,
+        Callback = null,
+        User = null,
+        R = ImAnimVariationFloat.None,
+        G = ImAnimVariationFloat.None,
+        B = ImAnimVariationFloat.None,
+        A = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationColor Rand(Vector4 acolort) => new()
+    {
+        Mode = ImAnimVariationMode.Random,
+        Amount = acolort,
+        MinClamp = Vector4.Zero,
+        MaxClamp = Vector4.One,
+        ColorSpace = ImAnimColorSpace.Oklab,
+        Callback = null,
+        User = null,
+        R = ImAnimVariationFloat.None,
+        G = ImAnimVariationFloat.None,
+        B = ImAnimVariationFloat.None,
+        A = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationColor Rand(float r, float g, float b, float a) => new()
+    {
+        Mode = ImAnimVariationMode.Random,
+        Amount = new Vector4(r, g, b, a),
+        MinClamp = Vector4.Zero,
+        MaxClamp = Vector4.One,
+        ColorSpace = ImAnimColorSpace.Oklab,
+        Callback = null,
+        User = null,
+        R = ImAnimVariationFloat.None,
+        G = ImAnimVariationFloat.None,
+        B = ImAnimVariationFloat.None,
+        A = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationColor Fn(ImAnim.VariationVec4Fn fn, void* userData = null) => new()
+    {
+        Mode = ImAnimVariationMode.Callback,
+        Amount = Vector4.Zero,
+        MinClamp = Vector4.Zero,
+        MaxClamp = Vector4.One,
+        ColorSpace = ImAnimColorSpace.Oklab,
+        Callback = (delegate* unmanaged[Cdecl]<int, void*, Vector4>)Marshal.GetFunctionPointerForDelegate(fn),
+        User = userData,
+        R = ImAnimVariationFloat.None,
+        G = ImAnimVariationFloat.None,
+        B = ImAnimVariationFloat.None,
+        A = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationColor Axis(ImAnimVariationFloat vr, ImAnimVariationFloat vg, ImAnimVariationFloat vb, ImAnimVariationFloat va) => new()
+    {
+        Mode = ImAnimVariationMode.None,
+        Amount = Vector4.Zero,
+        MinClamp = Vector4.Zero,
+        MaxClamp = Vector4.One,
+        ColorSpace = ImAnimColorSpace.Oklab,
+        Callback = null,
+        User = null,
+        R = vr,
+        G = vg,
+        B = vb,
+        A = va,
+    };
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimVariationFloat.cs

@@ -0,0 +1,103 @@
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct ImAnimVariationFloat
+{
+    public ImAnimVariationMode Mode;
+    public float Amount;
+    public float MinClamp;
+    public float MaxClamp;
+    public uint Seed;
+    public delegate* unmanaged[Cdecl]<int, void*, float> Callback;
+    public void* User;
+
+    public static ImAnimVariationFloat None => new()
+    {
+        Mode = ImAnimVariationMode.None,
+        Amount = 0,
+        MinClamp = float.MinValue,
+        MaxClamp = float.MaxValue,
+        Seed = 0,
+        Callback = null,
+        User = null
+    };
+
+    public static ImAnimVariationFloat Inc(float amt) => new()
+    {
+        Mode = ImAnimVariationMode.Increment,
+        Amount = amt,
+        MinClamp = float.MinValue,
+        MaxClamp = float.MaxValue,
+        Seed = 0,
+        Callback = null,
+        User = null
+    };
+
+    public static ImAnimVariationFloat Dec(float amt) => new()
+    {
+        Mode = ImAnimVariationMode.Decrement,
+        Amount = amt,
+        MinClamp = float.MinValue,
+        MaxClamp = float.MaxValue,
+        Seed = 0,
+        Callback = null,
+        User = null
+    };
+
+    public static ImAnimVariationFloat Mul(float f) => new()
+    {
+        Mode = ImAnimVariationMode.Multiply,
+        Amount = f,
+        MinClamp = float.MinValue,
+        MaxClamp = float.MaxValue,
+        Seed = 0,
+        Callback = null,
+        User = null
+    };
+
+    public static ImAnimVariationFloat Rand(float r) => new()
+    {
+        Mode = ImAnimVariationMode.Random,
+        Amount = r,
+        MinClamp = float.MinValue,
+        MaxClamp = float.MaxValue,
+        Seed = 0,
+        Callback = null,
+        User = null
+    };
+
+    public static ImAnimVariationFloat RandAbs(float r) => new()
+    {
+        Mode = ImAnimVariationMode.RandomAbs,
+        Amount = r,
+        MinClamp = float.MinValue,
+        MaxClamp = float.MaxValue,
+        Seed = 0,
+        Callback = null,
+        User = null
+    };
+
+    public static ImAnimVariationFloat PingPong(float amt) => new()
+    {
+        Mode = ImAnimVariationMode.PingPong,
+        Amount = amt,
+        MinClamp = float.MinValue,
+        MaxClamp = float.MaxValue,
+        Seed = 0,
+        Callback = null,
+        User = null
+    };
+
+    public static ImAnimVariationFloat Fn(ImAnim.VariationFloatFn fn, void* userData = null) => new()
+    {
+        Mode = ImAnimVariationMode.Callback,
+        Amount = 0,
+        MinClamp = float.MinValue,
+        MaxClamp = float.MaxValue,
+        Seed = 0,
+        Callback = (delegate* unmanaged[Cdecl]<int, void*, float>)Marshal.GetFunctionPointerForDelegate(fn),
+        User = userData
+    };
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimVariationInt.cs

@@ -0,0 +1,92 @@
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct ImAnimVariationInt
+{
+    public ImAnimVariationMode Mode;
+    public int Amount;
+    public int MinClamp;
+    public int MaxClamp;
+    public uint Seed;
+    public delegate* unmanaged[Cdecl]<int, void*, int> Callback;
+    public void* User;
+
+    public static ImAnimVariationInt None => new()
+    {
+        Mode = ImAnimVariationMode.None,
+        Amount = 0,
+        MinClamp = int.MinValue,
+        MaxClamp = int.MaxValue,
+        Seed = 0,
+        Callback = null,
+        User = null
+    };
+
+    public static ImAnimVariationInt Inc(int amt) => new()
+    {
+        Mode = ImAnimVariationMode.Increment,
+        Amount = amt,
+        MinClamp = int.MinValue,
+        MaxClamp = int.MaxValue,
+        Seed = 0,
+        Callback = null,
+        User = null
+    };
+
+    public static ImAnimVariationInt Dec(int amt) => new()
+    {
+        Mode = ImAnimVariationMode.Decrement,
+        Amount = amt,
+        MinClamp = int.MinValue,
+        MaxClamp = int.MaxValue,
+        Seed = 0,
+        Callback = null,
+        User = null
+    };
+
+    public static ImAnimVariationInt Mul(int f) => new()
+    {
+        Mode = ImAnimVariationMode.Multiply,
+        Amount = f,
+        MinClamp = int.MinValue,
+        MaxClamp = int.MaxValue,
+        Seed = 0,
+        Callback = null,
+        User = null
+    };
+
+    public static ImAnimVariationInt Rand(int r) => new()
+    {
+        Mode = ImAnimVariationMode.Random,
+        Amount = r,
+        MinClamp = int.MinValue,
+        MaxClamp = int.MaxValue,
+        Seed = 0,
+        Callback = null,
+        User = null
+    };
+
+    public static ImAnimVariationInt RandAbs(int r) => new()
+    {
+        Mode = ImAnimVariationMode.RandomAbs,
+        Amount = r,
+        MinClamp = int.MinValue,
+        MaxClamp = int.MaxValue,
+        Seed = 0,
+        Callback = null,
+        User = null
+    };
+
+    public static ImAnimVariationInt Fn(ImAnim.VariationIntFn fn, void* userData = null) => new()
+    {
+        Mode = ImAnimVariationMode.Callback,
+        Amount = 0,
+        MinClamp = int.MinValue,
+        MaxClamp = int.MaxValue,
+        Seed = 0,
+        Callback = (delegate* unmanaged[Cdecl]<int, void*, int>)Marshal.GetFunctionPointerForDelegate(fn),
+        User = userData
+    };
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimVariationVec2.cs

@@ -0,0 +1,149 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct ImAnimVariationVec2
+{
+    public ImAnimVariationMode Mode;
+    public Vector2 Amount;
+    public Vector2 MinClamp;
+    public Vector2 MaxClamp;
+    public uint Seed;
+    public delegate* unmanaged[Cdecl]<int, void*, Vector2> Callback;
+    public void* User;
+    public ImAnimVariationFloat X;
+    public ImAnimVariationFloat Y;
+
+    public static ImAnimVariationVec2 None => new()
+    {
+        Mode = ImAnimVariationMode.None,
+        Amount = Vector2.Zero,
+        MinClamp = new Vector2(float.MinValue),
+        MaxClamp = new Vector2(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec2 Inc(Vector2 amt) => new()
+    {
+        Mode = ImAnimVariationMode.Increment,
+        Amount = amt,
+        MinClamp = new Vector2(float.MinValue),
+        MaxClamp = new Vector2(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec2 Inc(float x, float y) => new()
+    {
+        Mode = ImAnimVariationMode.Increment,
+        Amount = new Vector2(x, y),
+        MinClamp = new Vector2(float.MinValue),
+        MaxClamp = new Vector2(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec2 Dec(Vector2 amt) => new()
+    {
+        Mode = ImAnimVariationMode.Decrement,
+        Amount = amt,
+        MinClamp = new Vector2(float.MinValue),
+        MaxClamp = new Vector2(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec2 Dec(float x, float y) => new()
+    {
+        Mode = ImAnimVariationMode.Decrement,
+        Amount = new Vector2(x, y),
+        MinClamp = new Vector2(float.MinValue),
+        MaxClamp = new Vector2(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec2 Mul(float f) => new()
+    {
+        Mode = ImAnimVariationMode.Multiply,
+        Amount = new Vector2(f),
+        MinClamp = new Vector2(float.MinValue),
+        MaxClamp = new Vector2(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec2 Rand(Vector2 amt) => new()
+    {
+        Mode = ImAnimVariationMode.Random,
+        Amount = amt,
+        MinClamp = new Vector2(float.MinValue),
+        MaxClamp = new Vector2(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec2 Rand(float x, float y) => new()
+    {
+        Mode = ImAnimVariationMode.Random,
+        Amount = new Vector2(x, y),
+        MinClamp = new Vector2(float.MinValue),
+        MaxClamp = new Vector2(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+    };
+
+    // TODO: iam_variation_vec2_fn
+    public static ImAnimVariationVec2 Fn(ImAnim.VariationVec2Fn fn, void* userData = null) => new()
+    {
+        Mode = ImAnimVariationMode.Callback,
+        Amount = Vector2.Zero,
+        MinClamp = new Vector2(float.MinValue),
+        MaxClamp = new Vector2(float.MaxValue),
+        Seed = 0,
+        Callback = (delegate* unmanaged[Cdecl]<int, void*, Vector2>)Marshal.GetFunctionPointerForDelegate(fn),
+        User = userData,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec2 Axis(ImAnimVariationFloat vx, ImAnimVariationFloat vy) => new()
+    {
+        Mode = ImAnimVariationMode.None,
+        Amount = Vector2.Zero,
+        MinClamp = new Vector2(float.MinValue),
+        MaxClamp = new Vector2(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = vx,
+        Y = vy,
+    };
+}

imgui/Dalamud.Bindings.ImAnim/Structs/ImAnimVariationVec4.cs

@@ -0,0 +1,170 @@
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Bindings.ImAnim;
+
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct ImAnimVariationVec4
+{
+    public ImAnimVariationMode Mode;
+    public Vector4 Amount;
+    public Vector4 MinClamp;
+    public Vector4 MaxClamp;
+    public uint Seed;
+    public delegate* unmanaged[Cdecl]<int, void*, Vector4> Callback;
+    public void* User;
+    public ImAnimVariationFloat X;
+    public ImAnimVariationFloat Y;
+    public ImAnimVariationFloat Z;
+    public ImAnimVariationFloat W;
+
+    public static ImAnimVariationVec4 None => new()
+    {
+        Mode = ImAnimVariationMode.None,
+        Amount = Vector4.Zero,
+        MinClamp = new Vector4(float.MinValue),
+        MaxClamp = new Vector4(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+        Z = ImAnimVariationFloat.None,
+        W = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec4 Inc(Vector4 amt) => new()
+    {
+        Mode = ImAnimVariationMode.Increment,
+        Amount = amt,
+        MinClamp = new Vector4(float.MinValue),
+        MaxClamp = new Vector4(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+        Z = ImAnimVariationFloat.None,
+        W = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec4 Inc(float x, float y, float z, float w) => new()
+    {
+        Mode = ImAnimVariationMode.Increment,
+        Amount = new Vector4(x, y, z, w),
+        MinClamp = new Vector4(float.MinValue),
+        MaxClamp = new Vector4(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+        Z = ImAnimVariationFloat.None,
+        W = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec4 Dec(Vector4 amt) => new()
+    {
+        Mode = ImAnimVariationMode.Decrement,
+        Amount = amt,
+        MinClamp = new Vector4(float.MinValue),
+        MaxClamp = new Vector4(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+        Z = ImAnimVariationFloat.None,
+        W = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec4 Dec(float x, float y, float z, float w) => new()
+    {
+        Mode = ImAnimVariationMode.Decrement,
+        Amount = new Vector4(x, y, z, w),
+        MinClamp = new Vector4(float.MinValue),
+        MaxClamp = new Vector4(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+        Z = ImAnimVariationFloat.None,
+        W = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec4 Mul(float f) => new()
+    {
+        Mode = ImAnimVariationMode.Multiply,
+        Amount = new Vector4(f),
+        MinClamp = new Vector4(float.MinValue),
+        MaxClamp = new Vector4(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+        Z = ImAnimVariationFloat.None,
+        W = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec4 Rand(Vector4 amt) => new()
+    {
+        Mode = ImAnimVariationMode.Random,
+        Amount = amt,
+        MinClamp = new Vector4(float.MinValue),
+        MaxClamp = new Vector4(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+        Z = ImAnimVariationFloat.None,
+        W = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec4 Rand(float x, float y, float z, float w) => new()
+    {
+        Mode = ImAnimVariationMode.Random,
+        Amount = new Vector4(x, y, z, w),
+        MinClamp = new Vector4(float.MinValue),
+        MaxClamp = new Vector4(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+        Z = ImAnimVariationFloat.None,
+        W = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec4 Fn(ImAnim.VariationVec4Fn fn, void* userData = null) => new()
+    {
+        Mode = ImAnimVariationMode.Callback,
+        Amount = Vector4.Zero,
+        MinClamp = new Vector4(float.MinValue),
+        MaxClamp = new Vector4(float.MaxValue),
+        Seed = 0,
+        Callback = (delegate* unmanaged[Cdecl]<int, void*, Vector4>)Marshal.GetFunctionPointerForDelegate(fn),
+        User = userData,
+        X = ImAnimVariationFloat.None,
+        Y = ImAnimVariationFloat.None,
+        Z = ImAnimVariationFloat.None,
+        W = ImAnimVariationFloat.None,
+    };
+
+    public static ImAnimVariationVec4 Axis(ImAnimVariationFloat vx, ImAnimVariationFloat vy, ImAnimVariationFloat vz, ImAnimVariationFloat vw) => new()
+    {
+        Mode = ImAnimVariationMode.None,
+        Amount = Vector4.Zero,
+        MinClamp = new Vector4(float.MinValue),
+        MaxClamp = new Vector4(float.MaxValue),
+        Seed = 0,
+        Callback = null,
+        User = null,
+        X = vx,
+        Y = vy,
+        Z = vz,
+        W = vw,
+    };
+}