73 lines
2.3 KiB
Go
73 lines
2.3 KiB
Go
package main
|
|
|
|
import (
|
|
rl "github.com/gen2brain/raylib-go/raylib"
|
|
)
|
|
|
|
// CircleAnimator manages both the position/radius alpha (0..1)
|
|
// and the displayed progress which eases toward the actual SPM progress.
|
|
type CircleAnimator struct {
|
|
PosAlpha float32 // 0 => top-right, 1 => center
|
|
DisplayProgress float32 // The "smooth" progress shown on screen
|
|
targetStep int // The step controlling circle's final position (0..2 => top-right, 3 => center)
|
|
|
|
// For smoothing the circle position alpha with "easeInOutCubic"
|
|
accumSec float32
|
|
duration float32
|
|
startAlpha float32
|
|
endAlpha float32
|
|
|
|
// For smoothing the displayed progress
|
|
// We'll do a simple exponential approach each frame.
|
|
// Alternatively, you could do a time-based tween.
|
|
smoothingFactor float32 // e.g. 0.1 => about 10% approach per frame
|
|
}
|
|
|
|
// NewCircleAnimator sets initial defaults
|
|
func NewCircleAnimator() *CircleAnimator {
|
|
return &CircleAnimator{
|
|
PosAlpha: 0.0, // start at top-right
|
|
DisplayProgress: 0.0,
|
|
duration: 1.0, // 1 second total for position tween
|
|
smoothingFactor: 0.07, // how fast progress approaches real
|
|
}
|
|
}
|
|
|
|
// SetStep sets whether we want circle in top-right (step<3 => alpha=0) or center (step=3 => alpha=1).
|
|
// This starts a new positional tween from current alpha to the new alpha.
|
|
func (c *CircleAnimator) SetStep(step int) {
|
|
c.targetStep = step
|
|
var newEnd float32 = 0.0
|
|
if step == 3 {
|
|
newEnd = 1.0
|
|
}
|
|
// Start new tween from current alpha to newEnd
|
|
c.startAlpha = c.PosAlpha
|
|
c.endAlpha = newEnd
|
|
c.accumSec = 0
|
|
}
|
|
|
|
// Update updates both the position alpha (with easeInOutCubic) and the displayed progress.
|
|
func (c *CircleAnimator) Update(realProgress int) {
|
|
dt := rl.GetFrameTime() // seconds
|
|
|
|
// 1) Update position alpha
|
|
if c.accumSec < c.duration {
|
|
c.accumSec += dt
|
|
if c.accumSec > c.duration {
|
|
c.accumSec = c.duration
|
|
}
|
|
p := c.accumSec / c.duration
|
|
eased := easeInOutCubic(p)
|
|
// Lerp from startAlpha to endAlpha with eased fraction
|
|
c.PosAlpha = c.startAlpha + (c.endAlpha-c.startAlpha)*eased
|
|
} else {
|
|
// no active tween, just keep the final alpha
|
|
c.PosAlpha = c.endAlpha
|
|
}
|
|
|
|
// 2) Smoothly approach the real progress
|
|
// (exponential approach: new = old + factor*(target - old))
|
|
target := float32(realProgress)
|
|
c.DisplayProgress += c.smoothingFactor * (target - c.DisplayProgress)
|
|
}
|