Presentation for iOSDC 2017

1. Swift
by Ray Fix for iOSDC

2. Ray Fix
Photo by Renato Sanchez Lozada on Unsplash
iOSDC

3. RayWenderlich.com
Ray Ray Wenderlich 😉

4. REVOLVE

5. REVOLVE

6. Swift

7. Swift Python R

8. •
• Swift

9. •
• Swift

10. •
• Swift

11. WWDC 2017 — fox2
https://developer.apple.com/videos/play/wwdc2017/604/

12. WWDC 2017 — fox2
https://developer.apple.com/videos/play/wwdc2017/604/

13. WWDC 2017 — ARKit
https://developer.apple.com/videos/play/wwdc2017/602/

14. WWDC 2017 — ARKit
https://developer.apple.com/videos/play/wwdc2017/602/

15. Fall 2017 — ARFaceAnchor
https://developer.apple.com/documentation/arkit/arfaceanchor?changes=latest_beta

16. I❤Swift

17. I❤Swift
https://github.com/rayfix/TypedTransforms

20. degrees radians

21. protocol AngleProtocol {
}
associatedtype TT

22. protocol AngleProtocol {
}
associatedtype T

23. protocol AngleProtocol {
}
associatedtype Real

24. protocol AngleProtocol {
}
associatedtype Real : FloatingPoint

25. AngleProtocol
protocol AngleProtocol {
associatedtype Real: FloatingPoint
init(radians: Real)
var radians: Real { set get }
}

26. (1)
extension AngleProtocol {
}

27. (1)
extension AngleProtocol {
}
static func +(lhs: Self, rhs: Self) -> Self {
return Self(radians: lhs.radians + rhs.radians)
}

28. (1)
extension AngleProtocol {
}
static func +=(lhs: inout Self, rhs: Self) {
lhs = lhs + rhs
}
static func +(lhs: Self, rhs: Self) -> Self {
return Self(radians: lhs.radians + rhs.radians)
}

29. (2)
extension AngleProtocol {
}

30. (2)
extension AngleProtocol {
}
static prefix func -(angle: Self) -> Self {
return Self(radians: -angle.radians)
}

31. (2)
extension AngleProtocol {
}
static prefix func -(angle: Self) -> Self {
return Self(radians: -angle.radians)
}
static func -(lhs: Self, rhs: Self) -> Self {
return lhs+(-rhs)
}

32. (2)
extension AngleProtocol {
}
static prefix func -(angle: Self) -> Self {
return Self(radians: -angle.radians)
}
static func -(lhs: Self, rhs: Self) -> Self {
return lhs+(-rhs)
}
static func -=(lhs: inout Self, rhs: Self) {
lhs = lhs - rhs
}

33. (3)
extension AngleProtocol {
}

34. (3)
extension AngleProtocol {
}
static func *(multiple: Real, angle: Self) -> Self {
return Self(radians: multiple * angle.radians)
}

35. (3)
extension AngleProtocol {
}
static func *(multiple: Real, angle: Self) -> Self {
return Self(radians: multiple * angle.radians)
}
static func *(angle: Self, multiple: Real) -> Self {
return multiple * angle
}

36. (3)
extension AngleProtocol {
}
static func *(multiple: Real, angle: Self) -> Self {
return Self(radians: multiple * angle.radians)
}
static func *(angle: Self, multiple: Real) -> Self {
return multiple * angle
}
static func /(angle: Self, divisor: Real) -> Self {
return angle * (1/divisor)
}

37. extension AngleProtocol: Hashable, Comparable {
} Stepanov, Alexander; McJones, Paul (2009). Elements of Programming. Addison-Wesley. ISBN 978-0-321-63537-2.

38. extension AngleProtocol: Hashable, Comparable {
}
static func ==(lhs: Self, rhs: Self) -> Bool {
return lhs.radians == rhs.radians
}
Stepanov, Alexander; McJones, Paul (2009). Elements of Programming. Addison-Wesley. ISBN 978-0-321-63537-2.

39. extension AngleProtocol: Hashable, Comparable {
}
static func ==(lhs: Self, rhs: Self) -> Bool {
return lhs.radians == rhs.radians
}
var hashValue: Int {
return radians.hashValue
}
Stepanov, Alexander; McJones, Paul (2009). Elements of Programming. Addison-Wesley. ISBN 978-0-321-63537-2.

40. extension AngleProtocol: Hashable, Comparable {
}
static func ==(lhs: Self, rhs: Self) -> Bool {
return lhs.radians == rhs.radians
}
var hashValue: Int {
return radians.hashValue
}
static func <(lhs: Self, rhs: Self) -> Bool {
return lhs.radians < rhs.radians
}
Stepanov, Alexander; McJones, Paul (2009). Elements of Programming. Addison-Wesley. ISBN 978-0-321-63537-2.

41. protocol AngleDegreesConvertible: AngleProtocol {
init(degrees: Real)
var degrees: Real { set get }
static var radiansToDegrees: Real { get }
}

42. (1)
extension AngleDegreesConvertible {
var degrees: Real {
get {
return radians * Self.radiansToDegrees
}
}
}

43. (1)
extension AngleDegreesConvertible {
var degrees: Real {
get {
return radians * Self.radiansToDegrees
}
}
}
radiansToDegrees

44. (1)
extension AngleDegreesConvertible {
var degrees: Real {
get {
return radians * Self.radiansToDegrees
}
}
}
radiansToDegrees
radiansToDegreesradians

45. (1)
extension AngleDegreesConvertible {
var degrees: Real {
get {
return radians * Self.radiansToDegrees
}
}
}
radiansToDegrees
radiansToDegrees degrees

46. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}

47. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}

48. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}
Inverse Transform

49. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}
ToDegreesradians
Inverse Transform

50. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}
ToDegrees radians
Inverse Transform
Radiansdegrees

51. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}

52. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}

53. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}
init(degrees: Real) {
let degreesToRadians = 1 / Self.radiansToDegrees
self.init(radians: degrees * degreesToRadians)
}

54. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}
init(degrees: Real) {
let degreesToRadians = 1 / Self.radiansToDegrees
self.init(radians: degrees * degreesToRadians)
}

55. (2)
init(degrees: Real) {
self.init(radians: degrees * Self.radiansToDegrees)
}
init(degrees: Real) {
let degreesToRadians = 1 / Self.radiansToDegrees
self.init(radians: degrees * degreesToRadians)
}

56. var degrees: Real {
set(newDegrees) {
let degreesToRadians = 1 / Self.radiansToDegrees
radians = newDegrees * degreesToRadians
}
}
(3)

57. var degrees: Real {
set(newDegrees) {
let degreesToRadians = 1 / Self.radiansToDegrees
radians = newDegrees * degreesToRadians
}
}
(3)

58. var degrees: Real {
set(newDegrees) {
let degreesToRadians = 1 / Self.radiansToDegrees
radians = newDegrees * degreesToRadians
}
}
(3)

59. To
🐶
🐕
🐩 😸
🐈
😽

60. To
🐶
🐕
🐩 😸
🐈
😽
To
🐶
🐕
🐩😸
🐈
😽

61. protocol AngleProtocol {
associatedtype Real:
init(radians: Real)
var radians: Real { set get }
}
FloatingPoint

62. protocol AngleProtocol {
associatedtype Real:
init(radians: Real)
var radians: Real { set get }
}
FloatingPoint

63. protocol AngleProtocol {
associatedtype Real:
init(radians: Real)
var radians: Real { set get }
}
TrigonometricFloatingPoint

64. protocol AngleProtocol {
associatedtype Real:
init(radians: Real)
var radians: Real { set get }
}
TrigonometricFloatingPoint
protocol TrigonometricFloatingPoint: FloatingPoint {
static func sine(radians: Self) -> Self
static func cosine(radians: Self) -> Self
}

65. sin

66. sin
func sin(_ angle: AngleProtocol) -> ???? {
}

67. sin
func sin(_ angle: AngleProtocol) -> ???? {
}

68. sin
func sin<A: AngleProtocol>(_ angle: A) -> A.Real {
return A.Real.sine(radians: angle.radians)
}
func sin(_ angle: AngleProtocol) -> ???? {
}

69. CGAngle
struct CGAngle: AngleDegreesConvertible {
var radians: CGFloat
static var radiansToDegrees: CGFloat {
return 180/CGFloat.pi
}
}
😍

70. CGAngle
struct CGAngle: AngleDegreesConvertible {
var radians: CGFloat
static var radiansToDegrees: CGFloat {
return 180/CGFloat.pi
}
}
😍

73. protocol Point2DProtocol {
associatedtype Scalar: FloatingPoint
init(_ x: Scalar, _ y: Scalar)
var x: Scalar { get set }
var y: Scalar { get set }
}

74. …
static func +(lhs: Self, rhs: Self) -> Self {
return Self(lhs.x + rhs.x, lhs.y + rhs.y)
}
static prefix func -(p: Self) -> Self {
return Self(-p.x, -p.y)
}
static func -(lhs: Self, rhs: Self) -> Self {
return lhs+(-rhs)
}
extension Point2DProtocol {
}

75. …
extension Point2DProtocol {
}
var lengthSquared: Scalar {
return self*self
}
var length: Scalar {
return lengthSquared.squareRoot()
}
func projected(on other: Self) -> Self {
return ((self*other)/(other*other))*other
}
🤠

76. extension CGPoint: Point2DProtocol {
public init(_ x: CGFloat, _ y: CGFloat) {
self.x = x
self.y = y
}
}
💯

77. let newPoint = transform * point
[ ]a
db
c
[x
y
]=[ax + cy
]bx + dy

78. let newPoint = transform * point
[ ]a
db
c
1
tx
ty
0 0 [x
y
1 ]=[ax + cy + tx
1 ]bx + dy + ty

80. CGAffineTransform

81. CGAffineTransform
Think Different

82. CGAffineTransform
Think Different
][ax + cy + tx 1bx + dy + ty
[ ]a
d
b
c
1tx ty
0
0
[x y 1
]=

83. let newPoint = transform * point
][ax + cy + tx 1bx + dy + ty
[ ]a
d
b
c
1tx ty
0
0
[x y 1
]=

84. let newPoint = transform * point
][ax + cy + tx 1bx + dy + ty
[ ]a
d
b
c
1tx ty
0
0
[x y 1
]=

85. let newPoint = transform * point
let newPoint = point * transform
][ax + cy + tx 1bx + dy + ty
[ ]a
d
b
c
1tx ty
0
0
[x y 1
]=

86. A
C
(0, 0)

87. A
C
(7, 7)
xa = (7, 7)
(0, 0)

88. A
C
(7, 7)
yc = xa * aToC
xa = (7, 7)
(0, 0)

89. A
C
(7, 7)
(1,0)
yc = xa * aToC
xa = (7, 7)
yc == (1, 0)
(0, 0)

90. A
C
(7, 7)
(1,0)
yc = xa * aToC
xa = (7, 7)
yc == (1, 0)
yc * aToC
(0, 0)

91. A
C
(7, 7)
(1,0)
yc = xa * aToC
xa = (7, 7)
yc == (1, 0)
yc * aToC
(0, 0)

92. A

93. A
B

94. A
C

95. A
C
aToB * bToC

96. A
C
aToB * bToC
aToC
=

97. [ ]1
10
0
1
0
0
tx ty [ ]sx
sy0
0
1
0
0
0 0 [ ]
cos a
cos a-sin a
sin a
1
0
0
0 0
translation scale rotation
[ ]1
10
0
1
0
0
0 0
identity
[ ]-1
10
0
1
0
0
0 0
horizontal flip
[ ]1
-10
0
1
0
0
0 0
vertical flip

98. ctm
[ ]2
-20
0
1
0
0
0 1096
userToDevice

99. CGAffineTransform
extension CGAffineTransform {
static func *(point: CGPoint, transform: CGAffineTransform)
-> CGPoint
{
return point.applying(transform)
}
static func *(lhs: CGAffineTransform, rhs: CGAffineTransform)
-> CGAffineTransform
{
return lhs.concatenating(rhs)
}
}
modelToDevice = modelToUser * userToDevice
devicePoint = userPoint * userToDevice

100. 2
let house: [CGPoint] = [CGPoint(1,-1),
CGPoint(1,1),
CGPoint(0,2),
CGPoint(-1,1),
CGPoint(-1,-1)]

101. 2
let house: [CGPoint] = [CGPoint(1,-1),
CGPoint(1,1),
CGPoint(0,2),
CGPoint(-1,1),
CGPoint(-1,-1)]
context.saveGState()
defer {
context.restoreGState()
}
let userToDevice = context.ctm
context.concatenate(userToDevice.inverted())

102. 2
let modelToUser =
CGAffineTransform(scaleX: 1, y: -1) *
CGAffineTransform(scaleX: 100, y: 100) *
CGAffineTransform(translationX: bounds.width/2,
y: bounds.height/2)

103. 2
let modelToUser =
CGAffineTransform(scaleX: 1, y: -1) *
CGAffineTransform(scaleX: 100, y: 100) *
CGAffineTransform(translationX: bounds.width/2,
y: bounds.height/2)
let modelToDevice = modelToUser * userToDevice
context.concatenate(modelToDevice)

104. 2
context.move(to: house.first!)
house.dropFirst().forEach { context.addLine(to: $0)}
context.closePath()
context.strokePath()

105. protocol CoordinateSpace {}
enum ModelSpace: CoordinateSpace {}
enum UserSpace: CoordinateSpace {}
enum DeviceSpace: CoordinateSpace {}

106. struct CGPointT<Space: CoordinateSpace>: Point2DProtocol {
var xy: CGPoint
:
}
let house: [CGPointT<ModelSpace>] = [CGPointT(1,-1),
CGPointT(1,1),
CGPointT(0,2),
CGPointT(-1,1),
CGPointT(-1,-1)]

107. struct CGAffineTransformT<From: CoordinateSpace,
To: CoordinateSpace>
{
var matrix: CGAffineTransform
public func inverted() -> CGAffineTransformT<To,From> {
return CGAffineTransformT<To,From>(matrix.inverted())
}
}

108. struct CGAffineTransformT<From: CoordinateSpace,
To: CoordinateSpace>
{
var matrix: CGAffineTransform
public func inverted() -> CGAffineTransformT<To,From> {
return CGAffineTransformT<To,From>(matrix.inverted())
}
}
public func * <From,To,I>(from: CGAffineTransformT<From, I>,
to: CGAffineTransformT<I, To>) ->
CGAffineTransformT<From, To>
{
return CGAffineTransformT<From,To>
(from.matrix.concatenating(to.matrix))
}

109. To
🐶
🐕
🐩 😸
🐈
😽

110. To
🐶
🐕
🐩 😸
🐈
😽
To
😸
🐈
😽
To
😸
🐈
😽

111. ARKit 3
SIMD
[ ]matrix_float4x4
[ ]float4
post multiply To
[ ]float4

112. ARKit 3
From
worldFromCameralet worldPoint = * cameraPoint

113. float4_t
struct float4_t<Space: CoordinateSpace> {
var point: float4
init(_ point: float4) {
self.point = point
}
}

114. matrix_float4x4_t
struct matrix_float4x4_t<To: CoordinateSpace,
From: CoordinateSpace> {
var matrix: matrix_float4x4
init(_ matrix: matrix_float4x4) {
self.matrix = matrix
}
}

115. extension matrix_float4x4_t {
static func *<To, From>(lhs: matrix_float4x4_t<To, From>,
rhs: float4_t<From>) -> float4_t<To>
{
return float4_t<To>(lhs.matrix * rhs.point)
}
}

116. transform

117. transform

118. transform
cameraFromWorld
worldFromCamera

119. transform
cameraFromWorld
worldFromCamera

121. final class TypedTransforms<Base> {
let base: Base
init(_ base: Base) {
self.base = base
}
}

122. final class TypedTransforms<Base> {
let base: Base
init(_ base: Base) {
self.base = base
}
}
protocol TypedTransformAdditions {
associatedtype Typed
var typed: Typed { get }
}

123. final class TypedTransforms<Base> {
let base: Base
init(_ base: Base) {
self.base = base
}
}
protocol TypedTransformAdditions {
associatedtype Typed
var typed: Typed { get }
}
extension TypedTransformAdditions {
var typed: TypedTransforms<Self> {
return TypedTransforms(self)
}
}

125. extension ARCamera: TypedTransformAdditions {}

126. extension TypedTransforms where Base: ARCamera {
var worldFromCamera: matrix_float4x4_t<WorldSpace,
CameraSpace>
{
return matrix_float4x4_t(base.transform)
}
}
extension ARCamera: TypedTransformAdditions {}

127. let worldFromCamera =
frame.camera.typed.worldFromCamera

128. let shotDirectionCamera =
float4_t<CameraSpace>(float4(0, 0, -3, 1))
let shotDirectionWorld = worldFromCamera *
shotDirectionCamera
let direction =
SCNVector3(float4: shotDirectionWorld.point)
let worldFromCamera =
frame.camera.typed.worldFromCamera

129. let position =
SCNVector3(float4: worldFromCamera.matrix.columns.3)
[ ]
matrix_float4x4
tx
ty
tz
1
0 21 3

130. let ball = Ball()
ball.position = position
ball.physicsBody?.applyForce(direction,
asImpulse: true)
sceneView.scene.rootNode.addChildNode(ball)