A Reactive 3D Game Engine in Scala

Most modern 3D game engines are written close to the metal in C++ to achieve smooth performance and stunning. Managed languages and runtimes are usually avoided for this task since they incur garbage collection lags and other performance penalties.

We decided to put this conventional wisdom to test with an experiment - we used an Rx-style reactive programming framework enriched with reactive collections and isolates in unison with a high-level OpenGL framework to build a modern 3D engine.

Game engines are traditionally written in low-level imperative style to achieve optimal performance. Such code can be hard to understand and maintain - the uprising reactive programming is much more natural for writing games, since game engines are in essence discrete event simulations. However, reactive programming comes with performance penalties that we overcome using Scala Specialization, inlining and efficient reactive data containers. Similarly, the OpenGL API exposes a plethora of low-level routines unfit for large scale development - a more structured approach to graphics programming with higher level programming abstractions is desired, but yields a higher performance cost. Through the use of Scala Macros we eliminate these inefficiencies while in the same time retaining the advantages of a structured graphics programming framework.

Result? A high-throughput reactive 3D real-time game engine achieving smooth 60FPS on modern hardware with high polygon counts, texture blending, GPU-based object instancing, and effects like ambient occlusion, shadow mapping and image filtering.

Transcript

1. 1 A Reactive 3D Game Engine in Scala Aleksandar Prokopec @_axel22_
2. 2 What’s a game engine?
3. 3 Simulation
4. 4 Real-time simulation
5. 5 15 ms Real-time simulation
6. 6 Demo first! http://youtu.be/pRCzSRhifLs
7. 7 Input Simulator Interaction Renderer
8. Reactive Collections http://reactive-collections.com 8
9. 9 Reactive values
10. Reactive[T] 10
11. val ticks: Reactive[Long] 11 ticks 1 1 2 2 3 3 4 4 60 60 61 61
12. ticks onEvent { x => log.debug(s”tick no.$x”) } 12 1 2 3 4 60 61 tick no.1 tick no.2 tick no.3 tick no.4 tick no.60 tick no.61 ...
13. ticks foreach { x => log.debug(s”tick no.$x”) } 13 1 2 3 4 60 61
14. 14 for (x <- ticks) { log.debug(s”tick no.$x”) }
15. 15 Reactive combinators
16. for (x <- ticks) yield { x / 60 } 16
17. val seconds: Reactive[Long] = for (x <- ticks) yield { x / 60 } 17
18. 60 61 val seconds: Reactive[Long] = for (x <- ticks) yield { x / 60 } 18 ticks 1 1 2 2 3 3 60 61 seconds 0 0 0 1 1 ticks seconds 0 0 0 1 1
19. val days: Reactive[Long] = seconds.map(_ / 86400) 19
20. val days: Reactive[Long] = seconds.map(_ / 86400) val secondsToday = 20
21. val days: Reactive[Long] = seconds.map(_ / 86400) val secondsToday = (seconds zip days) { (s, d) => s – d * 86400 } 21
22. val days: Reactive[Long] = seconds.map(_ / 86400) val secondsToday = (seconds zip days) { _ – _ * 86400 } 22 seconds days secondsToday
23. val angle = secondsInDay.map(angleFunc) 23
24. val angle = secondsInDay.map(angleFunc) val light = secondsInDay.map(lightFunc) 24
25. 25 https://www.youtube.com/watch?v=5g7DvNEs6K8&feature=youtu.be Preview
26. 26 val rotate = keys a ↓ shift ↓ a ↑ shift ↑ pgup ↓ pgup ↑ keys
27. 27 val rotate = keys.filter(_ == PAGEUP) a ↓ shift ↓ a ↑ shift ↑ pgup ↓ pgup ↑ keys pgup ↓ pgup ↑ filter
28. 28 val rotate = keys.filter(_ == PAGEUP) .map(_.down) a ↓ shift ↓ a ↑ shift ↑ pgup ↓ pgup ↑ keys pgup ↓ pgup ↑ filter true false map
29. 29 if (rotate()) viewAngle += 1 true false map
30. 30 Signals
31. 31 Reactives are discrete
32. 32 Signals are continuous
33. 33 trait Signal[T] extends Reactive[T] { def apply(): T }
34. 34 val rotate = keys.filter(_ == PAGEUP) .map(_.down) .signal(false) true false map signal
35. 35 val rotate: Signal[Boolean] = keys.filter(_ == PAGEUP) .map(_.down) .signal(false) true false map signal
36. 36 val rotate: Signal[Boolean] val ticks: Reactive[Long] ticks
37. 37 val rotate: Signal[Boolean] val ticks: Reactive[Long] ticks rotate
38. 38 val rotate: Signal[Boolean] val ticks: Reactive[Long] val viewAngle: Signal[Double] = ticks rotate viewAngle
39. 39 List(1, 2, 3).scanLeft(0)(_ + _)
40. 40 List(1, 2, 3).scanLeft(0)(_ + _) → List(0, 1, 3, 6)
41. 41 def scanLeft[S](z: S)(f: (S, T) => S) : List[S]
42. 42 def scanLeft[S](z: S)(f: (S, T) => S) : List[S] def scanPast[S](z: S)(f: (S, T) => S) : Signal[S]
43. 43 val rotate: Signal[Boolean] val ticks: Reactive[Long] val viewAngle: Signal[Double] = ticks.scanPast(0.0) ticks rotate viewAngle
44. 44 val rotate: Signal[Boolean] val ticks: Reactive[Long] val viewAngle: Signal[Double] = ticks.scanPast(0.0) { (a, _) => if (rotate()) a + 1 else a } ticks rotate viewAngle
45. 45 http://youtu.be/blG95W5uWQ8 Preview
46. 46 val velocity = ticks.scanPast(0.0) { (v, _) => } val viewAngle =
47. 47 val velocity = ticks.scanPast(0.0) { (v, _) => if (rotate()) v + 1 } val viewAngle =
48. 48 val velocity = ticks.scanPast(0.0) { (v, _) => if (rotate()) v + 1 else v – 0.5 } val viewAngle =
49. 49 val velocity = ticks.scanPast(0.0) { (v, _) => if (rotate()) v + 1 else v – 0.5 } val viewAngle = velocity.scanPast(0.0)(_ + _)
50. 50 http://youtu.be/NMVhirZLWmA Preview
51. 51 Higher-order reactive values
52. 52 (T => S) => (List[S] => List[T])
53. 53 (T => S) => (List[S] => List[T]) Reactive[Reactive[S]]
54. 54 val mids = mouse .filter(_.button == MIDDLE) mids ↓ ↓ ↓ ↑ ↑ ↑
55. 55 val mids = mouse .filter(_.button == MIDDLE) val up = mids.filter(!_.down) val down = mids.filter(_.down) mids ↓ ↓ ↓ up down ↓ ↓ ↓ ↑ ↑ ↑ ↑ ↑ ↑
56. 56 val mids = mouse .filter(_.button == MIDDLE) val up = mids.filter(!_.down) val down = mids.filter(_.down) val drags = down .map(_ => mouse) up down ↓ ↓ ↓ ↑ ↑ ↑
57. 57 val mids = mouse .filter(_.button == MIDDLE) val up = mids.filter(!_.down) val down = mids.filter(_.down) val drags = down .map(_ => mouse) up down ↓ ↓ ↓ ↑ ↑ ↑ Reactive[Reactive[MouseEvent]]
58. 58 val mids = mouse .filter(_.button == MIDDLE) val up = mids.filter(!_.down) val down = mids.filter(_.down) val drags = down .map(_ => mouse) up down ↓ ↓ ↓ ↑ ↑ ↑ drags
59. drags up ↑ ↑ ↑ 59 val mids = mouse .filter(_.button == MIDDLE) val up = mids.filter(!_.down) val down = mids.filter(_.down) val drags = down .map(_ => mouse.until(up)) down ↓ ↓ ↓ mouse.until(up)
60. 60 val mids = mouse .filter(_.button == MIDDLE) val up = mids.filter(!_.down) val down = mids.filter(_.down) val drags = down .map(_ => mouse.until(up)) down ↓ ↓ ↓ up ↑ ↑ ↑ drags
61. 61 val drags = down .map(_ => mouse.until(up)) .map(_.map(_.xy)) drags 1, 1 2, 3 3, 5 4, 6 6, 9 9, 9
62. 62 val drags = down .map(_ => mouse.until(up)) .map(_.map(_.xy)) .map(_.diffPast(_.xy - _.xy)) drags 0, 0 1, 2 1, 2 0, 0 2, 3 0, 0
63. 63 val drags = down .map(_ => mouse.until(up)) .map(_.map(_.xy)) .map(_.diffPast(_.xy - _.xy)) .concat() drags 0, 0 1, 2 1, 2 0, 0 2, 3 0, 0
64. 64 val drags = down .map(_ => mouse.until(up)) .map(_.map(_.xy)) .map(_.diffPast(_.xy - _.xy)) .concat() val pos = drags.scanPast((0, 0))(_ + _) drags 0, 0 1, 2 1, 2 0, 0 2, 3 0, 0 pos 0, 0 1, 2 2, 4 2, 4 4, 7 4, 7
65. 65 http://youtu.be/RsMSZ7OH2fo Preview However, a lot of object allocations lead to GC issues.
66. 66 Reactive mutators
67. 67 class Matrix { def apply(x: Int, y: Int): Double def update(x: Int, y: Int, v: Double) }
68. 68 val screenMat: Signal[Matrix] = (projMat zip viewMat)(_ * _) val invScreenMat = screenMat.map(_.inverse)
69. 69 Reactive[immutable.Matrix[T]]
70. 70 val screenMat: Signal[Matrix] = (projMat zip viewMat)(_ * _) val invScreenMat = screenMat.map(_.inverse) (4*4*8 + 16 + 16)*4*100 = 64 kb/s
71. 71 val screenMat = Mutable(new Matrix) (projMat, viewMat).mutate(screenMat) { (p, v) => screenMat().assignMul(p, v) } val invScreenMat = Mutable(new Matrix) screenMat.mutate(invScreenMat) { m => invScreenMat().assignInv(m) }
72. 72 Reactive collections
73. 73 http://youtu.be/ebbrAHNsexc Preview How do we model that a character is selected?
74. 74 val selected: Reactive[Set[Character]]
75. 75 val selected: ReactSet[Character]
76. 76 trait ReactSet[T] extends ReactContainer[T] { def apply(x: T): Boolean }
77. 77 trait ReactContainer[T] { def inserts: Reactive[T] def removes: Reactive[T] }
78. 78 A reactive collection is a pair of reactive values
79. 79 val selected = new ReactHashSet[Character]
81. 81 val selected = new ReactHashSet[Character] val decorations = selected .map(c => (c, decoFor(c)))
83. 83 class ReactContainer[T] { self => def inserts: Reactive[T] def removes: Reactive[T] def map[S](f: T => S) = new ReactContainer[S] { def inserts: Reactive[T] = self.inserts.map(f) def removes: Reactive[T] = self.removes.map(f) } }
84. 84 val selected = new ReactHashSet[Character] val decorations = selected .map(c => (c, decoFor(c))) .to[ReactHashMap]
85. 85 val selected = new ReactHashSet[Character] val decorations = selected .map(c => (c, decoFor(c))) .to[ReactHashMap]
86. 86 val selected = new ReactHashSet[Character] val decorations = selected .map(c => (c, decoFor(c))) .to[ReactHashMap]
87. 87 val selected = new ReactHashSet[Character] val decorations = selected .map(c => (c, decoFor(c))) .to[ReactHashMap]
88. 88 val selected = new ReactHashSet[Character] val decorations = selected .map(c => (c, decoFor(c))) .react.to[ReactHashMap]
89. 89 val selected = new ReactHashSet[Character] val decorations = selected .map(c => (c, decoFor(c))) .react.to[ReactHashMap]
90. 90 val selected = new ReactHashSet[Character] val decorations = selected .map(c => (c, decoFor(c))) .react.to[ReactHashMap]
91. 91 val selected = new ReactHashSet[Character] val decorations = selected .map(c => (c, decoFor(c))) .react.to[ReactHashMap]
92. 92 • reactive mutators • reactive collections • @specialized • Scala Macros • shipping computations to the GPU
93. 93 http://storm-enroute.com/macrogl/ MacroGL
94. 94 https://www.youtube.com/watch?v=UHCeXdxkx70 GC Preview
95. 95 Is Scala Ready?
96. 96 YES!
97. 97 Thank you!