Add ImAnim bindings

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,
+    };
+}