ScalaDays 2014 - Reactive Scala 3D Game Engine

1
A Reactive 3D Game Engine in Scala
Aleksandar Prokopec
@_axel22_

6
Demo first!
http://youtu.be/pRCzSRhifLs

7
Input Simulator
Interaction
Renderer

Reactive Collections
http://reactive-collections.com
8

val ticks: Reactive[Long]
11
ticks 1
1
2
2
3
3
4
4
60
60
61
61

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
...

ticks foreach { x =>
}
13
1 2 3 4 60 61

14
for (x <- ticks) {
}

for (x <- ticks) yield {
x / 60
}
16

val seconds: Reactive[Long] =
x / 60
}
17

6061
val seconds: Reactive[Long] =
x / 60
}
18
ticks 1
1
2
2
3
3 60 61
seconds
0 0 0 1 1
ticks
seconds
00011

val days: Reactive[Long] =
seconds.map(_ / 86400)
19

val secondsToday =
20

val secondsToday =
(seconds zip days) {
(s, d) =>
s – d * 86400
} 21

val secondsToday =
(seconds zip days) {
_ – _ * 86400
}
22
seconds days
secondsToday

val angle =
secondsInDay.map(angleFunc)
23

val angle =
secondsInDay.map(angleFunc)
val light =
secondsInDay.map(lightFunc)
24

25
https://www.youtube.com/watch?v=5g7DvNEs6K8&feature=youtu.be
Preview

26
val rotate =
keys
a ↓shift ↓ a ↑ shift ↑pgup ↓ pgup ↑keys

27
val rotate =
keys.filter(_ == PAGEUP)
pgup ↓ pgup ↑filter

28
val rotate =
.map(_.down)
pgup ↓ pgup ↑filter
true falsemap

29
if (rotate()) viewAngle += 1
true falsemap

33
trait Signal[T]
extends Reactive[T] {
def apply(): T
}

34
val rotate =
.map(_.down)
.signal(false)
true falsemap
signal

35
val rotate: Signal[Boolean] =
.map(_.down)
.signal(false)
true falsemap
signal

36
val rotate: Signal[Boolean]
ticks

37
ticks
rotate

38
val viewAngle: Signal[Double] =
ticks
rotate
viewAngle

39
List(1, 2, 3).scanLeft(0)(_ + _)

40
List(1, 2, 3).scanLeft(0)(_ + _)
→ List(0, 1, 3, 6)

41
def scanLeft[S](z: S)(f: (S, T) => S)
: List[S]

42
def scanLeft[S](z: S)(f: (S, T) => S)
: List[S]
def scanPast[S](z: S)(f: (S, T) => S)
: Signal[S]

43
ticks.scanPast(0.0)
ticks
rotate
viewAngle

44
ticks.scanPast(0.0) {
(a, _) =>
if (rotate()) a + 1 else a
}
ticks
rotate
viewAngle

45
http://youtu.be/blG95W5uWQ8
Preview

46
val velocity =
(v, _) =>
}
val viewAngle =

47
val velocity =
(v, _) =>
if (rotate()) v + 1
}
val viewAngle =

48
val velocity =
(v, _) =>
if (rotate()) v + 1
else v – 0.5
}
val viewAngle =

49
val velocity =
(v, _) =>
if (rotate()) v + 1
else v – 0.5
}
val viewAngle =
velocity.scanPast(0.0)(_ + _)

50
http://youtu.be/NMVhirZLWmA
Preview

51
Higher-order
reactive values

52
(T => S) => (List[S] => List[T])

53
(T => S) => (List[S] => List[T])
Reactive[Reactive[S]]

54
val mids = mouse
.filter(_.button == MIDDLE)
mids ↓ ↓ ↓↑ ↑ ↑

55
val mids = mouse
val up = mids.filter(!_.down)
val down = mids.filter(_.down)
mids ↓ ↓ ↓
up
down ↓ ↓ ↓
↑ ↑ ↑
↑ ↑ ↑

56
val mids = mouse
val drags = down
.map(_ => mouse)
up
down ↓ ↓ ↓
↑ ↑ ↑

57
val mids = mouse
val drags = down
.map(_ => mouse)
up
down ↓ ↓ ↓
↑ ↑ ↑
Reactive[Reactive[MouseEvent]]

58
val mids = mouse
val drags = down
.map(_ => mouse)
up
down ↓ ↓ ↓
↑ ↑ ↑
drags

drags
up ↑ ↑ ↑
59
val mids = mouse
val drags = down
.map(_ => mouse.until(up))
down ↓ ↓ ↓
mouse.until(up)

60
val mids = mouse
val drags = down
down ↓ ↓ ↓
up ↑ ↑ ↑
drags

61
val drags = down
.map(_.map(_.xy))
drags
1, 1
2, 3
3, 5
4, 6
6, 9
9, 9

62
val drags = down
.map(_.map(_.xy))
.map(_.diffPast(_.xy - _.xy))
drags
0, 0
1, 2
1, 2
0, 0
2, 3
0, 0

63
val drags = down
.map(_.map(_.xy))
.concat()
drags 0, 0 1, 2 1, 2 0, 0 2, 3 0, 0

64
val drags = down
.map(_.map(_.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
http://youtu.be/RsMSZ7OH2fo
Preview
However, a lot of object
allocations lead to GC issues.

67
class Matrix {
def apply(x: Int, y: Int): Double
def update(x: Int, y: Int, v: Double)
}

68
val screenMat: Signal[Matrix] =
(projMat zip viewMat)(_ * _)
val invScreenMat =
screenMat.map(_.inverse)

69
Reactive[immutable.Matrix[T]]

70
val screenMat: Signal[Matrix] =
(projMat zip viewMat)(_ * _)
val invScreenMat =
screenMat.map(_.inverse)
(4*4*8 + 16 + 16)*4*100 = 64 kb/s

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)
}

73
http://youtu.be/ebbrAHNsexc
Preview
How do we model that a
character is selected?

74
val selected: Reactive[Set[Character]]

75
val selected: ReactSet[Character]

76
trait ReactSet[T]
extends ReactContainer[T] {
def apply(x: T): Boolean
}

77
trait ReactContainer[T] {
def inserts: Reactive[T]
def removes: Reactive[T]
}

78
A reactive collection
is a pair
of reactive values

79
val selected =
new ReactHashSet[Character]

81
val selected =
val decorations = selected
.map(c => (c, decoFor(c)))

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
val selected =
.to[ReactHashMap]

85
val selected =
.to[ReactHashMap]

86
val selected =
.to[ReactHashMap]

87
val selected =
.to[ReactHashMap]

88
val selected =
.react.to[ReactHashMap]

89
val selected =

90
val selected =

91
val selected =

92
• reactive mutators
• reactive collections
• @specialized
• Scala Macros
• shipping computations to the GPU

93
http://storm-enroute.com/macrogl/
MacroGL

94
https://www.youtube.com/watch?v=UHCeXdxkx70
GC Preview

ScalaDays 2014 - Reactive Scala 3D Game Engine

More Related Content

What's hot

Viewers also liked

Similar to ScalaDays 2014 - Reactive Scala 3D Game Engine

More from Aleksandar Prokopec

Recently uploaded

ScalaDays 2014 - Reactive Scala 3D Game Engine