         t[2, 2] = uz * uz * (1 - ca) + ca
         return t
     }
-
-    /** Applies a translation to the receiver.
-
-        let v = C4Vector(x: 1, y: 1)
-        let t = C4Transform()
-        t.translate(v)
-
-    - parameter translation: A `C4Vector` that represents the translation to apply.
-    */
+    
+    /// Applies a translation to the receiver.
+    ///
+    /// ````
+    /// let v = C4Vector(x: 1, y: 1)
+    /// let t = C4Transform()
+    /// t.translate(v)
+    /// ````
+    ///
+    /// - parameter translation: A `C4Vector` that represents the translation to apply.
     public mutating func translate(translation: C4Vector) {
         let t = C4Transform.makeTranslation(translation)
         self = concat(self, t2: t)
     }
     
-    /** Applies a scale to the receiver. The `z` variable is optional.
-    
-        let t = C4Transform()
-        t.scale(2.0, 2.0)
-
-    - parameter sx: The amount to scale in the `x` axis
-    - parameter sy: The amount to scale in the `y` axis
-    - parameter sz: The amount to scale in the `z` axis
-
-    - returns: A `C4Transform` that can be used to rotate a receiver.
-    */
+    /// Applies a scale to the receiver. The `z` variable is optional.
+    ///
+    /// ````
+    /// let t = C4Transform()
+    /// t.scale(2.0, 2.0)
+    /// ````
+    ///
+    /// - parameter sx: The amount to scale in the `x` axis
+    /// - parameter sy: The amount to scale in the `y` axis
+    /// - parameter sz: The amount to scale in the `z` axis
+    ///
+    /// - returns: A `C4Transform` that can be used to rotate a receiver.
     public mutating func scale(sx: Double, _ sy: Double, _ sz: Double = 1) {
         let s = C4Transform.makeScale(sx, sy, sz)
         self = concat(self, t2: s)
     }
     
-    /** Applies a rotation. The `axis` component is optional.
-
-        let t = C4Transform()
-        t.rotate(M_PI)
-    
-    - parameter angle: The angle, in radians, to rotate
-    - parameter axis: The axis around which to rotate, defaults to the z axis {0,0,1}
-    */
+    /// Applies a rotation. The `axis` component is optional.
+    ///
+    /// ````
+    /// let t = C4Transform()
+    /// t.rotate(M_PI)
+    /// ````
+    ///
+    /// - parameter angle: The angle, in radians, to rotate
+    /// - parameter axis: The axis around which to rotate, defaults to the z axis {0,0,1}
     public mutating func rotate(angle: Double, axis: C4Vector = C4Vector(x: 0, y: 0, z: 1)) {
         let r = C4Transform.makeRotation(angle, axis: axis)
         self = concat(self, t2: r)
     }
-
-    /** The CGAffineTransform version of the receiver.
-    
-    - returns: A `CGAffineTransform` that is equivalent to the receiver.
-    */
+    
+    /// The CGAffineTransform version of the receiver.
+    ///
+    /// - returns: A `CGAffineTransform` that is equivalent to the receiver.
     public var affineTransform: CGAffineTransform {
         return CGAffineTransform(
             a:  CGFloat(self[0, 0]),

            self[3, 1] = newValue.y
        }
    }

    /** Creates a transform that represents a translation in 2d (x,y)
    
        let v = C4Vector(x: 1, y: 1)
        let t = C4Transform.makeTranslation(v)
    
    - parameter translation: A `C4Vector` that represents the translation to apply.

    - returns: A `C4Transform` that can be used to apply a translation to a receiver.
    */
    public static func makeTranslation(translation: C4Vector) -> C4Transform {
        var t = C4Transform()
        t[3, 0] = translation.x
        t[3, 1] = translation.y
        return t
    }

    /** Creates a transform that represents a scale in 3d (x, y, z). The `z` component is optional.
    
        let t = C4Transform.makeScale(2.0, 2.0)

    - parameter sx: The amount to scale in the `x` axis
    - parameter sy: The amount to scale in the `y` axis
    - parameter sz: The amount to scale in the `z` axis

    - returns: A `C4Transform` that can be used to scale a receiver.
    */
    public static func makeScale(sx: Double, _ sy: Double, _ sz: Double = 1) -> C4Transform {
        var t = C4Transform()
        t[0, 0] = sx

        self[0, 3] = Double(t.tx)
        self[1, 3] = Double(t.ty)
    }
    
    /// Creates a new transform from a `CATransform3D` structure.
    ///
    /// - parameter t: A `CATransform3D` structure.
    public init(_ t: CATransform3D) {
        self[0, 0] = Double(t.m11)
        self[0, 1] = Double(t.m12)
