Advance alternatives and similar libraries
Based on the "Animation" category.
Alternatively, view Advance alternatives based on common mentions on social networks and blogs.
-
Pop
An extensible iOS and OS X animation library, useful for physics-based interactions. -
Shimmer
An easy way to add a simple, shimmering effect to any view in an iOS app. -
IBAnimatable
Design and prototype customized UI, interaction, navigation, transition and animation for App Store ready Apps in Interface Builder with IBAnimatable. -
Keyframes
A library for converting Adobe AE shape based animations to a data format and play it back on Android and iOS devices. -
JHChainableAnimations
Easy to read and write chainable animations in Objective-C and Swift -
EasyAnimation
A Swift library to take the power of UIView.animateWithDuration(_:, animations:...) to a whole new level - layers, springs, chain-able animations and mixing view and layer animations together! -
RZTransitions
A library of custom iOS View Controller Animations and Interactions. -
DKChainableAnimationKit
⭐ Chainable animations in Swift -
CKWaveCollectionViewTransition
Cool wave like transition between two or more UICollectionView -
LSAnimator
⛓ Easy to Read and Write Multi-chain Animations Lib in Objective-C and Swift. -
Awesome-iOS-Animation
Curated list of iOS Animation libraries -
ActivityIndicatorView
A number of preset loading indicators created with SwiftUI -
AnimationEngine
Easily build advanced custom animations on iOS. -
DCAnimationKit
A collection of animations for iOS. Simple, just add water animations. -
ZoomTransitioning
ZoomTransitioning provides a custom transition with image zooming animation and swiping the screen edge. -
FlightAnimator
Advanced Natural Motion Animations, Simple Blocks Based Syntax -
AHKBendableView
UIView subclass that bends its edges when its position changes. -
AHDownloadButton
Customizable download button with progress and transition animations. It is based on Apple's App Store download button. -
MotionMachine
A powerful, elegant, and modular animation library for Swift. -
RippleEffectView
RippleEffectView - A Neat Rippling View Effect -
SamuraiTransition
SamuraiTransition is an open source Swift based library providing a collection of ViewController transitions featuring a number of neat “cutting” animations. -
JRMFloatingAnimation
An Objective-C animation library used to create floating image views. -
CCMRadarView
CCMRadarView uses the IBDesignable tools to make an easy customizable radar view with animation -
ConcentricProgressRingView
Fully customizable circular progress bar written in Swift. -
Walker
Each step you take reveals a new horizon. You have taken the first step today. -
SYBlinkAnimationKit
A blink effect animation framework for iOS, written in Swift. -
ADPuzzleAnimation
Inspired by Fabric - Answers animation. Allows to "build" given view with pieces. Allows to "destroy" given view into pieces -
SMSwipeableTabView
Swipeable Views with Tabs (Like Android SwipeView With Tabs Layout)
Appwrite - The open-source backend cloud platform
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of Advance or a related project?
README
Advance
An animation library for iOS, tvOS, and macOS that uses physics-based animations (including springs) to power interactions that move and respond realistically.
let view = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100))
// Springs animate changes to a value
let spring = Spring(initialValue: view.center)
// The `onChange` closure will be called every time the spring updates
spring.onChange = { [view] newCenter in
view.center = newCenter
}
/// The view's center will realistically animate to the new target value.
spring.target = CGPoint(x: 300, y: 200)
Installation
There are several ways to integrate Advance into your project.
Manually: add
Advance.xcodeproj
to your project, then addAdvance-{iOS|macOS|tvOS}.framework
as an "Embedded Binary" to your application target (under General in target settings). From there, addimport Advance
to your code and you're good to go.Carthage: add
github "timdonnelly/Advance"
to yourCartfile
.CocoaPods: add
pod 'Advance'
to yourPodfile
.Swift Package Manager: add a dependency to your
Project.swift
:.package(url: "http://github.com/timdonnelly/Advance", from: "3.0.0")
Requirements
- iOS 10+, tvOS 10+, or macOS 10.12+
- Swift 5.0 (Xcode 10.2 or higher)
Usage
API documentation is available here.
Advance animations are applied on every frame (using CADisplayLink
on iOS/tvOS, and CVDisplayLink
on macOS), allowing for fine-grained control at any time.
Spring
Spring
instances animate changes to a value over time, using spring physics.
let spring = Spring(initialValue: 0.0)
spring.onChange = { [view] newAlpha in
view.alpha = newAlpha
}
// Off it goes!
spring.target = 0.5
Configuring a spring
/// Spring values can be adjusted at any time.
spring.tension = 30.0 /// The strength of the spring
spring.damping = 2.0 /// The resistance (drag) that the spring encounters
spring.threshold = 0.1 /// The maximum delta between the current value and the spring's target (for each component) for which the simulation can enter a converged state.
/// Update the simulation state at any time.
spring.velocity = 6.5
spring.value = 0.2
/// Sets the spring's target and the current simulation value, and removes all velocity. This causes the spring to converge at the given value.
spring.reset(to: 0.5)
Animator
Animator
allows for more flexibility in the types of animation that can be performed, but gives up some convenience
in order to do so. Specifically, animators allow for any type of animation or simulation to be performed for a single
value.
let view = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100))
/// Animators coordinate animations to drive changes to a value.
let sizeAnimator = Animator(initialValue: view.bounds.size)
sizeAnimator.onChange = { [view] newSize in
view.bounds.size = newSize
}
/// A simple timed animation
sizeAnimator.animate(to: CGSize(width: 123, height: 456), duration: 0.25, timingFunction: .easeInOut)
/// Some time in the future (before the previous timed animation was complete)...
/// Spring physics will move the view's size to the new value, maintaining the velocity from the timed animation.
sizeAnimator.simulate(using: SpringFunction(target: CGSize(width: 300, height: 300)))
/// Some time in the future (before the previous spring animation was complete)...
/// The value will keep the same velocity that it had from the preceeding spring
/// animation, and a decay function will slowly bring movement to a stop.
sizeAnimator.simulate(using: DecayFunction(drag: 2.0))
Animators support two fundamentally different types of animations: timed and simulated.
Timed animations
Timed animations are, well, timed: they have a fixed duration, and they animate to a final value in a predictable manner.
animator.animate(to: CGSize(width: 123, height: 456), duration: 0.25, timingFunction: .easeInOut)
TimingFunction
described the pacing of a timed animation.
TimingFunction
comes with a standard set of functions:
TimingFunction.linear // No easing
TimingFunction.easeIn
TimingFunction.easeOut
TimingFunction.easeInOut
TimingFunction.swiftOut // Similar to Material Design's default curve
Custom timing functions can be expressed as unit beziers (described here).
let customTimingFunction = TimingFunction(x1: 0.1, y1: 0.2, x2: 0.6, y2: 0.0)
Simulated animations
Simulated animations use a simulation function to power a physics-based transition. Simulation functions are types conforming to the SimulationFunction
protocol.
Simulated animations may be started using two different methods:
// Begins animating with the custom simulation function, maintaining the previous velocity of the animator.
animator.simulate(using: MyCustomFunction())
// or...
// Begins animating with the custom simulation function, imparting the specified velocity into the simulation.
animator.simulate(using: DecayFunction(), initialVelocity: dragGestureRecognizer.velocity(in: view))
Animating Custom Types
Values conforming to the VectorConvertible
protocol can be animated by Advance. Conforming types can be converted to and from a Vector
implementation.
public protocol VectorConvertible: Equatable, Interpolatable {
associatedtype VectorType: SIMD where VectorType.Scalar == Double
init(vector: VectorType)
var vector: VectorType { get }
}
The library adds conformance for many common types through extensions.
Contributing
If you encounter any issues or surprises, please open an issue.
For suggestions or new features, please consider opening a PR with a functional implementation. Issues may be used if you aren't sure how to implement the change, but working code is typically easier to evaluate.
License
This project is released under the BSD 2-clause license.
*Note that all licence references and agreements mentioned in the Advance README section above
are relevant to that project's source code only.