                        state.forceAnimate
     }
     
-    /**
-     Lazy loads the overlay layer. 
+    override func apply(state: MotionTargetState) {
+        let ts = viewState(targetState: state)
+        
+        for (key, targetValue) in ts {
+            if nil == transitionStates[key] {
+                let current = currentValue(for: key)
+                transitionStates[key] = (current, current)
+            }
+            
+            animate(key: key, beginTime: 0, fromValue: targetValue, toValue: targetValue)
+        }
+    }
+
+    override func resume(elapsedTime: TimeInterval, isReversed: Bool) {
+        for (key, (fromValue, toValue)) in transitionStates {
+            transitionStates[key] = (currentValue(for: key), !isReversed ? toValue : fromValue)
+        }
+
+        targetState.duration = isReversed ? elapsedTime - targetState.delay : duration - elapsedTime
+        animate(delay: max(0, targetState.delay - elapsedTime))
+    }
+
+    override func seek(to elapsedTime: TimeInterval) {
+        seek(layer: snapshot.layer, elapsedTime: elapsedTime)
+        
+        if let v = contentLayer {
+            seek(layer: v, elapsedTime: elapsedTime)
+        }
+    
+        if let v = overlayLayer {
+            seek(layer: v, elapsedTime: elapsedTime)
+        }
+    }
+
+    override func startAnimations(isAppearing: Bool) {
+        if let beginState = targetState.beginState?.state {
+            let appeared = viewState(targetState: beginState)
+            for (k, v) in appeared {
+                snapshot.layer.setValue(v, forKeyPath: k)
+            }
+            
+            if let (k, v) = beginState.overlay {
+                let overlay = getOverlayLayer()
+                overlay.backgroundColor = k
+                overlay.opacity = Float(v)
+            }
+        }
+
+        let disappeared = viewState(targetState: targetState)
+        for (k, v) in disappeared {
+            let isAppearingState = currentValue(for: k)
+            let toValue = isAppearing ? isAppearingState : v
+            let fromValue = !isAppearing ? isAppearingState : v
+            
+            transitionStates[k] = (fromValue, toValue)
+        }
+
+        animate(delay: targetState.delay)
+    }
+}
+
+extension MotionCoreAnimationViewContext {
+    /**
+     Lazy loads the overlay layer.
      - Returns: A CALayer.
      */
-    func getOverlayLayer() -> CALayer {
+    fileprivate func getOverlayLayer() -> CALayer {
         if nil == overlayLayer {
             overlayLayer = CALayer()
             overlayLayer!.frame = snapshot.bounds

            
            anim = a
        }

        anim.fillMode = kCAFillModeBoth
        anim.isRemovedOnCompletion = false
        anim.beginTime = beginTime

        return anim
    }

    /**
     Retrieves the duration of an animation, including the
     duration of the animation and the initial delay.

    }
    
    /**
     Retrieves the current value for a given key.
     - Parameter for key: A String.
     - Returns: An optional Any value.
     */
    fileprivate func currentValue(for key: String) -> Any? {
        if let key = overlayKey(for: key) {
            return overlayLayer?.value(forKeyPath: key)
        }
