Animación SwiftUI
Descripción General
Guía completa del sistema de animación de SwiftUI, desde conceptos fundamentales hasta técnicas avanzadas. Este skill cubre el protocolo Animatable, la macro @Animatable de iOS 26, los tipos de animación y el sistema de Transactions.
Principio fundamental La animación en SwiftUI es interpolación matemática a lo largo del tiempo, impulsada por el protocolo VectorArithmetic. Comprender esta base desbloquea todo el poder del sistema de animación declarativa de SwiftUI.
Cuándo Usar Este Skill
- Implementar vistas o formas animadas personalizadas
- Entender por qué una propiedad no se anima (Int vs Float/Double)
- Elegir entre animaciones con resorte y curvas de tiempo
- Usar la macro @Animatable (iOS 26+)
- Hacer que las vistas se conformen al protocolo Animatable
- Depurar el comportamiento de fusión de animaciones
- Optimizar el rendimiento de las animaciones
- Crear animaciones complejas o de múltiples pasos
- Comprender los valores de modelo vs. presentación
- Implementar algoritmos de animación personalizados
Requisitos del Sistema
iOS 13+ para el protocolo Animatable
iOS 17+ para animaciones con resorte predeterminadas, animaciones con ámbito
iOS 26+ para la macro @Animatable
Parte 1: Comprender la Animación
¿Qué es la Interpolación?
La animación es el proceso de generar valores intermedios entre un estado inicial y uno final.
Ejemplo: Animación de opacidad
.opacity(0) → .opacity(1)
Mientras esta animación se ejecuta, SwiftUI calcula valores intermedios:
0.0 → 0.02 → 0.05 → 0.1 → 0.25 → 0.4 → 0.6 → 0.8 → 1.0
Cómo se distribuyen los valores
- Determinado por la curva de tiempo o la función de velocidad de la animación
- Las animaciones con resorte usan simulación física
- Las curvas de tiempo usan curvas de Bézier
- Cada tipo de animación calcula los valores de manera diferente
Protocolo VectorArithmetic
SwiftUI requiere que los datos animados se ajusten a VectorArithmetic, que proporciona:
protocol VectorArithmetic {
// Calcula la diferencia entre dos valores
static func - (lhs: Self, rhs: Self) -> Self
// Escala valores
static func * (lhs: Self, rhs: Double) -> Self
// Suma valores
static func + (lhs: Self, rhs: Self) -> Self
// Valor cero
static var zero: Self { get }
}
Tipos incorporados que se ajustan
- 1-dimensional:
CGFloat,Double,Float,Angle - 2-dimensional:
CGPoint,CGSize - 4-dimensional:
CGRect
Información clave La aritmética vectorial abstrae la dimensionalidad de los datos animados. SwiftUI puede animar todos estos tipos con una única implementación genérica.
Por Qué Int No Se Puede Animar
Int no se ajusta a VectorArithmetic porque:
- No hay valores intermedios fraccionarios — No existe un "3.5" entre 3 y 4
- No es continuo — Los enteros son valores discretos
- Escalar no tiene sentido — ¿Qué significa 5 × 0.5 para un entero?
¿Qué sucede cuando lo intentas?
struct CounterView: View {
@State private var count: Int = 0
var body: some View {
Text("\(count)")
.animation(.spring, value: count)
}
}
Resultado: SwiftUI simplemente reemplaza el texto anterior por el nuevo. No ocurre interpolación.
Solución: Usa Float o Double
struct AnimatedCounterView: View {
@State private var count: Float = 0
var body: some View {
Text("\(Int(count))")
.animation(.spring, value: count)
}
}
Resultado: SwiftUI interpola 0.0 → ... → 100.0, y muestras el entero redondeado en cada fotograma.
Valores de Modelo vs. Presentación
Los atributos animables tienen conceptualmente dos valores:
Valor de Modelo
- El valor objetivo establecido por tu código
- Se actualiza inmediatamente cuando cambia el estado
- Es lo que escribes en el cuerpo de tu vista
Valor de Presentación
- El valor interpolado actual que se está renderizando
- Se actualiza fotograma a fotograma durante la animación
- Es lo que el usuario ve realmente
Ejemplo
.scaleEffect(selected ? 1.5 : 1.0)
Cuando selected se convierte en true:
- Valor de modelo: Inmediatamente se convierte en
1.5 - Valor de presentación: Interpola
1.0 → 1.1 → 1.2 → 1.3 → 1.4 → 1.5a lo largo del tiempo
Parte 2: Protocolo Animatable
Descripción General
El protocolo Animatable permite que las vistas animen sus propiedades definiendo qué datos deben interpolarse.
protocol Animatable {
associatedtype AnimatableData: VectorArithmetic
var animatableData: AnimatableData { get set }
}
SwiftUI construye un atributo animable para cualquier vista que se ajuste a este protocolo.
Vistas Animables Incorporadas
Muchos modificadores de SwiftUI se ajustan a Animatable:
Efectos Visuales
.scaleEffect()— Anima la transformación de escala.rotationEffect()— Anima la rotación.offset()— Anima el desplazamiento de posición.opacity()— Anima la transparencia.blur()— Anima el radio de desenfoque.shadow()— Anima las propiedades de la sombra
Todos los tipos Shape
Circle,Rectangle,RoundedRectangleCapsule,Ellipse,Path- Implementaciones personalizadas de
Shape
AnimatablePair para Datos Multidimensionales
Al animar múltiples propiedades, usa AnimatablePair para combinar vectores.
Ejemplo: Implementación de scaleEffect
struct ScaleEffectModifier: ViewModifier, Animatable {
var scale: CGSize
var anchor: UnitPoint
// Combina dos vectores 2D en un vector 4D
var animatableData: AnimatablePair<CGSize.AnimatableData, UnitPoint.AnimatableData> {
get {
AnimatablePair(scale.animatableData, anchor.animatableData)
}
set {
scale.animatableData = newValue.first
anchor.animatableData = newValue.second
}
}
func body(content: Content) -> some View {
content.scaleEffect(scale, anchor: anchor)
}
}
Cómo funciona
CGSizetiene 2 dimensiones (ancho, alto)UnitPointtiene 2 dimensiones (x, y)AnimatablePairlos fusiona en un vector de 4 dimensiones- SwiftUI interpola los 4 valores juntos
Conformancia Personalizada a Animatable
Cuándo usarla
- Animar un diseño personalizado (como RadialLayout)
- Animar código de dibujo personalizado
- Animar propiedades que afectan las rutas de las formas
Ejemplo: Vista de número animado
struct AnimatableNumberView: View, Animatable {
var number: Double
var animatableData: Double {
get { number }
set { number = newValue }
}
var body: some View {
Text("\(Int(number))")
.font(.largeTitle)
}
}
// Uso
AnimatableNumberView(number: value)
.animation(.spring, value: value)
Cómo funciona
numbercambia de 0 a 100- SwiftUI llama a
bodypor cada fotograma de la animación - Cada fotograma obtiene un nuevo valor de
number: 0 → 5 → 15 → 30 → 55 → 80 → 100 - El texto se actualiza para mostrar el entero interpolado
Advertencia de Rendimiento
La conformancia personalizada a Animatable puede ser costosa.
Cuando haces que una vista se ajuste a Animatable:
- SwiftUI llama al
bodyde tu vista por cada fotograma de la animación - El diseño se vuelve a ejecutar en cada fotograma
- Esto ocurre en el hilo principal
Los efectos animables incorporados (como .scaleEffect(), .opacity()) son mucho más eficientes:
- Se ejecutan fuera del hilo principal
- No llaman al body de tu vista
- Actualizan solo la capa de renderizado
Directriz
- Usa efectos incorporados siempre que sea posible
- Solo usa conformancia personalizada a Animatable si no puedes lograr el efecto con modificadores incorporados
- Perfila con Instruments si tienes problemas de rendimiento
Ejemplo: Animación de diseño circular
// Esto es costoso pero necesario para animar a lo largo de una trayectoria circular
@Animatable
struct RadialLayout: Layout {
var offsetAngle: Angle
var animatableData: Angle.AnimatableData {
get { offsetAngle.animatableData }
set { offsetAngle.animatableData = newValue }
}
func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
proposal.replacingUnspecifiedDimensions()
}
func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
let radius = min(bounds.width, bounds.height) / 2
let center = CGPoint(x: bounds.midX, y: bounds.midY)
let angleStep = Angle.degrees(360.0 / Double(subviews.count))
for (index, subview) in subviews.enumerated() {
let angle = offsetAngle + angleStep * Double(index)
let x = center.x + radius * cos(angle.radians)
let y = center.y + radius * sin(angle.radians)
subview.place(at: CGPoint(x: x, y: y), anchor: .center, proposal: .unspecified)
}
}
}
Por qué es necesario: Animar offsetAngle requiere recalcular las posiciones en cada fotograma. Ningún modificador incorporado puede hacer esto.
Parte 3: Macro @Animatable (iOS 26+)
Descripción General
La macro @Animatable elimina el código repetitivo de ajustarse manualmente al protocolo Animatable.
Antes de iOS 26, tenías que:
- Ajustarte manualmente a
Animatable - Escribir el getter y setter de
animatableData - Usar
AnimatablePairpara múltiples propiedades - Excluir propiedades no animables manualmente
iOS 26+, solo añades @Animatable:
@MainActor
@Animatable
struct MyView: View {
var scale: CGFloat
var opacity: Double
var body: some View {
// ...
}
}
La macro automáticamente:
- Genera la conformancia a
Animatable - Inspecciona todas las propiedades almacenadas
- Crea
animatableDataa partir de propiedades que se ajustan a VectorArithmetic - Maneja datos multidimensionales con
AnimatablePair
Comparación Antes/Después
Antes de la macro @Animatable
struct HikingRouteShape: Shape {
var startPoint: CGPoint
var endPoint: CGPoint
var elevation: Double
var drawingDirection: Bool // No quieres animar esto
// Declaración tediosa y manual de animatableData
var animatableData: AnimatablePair<AnimatablePair<CGFloat, CGFloat>,
AnimatablePair<Double, AnimatablePair<CGFloat, CGFloat>>> {
get {
AnimatablePair(
AnimatablePair(startPoint.x, startPoint.y),
AnimatablePair(elevation, AnimatablePair(endPoint.x, endPoint.y))
)
}
set {
startPoint = CGPoint(x: newValue.first.first, y: newValue.first.second)
elevation = newValue.second.first
endPoint = CGPoint(x: newValue.second.second.first, y: newValue.second.second.second)
}
}
func path(in rect: CGRect) -> Path {
// Código de dibujo
}
}
Después de la macro @Animatable
@Animatable
struct HikingRouteShape: Shape {
var startPoint: CGPoint
var endPoint: CGPoint
var elevation: Double
@AnimatableIgnored
var drawingDirection: Bool // Excluida de la animación
func path(in rect: CGRect) -> Path {
// Código de dibujo
}
}
Líneas de código: 20 → 12 (reducción del 40%)
@AnimatableIgnored
Usa @AnimatableIgnored para excluir propiedades de la animación.
Cuándo usarlo
- Valores de depuración — Banderas solo para desarrollo
- IDs — Identificadores que no deberían animarse
- Marcas de tiempo — Cuándo se creó/actualizó la vista
- Estado interno — Contabilidad no visual
- Tipos que no se ajustan a VectorArithmetic — Colores, cadenas, booleanos
Ejemplo
@MainActor
@Animatable
struct ProgressView: View {
var progress: Double // Animado
var totalItems: Int // Animado (si es Float, no si es Int)
@AnimatableIgnored
var title: String // No animado
@AnimatableIgnored
var startTime: Date // No animado
@AnimatableIgnored
var debugEnabled: Bool // No animado
var body: some View {
VStack {
Text(title)
ProgressBar(value: progress)
if debugEnabled {
Text("Iniciado: \(startTime.formatted())")
}
}
}
}
Casos de Uso del Mundo Real
Las animaciones numéricas son extremadamente comunes en todas las categorías de aplicaciones:
Aplicaciones Fintech
@MainActor
@Animatable
struct StockPriceView: View {
var price: Double
var changePercent: Double
var body: some View {
VStack(alignment: .trailing) {
Text("$\(price, format: .number.precision(.fractionLength(2)))")
.font(.title)
Text("\(changePercent > 0 ? "+" : "")\(changePercent, format: .percent)")
.foregroundColor(changePercent > 0 ? .green : .red)
}
}
}
Caso de uso: Animar cambios en el precio de acciones, valor de cartera, transiciones de saldo de cuenta
Salud y Bienestar
@MainActor
@Animatable
struct HeartRateView: View {
var bpm: Double
@AnimatableIgnored
var timestamp: Date
var body: some View {
VStack {
Text("\(Int(bpm))")
.font(.system(size: 60, weight: .bold))
Text("BPM")
.font(.caption)
.foregroundColor(.secondary)
}
}
}
Caso de uso: Indicadores de frecuencia cardíaca, contadores de pasos, cálculos de calorías, distancia recorrida
Juegos
@MainActor
@Animatable
struct ScoreView: View {
var score: Float
var multiplier: Float
var body: some View {
HStack {
Text("\(Int(score))")
.font(.largeTitle)
Text("×\(multiplier, format: .number.precision(.fractionLength(1)))")
.font(.title2)
.foregroundColor(.orange)
}
}
}
Caso de uso: Animaciones de puntuación, transiciones de XP, progreso de nivel, multiplicadores de combo
Aplicaciones de Productividad
@MainActor
@Animatable
struct TimerView: View {
var remainingSeconds: Double
var body: some View {
VStack {
Text(formattedTime)
.font(.system(size: 48, design: .monospaced))
Text("segundos restantes")
.font(.caption)
}
}
var formattedTime: String {
let minutes = Int(remainingSeconds) / 60
let seconds = Int(remainingSeconds) % 60
return String(format: "%02d:%02d", minutes, seconds)
}
}
Caso de uso: Temporizadores Pomodoro, animaciones de cuenta regresiva, seguimiento de tiempo de tareas, fechas límite de proyectos
Parte 4: Tipos de Animación
Animaciones con Resorte (Spring)
Las animaciones con resorte son el tipo de animación predeterminado en SwiftUI desde iOS 17. Simulan física: un resorte conectado al valor objetivo.
Spring (iOS 17+)
// Sintaxis moderna
.animation(.spring, value: value) // Usa la configuración predeterminada del resorte del sistema
.animation(.spring(duration: 0.5, bounce: 0.3), value: value)
.animation(.spring(duration: 0.5, bounce: 0.7), value: value) // Más rebote
.animation(.spring(duration: 1.0, bounce: 0.0), value: value) // Sin rebote
Configuración:
duration: Cuánto dura la animación (período de oscilación)bounce: Cuánto rebota (0=sin rebote, 1=máximo rebote)
Spring (antes de iOS 17)
// Sintaxis heredada
.animation(.spring(), value: value)
.animation(.interpolatingSpring(mass: 1, stiffness: 100, damping: 10), value: value)
Curvas de Tiempo (Timing Curves)
Las curvas de tiempo ofrecen control preciso sobre la aceleración de la animación.
// Duración fija (en segundos)
.animation(.easeInOut(duration: 1.0), value: value)
.animation(.easeIn(duration: 0.5), value: value)
.animation(.easeOut(duration: 0.3), value: value)
.animation(.linear(duration: 2.0), value: value)
// Curva de Bézier cúbica personalizada
.animation(.timingCurve(0.2, 0.8, 0.4, 1.0, duration: 1.0), value: value)
Cuándo Usar Cada Tipo
| Tipo | Mejor Para | Ejemplo |
|---|---|---|
| Spring | Interacciones naturales, elementos UI, retroalimentación táctil | Botones emergentes, cambios de tamaño de vista |
| EaseInOut | Movimiento suave general, animaciones de pantalla | Transiciones de opacidad, desplazamiento de vistas |
| EaseOut | Movimiento que se desacelera naturalmente | Apertura de menús, diapositivas de notificaciones |
| Linear | Movimiento constante, barras de progreso | Barras de progreso indeterminadas, desplazamiento continuo |
| TimingCurve | Control preciso de la aceleración | Animaciones de iconos de carga, gráficos de movimiento |
Parte 5: Sistema de Transactions
Las Transactions son el mecanismo de SwiftUI para agrupar y controlar animaciones. Te permiten anular las animaciones predeterminadas, deshabilitar animaciones o pasar opciones de animación a través de la jerarquía de vistas.
Uso Básico
withAnimation(.spring(duration: 0.5)) {
// Todos los cambios de estado aquí se animan con un resorte
isExpanded.toggle()
}
// Sin animación
withTransaction(Transaction(animation: nil)) {
isExpanded.toggle()
}
Transacciones Explícitas
Crear y modificar una Transaction directamente:
var transaction = Transaction()
transaction.animation = .spring(duration: 0.5, bounce: 0.3)
transaction.disablesAnimations = true // Deshabilita todas las animaciones hijas
transaction.isContinuous = true // Para animaciones continuas como arrastrar
withTransaction(transaction) {
isExpanded.toggle()
}
Fusión de Transacciones
Cuando las animaciones están anidadas, SwiftUI fusiona las transacciones:
withAnimation(.spring) {
withAnimation(.easeInOut(duration: 1.0)) {
// ¿Qué animación gana?
isExpanded.toggle()
}
}
Regla de fusión: La transacción más externa tiene prioridad. En este caso, .spring reemplaza a .easeInOut.
Parte 6: Animaciones de Ruta (Path)
Animación de Formas Personalizadas
Puedes animar los puntos de control de una ruta de Bézier a lo largo del tiempo.
Requisito: La forma debe ajustarse a Animatable.
Ejemplo: Forma de ola con altura animada
struct WaveForm: Shape {
var height: Double
var animatableData: Double {
get { height }
set { height = newValue }
}
func path(in rect: CGRect) -> Path {
var path = Path()
let midY = rect.midY
let width = rect.width
path.move(to: CGPoint(x: 0, y: midY))
path.addCurve(
to: CGPoint(x: width, y: midY),
control1: CGPoint(x: width * 0.25, y: midY - height),
control2: CGPoint(x: width * 0.75, y: midY + height)
)
return path
}
}
// Uso
WaveForm(height: animatableHeight)
.stroke(.blue, lineWidth: 2)
.animation(.spring, value: animatableHeight)
Parte 7: Animación de Layout
Animación del Layout de una Jerarquía de Vistas
Para animar un layout personalizado, haz que tu tipo Layout se ajuste a Animatable.
Ejemplo: Animación de un layout de cuadrícula
@Animatable
struct AnimatedGridLayout: Layout {
var spacing: Double
var columns: Int
func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
// Calcular el tamaño basado en el número de columnas
// ...
}
func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
// Colocar subvistas basadas en el espaciado y columnas actuales
// ...
}
}
Parte 8: Animación de Capas y Sombra
Animación de Capas
Las vistas de capa (como Color, Image, Rectangle) pueden animar sus propiedades:
Color.blue
.opacity(0.5)
.animation(.easeInOut, value: opacity)
Image(systemName: "star")
.scaleEffect(scale)
.animation(.spring, value: scale)
Animación de Sombras
Rectangle()
.shadow(color: .black.opacity(shadowOpacity), radius: shadowRadius, x: shadowX, y: shadowY)
.animation(.spring, value: shadowOpacity)
.animation(.easeInOut, value: shadowRadius)
Parte 9: Animaciones con Gestos
Animación Basada en Gestos
Combina gestos con animaciones para crear interacciones receptivas.
struct DraggableCard: View {
@State private var offset: CGSize = .zero
@State private var isDragging = false
var body: some View {
RoundedRectangle(cornerRadius: 20)
.fill(.blue)
.frame(width: 200, height: 300)
.offset(offset)
.scaleEffect(isDragging ? 1.05 : 1.0)
.gesture(
DragGesture()
.onChanged { value in
withAnimation(.interactiveSpring) {
offset = value.translation
isDragging = true
}
}
.onEnded { _ in
withAnimation(.spring) {
offset = .zero
isDragging = false
}
}
)
}
}
Parte 10: Mejores Prácticas y Rendimiento
Consejos de Rendimiento
- Usa
.drawingGroup()cuando tengas muchas vistas animadas para renderizar en una imagen fuera de pantalla - Limita el número de vistas animadas simultáneamente
- Evita animar propiedades de layout (como frame, padding) ya que son costosas
- Prefiere
.scaleEffect()sobre.frame()para animaciones de tamaño - Usa
.animation(nil, value:)para deshabilitar animaciones donde no sean necesarias
Depuración
View Profileren Instruments para ver el costo de las animaciones- Usa modificadores
${ }en vistas para inspeccionar valores durante la animación - Imprime valores en el getter de
animatableDatadurante la depuración
Conclusión
Entender cómo SwiftUI maneja la animación a través de VectorArithmetic, el protocolo Animatable y la macro @Animatable te permite crear animaciones fluidas y eficientes. Comienza siempre con los efectos incorporados, usa @Animatable para simplificar la conformancia y recurre a la conformancia manual solo cuando necesites un control preciso sobre los datos interpolados.
Documentación creada para desarrolladores de SwiftUI que quieren dominar las animaciones.