Merge pull request #2 from littlektframework/0.3

0.3

Author: LeHaine

_docs/2d/animations.md

@@ -47,6 +47,10 @@ Creating an `AnimationPlayer` expects a type parameter as well. This needs to ma
 **Playing an animation in a loop:**
 
 ```kotlin
+val batch = SpriteBatch(this)
+val viewport = ExtendViewport(480, 270)
+val camera = viewport.camera
+
 val atlas: TextureAtlas = resourcesVfs["tiles.atlas.json"].readAtlas()
 val heroRun: Animation<TextureSlice> = atlas.getAnimation("heroRun")
 
@@ -56,12 +60,22 @@ anim.playLooped(heroRun)
 onRender { dt ->
     gl.clear(ClearBufferMask.COLOR_BUFFER_BIT)
     anim.update(dt) // handles requesting the next frames in the current animation
+    camera.update()
+    batch.use(camera.viewProjection) { batch ->
+        anim.currentKeyFrame?.let { // use the current key frame of the animation to render
+            batch.draw(it, 50f, 50f, scaleX = 5f, scaleY = 5f)
+        }
+    }
 }
 ```
 
 **Playing an animation a specific amount of times:**
 
 ```kotlin
+val batch = SpriteBatch(this)
+val viewport = ExtendViewport(480, 270)
+val camera = viewport.camera
+
 val atlas: TextureAtlas = resourcesVfs["tiles.atlas.json"].readAtlas()
 val heroRun: Animation<TextureSlice> = atlas.getAnimation("heroRun")
 val heroIdle: Animation<TextureSlice> = atlas.getAnimation("heroIdle")
@@ -73,6 +87,12 @@ anim.play(heroIdle, times = 5) // stops after 5 play throughs
 onRender { dt ->
     gl.clear(ClearBufferMask.COLOR_BUFFER_BIT)
     anim.update(dt)
+    camera.update()
+    batch.use(camera.viewProjection) { batch ->
+        anim.currentKeyFrame?.let {
+            batch.draw(it, 50f, 50f, scaleX = 5f, scaleY = 5f)
+        }
+    }
 }
 ```
 
@@ -84,7 +104,7 @@ val heroRun: Animation<TextureSlice> = atlas.getAnimation("heroRun")
 
 val anim = AnimaationPlayer<TextureSlice>().apply {
     onFrameChange = { index ->
-        if(index == 2) {
+        if (index == 2) {
             // do something
         }
     }
@@ -104,3 +124,78 @@ anim.playLooped(heroRun)
 
 anim.stop() // stops the current animation from playing
 ```
+
+### Registering Animation States
+
+Instead of having to handle playing animations manually we can register a state with a predicate that will automatically trigger the animation to play. Each state has a `priority` as well as a `predicate` that needs to return `true` in order to trigger. An animation with a higher `priority` will play over an animation with a lower `priority`.
+
+```kotlin
+val batch = SpriteBatch(this)
+val viewport = ExtendViewport(480, 270)
+val camera = viewport.camera
+
+val atlas: TextureAtlas = resourcesVfs["tiles.atlas.json"].readAtlas()
+val anim = AnimationPlayer<TextureSlice>()
+val atlas = resourcesVfs["tiles.atlas.json"].readAtlas()
+val heroSleep = atlas.getAnimation("heroSleeping")
+val heroSlingShot = atlas.getAnimation("heroSlingShot")
+val heroIdle = atlas.getAnimation("heroIdle", 250.milliseconds)
+val heroWakeup = atlas.getAnimation("heroWakeUp")
+val heroRun = atlas.getAnimation("heroRun")
+val heroRoll = atlas.getAnimation("heroRoll", 250.milliseconds)
+
+var shouldSleep = false
+var shouldWakeup = false
+var shouldRun = false
+var shouldRoll = false
+
+anim.apply {
+    // register all the animation states here.
+    registerState(heroRoll, 11) { shouldRoll }
+    registerState(heroWakeup, 10) { shouldWakeup }
+    registerState(heroRun, 5) { shouldRun }
+    registerState(heroSleep, 5) { shouldSleep }
+    registerState(heroIdle, 0) // returns true by default.
+}
+
+
+onRender { dt ->
+    gl.clearColor(Color.CLEAR)
+    gl.clear(ClearBufferMask.COLOR_BUFFER_BIT)
+
+    if (input.isKeyJustPressed(Key.NUM1)) {
+        shouldSleep = !shouldSleep
+    }
+
+    if (input.isKeyJustPressed(Key.NUM2)) {
+        shouldWakeup = !shouldWakeup
+    }
+
+    if (input.isKeyJustPressed(Key.NUM3)) {
+        shouldRun = !shouldRun
+    }
+
+    if (input.isKeyJustPressed(Key.NUM4)) {
+        shouldRoll = !shouldRoll
+    }
+
+    if (input.isKeyJustPressed(Key.ENTER)) {
+        // we can play an animation over any current animation state
+        anim.play(heroSlingShot)
+    }
+
+    if(input.isKeyJustPressed(Key.SPACE)) {
+        // we can play an animation over any current animation state
+        anim.play(heroRoll, 2.seconds)
+    }
+
+
+    anim.update(dt)
+    camera.update()
+    batch.use(camera.viewProjection) { batch ->
+        anim.currentKeyFrame?.let {
+            batch.draw(it, 50f, 50f, scaleX = 5f, scaleY = 5f)
+        }
+    }
+}
+```

_docs/2d/cameras-and-viewports.md

@@ -18,20 +18,16 @@ The camera allows us to:
 
 ### Orthographic Camera
 
-By default, a _Camera_ uses the default implementation of _Viewport_. This will stretch and shrink the items that are rendered on screen unless we change the cameras viewport to something else.
+By default, a _Camera_ doesn't contain or use a _Viewport_. It contains two properties that can be used to calculate the `projection` matrix: `virtualWidth` and `virtualHeight`.
 
 ```kotlin
-val camera = OrthographicCamera(graphics.width, graphics.height).apply {
-    viewport = ScreenViewport(graphics.width, graphics.height)
-}
+val camera = OrthographicCamera(graphics.width, graphics.height)
 ```
 
 When using a camera we want to make sure we call the `update()` method on it before doing any rendering to ensure it updates that its matrices are up to date. We then can use the `viewProjection` matrix in the _Camera_ class to render to a [SpriteBatch](/docs/2d/spritebatch).
 
 ```kotlin
-val camera = OrthographicCamera(graphics.width, graphics.height).apply {
-    viewport = ScreenViewport(graphics.width, graphics.height)
-}
+val camera = OrthographicCamera(graphics.width, graphics.height)
 
 onRender {
     gl.clear(ClearBufferMask.COLOR_BUFFER_BIT)
@@ -43,30 +39,25 @@ onRender {
 }
 ```
 
-We can also update the _Viewport_ of the _Camera_ when the game window resizes:
+We can also update the `virtualWidth` and `virtualHeight` of the _Camera_ when the game window resizes:
 
 ```kotlin
 onResize { width, height ->
-    // this will update the viewport size and update the cameras matrices
-    camera.update(width, height, context)
+    camera.virtualWidth = width
+    camera.virtualHeight = height
 }
 ```
 
 ## Using a Viewport
 
-When using a _Camera_, we are already indirectly using a _Viewport_. A _Camera_ manages its own _Viewport_ and can be manipulated directly on the camera itself.
+Instead of managing the size of the camera ourselves, we can use a _Viewport_ instead to handle the sizing. When creating a new _Viewport_ we can either pass in our own _Camera_ instance or let the viewport create its own which we then can reference.
 
 ```kotlin
-// this will update the internal viewport to the following virtual sizes
-camera.virtualWidth = 480
-camera.virtualHeight = 270
-
-
-viewport.virtualWidth = 480
-viewport.virtualHeight = 480
+val viewport = ExtendViewport(480, 270)
+val camera: OrthographicCamera = viewport.camera
 ```
 
-Resizing a viewport is also done in the _Camera_ class but can also be done directly on the _Viewport_ itself:
+A viewport can be resized by using the `update()` method which will also update the _Camera_ instance:
 
 ```kotlin
 onResize { width, height ->
@@ -85,12 +76,6 @@ viewport2.apply(context)
 // draw using the second viewport
 ```
 
-If we are using a _Camera_ we can access the _Viewport_ directly:
-
-```kotlin
-camera.viewport.apply(context)
-```
-
 ## Types of Viewports
 
 ### Stretch Viewport

_docs/overview/context-and-contextlistener.md

@@ -13,17 +13,21 @@ To get access to a `Context` instance we can create a [ContextListener](https://
 
 As stated above, the context contains all the references to the actual "meat" of LittleKt. The `Context` itself is just an interface that is implemented for each target platform. Through the access we can poll for input, add input processors, access the virtual file system, load assets through resources, store data, and even determine what platform it is currently running on run.
 
-The context also provides creating callbacks for certain events such as rendering, resizing, and disposing. We can add as many callbacks as we needed. They will be called in the order they were added.
+The context also provides creating callbacks for certain events such as rendering, resizing, and disposing. We can add as many callbacks as we needed. They will be called in the order they were added. Anytime we subscribe to an event, it returns a callback that we can invoke to unsubscribe.
 
 ```kotlin
 override suspend fun Context.start() {
-    onRender { dt ->
+    val unsubscribeRender = onRender { dt ->
         // render logic
         gl.clear(ClearBufferMask.COLOR_BUFFER_BIT)
     }
 
     onPostRender { dt ->
         // the same as render but runs after any render callbacks
+
+        if (input.isKeyJustPressed(Keys.ENTER)) {
+            unsubscribeRender() // we removed the render callback!
+        }
     }
 
     onResize { width, height ->

_docs/scene-graph/creating-a-scene.md

@@ -82,12 +82,12 @@ onRender { dt ->
 
     // we will need to make if we do other rendering with another camera / viewport
     // that we call GL.viewport using viewport.apply(context)
-    camera.viewport.apply(context)
+    viewport.apply(context)
     camera.update()
 }
 
 onResize { width, height ->
-    camera.update(width, height, context)
+    viewport.update(width, height, context)
     scene.resize(width, height)
 }