CABasicAnimation Schlüssel

Ich versuche zu wissen, was sind alle möglichen Tasten in CABasicAnimation

wie diese:

CABasicAnimation *imageRotation = [CABasicAnimation animationWithKeyPath:@"transform.rotation"];

macht eine Drehung ... wo finde ich alle möglichen Schlüssel?
und Dank der nach vorne

das ist, was ich jetzt mache .. danke

InformationsquelleAutor Mosab Alawad | 2012-12-17

2

Haben Sie als einen Blick in die class-Referenz für CABasicAnimation, und der entsprechende super-Klassen?

CABasicAnimation:
https://developer.apple.com/library/mac/#documentation/GraphicsImaging/Reference/CABasicAnimation_class/Introduction/Introduction.html

CAPropertyAnimation
https://developer.apple.com/library/mac/#documentation/GraphicsImaging/Reference/CAPropertyAnimation_class/Introduction/Introduction.html#//apple_ref/occ/cl/CAPropertyAnimation

CAAnimation
https://developer.apple.com/library/mac/#documentation/GraphicsImaging/Reference/CAAnimation_class/Introduction/Introduction.html#//apple_ref/occ/cl/CAAnimation
- Ich sehe nicht, eine konkrete Liste der unterstützten Schlüssel-Pfade für die animation überhaupt.
- Diese Seiten bieten nicht die Liste für mögliche Schlüsselpfad Werte.
InformationsquelleAutor Johann Dirdal
21

Folgenden ist die große animationWithKeyPath Werte.

Referenz http://www.adamzucchi.com/blog/?p=24

InformationsquelleAutor Midhun MP
6

Diese Quelle wird erwähnt in einem Kommentar auf eine der Antworten, sondern in der Hoffnung, dass diese akzeptiert werden können, für diejenigen, die in der Zukunft, die finden, diese Frage, die richtige Liste, wie der Tag, an dem gepostet wird, ist diese Seite auf der apple-Dokumentation:

https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/CoreAnimation_guide/AnimatableProperties/AnimatableProperties.html
https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/CoreAnimation_guide/Key-ValueCodingExtensions/Key-ValueCodingExtensions.html

Hier sind die keypaths den genannten links:

(Sofern nicht anders angegeben, CALayer-Eigenschaften verwenden Sie die Standard-CABasicAnimation)

CALayer
- anchorPoint: CGPoint
- backgroundColor: CGColor?
- backgroundFilters: [CIFilter]? (verwendet Standard-CATransition, sub-Eigenschaften der Filter, die animiert sind mit Standard-CABasicAnimation)
- borderColor: CGColor?
- borderWidth: CGFloat
- Grenzen: CGRect
- compositingFilter: CIFilter? (verwendet Standard-CATransition, sub-Eigenschaften der Filter, die animiert sind mit Standard-CABasicAnimation)
- Inhalt: CGImage?
- contentsRect: CGRect
- cornerRadius: CGFloat
- doppelseitig: Bool (kein Standard-animation)
- Filter: __[CIFilter]? (verwendet Standard-CATransition, sub-Eigenschaften der Filter, die animiert sind mit Standard-CABasicAnimation)
- Rahmen: CGRect (!!nicht animierbar!! nutzen, Grenzen und position)
- versteckt: Bool
- Maske: CALayer?
- masksToBounds: Bool
- Deckkraft: Float (0 <= opacity <= 1)
- position: CGPoint
- shadowColor: CGColor?
- shadowOffset: CGSize (die Standardeinstellung ist (0,-3))
- shadowOpacity: Float (0 <= shadowOpacity <= 1)
- shadowPath: CGPath?
- shadowRadius: CGFloat (die Standardeinstellung ist 3)
- sublayer: [CALayer]?
- sublayerTransform: CATransform3D
- verwandeln: CATransform3D
- zPosition: CGFloat
CALayer default stillschweigend CABasicAnimation**: Dauer = 0,25 s oder der Dauer der aktuellen Transaktion.

CALayer default stillschweigend CATransition**: Dauer = 0,25 s oder der Dauer der aktuellen Transaktion, type = kCATransitionFade, start progress = 0, Ende, Fortschritt = 1

CIFilter (macOS nur)
- Namen: String
- aktiviert: Bool
CATransform3D
- rotation.x: NSNumber (Bogenmaß)
- rotation.y: NSNumber (Bogenmaß)
- rotation.z: NSNumber (Bogenmaß)
- rotation: NSNumber (Bogenmaß) (identisch mit rotation.z)
- Skala.x: NSNumber
- Skala.y: NSNumber
- Skala.z: NSNumber
- Skala: NSNumber (durchschnittlich alle drei Skalierungsfaktoren)
- übersetzung.x: NSNumber
- übersetzung.y: NSNumber
- übersetzung.z: NSNumber
- übersetzung: NSValue mit einer NSSize oder CGSize
CGPoint
- x: CGFloat
- y: CGFloat
CGSize
- Breite: CGFloat
- Höhe: CGFloat
CGRect
- Herkunft: CGPoint
- Herkunft.x: CGFloat
- Herkunft.y: CGFloat
- Größe: CGSize
- Größe.Breite: CGFloat
- Größe.Höhe: CGFloat
- Während dieser Zusammenhang kann eine Antwort auf die Frage, ist es besser, die wesentlichen Teile der Antwort hier und den link zur Referenz. Link-nur Antworten können ungültig werden, wenn die verlinkten Seite ändert. - Nach Bewertung
- Behoben. Noch immer hängen der teilnehmenden auf Stack Overflow nach einer Weile als lurker 🙂
InformationsquelleAutor thecodewarrior
3

Kann man Sie in "Key-Path-Unterstützung für die Struktur der Felder" Abschnitt in CoreAnimation programming guide
- Aktualisiert link: developer.apple.com/library/ios/documentation/Cocoa/Conceptual/...
InformationsquelleAutor Vladimir

Update

Können Sie einfach schreiben: CABasicAnimation(Schlüsselpfad: #Schlüsselpfad(CAShapeLayer.bis))

Außerdem verwenden Sie Befehl+Umschalt+o öffnen, zum Beispiel, CALayer.h und sehen Sie sich ein Kommentare. Apple-team bietet Informationen über animierbar Funktion

End update

ziemlich wrapper für animierbare Tasten:

--- Beispiel ---

extension CABasicAnimation {
        convenience init(_ key: CAPropertyAnimation.Key, duration: Double) {
        self.init(keyPath: key.keyPath)
        self.duration = duration
    }
}

CABasicAnimation Schlüssel

extension CAPropertyAnimation {

    enum Key {

        case caLayer(_ property: CALayer.CALayerAnimatableProperty)
        case shapeLayer(_ property: CAShapeLayer.AnimatableProperty)
        case emmiterLayer(_ property: CAEmitterLayer.AnimatableProperty)
        case gradientLayer(_ property: CAGradientLayer.AnimatableProperty)
        case replicationLayer(_ property: CAReplicatorLayer.AnimatableProperty)
        case textLayer(_ property: CATextLayer.AnimatableProperty)

        var keyPath: String {
            switch self {
            case .caLayer(let property):           return property.key
            case .shapeLayer(let property):        return property.key
            case .emmiterLayer(let property):      return property.key
            case .gradientLayer(let property):     return property.key
            case .replicationLayer(let property):  return property.key
            case .textLayer(let property):         return property.key
            }
        }

    }

}

extension CALayer {

    /**

     - references:

     [Apple. Key-Value Coding Extensions](https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/CoreAnimation_guide/Key-ValueCodingExtensions/Key-ValueCodingExtensions.html#//apple_ref/doc/uid/TP40004514-CH12-SW2)

     [Apple. Animatable Properties.](https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/CoreAnimation_guide/AnimatableProperties/AnimatableProperties.html)

     [Stack overflow 1](https://stackoverflow.com/questions/44230796/what-is-the-full-keypath-list-for-cabasicanimation)

     [Stack overflow 2](https://stackoverflow.com/questions/13913101/cabasicanimation-keys)

    */

    enum CALayerAnimatableProperty {

        ///CGPoint
        case anchorPoint
        ///CGColor?
        case backgroundColor
        ///[CIFilter]? (uses default CATransition, sub-properties of filters are animated using default CABasicAnimation)
        case backgroundFilters
        ///CGColor?
        case borderColor
        ///CGFloat
        case borderWidth
        ///CGRect
        case bounds
        ///CGpoint
        case boundsOrigin
        ///CGFloat
        case boundsOriginX
        ///CGFloat
        case boundsOriginY
        ///CGSize
        case boundsSize
        ///CGFloat
        case boundsWidth
        ///CGFloat
        case boundsHeight
        ///CIFilter? (uses default CATransition, sub-properties of filters are animated using default CABasicAnimation)
        case compositingFilter
        ///CGImage?
        case contents
        ///CGRect
        case contentsRect
        ///CGFloat
        case cornerRadius
        ///Bool (no default animation)
        case doubleSided
        ///[CIFilter]? (uses default CATransition, sub-properties of filters are animated using default CABasicAnimation)
        case filters
        ///CGRect (!!not animatable!! use bounds and position)
        case frame
        ///Bool
        case hidden
        ///CALayer?
        case mask
        ///Bool
        case masksToBounds
        ///Float (0 <= opacity <= 1)
        case opacity
        ///CGPoint
        case position
        ///CGFloat
        case positionX
        ///CGFloat
        case positionY
        ///CGFloat
        case rotationX
        ///CGFloat
        case rotationY
        ///CGFloat
        case rotationZ
        ///CGFloat
        case scale
        ///CGFloat
        case scaleX
        ///CGFloat
        case scaleY
        ///CGFloat
        case scaleZ
        ///CGColor?
        case shadowColor
        ///CGSize (default is (0,-3))
        case shadowOffset
        ///Float (0 <= shadowOpacity <= 1)
        case shadowOpacity
        ///CGpath?
        case shadowPath
        ///CGFloat (default is 3)
        case shadowRadius
        ///[CALayer]?
        case sublayers
        ///CATransform3D
        case sublayerTransform
        ///CGSize
        case translation
        ///CGFloat
        case translationX
        ///CGFloat
        case translationY
        ///CGFloat
        case translationZ
        ///CATransform3D
        case transform
        ///CGFloat
        case zPosition

        var key: String {
            switch self {
            case .anchorPoint:          return "anchorPoint"
            case .backgroundFilters:    return "backgroundFilters"
            case .backgroundColor:      return "backgroundColor"
            case .borderColor:          return "borderColor"
            case .borderWidth:          return "borderWidth"
            case .bounds:               return "bounds"
            case .boundsOrigin:         return "bounds.origin"
            case .boundsOriginX:        return "bounds.origin.x"
            case .boundsOriginY:        return "bounds.origin.y"
            case .boundsSize:           return "bounds.size"
            case .boundsWidth:          return "bounds.size.width"
            case .boundsHeight:         return "bounds.size.height"
            case .compositingFilter:    return "compositingFilter"
            case .contents:             return "contents"
            case .contentsRect:         return "contentsRect"
            case .cornerRadius:         return "cornerRadius"
            case .filters:              return "filters"
            case .doubleSided:          return "doubleSided"
            case .frame:                return "frame"
            case .hidden:               return "hidden"
            case .mask:                 return "mask"
            case .masksToBounds:        return "masksToBounds"
            case .opacity:              return "opacity"
            case .position:             return "position"
            case .positionX:            return "position.x"
            case .positionY:            return "position.y"
            case .rotationX:            return "transform.rotation.x"
            case .rotationY:            return "transform.rotation.y"
            case .rotationZ:            return "transform.rotation.z"
            case .scale:                return "transform.scale"
            case .scaleX:               return "transform.scale.x"
            case .scaleY:               return "transform.scale.x"
            case .scaleZ:               return "transform.scale.x"
            case .shadowColor:          return "shadowColor"
            case .shadowOffset:         return "shadowOffset"
            case .shadowOpacity:        return "shadowOpacity"
            case .shadowPath:           return "shadowPath"
            case .shadowRadius:         return "shadowRadius"
            case .sublayers:            return "sublayers"
            case .sublayerTransform:    return "sublayerTransform"
            case .translation:          return "transform.translation"
            case .translationX:         return "transform.translation.x"
            case .translationY:         return "transform.translation.y"
            case .translationZ:         return "transform.translation.z"
            case .transform:            return "transform"
            case .zPosition:            return "zPosition"
            }
        }

    }

}

extension CAShapeLayer {

    enum AnimatableProperty {

        case inherited(_ property: CALayer.CALayerAnimatableProperty)
        ///CGColor?
        case fillColor
        ///[NSNumber]?
        case lineDashPhase
        ///CGFloat
        case lineWidth
        ///CGFloat
        case miterLimit
        ///CGColor?
        case strokeColor
        ///CGFloat
        case strokeStart
        ///CGFloat
        case strokeEnd

        var key: String {
            switch self {
            case .inherited(let property):  return property.key
            case .fillColor:                return "fillColor"
            case .lineDashPhase:            return "lineDashPhase"
            case .lineWidth:                return "lineWidth"
            case .miterLimit:               return "miterLimit"
            case .strokeColor:              return "strokeColor"
            case .strokeStart:              return "strokeStart"
            case .strokeEnd:                return "strokeEnd"
            }
        }

    }

}

extension CAEmitterLayer {

    enum AnimatableProperty {

        case inherited(_ property: CALayer.CALayerAnimatableProperty)
        ///CGPoint
        case emitterPosition
        ///CGFloat
        case emitterZPosition
        ///CGSize
        case emitterSize

        var key: String {
            switch self {
            case .inherited(let property):  return property.key
            case .emitterPosition:          return "emitterPosition"
            case .emitterZPosition:         return "emitterZPosition"
            case .emitterSize:              return "emitterSize"
            }
        }

    }

}

extension CAGradientLayer {

    enum AnimatableProperty {

        case inherited(_ property: CALayer.CALayerAnimatableProperty)
        ///[CGColor]? ([Any]? by Apple docs, but CGColor works as well)
        case colors
        ///[NSNuber]?
        case locations
        ///CGPoint
        case endPoint
        ///CGPoint
        case startPoint

        var key: String {
            switch self {
            case .inherited(let property):  return property.key
            case .colors:                   return "colors"
            case .locations:                return "locations"
            case .endPoint:                 return "endPoint"
            case .startPoint:               return "startPoint"
            }
        }

    }

}

extension CAReplicatorLayer {

    enum AnimatableProperty {

        case inherited(_ property: CALayer.CALayerAnimatableProperty)
        ///CFTimeInterval (Double)
        case instanceDelay
        ///CATransform3D
        case instanceTransform
        ///Float
        case instanceRedOffset
        ///Float
        case instanceGreenOffset
        ///Float
        case instanceBlueOffset
        ///Float
        case instanceAlphaOffset

        var key: String {
            switch self {
            case .inherited(let property):  return property.key
            case .instanceDelay:            return "instanceDelay"
            case .instanceTransform:        return "instanceTransform"
            case .instanceRedOffset:        return "instanceRedOffset"
            case .instanceGreenOffset:      return "instanceGreenOffset"
            case .instanceBlueOffset:       return "instanceBlueOffset"
            case .instanceAlphaOffset:      return "instanceAlphaOffset"
            }
        }

    }

}

extension CATextLayer {

    enum AnimatableProperty {

        case inherited(_ property: CALayer.CALayerAnimatableProperty)
        ///CGSize
        case fontSize
        ///CGColor?
        case foregroundColor


        var key: String {
            switch self {
            case .inherited(let property):  return property.key
            case .fontSize:                 return "fontSize"
            case .foregroundColor:          return "foregroundColor"
            }
        }

    }

}

InformationsquelleAutor Eugene

1

Grundsätzlich können Sie jede mögliche Schlüsselpfad.
Also, wenn ein Objekt implementiert die Eigenschaft "alpha", wie alle äußerungen, lassen Sie diese Eigenschaft animieren automatisch.

Den CAAnimation berechnet dann die Schritte zwischen dem Startpunkt und der Endpunkt der animation, legt diese und zeichnet die Ansicht.
- Dieser link ist jetzt tot 🙁
- Es gibt keinen link in meiner Antwort 😉
InformationsquelleAutor NSAddict

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

CALayer

CIFilter (macOS nur)

CATransform3D

CGPoint

CGSize

CGRect