ImSpinner: loading spinners, dozens of them, to show that some work is going on.
The C++ API of ImSpinner as it is bound to Python: the entries of the module imgui_bundle.imspinner, in the same order, with their C++ signatures and the headers’ comments. From the stubs: the functions excluded from the bindings, the typedefs and the macros are absent.
imspinner.h¶
SpinnerTypeT (enum)¶
| Member | Value | |
|---|---|---|
e_st_rainbow = 0 | 0 | |
e_st_angle | 1 | |
e_st_dots | 2 | |
e_st_ang | 3 | |
e_st_vdots | 4 | |
e_st_bounce_ball | 5 | |
e_st_eclipse | 6 | |
e_st_ingyang | 7 | |
e_st_barchartsine | 8 | |
e_st_count | 9 |
ease_mode (enum)¶
| Member | Value | |
|---|---|---|
e_ease_none = 0 | 0 | |
e_ease_inoutquad = 1 | 1 | |
e_ease_inoutexpo = 2 | 2 | |
e_ease_spring = 3 | 3 | |
e_ease_gravity = 4 | 4 | |
e_ease_infinity = 5 | 5 | |
e_ease_elastic = 6 | 6 | |
e_ease_sine = 7 | 7 | |
e_ease_damping = 8, } | 8 |
ImSpinner::SpinnerRainbow¶
inline void SpinnerRainbow(const char *label, float radius, float thickness, const ImColor &color, float speed, float ang_min = 0.f, float ang_max = PI_2, int arcs = 1, int mode = 0);const char *label: A string label for the spinner, used to identify it in ImGui. float radius: The radius of the spinner. float thickness: The thickness of the spinner’s border. const ImColor &color: The color of the spinner. float speed: The speed of the spinning animation. float ang_min: Minimum angle of spinning. float ang_max: Maximum angle of spinning. int arcs: Number of arcs of the spinner.
ImSpinner::SpinnerRainbowMix¶
inline void SpinnerRainbowMix(const char *label, float radius, float thickness, const ImColor &color, float speed, float ang_min = 0.f, float ang_max = PI_2, int arcs = 1, int mode = 0);ImSpinner::SpinnerRotatingHeart¶
inline void SpinnerRotatingHeart(const char *label, float radius, float thickness, const ImColor &color, float speed, float ang_min = 0.f);This function draws a rotating heart spinner.
ImSpinner::SpinnerAng¶
inline void SpinnerAng(const char *label, float radius, float thickness, const ImColor &color = white, const ImColor &bg = white, float speed = 2.8f, float angle = IM_PI, int mode = 0);SpinnerAng is a function that draws a spinner widget with a given angle.
ImSpinner::SpinnerAng8¶
inline void SpinnerAng8(const char *label, float radius, float thickness, const ImColor &color = white, const ImColor &bg = white, float speed = 2.8f, float angle = IM_PI, int mode = 0, float rkoef = 0.5f);ImSpinner::SpinnerAngMix¶
inline void SpinnerAngMix(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, float angle = IM_PI, int arcs = 4, int mode = 0);ImSpinner::SpinnerLoadingRing¶
inline void SpinnerLoadingRing(const char *label, float radius, float thickness, const ImColor &color = white, const ImColor &bg = half_white, float speed = 2.8f, int segments = 5);ImSpinner::SpinnerClock¶
inline void SpinnerClock(const char *label, float radius, float thickness, const ImColor &color = white, const ImColor &bg = half_white, float speed = 2.8f);ImSpinner::SpinnerPulsar¶
inline void SpinnerPulsar(const char *label, float radius, float thickness, const ImColor &bg = half_white, float speed = 2.8f, bool sequence = true, float angle = 0.f, int mode = 0);ImSpinner::SpinnerDoubleFadePulsar¶
inline void SpinnerDoubleFadePulsar(const char *label, float radius, float /*thickness*/, const ImColor &bg = half_white, float speed = 2.8f);ImSpinner::SpinnerTwinPulsar¶
inline void SpinnerTwinPulsar(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int rings = 2, int mode = 0);ImSpinner::SpinnerFadePulsar¶
inline void SpinnerFadePulsar(const char *label, float radius, const ImColor &color = white, float speed = 2.8f, int rings = 2, int mode = 0);ImSpinner::SpinnerFadePulsarSquare¶
inline void SpinnerFadePulsarSquare(const char *label, float radius, const ImColor &color = white, float speed = 2.8f, int rings = 2, int mode = 0);ImSpinner::SpinnerCircularLines¶
inline void SpinnerCircularLines(const char *label, float radius, const ImColor &color = white, float speed = 1.8f, int lines = 8, int mode = 0);ImSpinner::SpinnerDots¶
inline void SpinnerDots(const char *label, float *nextdot, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t dots = 12, float minth = -1.f, int mode = 0);ImSpinner::SpinnerVDots¶
inline void SpinnerVDots(const char *label, float radius, float thickness, const ImColor &color = white, const ImColor &bgcolor = white, float speed = 2.8f, size_t dots = 12, size_t mdots = 6, int mode = 0);ImSpinner::Spinner4Caleidospcope¶
inline void Spinner4Caleidospcope(const char *label, float radius, float thickness, const ImColor &color = 0xffffffff, float speed = 2.8f, int lt = 8);ImSpinner::SpinnerThickToSin¶
inline void SpinnerThickToSin(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int nt = 1, int lt = 8, int mode = 0);ImSpinner::SpinnerSquareSpins¶
inline void SpinnerSquareSpins(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f);ImSpinner::SpinnerTwinAng¶
inline void SpinnerTwinAng(const char *label, float radius1, float radius2, float thickness, const ImColor &color1 = white, const ImColor &color2 = red, float speed = 2.8f, float angle = IM_PI, int mode = 0);ImSpinner::SpinnerFilling¶
inline void SpinnerFilling(const char *label, float radius, float thickness, const ImColor &color1 = white, const ImColor &color2 = red, float speed = 2.8f);ImSpinner::SpinnerFillingMem¶
inline void SpinnerFillingMem(const char *label, float radius, float thickness, const ImColor &color, ImColor &colorbg, float speed);ImSpinner::SpinnerTopup¶
inline void SpinnerTopup(const char *label, float radius1, float radius2, const ImColor &color = red, const ImColor &fg = white, const ImColor &bg = white, float speed = 2.8f);ImSpinner::SpinnerTwinAng180¶
inline void SpinnerTwinAng180(const char *label, float radius1, float radius2, float thickness, const ImColor &color1 = white, const ImColor &color2 = red, float speed = 2.8f, float angle = PI_DIV_4, int mode = 0);ImSpinner::SpinnerTwinAng360¶
inline void SpinnerTwinAng360(const char *label, float radius1, float radius2, float thickness, const ImColor &color1 = white, const ImColor &color2 = red, float speed1 = 2.8f, float speed2 = 2.5f, int mode = 0);ImSpinner::SpinnerFadeTris¶
inline void SpinnerFadeTris(const char *label, float radius, const ImColor &color = white, float speed = 2.8f, size_t dim = 2, bool scale = false, int mode = 0);ImSpinner::SpinnerAngTwin¶
inline void SpinnerAngTwin(const char *label, float radius1, float radius2, float thickness, const ImColor &color = white, const ImColor &bg = half_white, float speed = 2.8f, float angle = IM_PI, size_t arcs = 1, int mode = 0);ImSpinner::SpinnerArcRotation¶
inline void SpinnerArcRotation(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t arcs = 4, int mode = 0);ImSpinner::SpinnerArcFade¶
inline void SpinnerArcFade(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t arcs = 4, int mode = 0);ImSpinner::SpinnerSimpleArcFade¶
inline void SpinnerSimpleArcFade(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f);ImSpinner::SpinnerSquareStrokeFade¶
inline void SpinnerSquareStrokeFade(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f);ImSpinner::SpinnerAsciiSymbolPoints¶
inline void SpinnerAsciiSymbolPoints(const char *label, const char* text, float radius, float thickness, const ImColor &color = white, float speed = 2.8f);ImSpinner::SpinnerSevenSegments¶
inline void SpinnerSevenSegments(const char *label, const char* text, float radius, float thickness, const ImColor &color = white, float speed = 2.8f);ImSpinner::SpinnerSquareStrokeFill¶
inline void SpinnerSquareStrokeFill(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f);ImSpinner::SpinnerSquareStrokeLoading¶
inline void SpinnerSquareStrokeLoading(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f);ImSpinner::SpinnerSquareLoading¶
inline void SpinnerSquareLoading(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f);ImSpinner::SpinnerFilledArcFade¶
inline void SpinnerFilledArcFade(const char *label, float radius, const ImColor &color = white, float speed = 2.8f, size_t arcs = 4, int mode = 0);ImSpinner::SpinnerPointsRoller¶
inline void SpinnerPointsRoller(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t points = 8, int circles = 2, float rspeed = 1.f);ImSpinner::SpinnerPointsArcBounce¶
inline void SpinnerPointsArcBounce(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t points = 4, int circles = 2, float rspeed = 0.f);ImSpinner::SpinnerFilledArcColor¶
inline void SpinnerFilledArcColor(const char *label, float radius, const ImColor &color = red, const ImColor &bg = white, float speed = 2.8f, size_t arcs = 4);ImSpinner::SpinnerFilledArcRing¶
inline void SpinnerFilledArcRing(const char *label, float radius, float thickness, const ImColor &color = red, const ImColor &bg = white, float speed = 2.8f, size_t arcs = 4);ImSpinner::SpinnerArcWedges¶
inline void SpinnerArcWedges(const char *label, float radius, const ImColor &color = red, float speed = 2.8f, size_t arcs = 4, int mode = 0);ImSpinner::SpinnerTwinBall¶
inline void SpinnerTwinBall(const char *label, float radius1, float radius2, float thickness, float b_thickness, const ImColor &ball = white, const ImColor &bg = half_white, float speed = 2.8f, size_t balls = 2, int mode = 0);ImSpinner::SpinnerSolarBalls¶
inline void SpinnerSolarBalls(const char *label, float radius, float thickness, const ImColor &ball = white, const ImColor &bg = half_white, float speed = 2.8f, size_t balls = 4);ImSpinner::SpinnerSolarScaleBalls¶
inline void SpinnerSolarScaleBalls(const char *label, float radius, float thickness, const ImColor &ball = white, float speed = 2.8f, size_t balls = 4);ImSpinner::SpinnerSolarArcs¶
inline void SpinnerSolarArcs(const char *label, float radius, float thickness, const ImColor &ball = white, const ImColor &bg = half_white, float speed = 2.8f, size_t balls = 4);ImSpinner::SpinnerMovingArcs¶
inline void SpinnerMovingArcs(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t arcs = 4);ImSpinner::SpinnerRainbowCircle¶
inline void SpinnerRainbowCircle(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t arcs = 4, float mode = 1);ImSpinner::SpinnerBounceBall¶
inline void SpinnerBounceBall(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int dots = 1, bool shadow = false);ImSpinner::SpinnerPulsarBall¶
inline void SpinnerPulsarBall(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, bool shadow = false, int mode = 0);ImSpinner::SpinnerAngTriple¶
inline void SpinnerAngTriple(const char *label, float radius1, float radius2, float radius3, float thickness, const ImColor &c1 = white, const ImColor &c2 = half_white, const ImColor &c3 = white, float speed = 2.8f, float angle = IM_PI);ImSpinner::SpinnerAngEclipse¶
inline void SpinnerAngEclipse(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, float angle = IM_PI);ImSpinner::SpinnerIngYang¶
inline void SpinnerIngYang(const char *label, float radius, float thickness, bool reverse, float yang_detlta_r, const ImColor &colorI = white, const ImColor &colorY = white, float speed = 2.8f, float angle = IM_PI * 0.7f, int mode = 0);ImSpinner::SpinnerGooeyBalls¶
inline void SpinnerGooeyBalls(const char *label, float radius, const ImColor &color, float speed, int mode = 0);ImSpinner::SpinnerRotateGooeyBalls¶
inline void SpinnerRotateGooeyBalls(const char *label, float radius, float thickness, const ImColor &color, float speed, int balls, int mode = 0);ImSpinner::SpinnerHerbertBalls¶
inline void SpinnerHerbertBalls(const char *label, float radius, float thickness, const ImColor &color, float speed, int balls);ImSpinner::SpinnerHerbertBalls3D¶
inline void SpinnerHerbertBalls3D(const char *label, float radius, float thickness, const ImColor &color, float speed);ImSpinner::SpinnerRotateTriangles¶
inline void SpinnerRotateTriangles(const char *label, float radius, float thickness, const ImColor &color, float speed, int tris, int mode = 0);ImSpinner::SpinnerRotateShapes¶
inline void SpinnerRotateShapes(const char *label, float radius, float thickness, const ImColor &color, float speed, int shapes, int pnt);ImSpinner::SpinnerSinSquares¶
inline void SpinnerSinSquares(const char *label, float radius, float thickness, const ImColor &color, float speed, int mode = 0);ImSpinner::SpinnerMoonLine¶
inline void SpinnerMoonLine(const char *label, float radius, float thickness, const ImColor &color = white, const ImColor &bg = red, float speed = 2.8f, float angle = IM_PI);ImSpinner::SpinnerCircleDrop¶
inline void SpinnerCircleDrop(const char *label, float radius, float thickness, float thickness_drop, const ImColor &color = white, const ImColor &bg = half_white, float speed = 2.8f, float angle = IM_PI);ImSpinner::SpinnerSurroundedIndicator¶
inline void SpinnerSurroundedIndicator(const char *label, float radius, float thickness, const ImColor &color = white, const ImColor &bg = half_white, float speed = 2.8f);ImSpinner::SpinnerWifiIndicator¶
inline void SpinnerWifiIndicator(const char *label, float radius, float thickness, const ImColor &color = red, const ImColor &bg = half_white, float speed = 2.8f, float cangle = 0.f, int dots = 3);ImSpinner::SpinnerTrianglesSelector¶
inline void SpinnerTrianglesSelector(const char *label, float radius, float thickness, const ImColor &color = white, const ImColor &bg = half_white, float speed = 2.8f, size_t bars = 8);ImSpinner::SpinnerFlowingGradient¶
inline void SpinnerFlowingGradient(const char *label, float radius, float thickness, const ImColor &color = white, const ImColor &bg = red, float speed = 2.8f, float angle = IM_PI);ImSpinner::SpinnerRotateSegments¶
inline void SpinnerRotateSegments(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t arcs = 4, size_t layers = 1, int mode = 0);ImSpinner::SpinnerLemniscate¶
inline void SpinnerLemniscate(const char* label, float radius, float thickness, const ImColor& color = white, float speed = 2.8f, float angle = IM_PI / 2.0f);ImSpinner::SpinnerRotateGear¶
inline void SpinnerRotateGear(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t pins = 12);ImSpinner::SpinnerRotateWheel¶
inline void SpinnerRotateWheel(const char *label, float radius, float thickness, const ImColor &bg_color = white, const ImColor &color = white, float speed = 2.8f, size_t pins = 12);ImSpinner::SpinnerAtom¶
inline void SpinnerAtom(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int elipses = 3);ImSpinner::SpinnerPatternRings¶
inline void SpinnerPatternRings(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int elipses = 3);ImSpinner::SpinnerPatternEclipse¶
inline void SpinnerPatternEclipse(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int elipses = 3, float delta_a = 2.f, float delta_y = 0.f);ImSpinner::SpinnerPatternSphere¶
inline void SpinnerPatternSphere(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int elipses = 3);ImSpinner::SpinnerRingSynchronous¶
inline void SpinnerRingSynchronous(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int elipses = 3);ImSpinner::SpinnerRingWatermarks¶
inline void SpinnerRingWatermarks(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int elipses = 3);ImSpinner::SpinnerRotatedAtom¶
inline void SpinnerRotatedAtom(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int elipses = 3, int mode = 0);ImSpinner::SpinnerRainbowBalls¶
inline void SpinnerRainbowBalls(const char *label, float radius, float thickness, const ImColor &color, float speed, int balls = 5, int mode = 0, int rings = 1, int mx = 1);ImSpinner::SpinnerRainbowShot¶
inline void SpinnerRainbowShot(const char *label, float radius, float thickness, const ImColor &color, float speed, int balls = 5, int mode = 0);ImSpinner::SpinnerSpiral¶
inline void SpinnerSpiral(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t arcs = 4);ImSpinner::SpinnerSpiralEye¶
inline void SpinnerSpiralEye(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f);ImSpinner::SpinnerBlocks¶
inline void SpinnerBlocks(const char *label, float radius, float thickness, const ImColor &bg, const ImColor &color, float speed);ImSpinner::SpinnerTwinBlocks¶
inline void SpinnerTwinBlocks(const char *label, float radius, float thickness, const ImColor &bg, const ImColor &color, float speed);ImSpinner::SpinnerScaleBlocks¶
inline void SpinnerScaleBlocks(const char *label, float radius, float thickness, const ImColor &color, float speed, int mode = 0);ImSpinner::SpinnerScaleSquares¶
inline void SpinnerScaleSquares(const char *label, float radius, float thikness, const ImColor &color, float speed);ImSpinner::SpinnerSquishSquare¶
inline void SpinnerSquishSquare(const char *label, float radius, const ImColor &color, float speed);ImSpinner::SpinnerArcPolarFade¶
inline void SpinnerArcPolarFade(const char *label, float radius, const ImColor &color = white, float speed = 2.8f, size_t arcs = 4, int mode = 0);ImSpinner::SpinnerArcPolarRadius¶
inline void SpinnerArcPolarRadius(const char *label, float radius, const ImColor &color = white, float speed = 2.8f, size_t arcs = 4, int mode = 0);ImSpinner::SpinnerCaleidoscope¶
inline void SpinnerCaleidoscope(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t arcs = 6, int mode = 0);ImSpinner::SpinnerSineArcs¶
inline void SpinnerSineArcs(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f);ImSpinner::SpinnerTrianglesShift¶
inline void SpinnerTrianglesShift(const char *label, float radius, float thickness, const ImColor &color = white, const ImColor &bg = half_white, float speed = 2.8f, size_t bars = 8);ImSpinner::SpinnerPointsShift¶
inline void SpinnerPointsShift(const char *label, float radius, float thickness, const ImColor &color = white, const ImColor &bg = half_white, float speed = 2.8f, size_t bars = 8);ImSpinner::SpinnerCircularPoints¶
inline void SpinnerCircularPoints(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.8f, int lines = 8);ImSpinner::SpinnerCurvedCircle¶
inline void SpinnerCurvedCircle(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t circles = 1);ImSpinner::SpinnerModCircle¶
inline void SpinnerModCircle(const char *label, float radius, float thickness, const ImColor &color = white, float ang_min = 1.f, float ang_max = 1.f, float speed = 2.8f);ImSpinner::SpinnerRotateSegmentsPulsar¶
inline void SpinnerRotateSegmentsPulsar(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t arcs = 4, size_t layers = 1);ImSpinner::SpinnerSplineAng¶
inline void SpinnerSplineAng(const char *label, float radius, float thickness, const ImColor &color = white, const ImColor &bg = white, float speed = 2.8f, float angle = IM_PI, int mode = 0);ImSpinner::SpinnerConicGrid¶
inline void SpinnerConicGrid(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Conic grid: a 2x2 block of conic-corner tiles (split by a “+” gap) with five dots at the edge midpoints and the centre; the whole figure spins .5 turn / sec (linear). Port of the CSS “l8” loader. mode 2 reverses the spin; mode 1 doubles it to a full turn.
ImSpinner::SpinnerArcArrow¶
inline void SpinnerArcArrow(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Arc arrow: a 270-degree ring arc with a triangular arrowhead at its leading tip, spinning a full turn / sec (linear). Port of the CSS “l11” loader. mode 1 drops the arrowhead (plain 3/4 ring); mode 2 reverses the spin.
ImSpinner::SpinnerOrbitMoon¶
inline void SpinnerOrbitMoon(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Orbit moon:
an orange hub at the centre, a green planet orbiting it once per second,
and a small grey moon circling the planet twice as fast. Port of the CSS
“l17” loader (its three signature colours are fixed). mode 2 reverses.
ImSpinner::SpinnerConicWheels¶
inline void SpinnerConicWheels(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Conic wheels:
three concentric four-colour pie discs spinning at different rates. In
CSS the parent’s spin compounds onto the inner discs, giving effective
periods of 2s / 1s / 1.2s per turn. Port of the CSS “l22” loader (its
four signature colours are fixed). mode 2 reverses the spin.
ImSpinner::SpinnerDotRing¶
inline void SpinnerDotRing(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Dot ring:
twelve dots evenly spaced (30 deg apart) on a circle, alternating two
colours, the whole ring spinning one turn / 2 sec counter-clockwise.
Port of the CSS “l30” loader (its two signature colours are fixed).
mode 2 reverses the spin.
imspinner_dots.h¶
ImSpinner::SpinnerBounceDots¶
inline void SpinnerBounceDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t dots = 3, int mode = 0);ImSpinner::SpinnerZipDots¶
inline void SpinnerZipDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t dots = 5);ImSpinner::SpinnerDotsToPoints¶
inline void SpinnerDotsToPoints(const char *label, float radius, float thickness, float offset_k, const ImColor &color = white, float speed = 1.8f, size_t dots = 5);ImSpinner::SpinnerDotsToBar¶
inline void SpinnerDotsToBar(const char *label, float radius, float thickness, float offset_k, const ImColor &color = white, float speed = 2.8f, size_t dots = 5);ImSpinner::SpinnerWaveDots¶
inline void SpinnerWaveDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int lt = 8);ImSpinner::SpinnerFadeDots¶
inline void SpinnerFadeDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int lt = 8, int mode = 0);ImSpinner::SpinnerThreeDots¶
inline void SpinnerThreeDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int lt = 8);ImSpinner::SpinnerFiveDots¶
inline void SpinnerFiveDots(const char *label, float radius, float thickness, const ImColor &color = 0xffffffff, float speed = 2.8f, int lt = 8);ImSpinner::SpinnerMultiFadeDots¶
inline void SpinnerMultiFadeDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int lt = 8);ImSpinner::SpinnerScaleDots¶
inline void SpinnerScaleDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int lt = 8);ImSpinner::SpinnerMovingDots¶
inline void SpinnerMovingDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t dots = 3);ImSpinner::SpinnerRotateDots¶
inline void SpinnerRotateDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int dots = 2, int mode = 0);ImSpinner::SpinnerOrionDots¶
inline void SpinnerOrionDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int arcs = 4);ImSpinner::SpinnerGalaxyDots¶
inline void SpinnerGalaxyDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int arcs = 4);ImSpinner::SpinnerIncDots¶
inline void SpinnerIncDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t dots = 6);ImSpinner::SpinnerIncFullDots¶
inline void SpinnerIncFullDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t dots = 4);ImSpinner::SpinnerIncScaleDots¶
inline void SpinnerIncScaleDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t dots = 6, float angle = 0.f, int mode = 0);ImSpinner::SpinnerSomeScaleDots¶
inline void SpinnerSomeScaleDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, size_t dots = 6, int mode = 0);ImSpinner::SpinnerDotsLoading¶
inline void SpinnerDotsLoading(const char *label, float radius, float thickness, const ImColor &color, const ImColor &bg, float speed);ImSpinner::SpinnerSquareRandomDots¶
inline void SpinnerSquareRandomDots(const char *label, float radius, float thickness, const ImColor &bg, const ImColor &color, float speed);ImSpinner::SpinnerHboDots¶
inline void SpinnerHboDots(const char *label, float radius, float thickness, const ImColor &color = white, float minfade = 0.0f, float ryk = 0.f, float speed = 1.1f, size_t dots = 6, int mode = 0);spinner idea by nitz ‘Chris Dailey’
ImSpinner::SpinnerMoonDots¶
inline void SpinnerMoonDots(const char *label, float radius, float thickness, const ImColor &first, const ImColor &second, float speed = 1.1f);ImSpinner::SpinnerTwinHboDots¶
inline void SpinnerTwinHboDots(const char *label, float radius, float thickness, const ImColor &color = white, float minfade = 0.0f, float ryk = 0.f, float speed = 1.1f, size_t dots = 6, float delta = 0.f);ImSpinner::SpinnerThreeDotsStar¶
inline void SpinnerThreeDotsStar(const char *label, float radius, float thickness, const ImColor &color = white, float minfade = 0.0f, float ryk = 0.f, float speed = 1.1f, float delta = 0.f);ImSpinner::SpinnerSwingDots¶
inline void SpinnerSwingDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f);ImSpinner::SpinnerDnaDots¶
inline void SpinnerDnaDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.8f, int lt = 8, float delta = 0.5f, bool mode = 0);ImSpinner::Spinner3SmuggleDots¶
inline void Spinner3SmuggleDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 4.8f, int lt = 8, float delta = 0.5f, bool mode = 0);ImSpinner::SpinnerDotsTyping¶
inline void SpinnerDotsTyping(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int dots = 3);Typing dots: a row of dots appears one by one (. -> .. -> ...) via a stepped clip, then resets. Drawn as ‘dots’ filled circles laid across the cell width.
ImSpinner::SpinnerDotsStep¶
inline void SpinnerDotsStep(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int dots = 3);Stepping dot: a single dot hops across ‘dots’ slots (left -> ... -> right) in discrete steps, then jumps back. Only one dot is shown at a time.
ImSpinner::SpinnerDotsGather¶
inline void SpinnerDotsGather(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 0.5f, int dots = 3);Gathering dots: a row of dots spreads apart, then squeezes together at the centre (the dots also grow a little when gathered), ping-ponging.
ImSpinner::SpinnerDotsShift¶
inline void SpinnerDotsShift(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 0.5f);Shifting dots: three dots; the centre one is fixed while the left dot pulls in toward it, then the right dot pushes out, ping-ponging (a little shuffle). Offsets are proportional to the dot size, as in the CSS box-shadow.
ImSpinner::SpinnerDotsOrbit¶
inline void SpinnerDotsOrbit(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 0.66f);Orbiting dots: three dots dance: a fixed left dot, a dot sliding right, and a dot orbiting a half-circle over them; the whole thing mirror-flips each half-cycle. The flip lands when the layout is symmetric, so it stays seamless. Offsets are in dot-radii (CSS px / 7.5).
ImSpinner::SpinnerDotsCircle¶
inline void SpinnerDotsCircle(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 0.66f);Circling dots: two dots slide right and back together while a third dot orbits a full circle around the centre. Offsets are in dot-radii (CSS px / 7.5).
ImSpinner::SpinnerDotsSquare¶
inline void SpinnerDotsSquare(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Square-chasing dot: three dots sit on three corners of a square; each quarter one dot slides along an edge into the empty corner, so the gap chases around the square. The 0%/100% configurations match (same corner set), so it loops seamlessly.
ImSpinner::SpinnerDotsShuffle¶
inline void SpinnerDotsShuffle(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Shuffling dots: four dots fan out of a row into little loops and shuffle back, swapping places; the 0%/100% sets match, so it loops seamlessly. Offsets are in dot-radii (x in {-3,0,3}, y in {-1,0,1}).
ImSpinner::SpinnerDotsSplit¶
inline void SpinnerDotsSplit(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Splitting dots:
three columns, each a pair of dots that opens (one up, one down to the edges)
and closes (meets at the centre), staggered so a split-wave runs left to right.
Y values are in half-height units; the 83%->100% segment closes the last column.
ImSpinner::SpinnerDotsLeader¶
inline void SpinnerDotsLeader(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Leader dots: a full dot sweeps left to right while two trailing pairs open to the edges and shift columns. A closed pair sits near the centre and reads as a single dot, so the leader/pair swap at the loop looks seamless. X in {-1,0,1}, Y in half-heights.
ImSpinner::SpinnerDotsRolling¶
inline void SpinnerDotsRolling(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Rolling dots: a repeating row of dots mirror-flips each half-cycle (scaleX) while a clipped overlay (right half) rotates, so dots carousel through the row. Tile = 75% of width, dot at 1/6 of tile; overlay uses translateX(-37.5%) + rotate (0..1 turn over the first 80% of its 0.5s cycle).
ImSpinner::SpinnerDotsTriangle¶
inline void SpinnerDotsTriangle(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);ImSpinner::SpinnerDotsCascade¶
inline void SpinnerDotsCascade(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);ImSpinner::SpinnerDotsSwap¶
inline void SpinnerDotsSwap(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);ImSpinner::SpinnerDotsSpread¶
inline void SpinnerDotsSpread(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);ImSpinner::SpinnerDotsTwin¶
inline void SpinnerDotsTwin(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 0.5f);ImSpinner::SpinnerDotsHop¶
inline void SpinnerDotsHop(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f / 1.5f);ImSpinner::SpinnerDotsJiggle¶
inline void SpinnerDotsJiggle(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Jiggling dots:
two background dots at 25%/75% wobble outward at 40% and the left nudges at
90%; a centred ::before dot shakes horizontally (cubic-bezier elastic, 1s).
ImSpinner::SpinnerDotsVibrate¶
inline void SpinnerDotsVibrate(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Vibrating dots: static left/right background dots; the centred ::before dot vibrates horizontally (l25-1, 1s) and vertically (l25-2, 0.5s, inset bounce) with cubic-bezier(.5,-900,.5,900) elastic easing.
ImSpinner::SpinnerDotsWiper¶
inline void SpinnerDotsWiper(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.f);Wiper dots:
static left/right background dots plus two clipped semicircles (::before/
::after) that swing ±90° from side pivots (scaleY ±1, 0.5s alternate).
ImSpinner::SpinnerDotsCollapse¶
inline void SpinnerDotsCollapse(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 0.5f);Collapsing dots: a centre dot with an expanding spread ring; four box-shadow dots collapse inward one-by-one (right→left→bottom→top), then snap back (2s CSS cycle).
ImSpinner::SpinnerDotsFlip¶
inline void SpinnerDotsFlip(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Flipping dots: two columns (::before/::after) of top+bottom dots rotate ±180° about the bottom pivot while the loader bounces vertically (translateY, 1s).
ImSpinner::SpinnerDotsTurn¶
inline void SpinnerDotsTurn(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Turning dots: two columns of top+bottom dots; ::before pivots at the bottom, ::after at the top; both rotate −270° during the last 30% of the 1s cycle.
ImSpinner::SpinnerDotsCarousel¶
inline void SpinnerDotsCarousel(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Carousel dots, a port of the CSS dots/l31:
two overlaid dot-pairs (::before/::after); the loader slides 37.5% while
::after uses rotate(−½turn) translate(37.5%) rotate(½turn) to swap dots.
ImSpinner::SpinnerDotsHalfTurn¶
inline void SpinnerDotsHalfTurn(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Half-turn dots, a port of the CSS dots/l32: two overlaid dot-pairs (::before at left/right, ::after at ⅓ and ⅔); both hold still until 80%, then rotate ±180° (reverse on ::after).
ImSpinner::SpinnerDotsSlideFlip¶
inline void SpinnerDotsSlideFlip(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Slide-flip dots, a port of the CSS dots/l33: two flex halves (::before/::after), each with left/right dots; both slide (100% − 3/7) while rotating ±½turn about the inner dot pivot.
ImSpinner::SpinnerDotsStaggerTurn¶
inline void SpinnerDotsStaggerTurn(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Stagger-turn dots: two overlaid dot-pairs (left/right, 25%); ::after is offset translate(37.5%) with a 0.5 s delay; each layer rotates 180° during the first half of its cycle.
ImSpinner::SpinnerDotsStretch¶
inline void SpinnerDotsStretch(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Stretch dots:
two overlaid bars (::before left, ::after right); each grows via aspect-ratio
2.3→3.7 while translateY(±8px) bounces in opposite directions.
ImSpinner::SpinnerDotsMirrorStretch¶
inline void SpinnerDotsMirrorStretch(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Mirror-stretch dots, a port of the CSS dots/l36: like l35 but l36-1 adds translateX(19px); the loader flips scaleY every 2 s.
ImSpinner::SpinnerDotsPinch¶
inline void SpinnerDotsPinch(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Pinch dots, a port of the CSS dots/l37:
centre dot + 4 box-shadow satellites; l37-1 (0.75 s alternate) pinches
±30/±10 → ±14/±12 with spread change; l37-2 (1.5 s) rotates 180°.
ImSpinner::SpinnerDotsCorners¶
inline void SpinnerDotsCorners(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 2.f);Corner-run dots: four corner dots (background-size 40%); each slides clockwise to the next corner every 0.5 s (TL→TR→BR→BL→…).
ImSpinner::SpinnerDotsNudgeRotate¶
inline void SpinnerDotsNudgeRotate(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Nudge-rotate dots: two halves (l33 geometry); l39-1 nudges ±translate(400%/14) during 30–70%; l39-0 rotates the loader 180° between 30% and 50%.
ImSpinner::SpinnerDotsUnfold¶
inline void SpinnerDotsUnfold(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Unfold dots: four dots (20% each) stack left then spread to 0, ⅓, ⅔, 100% (l40-1, 0.75 s alternate); l40-2 mirror-flips scale(±1) every 1.5 s alternate.
ImSpinner::SpinnerDotsShuttle¶
inline void SpinnerDotsShuttle(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Shuttle dots: two static middle dots (⅓, ⅔); ::before/::after circles run a rectangular path (down → across → up) in mirror on the left/right ends.
ImSpinner::SpinnerDotsSpreadShuttle¶
inline void SpinnerDotsSpreadShuttle(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Spread-shuttle dots, a port of the CSS dots/l42:
like l41 but end dots travel translate(400%/3); middle dots spread from
⅓/⅔ to the edges during the last 40% (l42-0).
ImSpinner::SpinnerDotsTriad¶
inline void SpinnerDotsTriad(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Triad dots: two clusters of three (middle / top / bottom); dots spread vertically then swap columns (0↔⅓ and ⅔↔1). Loader aspect-ratio 2.5, --s/8 rest offset.
ImSpinner::SpinnerDotsSatellite¶
inline void SpinnerDotsSatellite(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f);Satellite dots: static left/right dots; two centre circles orbit pivots at ±75% width, rotating 360° during 58–100% (::after −1 turn, delay −0.5 s).
ImSpinner::SpinnerDotsTrack¶
inline void SpinnerDotsTrack(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 0.5f)Track dots: static left/right dots; ::before (background inherit) carries two dots through translate(±37.5%) + rotate(0→360°) keyframes over 2 s.
imspinner_text.h¶
ImSpinner::SpinnerTextFade¶
inline void SpinnerTextFade(const char *label, float radius, const ImColor &color = white, float speed = 1.f, const char *text = "Loading...");Pulsing text loader, a port of the CSS:
.loader:before { content:"Loading..." }
@keyframes l1 { to { opacity: 0 } } /* 1s linear infinite alternate */‘alternate’ + ‘linear’ => triangle wave; a full fade-out/fade-in cycle spans 2 units of (time*speed).
ImSpinner::SpinnerTextFading¶
inline void SpinnerTextFading(const char *label, const char* text, float radius, float fsize, const ImColor &color = white, float speed = 2.8f);Per-character fading text: each glyph fades in/out with a phase offset and a hue shift along the string, producing a travelling shimmer over the text.
ImSpinner::SpinnerTextUnderline¶
inline void SpinnerTextUnderline(const char *label, float radius, const ImColor &color = white, float speed = 0.5f, float thickness = 3.f, const char *text = "Loading...");Text with a growing underline, a port of the CSS:
background: linear-gradient(currentColor 0 0) 0 100%/0% 3px no-repeat;
@keyframes l2 { to { background-size: 100% 3px } } /* 2s linear infinite */A ‘thickness’-tall bar under the text grows from 0 to full text width, then snaps back to 0 and repeats (linear, not alternate).
ImSpinner::SpinnerTextUnderlineDots¶
inline void SpinnerTextUnderlineDots(const char *label, float radius, const ImColor &color = white, float speed = 0.5f, float thickness = 3.f, int dashes = 6, const char *text = "Loading...");Text with a marching dashed underline, a port of the CSS:
background: repeating-linear-gradient(90deg,currentColor 0 8%,#0000 0 10%) ... 3px;
@keyframes l3 { to { background-position: 80% 100% } } /* 2s steps(6) infinite */A row of dashes under the text shifts by one period over the cycle in
‘steps’ discrete jumps (steps() timing), looping seamlessly.
ImSpinner::SpinnerTextTyping¶
inline void SpinnerTextTyping(const char *label, float radius, const ImColor &color = white, float speed = 1.f, int tail = 3, const char *text = "Loading...");Typing text, a port of the CSS clip-path typers:
l4: clip-path inset 3ch -> -1ch, steps(4) -> reveals the last ‘tail’ chars
l5: clip-path inset 100% -> -1ch, steps(11) -> types the whole word out
The last ‘tail’ characters are revealed one by one, left to right (e.g.
“Loading” -> “Loading.” -> “Loading..” -> “Loading...”), then it repeats.
Pass tail <= 0 to type out the entire string. The full text is laid out
(left edge fixed) so nothing shifts as it reveals.
ImSpinner::SpinnerTextScroll¶
inline void SpinnerTextScroll(const char *label, float radius, const ImColor &color = white, float speed = 0.5f, const char *text = "Loading...");Scrolling marquee text, a port of the CSS:
color: #0000; text-shadow: 0 0 c, 11ch 0 c; overflow: hidden;
@keyframes l6 { to { text-shadow: -11ch 0 c, 0ch 0 c } } /* 2s linear infinite */Two copies of the text, spaced one text-width + 1ch apart, slide left inside a text-width window: as one leaves to the left the next enters from the right, looping seamlessly.
ImSpinner::SpinnerTextColorFill¶
inline void SpinnerTextColorFill(const char *label, float radius, const ImColor &color = ImColor(0xC0, 0x29, 0x42), const ImColor &bg = white, float speed = 0.5f, int mode = 0, const char *text = "Loading...");Two-tone color sweep, a port of the CSS background-clip:text loaders:
l7 (mode 0): linear-gradient(#C02942 .., #000 0) -> a hard edge sweeps across,
chars fill from ‘bg’ to ‘color’ left to right (cumulative).
l8 (mode 1): linear-gradient(#000 .., #C02942 1ch, #000 0) -> a 1-char ‘color’
band scans across, one character is highlighted at a time.
Both step one character per cycle (CSS steps()), then repeat.
(CSS base is #000; here ‘bg’ defaults to white so it shows on a dark theme.)
ImSpinner::SpinnerTextScrollColors¶
inline void SpinnerTextScrollColors(const char *label, float radius, const ImColor &color = white, float speed = 0.2f, const char *text = "Loading...");Multi-color scrolling marquee, a port of the CSS l9:
5 text-shadow copies (base, olive, crimson, teal, base) spaced 11ch apart,
shifting left by 11ch each quarter with cubic-bezier(.3,1,0,1) easing;
animation: 5s infinite. overflow:hidden clips to the text width.
Each segment snaps the text to the next color, looping seamlessly because the
first and last copies share ‘color’. (CSS base is #000; here it defaults to
white so it shows on a dark theme.)
ImSpinner::SpinnerTextColorCycle¶
inline void SpinnerTextColorCycle(const char *label, float radius, const ImColor &color = white, float speed = 0.2f, const char *text = "Loading...");Color-cycling text, a port of the CSS l10:
linear-gradient of 4 solid blocks (base, olive, crimson, teal), each one
text-width wide, scrolled under background-clip:text with cubic-bezier easing.
The whole text cycles through the palette; on each transition the boundary
between two colors wipes across the text (pixel-accurate, not per-character).
animation: 5s infinite, loops seamlessly (teal -> base -> ...).
(CSS base is #000; here it defaults to white so it shows on a dark theme.)
ImSpinner::SpinnerTextBounce¶
inline void SpinnerTextBounce(const char *label, float radius, const ImColor &color = white, float speed = 1.f, const char *text = "Loading...");Bouncing letters, a port of the CSS l11:
two stacked copies masked to alternating characters move in opposite
directions; a wild cubic-bezier(.5,220,.5,-220) makes translateY oscillate.
Here each character is drawn with a vertical offset whose sign alternates by
index and oscillates over time -> neighbouring letters bob up/down in antiphase.
ImSpinner::SpinnerTextSplit¶
inline void SpinnerTextSplit(const char *label, float radius, const ImColor &color = white, float speed = 1.f, int mode = 0, const char *text = "Loading...");Split-and-slide text, a port of the CSS l12 / l13: two stacked copies clipped to the top / bottom half of the text slide in opposite directions by one text-width, then pause; a shadow copy one text-width away wraps them seamlessly, overflow:hidden clips to the width. mode 0 (l12): both halves move together (top right, bottom left). mode 1 (l13): the bottom half is half a cycle behind, and the dash happens in the first quarter -> the halves slide one after the other.
ImSpinner::SpinnerTextUnderlineScroll¶
inline void SpinnerTextUnderlineScroll(const char *label, float radius, const ImColor &color = white, float speed = 0.66f, float thickness = 3.f, const char *text = "Loading...");Fill-then-scroll text, a port of the CSS l14 (two phases over the cycle):
0..80%: text stays put while an underline bar grows 0% -> 100%.
80..100%: the bar retracts 100% -> 0% and the text scrolls one text-width
left (a wrap copy slides in from the right, overflow:hidden clips).
So the progress fills, then the line slides away and a fresh one comes in.
ImSpinner::SpinnerTextRoll¶
inline void SpinnerTextRoll(const char *label, float radius, const ImColor &color = white, float speed = 1.f, const char *text = "Loading...");Rolling letters, a port of the CSS l15:
alternating characters roll vertically by one line-height in opposite
directions (a copy rolls out while an identical one rolls in), moving over
0..80% of the cycle then pausing. Clipped to the line box so it’s seamless.
ImSpinner::SpinnerTextColorful¶
inline void SpinnerTextColorful(const char *label, float radius, const ImColor &color = white, float speed = 0.5f, const char *text = "Loading...");Per-letter color blink, a port of the CSS l16. The CSS uses letter-spacing +
9 shifted text-shadows so every character is an independent shadow that can be
colored on its own; keyframes (20/40/60/80%) recolor different letters, here
reproduced as a palette + a 5-keyframe table, interpolated over the cycle.
(CSS uncolored letters are currentColor; here that’s ‘color’, default white.)
The color table targets the 10 chars of “Loading...”; extra chars stay ‘color’.
ImSpinner::SpinnerTextCascade¶
inline void SpinnerTextCascade(const char *label, float radius, const ImColor &color = white, float speed = 0.5f, const char *text = "Loading...");Cascading letters, a port of the CSS l17:
letters drop in from above one by one (left to right) over 0..40%, hold the
whole word 40..60%, then fall out downward one by one (right to left) 60..100%.
Clipped to the line box so off-line letters are hidden.
ImSpinner::SpinnerTextConveyor¶
inline void SpinnerTextConveyor(const char *label, float radius, const ImColor &color = white, float speed = 0.33f, const char *text = "Loading...");Conveyor letters, a port of the CSS l18 (the horizontal twin of the cascade):
letters slide in from the right one by one (left to right) over 0..40%, hold
the whole word 40..60%, then slide out to the left one by one 60..100%.
Clipped to the text window so off-window letters are hidden.
ImSpinner::SpinnerTextReveal¶
inline void SpinnerTextReveal(const char *label, float radius, const ImColor &color = white, float speed = 0.5f, const char *text = "Loading...");Sequential fade reveal, a port of the CSS l19:
letters fade in one by one (left to right) over 0..40%, hold the whole word
40..60%, then fade out one by one (left to right) 60..100%. The letters do
not move; only their alpha changes.
ImSpinner::SpinnerTextWave¶
inline void SpinnerTextWave(const char *label, float radius, const ImColor &color = white, float speed = 0.5f, const char *text = "Loading...");Traveling hop wave, a port of the CSS l20: each letter hops up in turn (left to right), one at a time, so a wave runs across the word and repeats. Letter i peaks at (i+1)/(len+1) of the cycle; the linear keyframes make each hop a triangle (up then back).
ImSpinner::SpinnerTextSweep¶
inline void SpinnerTextSweep(const char *label, float radius, const ImColor &color = white, const ImColor &bg = ImColor(0, 0, 0), float speed = 0.5f, const char *text = "Loading...");Sweeping highlight, a port of the CSS l21:
a bar sweeps across the text left to right; inside the bar the text is
inverted (drawn in ‘bg’ over a ‘color’ fill), outside it stays ‘color’.
The bar fills over the cycle, then restarts. (CSS is white-on-black vs
black-on-page; adapted here with a ‘color’ fill so it reads on a dark theme.)
ImSpinner::SpinnerTextShine¶
inline void SpinnerTextShine(const char *label, float radius, const ImColor &color = white, const ImColor &bg = ImColor(0, 0, 0), float speed = 0.5f, const char *text = "Loading...");Shine band, a port of the CSS l22: a band (CSS: a 135deg diagonal ~1em stripe) sweeps across the text; inside the band the text is inverted (‘bg’ over a ‘color’ fill), like a glint passing over it. Here the band is vertical (axis-aligned clips can’t tilt).
ImSpinner::SpinnerTextScrollSweep¶
inline void SpinnerTextScrollSweep(const char *label, float radius, const ImColor &color = white, const ImColor &bg = ImColor(0, 0, 0), float speed = 0.5f, const char *text = "Loading...");Scroll + inverting sweep, a port of the CSS l23:
the text scrolls left (seamless marquee) while a full-width band sweeps
across; inside the band the text is inverted (‘bg’ over a ‘color’ fill).
The band covers the whole window at mid-cycle. (CSS is white/black on a
light page; adapted here with a ‘color’ fill so it reads on a dark theme.)
ImSpinner::SpinnerTextSpotlight¶
inline void SpinnerTextSpotlight(const char *label, float radius, const ImColor &color = white, float speed = 0.5f, const char *text = "Loading...");Scanning spotlight, a port of the CSS l24:
a round spotlight (radial gradient) sweeps back and forth across the text
(alternate), brightening the letters it passes (bright inside, dim outside).
A True round clip isn’t available, so each letter’s brightness is set by its
distance to the spotlight centre, giving the same scanning-glow effect.
ImSpinner::SpinnerTextShake¶
inline void SpinnerTextShake(const char *label, float radius, const ImColor &color = white, float speed = 1.f, int mode = 0, const char *text = "Loading...");Glitchy shake, a port of the CSS l25:
the whole word moves between 8 fixed offsets over the cycle (scaled from the
CSS px values at 30px font). mode 0: snap (each held for 1/8, then jumps),
like the CSS; mode 1: smoothly interpolate between offsets for a fluid wobble.
ImSpinner::SpinnerTextFlip¶
inline void SpinnerTextFlip(const char *label, float radius, const ImColor &color = white, float speed = 0.5f, const char *text = "Loading...");3D-ish flip, an approximation of the CSS l26:
the word flips over X, then over Y, then scales to -1, returning to identity.
True perspective isn’t available, so the text’s vertices are scaled about its
centre (sx = cos(rotY)*s, sy = cos(rotX)*s): it squashes to a line and mirrors
-- a flat ‘card flip’ rather than a perspective rotation.
ImSpinner::SpinnerTextSpin¶
inline void SpinnerTextSpin(const char *label, float radius, const ImColor &color = white, float speed = 0.5f, const char *text = "Loading...");Two halves spinning, a port of the CSS l27: the text is split in two; each half rotates a full turn over the first half of its cycle then holds, with the second half delayed by half a cycle, so the halves spin alternately. Vertices are rotated about each half’s own centre.
ImSpinner::SpinnerTextTumble¶
inline void SpinnerTextTumble(const char *label, float radius, const ImColor &color = white, float speed = 0.5f, int mode = 0, const char *text = "Loading...");Tumble flip, a port of the CSS l28: the word spins 180 in-plane, then flips over Y, then over X, returning to identity. mode 0: flat tumble (vertices scaled by the flips, then rotated); mode 1: True 3D perspective (vertices rotated in 3D about Z/Y/X, then projected with depth division, like CSS perspective(300px)).
ImSpinner::SpinnerTextSwirl¶
inline void SpinnerTextSwirl(const char *label, float radius, const ImColor &color = white, float speed = 0.5f, const char *text = "Loading...");Counter-rotating swirl, a port of the CSS l29:
alternating characters spin a full turn about the WHOLE word’s centre in
opposite directions (even +1 turn, odd -1 turn) over 0..80%, then hold.
Each letter’s vertices are rotated about the shared centre, so the letters
swirl around it.
ImSpinner::SpinnerTextRollWave¶
inline void SpinnerTextRollWave(const char *label, float radius, const ImColor &color = white, float speed = 0.5f, const char *text = "Loading...");Vertical roll wave, an approximation of the CSS l30: alternating letters roll vertically by one line, half a cycle out of phase, so a vertical wave runs across the word. Each column rolls seamlessly (a wrap copy enters from above), clipped to the line box.
ImSpinner::SpinnerTextVibrate¶
inline void SpinnerTextVibrate(const char *label, float radius, const ImColor &color = white, float speed = 1.f, const char *text = "Loading...");Vibrating text, an approximation of the CSS l31: the wild cubic-bezier(.5,-150,.5,150) amplifies tiny per-letter offsets into a fast buzz. Here each letter jitters with its own incommensurate x/y frequency and phase, giving a continuous nervous vibration.
ImSpinner::SpinnerTextGlitch¶
inline void SpinnerTextGlitch(const char *label, float radius, float speed = 1.f, const char *text = "Loading...");RGB-split glitch, an approximation of the CSS l32:
three text copies (red/green/blue) with tiny offsets; the wild cubic-bezier
amplifies them into a chromatic-aberration buzz. Here each channel jitters
with its own phase, so the colors separate and shimmer. (Colors are fixed
R/G/B, so there is no ‘color’ parameter.)
ImSpinner::SpinnerTextBlur¶
inline void SpinnerTextBlur(const char *label, float radius, const ImColor &color = white, float speed = 1.f, const char *text = "Loading...");Random letter blur, an approximation of the CSS l33: single letters flicker out of focus (a text-shadow blur) one at a time during the middle of the cycle. ImGui can’t blur, so a ‘blurred’ letter is faked with a translucent offset halo plus a dimmed centre. The schedule is the CSS table.
ImSpinner::SpinnerTextDropout¶
inline void SpinnerTextDropout(const char *label, float radius, const ImColor &color = white, float speed = 1.f, const char *text = "Loading...");Character dropout glitch, a port of the CSS l34: individual characters blink out (become spaces) at scheduled times, so the word flickers with missing letters, then returns to whole. Char positions are preserved (monospace). The drop schedule is the CSS table (10-char “Loading...”).
ImSpinner::SpinnerTextScanline¶
inline void SpinnerTextScanline(const char *label, float radius, const ImColor &color = white, float speed = 1.f, int mode = 0, const char *text = "Loading...");Scanline glitch, an approximation of the CSS l35 / l36: mode 0: a thin horizontal band scans vertically; the slice inside it is displaced horizontally (a fast jitter), the rest stays crisp. mode 1: a vertical band (1.5ch) scans horizontally; the slice is displaced vertically. A VHS/scanline displacement glitch either way. (CSS uses mask-composite; here clip regions.)
ImSpinner::SpinnerTextSquash¶
inline void SpinnerTextSquash(const char *label, float radius, const ImColor &color = white, float speed = 1.f, const char *text = "Loading...");Squash-slice scan, an approximation of the CSS l37: a vertical band (2ch) scans horizontally; inside the band the text is squashed vertically (scaleY 0.5), the rest stays crisp -- a scanning vertical compression.
ImSpinner::SpinnerTextScramble¶
inline void SpinnerTextScramble(const char *label, float radius, const ImColor &color = white, float speed = 1.f);Scramble shuffle, a port of the CSS l38:
the word snaps between 6 scrambled arrangements of “Loading...” (a slot-machine
scramble) over the cycle (steps(6)); one of them is the readable word. The
scrambles are baked in (they are authored for “Loading...”), so there is no
‘text’ parameter.
ImSpinner::SpinnerTextDecode¶
inline void SpinnerTextDecode(const char *label, float radius, const ImColor &color = white, float speed = 0.5f, const char *text = "Loading...");Decode/encode glitch, an approximation of the CSS l39: letters are progressively replaced by symbols left to right, then back (steps(11) alternate), like a decoding effect. The CSS uses rare APL/alchemy glyphs the default font lacks, so ASCII symbols are substituted here.
ImSpinner::SpinnerTextVanish¶
inline void SpinnerTextVanish(const char *label, float radius, const ImColor &color = white, float speed = 0.5f, const char *text = "Loading...")Letters fly off, a port of the CSS l40: letters float up (-20px) and fade out one by one in a scattered order until the word is gone, then they all drop back in together. Then it repeats.
};imspinner_bars.h¶
ImSpinner::SpinnerFadeBars¶
inline void SpinnerFadeBars(const char *label, float w, const ImColor &color = white, float speed = 2.8f, size_t bars = 3, bool scale = false);ImSpinner::SpinnerBarsRotateFade¶
inline void SpinnerBarsRotateFade(const char *label, float rmin, float rmax , float thickness, const ImColor &color = white, float speed = 2.8f, size_t bars = 6);ImSpinner::SpinnerBarsScaleMiddle¶
inline void SpinnerBarsScaleMiddle(const char *label, float w, const ImColor &color = white, float speed = 2.8f, size_t bars = 3);ImSpinner::SpinnerBarChartSine¶
inline void SpinnerBarChartSine(const char *label, float radius, float thickness, const ImColor &color, float speed, int bars = 5, int mode = 0);ImSpinner::SpinnerBarChartAdvSine¶
inline void SpinnerBarChartAdvSine(const char *label, float radius, float thickness, const ImColor &color, float speed, int mode = 0);ImSpinner::SpinnerBarChartAdvSineFade¶
inline void SpinnerBarChartAdvSineFade(const char *label, float radius, float thickness, const ImColor &color, float speed, int mode = 0);ImSpinner::SpinnerBarChartRainbow¶
inline void SpinnerBarChartRainbow(const char *label, float radius, float thickness, const ImColor &color, float speed, int bars = 5, int mode = 0);ImSpinner::SpinnerFluid¶
inline void SpinnerFluid(const char *label, float radius, const ImColor &color, float speed, int bars = 3);ImSpinner::SpinnerFluidPoints¶
inline void SpinnerFluidPoints(const char *label, float radius, float thickness, const ImColor &color, float speed, size_t dots = 6, float delta = 0.35f);ImSpinner::SpinnerBarsSeqPulse¶
inline void SpinnerBarsSeqPulse(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Sequential height pulse: three bars (20% width); each shrinks to 10% height in turn (33/50/66%).
ImSpinner::SpinnerBarsCascadeGrow¶
inline void SpinnerBarsCascadeGrow(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Cascade grow: three bottom-anchored bars grow in sequence (60→80→100% cascade).
ImSpinner::SpinnerBarsRise¶
inline void SpinnerBarsRise(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Rising bars: three bars slide upward from the bottom (staggered 1/6 phase each).
ImSpinner::SpinnerBarsCornerHop¶
inline void SpinnerBarsCornerHop(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Corner hop: three bars hop diagonally from bottom-right anchor toward the top row.
ImSpinner::SpinnerBarsDiagonalGrow¶
inline void SpinnerBarsDiagonalGrow(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Diagonal grow: three bars (aspect 0.75) hop between corners via background-position steps.
ImSpinner::SpinnerBarsBounceCenter¶
inline void SpinnerBarsBounceCenter(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Bounce center: three centre-anchored bars (max 50% height) bounce between vertical slots.
ImSpinner::SpinnerBarsScaleAlt¶
inline void SpinnerBarsScaleAlt(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Scale alternate: three bars pulse height 50%↔20%↔100% in sequence (animation-direction: alternate).
ImSpinner::SpinnerBarsCornerWave¶
inline void SpinnerBarsCornerWave(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Corner wave: three bottom bars step through a corner wave (16.67% keyframes).
ImSpinner::SpinnerBarsJump¶
inline void SpinnerBarsJump(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Jump bars: three bars (60% max height) swap between top and bottom at 33/66%.
ImSpinner::SpinnerBarsDoubleRow¶
inline void SpinnerBarsDoubleRow(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Double row: two rows of three bar segments slide horizontally (33/66/100% positions).
ImSpinner::SpinnerBarsSixPulse¶
inline void SpinnerBarsSixPulse(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Six-bar pulse: six corner bars (3×2) pulse height 50%→30% at 80% of the cycle.
ImSpinner::SpinnerBarsSixStagger¶
inline void SpinnerBarsSixStagger(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Six-bar stagger: corner bars shrink to 30% height one-by-one, then grow back in wave order.
ImSpinner::SpinnerBarsMorphPlus¶
inline void SpinnerBarsMorphPlus(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Morph plus: five bars morph 20×100% → 20×20% → 100×20% (alternate ping-pong).
ImSpinner::SpinnerBarsFlipSix¶
inline void SpinnerBarsFlipSix(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Flip six: six bars shrink height (0.5 s alternate) while positions flip every 2 s.
ImSpinner::SpinnerBarsSwapTriBottom¶
inline void SpinnerBarsSwapTriBottom(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Swap tri-bottom: three bars shrink to 40% height while bottom anchors cycle positions.
ImSpinner::SpinnerBarsSwapTriZigzag¶
inline void SpinnerBarsSwapTriZigzag(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Swap tri-zigzag: three bars shrink while anchors zigzag between corner pairs.
ImSpinner::SpinnerBarsMorphDiagonal¶
inline void SpinnerBarsMorphDiagonal(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Morph diagonal: three diagonal bars morph 20×100% → 20×20% → 100×20%.
ImSpinner::SpinnerBarsSlideDiagonal¶
inline void SpinnerBarsSlideDiagonal(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Slide diagonal: three diagonal bars shrink to 20% height while outer positions swap.
ImSpinner::SpinnerBarsConicAlternate¶
inline void SpinnerBarsConicAlternate(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Conic alternate: two 40% conic-corner tiles; the second slides on a diagonal (alternate).
ImSpinner::SpinnerBarsConicWalk¶
inline void SpinnerBarsConicWalk(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Conic walk: two conic-corner tiles step through a 2×2 corner path (1.5 s loop).
ImSpinner::SpinnerBarsMarchIn¶
inline void SpinnerBarsMarchIn(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);March rows in: four stripe rows enter from the left, pause, then exit right (1.5 s).
ImSpinner::SpinnerBarsMarchDown¶
inline void SpinnerBarsMarchDown(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);March rows down: four stripe rows drop in from the top, pause, then exit downward (1.5 s).
ImSpinner::SpinnerBarsWaveSkew¶
inline void SpinnerBarsWaveSkew(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Wave rows skew: four rows skew diagonally (aspect 1.6) then snap back to centre.
ImSpinner::SpinnerBarsRowDrop¶
inline void SpinnerBarsRowDrop(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Row drop stagger: four rows drop down one-by-one (aspect 0.8, alternate ping-pong).
ImSpinner::SpinnerBarsZigzagRows¶
inline void SpinnerBarsZigzagRows(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Zigzag rows: four rows alternate stripe alignment left/right (0.75 s).
ImSpinner::SpinnerBarsFillCascade¶
inline void SpinnerBarsFillCascade(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Fill cascade: stripe rows fill left→right in a staggered cascade (0.75 s linear).
ImSpinner::SpinnerBarsPingPongRows¶
inline void SpinnerBarsPingPongRows(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Ping-pong rows: four rows alternate stripe alignment (0↔100%) with a long hold.
ImSpinner::SpinnerBarsWaveRowsWide¶
inline void SpinnerBarsWaveRowsWide(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Wave rows wide: four rows wave between centre, left, and right (aspect 1.4).
ImSpinner::SpinnerBarsGridFade¶
inline void SpinnerBarsGridFade(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Grid fade:
3×3 dot grid; cells fade out in a travelling wave (2 s).
ImSpinner::SpinnerBarsGridSpread¶
inline void SpinnerBarsGridSpread(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Grid spread:
3×3 dot grid; cells pulse box-shadow spread in a wave (2 s).
ImSpinner::SpinnerBarsStretch¶
inline void SpinnerBarsStretch(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Stretch capsules: three vertical pill bars grow from a centre dot to full height and back (animation-direction: alternate). mode 1 staggers the three columns.
ImSpinner::SpinnerBarsStretchSeq¶
inline void SpinnerBarsStretchSeq(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Stretch sequential: three pill bars grow to full height one-by-one (left->right), then the alternate timeline shrinks them back. mode 1 fills right->left.
ImSpinner::SpinnerBarsBounceBall¶
inline void SpinnerBarsBounceBall(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Bounce ball: three tall bottom-anchored bars; a ball rolls left<->right (1.5 s) across their tops while bouncing (0.75 s). mode 1 uses one long arc per traverse; mode 2 reverses the travel direction.
ImSpinner::SpinnerBarsKnockDots¶
inline void SpinnerBarsKnockDots(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Knock dots: three dots in a row; a bar rolls left<->right (1 s) bouncing (0.5 s) and the dot it lands on is knocked down to the bottom. mode 1 pops the dot’s size instead of dropping it; mode 2 reverses the travel direction.
ImSpinner::SpinnerBarsStaircase¶
inline void SpinnerBarsStaircase(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Staircase ball: three bottom-anchored bars of descending height (100/66/33%); a ball rolls left->right (2 s loop) bouncing (0.5 s) while drifting down the steps. mode 1 uses three bounces; mode 2 reverses (rolls up, right->left).
ImSpinner::SpinnerBarsKnockAway¶
inline void SpinnerBarsKnockAway(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Knock away:
a bar rolls left->right (bouncing) and knocks the first two dots down at
1/3 and 2/3; at the end it shoves the last dot sideways and tumbles off.
mode 1 drops all three dots in sequence; mode 2 reverses the timeline.
ImSpinner::SpinnerBarsGates¶
inline void SpinnerBarsGates(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Gates: three columns (top + bottom bar) act as gates that retract from the centre to let a ball roll through, then close behind it. mode 1 adds a vertical weave to the ball; mode 2 reverses the travel direction.
ImSpinner::SpinnerBarsCapture¶
inline void SpinnerBarsCapture(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Capture: a ball rolls in through the first gate to the centre, where the middle gate opens to admit it and then closes around it, trapping the ball. mode 1 pulses the trapped ball; mode 2 reverses (ball escapes left).
ImSpinner::SpinnerBarsEscape¶
inline void SpinnerBarsEscape(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Escape: like Capture, but after being trapped at the centre the ball slips to a side gap and shoots out of the top. mode 1 ejects downward; mode 2 reverses the timeline.
ImSpinner::SpinnerBarsDevour¶
inline void SpinnerBarsDevour(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Devour: a ball sucks in two dots from the right, growing (1x -> 1.5x -> 2x) with each, while a bar slides in to the centre; then the ball dashes off left and resets. mode 1 keeps the ball in place (no dash); mode 2 reverses.
ImSpinner::SpinnerBarsLift¶
inline void SpinnerBarsLift(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Lift: three tall rounded bars slide from the bottom to the top in a staggered wave, then back (alternate). mode 1 reverses the stagger order; mode 2 reverses the timeline.
ImSpinner::SpinnerBarsGapSlide¶
inline void SpinnerBarsGapSlide(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Gap slide: three static bars, each with a round gap that travels along it; the gap hops from bar to bar in sequence (alternate). mode 1 moves all gaps in sync; mode 2 reverses the timeline.
ImSpinner::SpinnerBarsConverge¶
inline void SpinnerBarsConverge(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Converge: in each column a top bar and a bottom dot slide together to the centre and back, in a left-to-right wave (alternate). mode 1 moves all columns in sync; mode 2 reverses the timeline.
ImSpinner::SpinnerBarsSwapEnds¶
inline void SpinnerBarsSwapEnds(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Swap ends: in each column a bar and a dot swap top/bottom ends, flipping one column after another in a wave (alternate). mode 1 flips all columns in sync; mode 2 reverses the timeline.
ImSpinner::SpinnerBarsRelay¶
inline void SpinnerBarsRelay(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Relay: a nine-step wave (2 s loop): bars drop one by one, rise carrying their dot underneath, then the dots drop back in turn. mode 1 mirrors the column order; mode 2 reverses the timeline.
ImSpinner::SpinnerBarsPush¶
inline void SpinnerBarsPush(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Push: in each column a dot descends from the top to the centre and pushes the bar below it, one column after another (alternate). mode 1 mirrors the column order; mode 2 reverses the timeline.
ImSpinner::SpinnerBarsPushWave¶
inline void SpinnerBarsPushWave(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Push wave: like Push, but a single dot-push travels across the columns one at a time and resets before the next (linear loop). mode 1 mirrors the column order; mode 2 reverses the timeline.
ImSpinner::SpinnerBarsGather¶
inline void SpinnerBarsGather(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Gather: four arms fly in from off-screen to assemble a plus around a centre dot, rotate 90 degrees, then fly back out (1.5 s loop). mode 1 rotates the opposite way; mode 2 reverses the timeline.
ImSpinner::SpinnerBarsSplit¶
inline void SpinnerBarsSplit(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Split: two horizontal bars spread from the centre to the edges while a dot drops to the middle (0.5 s alternate); the whole figure rotates in 90-degree steps. mode 1 rotates continuously; mode 2 reverses the rotation.
ImSpinner::SpinnerBarsSlot¶
inline void SpinnerBarsSlot(const char *label, float radius, float thickness, const ImColor &color = white, float speed = 1.f, int mode = 0);Slot: a dot passes top->bottom through two bars that open as a gate and close behind it (1 s linear loop), while the figure rotates in 90-degree steps. mode 1 rotates continuously; mode 2 reverses the rotation.