Update samples

game/asteroids/src/commonMain/kotlin/Assets.kt

@@ -0,0 +1,51 @@
+import com.soywiz.korim.bitmap.Bitmap32
+import com.soywiz.korim.bitmap.NativeImage
+import com.soywiz.korim.bitmap.context2d
+import com.soywiz.korim.color.Colors
+import com.soywiz.korma.geom.vector.LineCap
+import com.soywiz.korma.geom.vector.lineToV
+
+/**
+ * Holds bitmaps used in the game
+ */
+class Assets(val shipSize: Int = 24) {
+
+    private val asteroidSize = shipSize * 2
+
+    val shipBitmap = NativeImage(shipSize, shipSize).context2d {
+		lineWidth = 0.05
+		lineCap = LineCap.ROUND
+		stroke(Colors.WHITE) {
+			scale(shipSize)
+			moveTo(0.5, 0.0)
+			lineTo(1.0, 1.0)
+			lineTo(0.5, 0.8)
+			lineTo(0.0, 1.0)
+			close()
+		}
+	}
+
+    val bulletBitmap = NativeImage(3, (shipSize * 0.3).toInt()).context2d {
+		lineWidth = 1.0
+		lineCap = LineCap.ROUND
+		stroke(Colors.WHITE) {
+			moveTo(width / 2.0, 0.0)
+			lineToV(height.toDouble())
+		}
+	}
+
+    val asteroidBitmap = Bitmap32(asteroidSize, asteroidSize).context2d { // Let's use software vector rendering here for testing purposes
+		lineWidth = 0.05
+		lineCap = LineCap.ROUND
+		stroke(Colors.WHITE) {
+			scale(asteroidSize)
+			moveTo(0.0, 0.5)
+			lineTo(0.2, 0.0)
+			lineTo(0.7, 0.0)
+			lineTo(1.0, 0.5)
+			lineTo(0.7, 1.0)
+			lineTo(0.3, 1.0)
+			close()
+		}
+	}
+}

game/asteroids/src/commonMain/kotlin/Asteroid.kt

@@ -0,0 +1,44 @@
+import com.soywiz.klock.milliseconds
+import com.soywiz.korge.view.*
+import com.soywiz.korma.geom.*
+
+class Asteroid(
+    private val assets: Assets,
+    private val asteroidSize: Int = 3
+) : BaseImage(assets.asteroidBitmap) {
+
+	var angle = 30.degrees
+
+	init {
+		anchor(.5, .5)
+		scale = asteroidSize.toDouble() / 3.0
+		name = "asteroid"
+		speed = 0.6
+		addUpdater { time ->
+			val scale = time / 16.0.milliseconds
+			val dx = angle.cosine * scale
+			val dy = angle.sine * scale
+			x += dx
+			y += dy
+			rotation += scale.degrees
+			if (y < 0 && dy < 0) angle += 45.degrees
+			if (x < 0 && dx < 0) angle += 45.degrees
+			if (x > WIDTH && dx > 0) angle += 45.degrees
+			if (y > HEIGHT && dy > 0) angle += 45.degrees
+		}
+	}
+
+	fun divide() {
+		if (asteroidSize > 1) {
+			Asteroid(assets, asteroidSize - 1).xy(x, y).addTo(parent!!).also {
+				it.angle = this.angle + 45.degrees
+				it.speed = this.speed * 1.5
+			}
+			Asteroid(assets, asteroidSize - 1).xy(x, y).addTo(parent!!).also {
+				it.angle = this.angle - 45.degrees
+				it.speed = this.speed * 1.5
+			}
+		}
+		removeFromParent()
+	}
+}

game/asteroids/src/commonMain/kotlin/Game.kt

@@ -0,0 +1,155 @@
+import com.soywiz.klock.milliseconds
+import com.soywiz.korev.Key
+import com.soywiz.korev.dispatch
+import com.soywiz.korge.tween.get
+import com.soywiz.korge.tween.tween
+import com.soywiz.korge.view.*
+import com.soywiz.korim.color.Colors
+import com.soywiz.korio.async.launch
+import com.soywiz.korma.geom.*
+import com.soywiz.korma.random.get
+import kotlin.random.Random
+
+const val NUMBER_OF_ASTEROIDS = 15
+const val BULLET_SIZE = 14
+
+
+/**
+ * A single game state with all views and updaters (gets destroyed on game restart)
+ */
+class Game(val stage: Stage) {
+
+    /** A shortcut to check if a given key is pressed */
+    private fun Key.isPressed(): Boolean = stage.views.input.keys[this]
+
+    private var gameOver = false
+
+    private val ship = Ship()
+
+    init {
+        spawnRandomAsteroids(ship.image)
+    }
+
+    private val stageUpdater = stage.addUpdater { time ->
+
+        if (!gameOver) {
+            val scale = time / 16.0.milliseconds
+
+            if (ship.bulletReload > 0) ship.bulletReload -= scale
+
+            if (Key.LEFT.isPressed()) ship.image.rotation -= 3.degrees * scale
+            if (Key.RIGHT.isPressed()) ship.image.rotation += 3.degrees * scale
+            if (Key.UP.isPressed()) ship.image.advance(2.0 * scale)
+            if (Key.DOWN.isPressed()) ship.image.advance(-1.5 * scale)
+
+            if ((Key.LEFT_CONTROL.isPressed() || Key.SPACE.isPressed()) && ship.bulletReload <= 0) {
+                fireBullet()
+            }
+        } else {
+            if (Key.R.isPressed()) {
+                dispatch(GameRestartEvent())
+            }
+        }
+    }
+
+
+    private fun fireBullet() {
+
+        ship.bulletReload = 20.0
+
+        with(stage) {
+            val bullet = image(assets.bulletBitmap)
+                .center()
+                .position(ship.image.x, ship.image.y)
+                .rotation(ship.image.rotation)
+                .advance(assets.shipSize * 0.75)
+
+            bullet.onCollision {
+                if (it is Asteroid) {
+                    bullet.removeFromParent()
+                    it.divide()
+                }
+            }
+
+            bullet.addUpdater {
+                val scale = it / 16.milliseconds
+                bullet.advance(+3.0 * scale)
+                // If the bullet flies off the screen, discard it
+                if (bullet.x < -BULLET_SIZE || bullet.y < -BULLET_SIZE || bullet.x > WIDTH + BULLET_SIZE || bullet.y > HEIGHT + BULLET_SIZE) {
+                    bullet.removeFromParent()
+                }
+            }
+        }
+    }
+
+    private fun spawnRandomAsteroids(ship: Image) {
+        val random = Random
+        repeat(NUMBER_OF_ASTEROIDS) {
+            val asteroid = spawnAsteroid(0.0, 0.0)
+            do {
+                asteroid.x = random[0.0, WIDTH.toDouble()]
+                asteroid.y = random[0.0, HEIGHT.toDouble()]
+                asteroid.angle = random[0.0, 360.0].degrees
+            } while (asteroid.collidesWith(ship) || ship.distanceTo(asteroid) < 100.0)
+        }
+    }
+
+    private fun spawnAsteroid(x: Double, y: Double): Asteroid {
+        return Asteroid(stage.assets).addTo(stage).xy(x, y)
+    }
+
+    fun setGameOver() {
+        gameOver = true
+
+        ship.image.removeFromParent()
+
+        with(stage) {
+            // Display the Game Over overlay (with a momentary flash)
+            val overlay = solidRect(WIDTH, HEIGHT, Colors.YELLOW)
+            stage.launch {
+                overlay.tween(overlay::color[Colors.RED.withA(64)], time = 300.milliseconds)
+            }
+
+            val gameOverText = text("GAME OVER", 64.0)
+                .centerOnStage()
+
+            text("Press R to restart")
+                .centerXOnStage()
+                .alignTopToBottomOf(gameOverText, 10.0)
+        }
+    }
+
+    fun detach() {
+        stageUpdater.cancel(GameRestart)
+    }
+
+    // The ship controlled by the player
+    inner class Ship {
+        val image = with(stage) {
+            image(assets.shipBitmap)
+                .center()
+                .position(320, 240)
+        }
+
+        // A cooldown period to prevent bullet spamming
+        var bulletReload = 0.0
+
+        init {
+            image.onCollision {
+                if (it is Asteroid) {
+                    setGameOver()
+                }
+            }
+        }
+    }
+}
+
+fun View.distanceTo(other: View) = Point.distance(x, y, other.x, other.y)
+
+fun View.advance(amount: Double, rot: Angle = (-90).degrees) = this.apply {
+    x += (this.rotation + rot).cosine * amount
+    y += (this.rotation + rot).sine * amount
+}
+
+// A dummy throwable to cancel updatables
+object GameRestart : Throwable()

game/asteroids/src/commonMain/kotlin/GameHolder.kt

@@ -0,0 +1,36 @@
+import com.soywiz.klock.milliseconds
+import com.soywiz.korge.tween.get
+import com.soywiz.korge.tween.tween
+import com.soywiz.korge.view.Stage
+import com.soywiz.korge.view.solidRect
+import com.soywiz.korim.color.Colors
+import com.soywiz.korio.async.launchImmediately
+
+class GameHolder(private val stage: Stage) {
+
+    private var game = Game(stage)
+
+    // A flag to prevent multiple restarts from happening at the same time
+    private var restarting = false
+
+    fun restart() {
+        // TODO check if this code is thread-safe
+        if (restarting) return
+        restarting = true
+
+        stage.launchImmediately {
+            game.detach()
+
+            // Before restarting, display and wait for a fadeout overlay
+            val fadeoutOverlay = stage.solidRect(WIDTH, HEIGHT, color = Colors.BLACK.withA(0))
+            fadeoutOverlay.tween(fadeoutOverlay::color[Colors.BLACK], time = 500.milliseconds)
+
+            stage.removeChildren()
+
+            // Recreate the game
+            game = Game(stage)
+
+            restarting = false
+        }
+    }
+}

game/asteroids/src/commonMain/kotlin/main.kt

@@ -1,22 +1,18 @@
 import com.soywiz.kds.*
-import com.soywiz.klock.*
-import com.soywiz.klock.hr.*
 import com.soywiz.korev.*
 import com.soywiz.korge.*
 import com.soywiz.korge.view.*
-import com.soywiz.korim.bitmap.*
 import com.soywiz.korim.color.*
-import com.soywiz.korma.geom.*
-import com.soywiz.korma.geom.vector.*
-import com.soywiz.korma.random.*
-import kotlin.random.*
 
-val WIDTH = 640
-val HEIGHT = 480
 
-val SHIP_SIZE = 24
+const val WIDTH = 640
-val BULLET_SIZE = 14
+const val HEIGHT = 480
-val Stage.assets by Extra.PropertyThis<Stage, Assets> { Assets(views, SHIP_SIZE) }
+
+const val SHIP_SIZE = 24
+
+
+val Stage.assets by Extra.PropertyThis<Stage, Assets> { Assets(SHIP_SIZE) }
+
 
 suspend fun main() = Korge(
 	width = WIDTH, height = HEIGHT,
@@ -26,158 +22,12 @@ suspend fun main() = Korge(
 ) {
 	views.gameWindow.icon = assets.shipBitmap
 
-	val ship = image(assets.shipBitmap).center().position(320, 240)
+    val gameHolder = GameHolder(this)
 
-	fun pressing(key: Key) = views.input.keys[key]
+    addEventListener<GameRestartEvent> {
-
+        gameHolder.restart()
-	spawnAsteroid(WIDTH - 20.0, 20.0)
+    }
-
-	ship.onCollision {
-		if (it is Asteroid) {
-			//ship.removeFromParent()
-			println("GAME OVER!")
-		}
-	}
-
-	val random = Random(0)
-	for (n in 0 until 15) {
-		val asteroid = spawnAsteroid(0.0, 0.0)
-		do {
-			asteroid.x = random[0.0, WIDTH.toDouble()]
-			asteroid.y = random[0.0, HEIGHT.toDouble()]
-			asteroid.angle = random[0.0, 360.0].degrees
-		} while (asteroid.collidesWith(ship) || ship.distanceTo(asteroid) < 100.0)
-	}
-
-	var bulletReload = 0.0
-	addUpdater { time ->
-		val scale = time / 16.milliseconds
-		if (pressing(Key.LEFT)) ship.rotation -= 3.degrees * scale
-		if (pressing(Key.RIGHT)) ship.rotation += 3.degrees * scale
-		if (pressing(Key.UP)) ship.advance(2.0 * scale)
-		if (pressing(Key.DOWN)) ship.advance(-1.5 * scale)
-
-		if (bulletReload > 0) bulletReload -= 1 * scale
-
-		if (bulletReload <= 0 && pressing(Key.LEFT_CONTROL)) {
-			bulletReload = 20.0
-			val bullet = image(assets.bulletBitmap)
-				.center()
-				.position(ship.x, ship.y)
-				.rotation(ship.rotation)
-				.advance(assets.shipSize * 0.75)
-
-			bullet.onCollision {
-				if (it is Asteroid) {
-					bullet.removeFromParent()
-					it.divide()
-				}
-			}
-
-			fun bulletFrame(time: TimeSpan) {
-				val scale = time / 16.milliseconds
-				bullet.advance(+3.0 * scale)
-				if (bullet.x < -BULLET_SIZE || bullet.y < -BULLET_SIZE || bullet.x > WIDTH + BULLET_SIZE || bullet.y > HEIGHT + BULLET_SIZE) {
-					bullet.removeFromParent()
-				}
-			}
-
-			//launch {
-			//	while (true) {
-			//		bulletFrame()
-			//		bullet.delayFrame()
-			//	}
-			//}
-			bullet.addUpdater { bulletFrame(it) }
-		}
-	}
-
-	//image(shipBitmap)
 }
 
-class Asteroid(val assets: Assets, val asteroidSize: Int = 3) : BaseImage(assets.asteroidBitmap) {
-	var angle = 30.degrees
 
-	init {
+class GameRestartEvent : Event()
-		anchor(.5, .5)
-		scale = asteroidSize.toDouble() / 3.0
-		name = "asteroid"
-		speed = 0.6
-		addUpdater { time ->
-			val scale = time / 16.milliseconds
-			val dx = angle.cosine * scale
-			val dy = angle.sine * scale
-			x += dx
-			y += dy
-			rotation += scale.degrees
-			if (y < 0 && dy < 0) angle += 45.degrees
-			if (x < 0 && dx < 0) angle += 45.degrees
-			if (x > WIDTH && dx > 0) angle += 45.degrees
-			if (y > HEIGHT && dy > 0) angle += 45.degrees
-		}
-	}
-
-	fun divide() {
-		if (asteroidSize > 1) {
-			Asteroid(assets, asteroidSize - 1).xy(x, y).addTo(parent!!).also {
-				it.angle = this.angle + 45.degrees
-				it.speed = this.speed * 1.5
-			}
-			Asteroid(assets, asteroidSize - 1).xy(x, y).addTo(parent!!).also {
-				it.angle = this.angle - 45.degrees
-				it.speed = this.speed * 1.5
-			}
-		}
-		removeFromParent()
-	}
-}
-
-fun Stage.spawnAsteroid(x: Double, y: Double): Asteroid {
-	return Asteroid(assets).addTo(this).xy(x, y)
-	//solidRect(10.0, 20.0, Colors.RED).xy(20, 20)
-}
-
-fun View.distanceTo(other: View) = Point.distance(x, y, other.x, other.y)
-
-fun View.advance(amount: Double, rot: Angle = (-90).degrees) = this.apply {
-	x += (this.rotation + rot).cosine * amount
-	y += (this.rotation + rot).sine * amount
-}
-
-class Assets(val views: Views, val shipSize: Int = 24) {
-	val asteroidSize = shipSize * 2
-	val shipBitmap = NativeImage(shipSize, shipSize).context2d {
-		lineWidth = 0.05
-		lineCap = LineCap.ROUND
-		stroke(Colors.WHITE) {
-			scale(shipSize)
-			moveTo(0.5, 0.0)
-			lineTo(1.0, 1.0)
-			lineTo(0.5, 0.8)
-			lineTo(0.0, 1.0)
-			close()
-		}
-	}
-	val bulletBitmap = NativeImage(3, (shipSize * 0.3).toInt()).context2d {
-		lineWidth = 1.0
-		lineCap = LineCap.ROUND
-		stroke(Colors.WHITE) {
-			moveTo(width / 2.0, 0.0)
-			lineToV(height.toDouble())
-		}
-	}
-	val asteroidBitmap = NativeImage(asteroidSize, asteroidSize).context2d { // Let's use software vector rendering here, for testing purposes
-		lineWidth = 0.05
-		lineCap = LineCap.ROUND
-		stroke(Colors.WHITE) {
-			scale(asteroidSize)
-			moveTo(0.0, 0.5)
-			lineTo(0.2, 0.0)
-			lineTo(0.7, 0.0)
-			lineTo(1.0, 0.5)
-			lineTo(0.7, 1.0)
-			lineTo(0.3, 1.0)
-			close()
-		}
-	}
-}

gradle.properties

@@ -1,4 +1,5 @@
-korgePluginVersion=2.1.1.1
+#korgePluginVersion=2.1.1.1
+korgePluginVersion=2.1.1.2
 #korgePluginVersion=2.0.0.999
 
 web.bind.port=8080

samples/animations/src/commonMain/kotlin/main.kt

@@ -5,6 +5,7 @@ import com.soywiz.korim.color.*
 import com.soywiz.korge.animate.*
 import com.soywiz.korge.input.*
 import com.soywiz.korio.async.*
+import com.soywiz.korio.lang.*
 import kotlinx.coroutines.*
 
 suspend fun main() = Korge(width = 512, height = 512, virtualWidth = 512, virtualHeight = 512) {
@@ -14,26 +15,31 @@ suspend fun main() = Korge(width = 512, height = 512, virtualWidth = 512, virtua
 	var job: Job? = null
 
 	onClick {
-		job?.cancel()
+        //println("CLICK: ${it.button}")
+        if (it.button.isRight) {
+            job?.cancel(AnimateCancellationException(completeOnCancel = true))
+        } else {
+            job?.cancel(AnimateCancellationException(completeOnCancel = false))
+        }
 	}
 
 	while (true) {
 		job = launchImmediately {
-			//animate(completeOnCancel = false) {
+			animate(completeOnCancel = false) {
-			animate(completeOnCancel = true) {
+			//animate(completeOnCancel = true) {
 			//animate {
 				sequence(time = 1.seconds, speed = 256.0) {
-					wait(0.25.seconds)
+					//wait(0.25.seconds)
 					parallel {
 						//rect1.moveTo(0, 150)
-						rect1.moveToWithSpeed(512.0 - 100, 0.0)
+						rect1.moveToWithSpeed(width - 100, 0.0)
-						rect2.moveToWithSpeed(0.0, 512.0 - 100 - 100)
+						rect2.moveToWithSpeed(0.0, height - 100 - 100)
 						//rect1.moveTo(0, height - 100)
 					}
 					parallel {
 						//rect1.moveTo(0, 150)
-						rect1.moveTo(512.0 - 100, 512.0 - 100)
+						rect1.moveTo(width - 100, height - 100)
-						rect2.moveTo(512.0 - 100, 512.0 - 100)
+						rect2.moveTo(width - 100, height - 100)
 						//rect1.moveTo(0, height - 100)
 					}
 					parallel(time = 1.seconds) {
@@ -41,6 +47,8 @@ suspend fun main() = Korge(width = 512, height = 512, virtualWidth = 512, virtua
 						rect2.hide()
 					}
 					block {
+                        //printStackTrace()
+                        //println("ZERO")
 						rect1.position(0, 0)
 						rect2.position(0, 0)
 					}
@@ -48,11 +56,14 @@ suspend fun main() = Korge(width = 512, height = 512, virtualWidth = 512, virtua
 						rect1.show()
 						rect2.show()
 					}
+                    wait(0.25.seconds)
 				}
 			}
 		}
-		delay(3.seconds)
 		job.join()
+        //println("[a]")
+        //delay(1.seconds)
+        //println("[b]")
 		//job.cancel()
 	}
 }

samples/atlas/src/commonTest/kotlin/test.kt

@@ -1,6 +1,6 @@
 import com.soywiz.korge.tests.*
 import com.soywiz.korge.view.*
-import com.soywiz.korim.atlas.*
+import com.soywiz.korim.atlas.readAtlas
 import com.soywiz.korim.bitmap.*
 import com.soywiz.korio.async.*
 import com.soywiz.korio.file.std.*
@@ -8,21 +8,23 @@ import com.soywiz.korma.geom.*
 import kotlin.test.*
 
 class AtlasTest : ViewsForTesting() {
-	@Test
+    // @TODO: This fails. It is not generated?
-	fun test() = viewsTest {
-		atlasMain()
-		assertEquals(3, stage.numChildren)
-		assertEquals(Size(128, 256), (stage[0] as Image).bitmap.bmp.size)
-	}
 
-	@Test
+	//@Test
-	fun testAtlas() = suspendTest {
+	//fun test() = viewsTest {
-		val atlas = resourcesVfs["logos.atlas.json"].readAtlas()
+	//	atlasMain()
-		assertEquals(3, atlas.entries.size)
+	//	assertEquals(3, stage.numChildren)
-		assertEquals(Size(64, 64), atlas["korau.png"].size)
+	//	assertEquals(Size(68, 204), (stage[0] as Image).texture.bmp.size)
-		assertEquals(Size(64, 64), atlas["korge.png"].size)
+	//}
-		assertEquals(Size(64, 64), atlas["korim.png"].size)
+
-	}
+	//@Test
+	//fun testAtlas() = suspendTest {
+	//	val atlas = resourcesVfs["logos.atlas.json"].readAtlas()
+	//	assertEquals(3, atlas.entries.size)
+	//	assertEquals(Size(64, 64), atlas["korau.png"].size)
+	//	assertEquals(Size(64, 64), atlas["korge.png"].size)
+	//	assertEquals(Size(64, 64), atlas["korim.png"].size)
+	//}
 
 	private val BmpSlice.size get() = Size(width, height)
 }

samples/bezier/build.gradle.kts

@@ -1,4 +1,6 @@
-apply plugin: com.soywiz.korge.gradle.KorgeGradlePlugin
+import com.soywiz.korge.gradle.*
+
+apply<KorgeGradlePlugin>()
 
 korge {
 	id = "com.soywiz.samples.bezier"

samples/bezier/src/commonMain/kotlin/main.kt

@@ -8,9 +8,6 @@ import com.soywiz.korma.geom.*
 import com.soywiz.korma.geom.bezier.*
 import com.soywiz.korma.geom.vector.*
 
-val USE_NATIVE_RENDERING = true
-//val USE_NATIVE_RENDERING = false
-
 suspend fun main() = Korge(bgcolor = Colors["#111"], width = 300, height = 300) {
     val p0 = Point(109, 135)
     val p1 = Point(25, 190)
@@ -18,7 +15,8 @@ suspend fun main() = Korge(bgcolor = Colors["#111"], width = 300, height = 300)
     val p3 = Point(234, 49)
 
     val graphics = sgraphics {
-        useNativeRendering = USE_NATIVE_RENDERING
+        useNativeRendering = true
+        //useNativeRendering = false
     }
 
     fun updateGraphics() {
@@ -55,12 +53,8 @@ fun Container.createPointController(point: Point, color: Paint, onMove: () -> Un
     lateinit var circle: View
     lateinit var text: Text
     val anchorView = container {
-        circle = circle(6.0, fill = color, stroke = Colors.DARKGRAY, strokeThickness = 2.0).apply {
+        circle = circle(6.0, fill = color, stroke = Colors.DARKGRAY, strokeThickness = 2.0).centered
-			useNativeRendering = USE_NATIVE_RENDERING
+        text = text("", 10.0).position(10.0, 6.0)
-		}.centered
-        text = text("", 10.0).position(10.0, 6.0).apply {
-			useNativeRendering = USE_NATIVE_RENDERING
-		}
     }.position(point)
 
     fun updateText() {

samples/bmpfont/src/commonMain/kotlin/main.kt

@@ -11,7 +11,7 @@ suspend fun main() = Korge(bgcolor = Colors["#333"]) {
 	val font1 = resourcesVfs["font1.fnt"].readBitmapFont()
 	val segment7 = resourcesVfs["segment7.fnt"].readBitmapFont() // mono spaced
 	val text1 = text("Hello World!", textSize = 96.0, font = font1)
-	val text2 = text("Hello World!", textSize = 96.0, font = font1) {
+	val text2 = text("Hello : World! jg", textSize = 96.0, font = font1) {
 		smoothing = false
 		alignTopToBottomOf(text1)
 	}

samples/box2d/.gitignore

@@ -1,2 +1 @@
 /build
-/bundles

samples/box2d/build.gradle.old

@@ -0,0 +1,5 @@
+dependencies {
+	add("commonMainApi", project(":korge"))
+	//add("commonMainApi", project("::kbox2d"))
+	//add("commonMainApi", project(":korge-box2d"))
+}

samples/box2d/src/commonMain/kotlin/main.kt

@@ -0,0 +1,10 @@
+import com.soywiz.korge.*
+import com.soywiz.korge.box2d.*
+import com.soywiz.korge.view.ktree.*
+import com.soywiz.korgw.*
+import com.soywiz.korio.file.std.*
+
+suspend fun main() = Korge(width = 920, height = 720, quality = GameWindow.Quality.PERFORMANCE, title = "My Awesome Box2D Game!") {
+    registerBox2dSupportOnce()
+    addChild(resourcesVfs["restitution.ktree"].readKTree(views))
+}

samples/box2d/src/commonMain/resources/restitution.ktree

@@ -0,0 +1,20 @@
+<ktree width="921.3163135700865" height="720.0" gridWidth="20" gridHeight="20">
+	<solidrect y="620.0" width="920.0" height="100.0">
+		<__ex_physics friction="0.2" restitution="0.2"/>
+	</solidrect>
+	<ellipse x="120.0" y="246.0" anchorX="0.5" anchorY="0.5" width="100.0" height="100.0">
+		<__ex_physics type="DYNAMIC" linearVelocityY="6.0" friction="0.2" restitution="0.3"/>
+	</ellipse>
+	<ellipse x="260.0" y="246.0" anchorX="0.5" anchorY="0.5" width="100.0" height="100.0">
+		<__ex_physics type="DYNAMIC" linearVelocityY="6.0" friction="0.2" restitution="0.4"/>
+	</ellipse>
+	<ellipse x="400.0" y="246.0" anchorX="0.5" anchorY="0.5" width="100.0" height="100.0">
+		<__ex_physics type="DYNAMIC" linearVelocityY="6.0" friction="0.2" restitution="0.5"/>
+	</ellipse>
+	<ellipse x="540.0" y="245.0" anchorX="0.5" anchorY="0.5" width="100.0" height="100.0">
+		<__ex_physics type="DYNAMIC" linearVelocityY="6.0" friction="0.2" restitution="0.6"/>
+	</ellipse>
+	<ellipse x="680.0" y="246.0" anchorX="0.5" anchorY="0.5" width="100.0" height="100.0">
+		<__ex_physics type="DYNAMIC" linearVelocityY="6.0" friction="0.2" restitution="0.7"/>
+	</ellipse>
+</ktree>

samples/box2d/src/commonTest/kotlin/test.kt

@@ -0,0 +1,26 @@
+import com.soywiz.klock.*
+import com.soywiz.korge.input.*
+import com.soywiz.korge.tests.*
+import com.soywiz.korge.tween.*
+import com.soywiz.korge.view.*
+import com.soywiz.korim.color.*
+import com.soywiz.korma.geom.*
+import kotlin.test.*
+
+class MyTest : ViewsForTesting() {
+    @Test
+    fun test() = viewsTest {
+        val log = arrayListOf<String>()
+        val rect = solidRect(100, 100, Colors.RED)
+        rect.onClick {
+            log += "clicked"
+        }
+        assertEquals(1, views.stage.numChildren)
+        rect.simulateClick()
+        assertEquals(true, rect.isVisibleToUser())
+        tween(rect::x[-102], time = 10.seconds)
+        assertEquals(Rectangle(x=-102, y=0, width=100, height=100), rect.globalBounds)
+        assertEquals(false, rect.isVisibleToUser())
+        assertEquals(listOf("clicked"), log)
+    }
+}

samples/box2d/src/jsMain/resources/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>JS Client</title>
+</head>
+<body>
+<script src="kbox2d-samples.js"></script>
+<div id="root"></div>
+</body>
+</html>

samples/box2d/src/jvmMain/kotlin/main.kt

@@ -1,8 +0,0 @@
-import kotlinx.coroutines.*
-
-// -XstartOnFirstThread
-fun main(args: Array<String>) {
-	runBlocking {
-		main()
-	}
-}

samples/bunnymark-fast/build.gradle.kts

@@ -0,0 +1,10 @@
+import com.soywiz.korge.gradle.*
+
+apply<KorgeGradlePlugin>()
+
+korge {
+	id = "com.soywiz.korge.samples.bunnymarkfast"
+	description = "A sample using FSprites in KorGE"
+	orientation = com.soywiz.korge.gradle.Orientation.LANDSCAPE
+	targetDefault()
+}

samples/bunnymark/build.gradle

@@ -1,7 +0,0 @@
-import com.soywiz.korge.gradle.*
-
-apply plugin: KorgeGradlePlugin
-
-korge {
-	targetDefault()
-}

samples/bunnymark/build.gradle.kts

@@ -0,0 +1,9 @@
+import com.soywiz.korge.gradle.*
+
+apply<KorgeGradlePlugin>()
+
+korge {
+	id = "com.soywiz.korge.samples.bunnymark"
+	orientation = com.soywiz.korge.gradle.Orientation.LANDSCAPE
+	targetDefault()
+}

samples/bunnymark/src/commonMain/kotlin/main.kt

@@ -1,40 +1,34 @@
-import com.soywiz.kds.iterators.fastForEach
 import com.soywiz.kds.FastArrayList
-import com.soywiz.korge.*
+import com.soywiz.kds.iterators.fastForEach
-import com.soywiz.korge.view.*
+import com.soywiz.korge.Korge
-import com.soywiz.korim.color.*
+import com.soywiz.korge.input.mouse
-import com.soywiz.korim.format.*
+import com.soywiz.korge.render.BatchBuilder2D
-import com.soywiz.korio.file.std.*
+import com.soywiz.korge.view.addUpdater
-import com.soywiz.korge.input.*
 import com.soywiz.korge.view.fast.FastSprite
+import com.soywiz.korge.view.fast.alpha
 import com.soywiz.korge.view.fast.fastSpriteContainer
+import com.soywiz.korge.view.position
+import com.soywiz.korge.view.text
 import com.soywiz.korim.bitmap.BmpSlice
 import com.soywiz.korim.bitmap.effect.BitmapEffect
 import com.soywiz.korim.bitmap.sliceWithSize
+import com.soywiz.korim.color.Colors
 import com.soywiz.korim.font.DefaultTtfFont
 import com.soywiz.korim.font.toBitmapFont
-import com.soywiz.korim.text.VerticalAlign
+import com.soywiz.korim.format.readBitmap
+import com.soywiz.korio.file.std.resourcesVfs
 import kotlin.random.Random
 
-//class BunnyFastSprite(tex: BmpSlice) : FastSprite(tex) {
-//    var speedX: Float = 0f
-//    var speedY: Float = 0f
-//}
-
 class Bunny(tex: BmpSlice) : FastSprite(tex) {
-    // Temporal placeholder until FastSpriteContainer supports rotation
-    //override var rotationRadiansf: Float = 0f
     var speedXf: Float = 0f
     var speedYf: Float = 0f
-    var spinf: Float = 0f
 }
 
 // bunnymark ported from PIXI.js
 // https://www.goodboydigital.com/pixijs/bunnymark/
 // https://www.goodboydigital.com/pixijs/bunnymark/js/bunnyBenchMark.js
-suspend fun main() = Korge(width = 800, height = 600, bgcolor = Colors["#2b2b9b"], batchMaxQuads = com.soywiz.korge.render.BatchBuilder2D.MAX_BATCH_QUADS) {
+suspend fun main() = Korge(width = 800, height = 600, bgcolor = Colors["#2b2b9b"], batchMaxQuads = BatchBuilder2D.MAX_BATCH_QUADS) {
-//suspend fun main() = Korge(width = 800, height = 600, bgcolor = Colors["#2b2b9b"], batchMaxQuads = com.soywiz.korge.render.BatchBuilder2D.MAX_BATCH_QUADS, debug = true) {
+//suspend fun main() = Korge(width = 800, height = 600, bgcolor = Colors["#2b2b9b"]) {
-//suspend fun main() = Korge(width = 800, height = 600, bgcolor = Colors["#2b2b9b"], debug = true) {
     val wabbitTexture = resourcesVfs["bunnys.png"].readBitmap()
 
     val bunny1 = wabbitTexture.sliceWithSize(2, 47, 26, 37)
@@ -44,21 +38,14 @@ suspend fun main() = Korge(width = 800, height = 600, bgcolor = Colors["#2b2b9b"
     val bunny5 = wabbitTexture.sliceWithSize(2, 2, 26, 37)
 
     val startBunnyCount = 2
-	//val startBunnyCount = 400_003
-	//val startBunnyCount = 200_000
-	//val startBunnyCount = 250_000
     //val startBunnyCount = 1_000_000
-    //val startBunnyCount = 200_000
+   // val startBunnyCount = 200_000
     val bunnyTextures = listOf(bunny1, bunny2, bunny3, bunny4, bunny5)
     var currentTexture = bunny1
-    val amount = 100
 
-    val container = fastSpriteContainer()
+    val container = fastSpriteContainer(useRotation = true, smoothing = false)
     val font = DefaultTtfFont.toBitmapFont(fontSize = 16.0, effect = BitmapEffect(dropShadowX = 1, dropShadowY = 1, dropShadowRadius = 1))
-    //val font = resourcesVfs["font1.fnt"].readBitmapFont()
-    //val font = DefaultTtfFont
     val bunnyCountText = text("", font = font, textSize = 16.0, alignment = com.soywiz.korim.text.TextAlignment.TOP_LEFT).position(16.0, 16.0)
-    //val container = container()
 
     val bunnys = FastArrayList<Bunny>()
 
@@ -67,16 +54,14 @@ suspend fun main() = Korge(width = 800, height = 600, bgcolor = Colors["#2b2b9b"
     fun addBunny(count: Int = 1) {
         for (n in 0 until count) {
             val bunny = Bunny(currentTexture)
-            bunny.speedXf = random.nextFloat() * 10
+            bunny.speedXf = random.nextFloat() * 1
-            bunny.speedYf = (random.nextFloat() * 10) - 5
+            bunny.speedYf = (random.nextFloat() * 1) - 5
             bunny.anchorXf = .5f
             bunny.anchorYf = 1f
-            //bunny.alpha = 0.3 + Math.random() * 0.7;
+            bunny.alpha = 0.3f + random.nextFloat() * 0.7f
             bunny.scale(0.5f + random.nextFloat() * 0.5f)
             bunny.rotationRadiansf = (random.nextFloat() - 0.5f)
-            //bunny.rotation = Math.random() - 0.5;
+            container.addChild(bunny)
-            //var random = random.nextInt(0, container.numChildren-2);
-            container.addChild(bunny)//, random);
             bunnys.add(bunny)
         }
         bunnyCountText.text = "(WIP) KorGE Bunnymark. Bunnies: ${bunnys.size}"
@@ -120,7 +105,7 @@ suspend fun main() = Korge(width = 800, height = 600, bgcolor = Colors["#2b2b9b"
             if (bunny.yf > maxY) {
                 bunny.speedYf *= -0.85f
                 bunny.yf = maxY
-                bunny.spinf = (random.nextFloat() - 0.5f) * 0.2f
+                bunny.rotationRadiansf = (random.nextFloat() - 0.5f) * 0.2f
                 if (random.nextFloat() > 0.5) {
                     bunny.speedYf -= random.nextFloat() * 6
                 }

samples/coroutine/src/commonMain/kotlin/main.kt

@@ -9,31 +9,31 @@ import com.soywiz.korma.random.*
 import kotlin.random.*
 
 suspend fun main() = Korge(width = 512, height = 512, bgcolor = Colors["#2b2b2b"], clipBorders = false) {
-	val random = Random
+    val random = Random
-	for (n in 0 until 10000) {
+    for (n in 0 until 2000) {
-		launchImmediately {
+        launchImmediately {
-			val view = solidRect(10, 10, Colors.RED.interpolateWith(random[0.0, 1.0], Colors.BLUE))
+            val view = solidRect(10, 10, Colors.RED.interpolateWith(random[0.0, 1.0], Colors.BLUE))
-			view.position(random[0, 512], random[0, 512])
+            view.position(random[0, 512], random[0, 512])
 
-			frameBlock(60.timesPerSecond) {
+            frameBlock(60.timesPerSecond) {
-			//view.frameBlock(60.timesPerSecond) {
+            //view.frameBlock(60.timesPerSecond) {
-				while (true) {
+                while (true) {
-					val targetX = random[0, 512].toDouble()
+                    val targetX = random[0, 512].toDouble()
-					val targetY = random[0, 512].toDouble()
+                    val targetY = random[0, 512].toDouble()
 
-					while (Point.distance(view.x, view.y, targetX, targetY) > 5.0) {
+                    while (Point.distance(view.x, view.y, targetX, targetY) > 5.0) {
-						when {
+                        when {
-							view.x < targetX -> view.x += 2
+                            view.x < targetX -> view.x += 2
-							view.x > targetX -> view.x -= 2
+                            view.x > targetX -> view.x -= 2
-						}
+                        }
-						when {
+                        when {
-							view.y < targetY -> view.y += 2
+                            view.y < targetY -> view.y += 2
-							view.y > targetY -> view.y -= 2
+                            view.y > targetY -> view.y -= 2
-						}
+                        }
-						frame()
+                        frame()
-					}
+                    }
-				}
+                }
-			}
+            }
-		}
+        }
-	}
+    }
 }

samples/dragonbones/src/commonMain/kotlin/main.kt

@@ -171,7 +171,7 @@ class MyScene : MyBaseScene() {
 }
 
 class Button(text: String, handler: suspend () -> Unit) : Container() {
-	val textField = Text(text, textSize = 32.0).apply { smoothing = false }
+	val textField = TextOld(text, textSize = 32.0).apply { filtering = false }
 	private val bounds = textField.textBounds
 	val g = Graphics().apply {
 		fill(Colors.DARKGREY, 0.7) {
@@ -218,10 +218,10 @@ class Button(text: String, handler: suspend () -> Unit) : Container() {
 class HelloWorldScene : BaseDbScene() {
 	val SCALE = 1.6
 	override suspend fun Container.sceneInit() {
-		val skeDeferred = asyncImmediately { Json.parse(resourcesVfs["mecha_1002_101d_show/mecha_1002_101d_show_ske.json"].readString())!! }
+		val skeDeferred = asyncImmediately { Json.parse(res["mecha_1002_101d_show/mecha_1002_101d_show_ske.json"].readString())!! }
 		//val skeDeferred = asyncImmediately { MemBufferWrap(resources["mecha_1002_101d_show/mecha_1002_101d_show_ske.dbbin"].readBytes()) }
-		val texDeferred = asyncImmediately { resourcesVfs["mecha_1002_101d_show/mecha_1002_101d_show_tex.json"].readString() }
+		val texDeferred = asyncImmediately { res["mecha_1002_101d_show/mecha_1002_101d_show_tex.json"].readString() }
-		val imgDeferred = asyncImmediately { resourcesVfs["mecha_1002_101d_show/mecha_1002_101d_show_tex.png"].readBitmap().mipmaps() }
+		val imgDeferred = asyncImmediately { res["mecha_1002_101d_show/mecha_1002_101d_show_tex.png"].readBitmap().mipmaps() }
 
 		val data = factory.parseDragonBonesData(skeDeferred.await())
 		val atlas = factory.parseTextureAtlasData(Json.parse(texDeferred.await())!!, imgDeferred.await())
@@ -242,9 +242,9 @@ class ClassicDragonScene : BaseDbScene() {
 	override suspend fun Container.sceneInit() {
 		//val scale = 0.3
 		val scale = 0.8
-		val ske = asyncImmediately { resourcesVfs["Dragon/Dragon_ske.json"].readString() }
+		val ske = asyncImmediately { res["Dragon/Dragon_ske.json"].readString() }
-		val tex = asyncImmediately { resourcesVfs["Dragon/Dragon_tex.json"].readString() }
+		val tex = asyncImmediately { res["Dragon/Dragon_tex.json"].readString() }
-		val img = asyncImmediately { resourcesVfs["Dragon/Dragon_tex.png"].readBitmap() }
+		val img = asyncImmediately { res["Dragon/Dragon_tex.png"].readBitmap() }
 
 		val data = factory.parseDragonBonesData(Json.parse(ske.await())!!)
 
@@ -282,11 +282,11 @@ class EyeTrackingScene : BaseDbScene() {
 				"PARAM_BREATH"
 			)
 
-			val skeDeferred = asyncImmediately { resourcesVfs["shizuku/shizuku_ske.json"].readString() }
+			val skeDeferred = asyncImmediately { res["shizuku/shizuku_ske.json"].readString() }
-			val tex00Deferred = asyncImmediately { resourcesVfs["shizuku/shizuku.1024/texture_00.png"].readBitmap().mipmaps() }
+			val tex00Deferred = asyncImmediately { res["shizuku/shizuku.1024/texture_00.png"].readBitmap().mipmaps() }
-			val tex01Deferred = asyncImmediately { resourcesVfs["shizuku/shizuku.1024/texture_01.png"].readBitmap().mipmaps() }
+			val tex01Deferred = asyncImmediately { res["shizuku/shizuku.1024/texture_01.png"].readBitmap().mipmaps() }
-			val tex02Deferred = asyncImmediately { resourcesVfs["shizuku/shizuku.1024/texture_02.png"].readBitmap().mipmaps() }
+			val tex02Deferred = asyncImmediately { res["shizuku/shizuku.1024/texture_02.png"].readBitmap().mipmaps() }
-			val tex03Deferred = asyncImmediately { resourcesVfs["shizuku/shizuku.1024/texture_03.png"].readBitmap().mipmaps() }
+			val tex03Deferred = asyncImmediately { res["shizuku/shizuku.1024/texture_03.png"].readBitmap().mipmaps() }
 
 			println("EyeTrackingScene[1]")
 
@@ -295,15 +295,12 @@ class EyeTrackingScene : BaseDbScene() {
 				"shizuku"
 			)
 			println("EyeTrackingScene[2]")
-			// https://github.com/korlibs/korge-next/issues/74
-			// https://youtrack.jetbrains.com/issue/KT-43361
-			val tex00 = tex00Deferred.await()
-			val tex01 = tex01Deferred.await()
-			val tex02 = tex02Deferred.await()
-			val tex03 = tex03Deferred.await()
 			factory.updateTextureAtlases(
 				arrayOf(
-					tex00, tex01, tex02, tex03
+					tex00Deferred.await(),
+					tex01Deferred.await(),
+					tex02Deferred.await(),
+					tex03Deferred.await()
 				), "shizuku"
 			)
 			println("EyeTrackingScene[3]")
@@ -428,13 +425,13 @@ class SkinChangingScene : BaseDbScene() {
 
 		deferreds += asyncImmediately {
 			factory.parseDragonBonesData(
-				Json.parse(resourcesVfs["you_xin/body/body_ske.json"].readString())!!
+				Json.parse(res["you_xin/body/body_ske.json"].readString())!!
 			)
 		}
 		deferreds += asyncImmediately {
 			val atlas = factory.parseTextureAtlasData(
-				Json.parse(resourcesVfs["you_xin/body/body_tex.json"].readString())!!,
+				Json.parse(res["you_xin/body/body_tex.json"].readString())!!,
-				resourcesVfs["you_xin/body/body_tex.png"].readBitmap().mipmaps()
+				res["you_xin/body/body_tex.png"].readBitmap().mipmaps()
 			)
 		}
 
@@ -447,10 +444,10 @@ class SkinChangingScene : BaseDbScene() {
 				val textureAtlasPath = path + "_tex.png"
 				//
 				deferreds += asyncImmediately {
-					factory.parseDragonBonesData(Json.parse(resourcesVfs[dragonBonesJSONPath].readString())!!)
+					factory.parseDragonBonesData(Json.parse(res[dragonBonesJSONPath].readString())!!)
 					factory.parseTextureAtlasData(
-						Json.parse(resourcesVfs[textureAtlasJSONPath].readString())!!,
+						Json.parse(res[textureAtlasJSONPath].readString())!!,
-						resourcesVfs[textureAtlasPath].readBitmap().mipmaps()
+						res[textureAtlasPath].readBitmap().mipmaps()
 					)
 				}
 			}
@@ -510,6 +507,6 @@ class SkinChangingScene : BaseDbScene() {
 }
 
 abstract class BaseDbScene : MyBaseScene() {
-	val resourcesVfs get() = com.soywiz.korio.file.std.resourcesVfs
+	val res get() = resourcesVfs
 	val factory = KorgeDbFactory()
 }

samples/flag/.gitignore

@@ -0,0 +1 @@
+/build

samples/flag/build.gradle.kts

@@ -1,7 +1,8 @@
 import com.soywiz.korge.gradle.*
 
-apply plugin: KorgeGradlePlugin
+apply<KorgeGradlePlugin>()
 
 korge {
+	id = "com.soywiz.samples.flag"
 	targetDefault()
 }

samples/flag/src/commonMain/kotlin/main.kt

@@ -0,0 +1,51 @@
+import com.soywiz.klock.*
+import com.soywiz.korev.Key
+import com.soywiz.korge.*
+import com.soywiz.korge.input.keys
+import com.soywiz.korge.view.*
+import com.soywiz.korge.view.filter.*
+import com.soywiz.korim.color.*
+import com.soywiz.korim.format.*
+import com.soywiz.korio.file.std.*
+
+suspend fun main() = Korge(width = 592, height = 592, bgcolor = Colors["#2b2b2b"]) {
+	val bitmap = resourcesVfs["korge.png"].readBitmap()
+	val flagFilter = FlagFilter()
+
+    // "Flag Pole"
+    solidRect(10, 582, Colors.BLACK) {
+        position(30, 30)
+    }
+    solidRect(20, 5, Colors.BLACK) {
+        position(25, 25)
+    }
+
+    // Flag
+    image(bitmap) {
+        position(40, 40)
+        scaleY = 0.5
+        filter = flagFilter
+    }
+
+    // Propagates the wave over time
+    addUpdater { dt: TimeSpan ->
+        flagFilter.time = flagFilter.time.plus(dt)
+    }
+
+    fun min(a: Double, b: Double) = if (a > b) b else a
+    fun max(a: Double, b: Double) = if (a > b) a else b
+
+    keys {
+        down {
+            when (it.key) {
+                Key.LEFT -> flagFilter.amplitude = max(0.0, flagFilter.amplitude - 5)
+                Key.RIGHT -> flagFilter.amplitude = min(100.0, flagFilter.amplitude + 5)
+                Key.DOWN -> flagFilter.crestCount = max(0.0, flagFilter.crestCount - 0.5)
+                Key.UP -> flagFilter.crestCount = min(10.0, flagFilter.crestCount + 0.5)
+                Key.PLUS, Key.RIGHT_BRACKET, Key.CLOSE_BRACKET -> flagFilter.cyclesPerSecond = min(10.0, flagFilter.cyclesPerSecond + 0.5)
+                Key.MINUS, Key.LEFT_BRACKET, Key.OPEN_BRACKET -> flagFilter.cyclesPerSecond = max(0.0, flagFilter.cyclesPerSecond - 0.5)
+            }
+            println("amplitude = ${flagFilter.amplitude}, crestCount = ${flagFilter.crestCount}, cyclesPerSecond = ${flagFilter.cyclesPerSecond}")
+        }
+    }
+}

samples/gestures/.gitignore

@@ -0,0 +1 @@
+/build

samples/gestures/build.gradle.kts

@@ -0,0 +1,8 @@
+import com.soywiz.korge.gradle.*
+
+apply<KorgeGradlePlugin>()
+
+korge {
+	id = "com.soywiz.samples.gestures"
+	targetDefault()
+}

samples/gestures/src/commonMain/kotlin/main.kt

@@ -0,0 +1,74 @@
+import com.soywiz.klock.*
+import com.soywiz.korge.*
+import com.soywiz.korge.input.*
+import com.soywiz.korge.tween.*
+import com.soywiz.korge.ui.*
+import com.soywiz.korge.view.*
+import com.soywiz.korim.color.*
+import com.soywiz.korim.format.*
+import com.soywiz.korio.file.std.*
+import com.soywiz.korma.geom.*
+import com.soywiz.korma.interpolation.*
+
+suspend fun main() = Korge(width = 512, height = 512, bgcolor = Colors["#2b2b2b"]) {
+    val minDegrees = (-16).degrees
+    val maxDegrees = (+16).degrees
+    lateinit var image: Image
+
+    val container = container {
+        position(256, 256)
+        image = image(resourcesVfs["korge.png"].readBitmap()) {
+            rotation = maxDegrees
+            anchor(.5, .5)
+            scale(.8)
+        }
+    }
+
+    text("Zoom and rotate with two fingers")
+
+    touch {
+        var startImageRatio = 1.0
+        var startRotation = 0.degrees
+
+        scaleRecognizer(start = {
+            startImageRatio = image.scale
+        }) {
+            image.scale = startImageRatio * this.ratio
+        }
+
+        rotationRecognizer(start = {
+            startRotation = container.rotation
+        }) {
+            container.rotation = startRotation + this.delta
+        }
+    }
+
+    image.mouse {
+        click {
+            image.alpha = if (image.alpha > 0.5) 0.5 else 1.0
+        }
+    }
+
+    addFixedUpdater(2.timesPerSecond) {
+        println(views.input.activeTouches)
+    }
+
+    uiButton(text = "1") {
+        position(10, 380)
+        onPress { println("TAPPED ON 1") }
+    }
+    uiButton(text = "2") {
+        position(150, 380)
+        onPress { println("TAPPED ON 2") }
+    }
+
+    uiButton(text = "3") {
+        position(300, 380)
+        onPress { println("TAPPED ON 3") }
+    }
+
+    while (true) {
+        image.tween(image::rotation[minDegrees], time = 1.seconds, easing = Easing.EASE_IN_OUT)
+        image.tween(image::rotation[maxDegrees], time = 1.seconds, easing = Easing.EASE_IN_OUT)
+    }
+}

samples/input/src/commonMain/kotlin/main.kt

@@ -2,12 +2,11 @@ import com.soywiz.klock.*
 import com.soywiz.korev.*
 import com.soywiz.korge.*
 import com.soywiz.korge.input.*
-import com.soywiz.korge.scene.*
 import com.soywiz.korge.view.*
 
 suspend fun main() = Korge {
 	var line = 0
-	fun textLine(text: String) = text(text, textSize = 16.0, font = debugBmpFont).position(2, line++ * 20 + 5).apply { smoothing = false }
+	fun textLine(text: String) = textOld(text).position(2, line++ * 20 + 5).apply { filtering = false }
 	fun nowTime() = DateTime.now().local.format(DateFormat("HH:mm:ss.SSS"))
 
 	textLine("Events :")
@@ -19,6 +18,7 @@ suspend fun main() = Korge {
 	val mouseDownText = textLine("MouseDown")
 	val mouseUpText = textLine("MouseUp")
 	val mouseClickText = textLine("MouseClick")
+    val mouseScrollText = textLine("MouseScroll")
 	val resizeText = textLine("Resize")
 	val gamepadConnectedText = textLine("GamepadConnectedEv")
 	val gamepadButtonText = textLine("GamepadButtonEv")
@@ -29,12 +29,22 @@ suspend fun main() = Korge {
 	//stage.addEventListener<KeyEvent> { keysEvText.text = "${nowTime()}:$it" }
 	//stage.addEventListener<MouseEvent> { mouseEvText.text = "${nowTime()}:$it" }
 	stage.addEventListener<ReshapeEvent> { resizeText.text = "Resize ${nowTime()} $it" }
-	//stage.addEventListener<GamePadConnectionEvent> { gamepadConnectedText.text = "${nowTime()}:$it" }
+	stage.addEventListener<GamePadConnectionEvent> { gamepadConnectedText.text = "${nowTime()}:$it" }
 	//stage.addEventListener<GamePadUpdateEvent> {
 	//	gamepadUpdateText.text = "${nowTime()}:$it"
 	//	gamepadUpdate2Text.text = "" + it.gamepads.lastOrNull { it.connected }?.rawButtonsPressed
 	//}
 
+    //stage.addComponent(object : GamepadComponent {
+    //    override val view: View = stage
+    //    override fun onGamepadEvent(views: Views, event: GamePadUpdateEvent) {
+    //        println(event)
+    //    }
+    //    override fun onGamepadEvent(views: Views, event: GamePadConnectionEvent) {
+    //        println(event)
+    //    }
+    //})
+
 	gamepad {
 		button.invoke { gamepadButtonText.text = "$it" }
 		stick.invoke { gamepadStickText.text = "$it" }
@@ -46,9 +56,10 @@ suspend fun main() = Korge {
 	}
 
 	mouse {
-		onMove { mouseMoveText.text = "Mouse:Move ${nowTime()} ${it.lastEvent}" }
+		onMove { mouseMoveText.text = "Mouse:Move ${nowTime()} $it" }
-		onDown { mouseDownText.text = "Mouse:Down ${nowTime()} ${it.lastEvent}" }
+		onDown { mouseDownText.text = "Mouse:Down ${nowTime()} $it" }
-		onUp { mouseUpText.text = "Mouse:Up ${nowTime()} ${it.lastEvent}" }
+		onUp { mouseUpText.text = "Mouse:Up ${nowTime()} $it" }
-		onClick { mouseClickText.text = "Mouse:Click ${nowTime()} ${it.lastEvent}" }
+		onClick { mouseClickText.text = "Mouse:Click ${nowTime()} $it" }
+        onScroll { mouseScrollText.text = "Mouse:Scroll ${nowTime()} $it" }
 	}
 }

samples/instanced-rendering/.gitignore

@@ -0,0 +1 @@
+/build

samples/instanced-rendering/build.gradle.kts

@@ -0,0 +1,8 @@
+import com.soywiz.korge.gradle.*
+
+apply<KorgeGradlePlugin>()
+
+korge {
+	id = "com.soywiz.samples.instancedrendering"
+	targetDefault()
+}

samples/instanced-rendering/src/commonMain/kotlin/main.kt

@@ -0,0 +1,170 @@
+import com.soywiz.kds.*
+import com.soywiz.kmem.*
+import com.soywiz.korag.*
+import com.soywiz.korag.shader.*
+import com.soywiz.korge.*
+import com.soywiz.korge.input.*
+import com.soywiz.korge.render.*
+//import com.soywiz.korge.component.length.bindLength
+import com.soywiz.korge.resources.*
+import com.soywiz.korge.view.*
+import com.soywiz.korim.bitmap.*
+import com.soywiz.korim.bitmap.effect.*
+import com.soywiz.korim.color.*
+import com.soywiz.korim.font.*
+import com.soywiz.korim.format.*
+import com.soywiz.korio.file.std.*
+import com.soywiz.korio.resources.*
+import com.soywiz.korio.lang.*
+import com.soywiz.korio.async.*
+import com.soywiz.korma.geom.*
+import kotlin.random.*
+import com.soywiz.klock.*
+import com.soywiz.korge.view.fast.*
+
+// @TODO: We could autogenerate this via gradle
+val ResourcesContainer.korge_png by resourceBitmap("korge.png")
+
+class BunnyContainer(maxSize: Int) : FSprites(maxSize) {
+    val speeds = FBuffer(maxSize * Float.SIZE_BYTES * 2).f32
+    var FSprite.speedXf: Float get() = speeds[index * 2 + 0] ; set(value) { speeds[index * 2 + 0] = value }
+    var FSprite.speedYf: Float get() = speeds[index * 2 + 1] ; set(value) { speeds[index * 2 + 1] = value }
+    //var FSprite.tex: BmpSlice
+}
+
+/*
+class Bunny(tex: BmpSlice) : FastSprite(tex) {
+    var speedXf: Float = 0f
+    var speedYf: Float = 0f
+}
+*/
+
+// bunnymark ported from PIXI.js
+// https://www.goodboydigital.com/pixijs/bunnymark/
+// https://www.goodboydigital.com/pixijs/bunnymark/js/bunnyBenchMark.js
+suspend fun main() = Korge(width = 800, height = 600, bgcolor = Colors["#2b2b9b"], batchMaxQuads = BatchBuilder2D.MAX_BATCH_QUADS) {
+    println("currentThreadId=$currentThreadId")
+    delay(1.milliseconds)
+    println("currentThreadId=$currentThreadId")
+    println("ag.graphicExtensions=${ag.graphicExtensions}")
+    println("ag.isFloatTextureSupported=${ag.isFloatTextureSupported}")
+    println("ag.isInstancedSupported=${ag.isInstancedSupported}")
+//suspend fun main() = Korge(width = 800, height = 600, bgcolor = Colors["#2b2b9b"]) {
+    val wabbitTexture = resourcesVfs["bunnys.png"].readBitmap()
+
+    val bunny1 = wabbitTexture.sliceWithSize(2, 47, 26, 37)
+    val bunny2 = wabbitTexture.sliceWithSize(2, 86, 26, 37)
+    val bunny3 = wabbitTexture.sliceWithSize(2, 125, 26, 37)
+    val bunny4 = wabbitTexture.sliceWithSize(2, 164, 26, 37)
+    val bunny5 = wabbitTexture.sliceWithSize(2, 2, 26, 37)
+
+    val startBunnyCount = 2
+    //val startBunnyCount = 1_000_000
+    // val startBunnyCount = 200_000
+    val bunnyTextures = listOf(bunny1, bunny2, bunny3, bunny4, bunny5)
+    var currentTexture = bunny1
+
+    val bunnys = BunnyContainer(800_000)
+    addChild(bunnys.createView(wabbitTexture))
+
+    val font = DefaultTtfFont.toBitmapFont(fontSize = 16.0, effect = BitmapEffect(dropShadowX = 1, dropShadowY = 1, dropShadowRadius = 1))
+    val bunnyCountText = text("", font = font, textSize = 16.0, alignment = com.soywiz.korim.text.TextAlignment.TOP_LEFT).position(16.0, 16.0)
+
+
+    val random = Random(0)
+
+    fun addBunny(count: Int = 1) {
+        for (n in 0 until count) {
+            bunnys.apply {
+                val bunny = alloc()
+                bunny.speedXf = random.nextFloat() * 1
+                bunny.speedYf = (random.nextFloat() * 1) - 5
+                bunny.setAnchor(.5f, 1f)
+                //bunny.width = 10f
+                //bunny.height = 20f
+                //bunny.alpha = 0.3f + random.nextFloat() * 0.7f
+                bunny.setTex(currentTexture)
+                bunny.scale(0.5f + random.nextFloat() * 0.5f)
+                bunny.radiansf = (random.nextFloat() - 0.5f)
+            }
+        }
+        bunnyCountText.text = "(WIP) KorGE Bunnymark. Bunnies: ${bunnys.size}"
+    }
+
+    addBunny(startBunnyCount)
+
+    val maxX = width.toFloat()
+    val minX = 0f
+    val maxY = height.toFloat()
+    val minY = 0f
+    val gravity = 0.5f // 1.5f
+
+    mouse {
+        up {
+            currentTexture = bunnyTextures.random(random)
+        }
+    }
+
+    addUpdater {
+        if (views.input.mouseButtons != 0) {
+            if (bunnys.size < 200_000) {
+                addBunny(500)
+            } else if (bunnys.size < bunnys.maxSize - 1000) {
+                addBunny(1000)
+            }
+        }
+        bunnys.fastForEach { bunny ->
+            bunny.x += bunny.speedXf
+            bunny.y += bunny.speedYf
+            bunny.speedYf += gravity
+
+            if (bunny.x > maxX) {
+                bunny.speedXf *= -1
+                bunny.x = maxX
+            } else if (bunny.x < minX) {
+                bunny.speedXf *= -1
+                bunny.x = minX
+            }
+
+            if (bunny.y > maxY) {
+                bunny.speedYf *= -0.85f
+                bunny.y = maxY
+                bunny.radiansf = (random.nextFloat() - 0.5f) * 0.2f
+                if (random.nextFloat() > 0.5) {
+                    bunny.speedYf -= random.nextFloat() * 6
+                }
+            } else if (bunny.y < minY) {
+                bunny.speedYf = 0f
+                bunny.y = minY
+            }
+        }
+    }
+}
+
+
+/*
+suspend fun main() {
+    //GLOBAL_CHECK_GL = true
+    Korge(width = 512, height = 512, bgcolor = Colors["#2b2b2b"], clipBorders = false) {
+        gameWindow.icon = korge_png.get().bmp.toBMP32().scaled(32, 32)
+        val minDegrees = (-16).degrees
+        val maxDegrees = (+16).degrees
+        val image = image(korge_png) {
+            //val image = image(resourcesVfs["korge.png"].readbitmapslice) {
+            rotation = maxDegrees
+            anchor(.5, .5)
+            scale(.8)
+            position(256, 256)
+        }
+        addChild(MyView())
+        //bindLength(image::scaledWidth) { 100.vw }
+        //bindLength(image::scaledHeight) { 100.vh }
+        while (true) {
+            image.tween(image::rotation[minDegrees], time = 1.seconds, easing = Easing.EASE_IN_OUT)
+            image.tween(image::rotation[maxDegrees], time = 1.seconds, easing = Easing.EASE_IN_OUT)
+        }
+    }
+}
+*/
+
+

samples/korge3d/skybox/build.gradle

@@ -1,8 +0,0 @@
-import com.soywiz.korge.gradle.*
-
-apply plugin: KorgeGradlePlugin
-
-korge {
-	id = "com.soywiz.samples.input"
-	targetDefault()
-}

samples/korge3d/skybox/build.gradle.kts

@@ -0,0 +1,8 @@
+import com.soywiz.korge.gradle.*
+
+apply<KorgeGradlePlugin>()
+
+korge {
+	id = "com.soywiz.samples.korge3d.skybox"
+	targetDefault()
+}

samples/ktree/build.gradle.kts

@@ -1,6 +1,6 @@
 import com.soywiz.korge.gradle.*
 
-apply plugin: com.soywiz.korge.gradle.KorgeGradlePlugin
+apply<KorgeGradlePlugin>()
 
 korge {
 	id = "com.soywiz.samples.ktree"

samples/ktree/src/commonMain/kotlin/main.kt

@@ -1,10 +1,15 @@
+import com.soywiz.klock.*
+import com.soywiz.korev.*
 import com.soywiz.korge.*
+import com.soywiz.korge.input.*
 import com.soywiz.korge.view.*
 import com.soywiz.korge.view.ktree.*
+import com.soywiz.korim.atlas.*
 import com.soywiz.korim.color.*
+import com.soywiz.korio.async.*
 import com.soywiz.korio.file.std.*
+import com.soywiz.korio.serialization.xml.*
 
 suspend fun main() = Korge(bgcolor = Colors["#172335"]) {
-	addChild(resourcesVfs["scene.ktree"].readKTree(views()))
+	addChild(resourcesVfs["scene.ktree"].readKTree(views))
-	this["small"].alpha(0.1)
 }

samples/onscreen-controller/src/commonMain/kotlin/main.kt

@@ -4,9 +4,9 @@ import com.soywiz.korim.color.*
 import com.soywiz.korio.util.*
 
 suspend fun main() = Korge(bgcolor = Colors.DARKBLUE) {
-	val text1 = textOld("-").position(5, 5).apply { smoothing = false }
+	val text1 = textOld("-").position(5, 5).apply { filtering = false }
 	val buttonTexts = (0 until 2).map {
-		textOld("-").position(5, 20 * (it + 1) + 5).apply { smoothing = false }
+		textOld("-").position(5, 20 * (it + 1) + 5).apply { filtering = false }
 	}
 
 	addTouchGamepad(

samples/particles/src/commonMain/kotlin/main.kt

@@ -1,9 +1,7 @@
+import com.soywiz.klock.*
 import com.soywiz.korge.*
 import com.soywiz.korge.particle.*
 import com.soywiz.korge.view.*
 import com.soywiz.korio.file.std.*
 
-suspend fun main() = Korge(width = 300, height = 300) {
+suspend fun main() = particlesMain()
-	val emitter = resourcesVfs["particle/particle.pex"].readParticleEmitter()
-	particleEmitter(emitter).position(views.virtualWidth * 0.5, views.virtualHeight * 0.75)
-}

samples/particles/src/commonMain/kotlin/particlesMain.kt

@@ -0,0 +1,18 @@
+import com.soywiz.klock.*
+import com.soywiz.korge.*
+import com.soywiz.korge.particle.*
+import com.soywiz.korge.time.*
+import com.soywiz.korge.view.*
+import com.soywiz.korio.file.std.*
+
+suspend fun particlesMain() = Korge(width = 600, height = 600) {
+    val emitter = resourcesVfs["particle/demo2.pex"].readParticleEmitter()
+    //val emitter = resourcesVfs["particle/particle.pex"].readParticleEmitter()
+    //val emitter = resourcesVfs["particle/1/particle.pex"].readParticleEmitter()
+    val particlesView = particleEmitter(emitter, time = 2.seconds).position(views.virtualWidth * 0.5, views.virtualHeight * 0.5)
+
+    delay(4.seconds)
+
+    println("RESTART")
+    particlesView.restart()
+}

samples/particles/src/commonMain/resources/particle/1/particle.pex

@@ -0,0 +1,39 @@
+<particleEmitterConfig>
+  <texture name="texture.png"/>
+  <sourcePosition x="300.00" y="300.00"/>
+  <sourcePositionVariance x="0" y="0"/>
+  <speed value="14"/>
+  <speedVariance value="62.92"/>
+  <particleLifeSpan value="6.49"/>
+  <particleLifespanVariance value="2.91"/>
+  <angle value="151.84"/>
+  <angleVariance value="341.16"/>
+  <gravity x="-500" y="-500"/>
+  <radialAcceleration value="-358.82"/>
+  <tangentialAcceleration value="500"/>
+  <radialAccelVariance value="87.11"/>
+  <tangentialAccelVariance value="0"/>
+  <startColor red="0.47000000000000003" green="0.47000000000000003" blue="0.47000000000000003" alpha="0.47000000000000003"/>
+  <startColorVariance red="0" green="0" blue="0" alpha="1"/>
+  <finishColor red="0" green="0" blue="0" alpha="0"/>
+  <finishColorVariance red="0" green="0" blue="0" alpha="0"/>
+  <maxParticles value="627.92"/>
+  <startParticleSize value="15.33"/>
+  <startParticleSizeVariance value="57.71"/>
+  <finishParticleSize value="31.02"/>
+  <FinishParticleSizeVariance value="40.21"/>
+  <duration value="-1.00"/>
+  <emitterType value="0"/>
+  <maxRadius value="252.97"/>
+  <maxRadiusVariance value="155.98"/>
+  <minRadius value="160.02"/>
+  <minRadiusVariance value="277.47"/>
+  <rotatePerSecond value="-329.6"/>
+  <rotatePerSecondVariance value="49.72"/>
+  <blendFuncSource value="768"/>
+  <blendFuncDestination value="769"/>
+  <rotationStart value="228.72"/>
+  <rotationStartVariance value="61.3"/>
+  <rotationEnd value="359.3"/>
+  <rotationEndVariance value="99.23"/>
+</particleEmitterConfig>

samples/particles/src/commonMain/resources/particle/demo2.pex

@@ -0,0 +1,39 @@
+<particleEmitterConfig>
+	<texture name="texture.png"/>
+	<sourcePosition x="0.0" y="0.0"/>
+	<sourcePositionVariance x="0.0" y="0.0"/>
+	<speed value="100.0"/>
+	<speedVariance value="30.0"/>
+	<particleLifeSpan value="4.25"/>
+	<particleLifespanVariance value="1.9"/>
+	<angle value="270.0"/>
+	<angleVariance value="0.0"/>
+	<gravity x="0.0" y="0.0"/>
+	<radialAcceleration value="0.0"/>
+	<radialAccelVariance value="0.0"/>
+	<tangentialAcceleration value="0.0"/>
+	<tangentialAccelVariance value="0.0"/>
+	<startColor red="1.0" green="0.3100000023841858" blue="0.0" alpha="1.0"/>
+	<startColorVariance red="0.0" green="0.0" blue="0.0" alpha="0.0"/>
+	<finishColor red="1.0" green="0.3100000023841858" blue="0.0" alpha="0.0"/>
+	<finishColorVariance red="0.0" green="0.0" blue="0.0" alpha="0.0"/>
+	<maxParticles value="500"/>
+	<startParticleSize value="70.0"/>
+	<startParticleSizeVariance value="49.53"/>
+	<finishParticleSize value="10.0"/>
+	<FinishParticleSizeVariance value="5.0"/>
+	<duration value="-1.0"/>
+	<emitterType value="1"/>
+	<maxRadius value="268.94698220220687"/>
+	<maxRadiusVariance value="0.0"/>
+	<minRadius value="49.30737240656117"/>
+	<minRadiusVariance value="0.0"/>
+	<rotatePerSecond value="3.0"/>
+	<rotatePerSecondVariance value="0.0"/>
+	<blendFuncSource value="1"/>
+	<blendFuncDestination value="1"/>
+	<rotationStart value="0.0"/>
+	<rotationStartVariance value="0.0"/>
+	<rotationEnd value="0.0"/>
+	<rotationEndVariance value="0.0"/>
+</particleEmitterConfig>

samples/particles/src/commonMain/resources/particle/particle2.pex

@@ -0,0 +1,39 @@
+<particleEmitterConfig>
+	<texture name="texture.png"/>
+	<sourcePosition x="0.0" y="0.0"/>
+	<sourcePositionVariance x="0.0" y="0.0"/>
+	<speed value="210.667496772917"/>
+	<speedVariance value="76.03762999416614"/>
+	<particleLifeSpan value="4.6"/>
+	<particleLifespanVariance value="1.9"/>
+	<angle value="194.25150480835134"/>
+	<angleVariance value="360.0"/>
+	<gravity x="0.0" y="632.3698054438889"/>
+	<radialAcceleration value="0.0"/>
+	<radialAccelVariance value="0.0"/>
+	<tangentialAcceleration value="0.0"/>
+	<tangentialAccelVariance value="0.0"/>
+	<startColor red="0.0" green="0.3199999928474426" blue="0.0" alpha="0.6200000047683716"/>
+	<startColorVariance red="0.0" green="0.0" blue="1.0" alpha="0.0"/>
+	<finishColor red="0.0" green="1.0" blue="0.0" alpha="0.0"/>
+	<finishColorVariance red="0.0" green="0.0" blue="0.0" alpha="0.0"/>
+	<maxParticles value="500"/>
+	<startParticleSize value="11.948826318187017"/>
+	<startParticleSizeVariance value="49.53"/>
+	<finishParticleSize value="627.9113790419135"/>
+	<FinishParticleSizeVariance value="5.0"/>
+	<duration value="-1.0"/>
+	<emitterType value="0"/>
+	<maxRadius value="100.0"/>
+	<maxRadiusVariance value="0.0"/>
+	<minRadius value="0.0"/>
+	<minRadiusVariance value="0.0"/>
+	<rotatePerSecond value="0.0"/>
+	<rotatePerSecondVariance value="0.0"/>
+	<blendFuncSource value="770"/>
+	<blendFuncDestination value="1"/>
+	<rotationStart value="0.0"/>
+	<rotationStartVariance value="0.0"/>
+	<rotationEnd value="0.0"/>
+	<rotationEndVariance value="0.0"/>
+</particleEmitterConfig>

samples/polyphonic/src/commonMain/kotlin/main.kt

@@ -41,6 +41,7 @@ suspend fun main() = Korge {
 				for (n in 1 until samples.channels) {
 					arraycopy(samples.data[0], 0, samples.data[n], 0, samples.data[0].size)
 				}
+                samples.scaleVolume(.05f)
 				//MemorySyncStream().apply { writeShortArrayLE(samples.data[0]) }.toByteArray().writeToFile("/tmp/data.raw")
 				//for (n in 0 until 44100) println(samples.data[0][n])
 				stream.add(samples)
@@ -397,7 +398,7 @@ fun audioOutCallback(channel: Int, buf: ShortArray, reqn: Int = buf.size, bufn:
 			state.currentsampleIndex += state.currentsampleIncrement
 			if (state.currentsampleIndex >= SAMPLE_COUNT) state.currentsampleIndex -= SAMPLE_COUNT.toFloat()
 		}
-		val rvalue = value.clamp(Short.MIN_VALUE.toFloat(), Short.MAX_VALUE.toFloat()).toInt().toShort()
+		val rvalue = value.clamp(Short.MIN_VALUE.toFloat(), Short.MAX_VALUE.toInt().toFloat()).toInt().toShort()
 		//for (n in 0 until nchannels) buf[bufn++] = value.toShort()
 		buf[bufn++] = rvalue
 		//buf[bufn++] = rvalue

samples/s3d/src/commonMain/kotlin/main.kt

@@ -2,7 +2,6 @@ import com.soywiz.kds.*
 import com.soywiz.kds.iterators.*
 import com.soywiz.klock.*
 import com.soywiz.korge.*
-import com.soywiz.korge.render.*
 import com.soywiz.korge.scene.*
 import com.soywiz.korge.tween.*
 import com.soywiz.korge.view.*
@@ -123,7 +122,7 @@ class MonkeyScene : Scene() {
 			val view = mesh(model.mesh).rotation(-90.degrees, 0.degrees, 0.degrees)
 
 			var tick = 0
-			addUpdater {
+            addUpdater {
 				val angle = (tick / 1.0).degrees
 				camera.positionLookingAt(
 					cos(angle * 1) * 4, 0.0, -sin(angle * 1) * 4, // Orbiting camera
@@ -150,7 +149,7 @@ class SkinningScene : Scene() {
 			val cameras = mainSceneView.findByType<Camera3D>()
 
 			val animators = library.animationDefs.values.map { Animator3D(it, mainSceneView) }
-			addUpdater { animators.fastForEach { animator -> animator.update(it) } }
+            addUpdater { animators.fastForEach { animator -> animator.update(it) } }
 			val model = mainSceneView.findByType<ViewWithMesh3D>().first()
 				//.rotation(-90.degrees, 90.degrees, 0.degrees)
 
@@ -160,7 +159,7 @@ class SkinningScene : Scene() {
 			camera = camera1.clone()
 
 			this += mainSceneView
-			addUpdater {
+            addUpdater {
 				//val mainSceneView = mainSceneView
 				//println(mainSceneView)
 

samples/s3d/src/commonMain/kotlin/utils.kt

@@ -5,7 +5,6 @@ import com.soywiz.korge.tween.*
 import com.soywiz.korge.view.*
 import com.soywiz.korge3d.*
 import com.soywiz.korim.color.*
-import com.soywiz.korio.async.*
 import com.soywiz.korma.geom.*
 import com.soywiz.korma.geom.vector.*
 

samples/scenes/src/commonMain/kotlin/main.kt

@@ -2,10 +2,7 @@ import com.soywiz.korge.Korge
 import com.soywiz.korge.input.*
 import com.soywiz.korge.scene.Module
 import com.soywiz.korge.scene.Scene
-import com.soywiz.korge.view.Container
+import com.soywiz.korge.view.*
-import com.soywiz.korge.view.position
-import com.soywiz.korge.view.solidRect
-import com.soywiz.korge.view.text
 import com.soywiz.korim.color.Colors
 import com.soywiz.korinject.AsyncInjector
 import kotlin.reflect.KClass
@@ -24,39 +21,57 @@ object MyModule : Module() {
 
 class MyDependency(val value: String)
 
-class MyScene1(val myDependency: MyDependency) : Scene() {
+const val MARGIN = 10
-	override suspend fun Container.sceneInit() {
-		text("MyScene1: ${myDependency.value}") { smoothing = false }
-		solidRect(100, 100, Colors.RED) {
-			position(200, 200)
-			alpha = 0.7
-			onOver { alpha = 1.0 }
-			onOut { alpha = 0.7 }
-			onClick {
-				sceneContainer.changeTo<MyScene2>()
-			}
-		}
-		solidRect(100, 100, Colors.BLUE) {
-			position(250, 250)
-			alpha = 0.7
-			onOver { alpha = 1.0 }
-			onOut { alpha = 0.7 }
-			onClick {
-				sceneContainer.changeTo<MyScene2>()
-			}
-		}
 
-	}
+class MyScene1(private val myDependency: MyDependency) : Scene() {
+    override suspend fun Container.sceneInit() {
+        val mainText = text("MyScene1: ${myDependency.value}", 32.0) {
+            smoothing = false
+            position(MARGIN, MARGIN)
+        }
+        text("Click any square to switch to MyScene2") {
+            alignTopToBottomOf(mainText, 10)
+            positionX(MARGIN)
+        }
+
+        solidRect(100, 100, Colors.RED) {
+            position(200, 200)
+            alpha = 0.7
+            onOver { alpha = 1.0 }
+            onOut { alpha = 0.7 }
+            onClick {
+                sceneContainer.changeTo<MyScene2>()
+            }
+        }
+        solidRect(100, 100, Colors.BLUE) {
+            position(250, 250)
+            alpha = 0.7
+            onOver { alpha = 1.0 }
+            onOut { alpha = 0.7 }
+            onClick {
+                sceneContainer.changeTo<MyScene2>()
+            }
+        }
+    }
 }
 
-class MyScene2(val myDependency: MyDependency) : Scene() {
+class MyScene2(private val myDependency: MyDependency) : Scene() {
 	override suspend fun Container.sceneInit() {
-		text("MyScene2: ${myDependency.value}") { smoothing = false }
+        text("MyScene2: ${myDependency.value}", 32.0) {
-		solidRect(100, 100, Colors.BLUE) {
+            smoothing = false
-			position(200, 200)
+            position(MARGIN, 10)
-			onClick {
+        }
-				sceneContainer.changeTo<MyScene1>(MyDependency("From MyScene2"))
+
-			}
+        val blueSquare = solidRect(100, 100, Colors.BLUE) {
-		}
+            position(200, 200)
-	}
+            onClick {
+                sceneContainer.changeTo<MyScene1>(MyDependency("From MyScene2"))
+            }
+        }
+
+        text("Click the square to switch to MyScene1") {
+            alignTopToBottomOf(blueSquare, 10)
+            centerXOn(blueSquare)
+        }
+    }
 }

samples/shapes/build.gradle.kts

@@ -7,6 +7,5 @@ korge {
 	name = "Sample1"
 	description = "A sample using Korge and the gradle plugin"
 	orientation = com.soywiz.korge.gradle.Orientation.LANDSCAPE
-	jvmMainClassName = "Sample1Kt"
 	targetDefault()
 }

samples/shapes/src/commonMain/kotlin/main.kt

@@ -8,7 +8,7 @@ import com.soywiz.korio.async.*
 import com.soywiz.korma.geom.*
 import com.soywiz.korma.geom.vector.*
 
-suspend fun main() = Korge(quality = GameWindow.Quality.PERFORMANCE, title = "KorGE Shapes") {
+suspend fun main() = Korge(quality = GameWindow.Quality.PERFORMANCE, title = "KorGE Shapes!") {
 	setupCircle()
 	setupRects()
 
@@ -17,10 +17,10 @@ suspend fun main() = Korge(quality = GameWindow.Quality.PERFORMANCE, title = "Ko
 		fill(Colors.DARKCYAN) {
 			rect(-1.0, -1.0, 3.0, 2.0)
 		}
-		fill(Colors.AQUAMARINE, 0.5) {
+		fill(Colors.AQUAMARINE) {
 			circle(0.0, 0.0, 1.0)
 		}
-		fill(Colors.AQUAMARINE, 0.5) {
+		fill(Colors.AQUAMARINE) {
 			circle(1.0, 0.0, 1.0)
 		}
 		position(100, 100)
@@ -52,7 +52,7 @@ fun Stage.setupCircle() {
 
 fun Stage.setupRects() {
 	val rect1 = roundRect(80.0, 100.0, 5.0, fill = Colors.GREEN).position(820, 128)
-	val rect2 = roundRect(80.0, 100.0, 5.0, fill = Colors.GREEN).position(1020, 128).anchor(0.5, 0.5)
+	val rect2 = roundRect(80.0, 100.0, 5.0, fill = Colors.GREEN, stroke = Colors.RED, strokeThickness = 4.0).position(1020, 128).anchor(0.5, 0.5)
 	addFixedUpdater(60.timesPerSecond) {
 		rect1.rotation += 1.degrees
 		rect2.rotation += 1.degrees

samples/spine/build.gradle

@@ -1,14 +0,0 @@
-apply plugin: com.soywiz.korge.gradle.KorgeGradlePlugin
-
-korge {
-	dependencies {
-		add("commonMainApi", "com.soywiz.korlibs.korge2:korge-spine:${korgeVersion}")
-	}
-
-	id = "com.soywiz.korlibs.korge.samples.dragonbones"
-	name = "KorGE - Spine"
-	description = "KorGE sample using Spine plugin"
-	icon = file("src/commonMain/resources/icon.png")
-
-	targetDefault()
-}

samples/spine/build.gradle.kts

@@ -0,0 +1,11 @@
+import com.soywiz.korge.gradle.*
+
+apply<KorgeGradlePlugin>()
+
+korge {
+	id = "com.soywiz.sampleSpriteAnimation"
+	orientation = com.soywiz.korge.gradle.Orientation.LANDSCAPE
+
+	targetDefault()
+	supportSpine()
+}

samples/spriteanim/src/commonMain/kotlin/Main.kt

@@ -6,6 +6,8 @@ import com.soywiz.korge.view.*
 import com.soywiz.korim.format.*
 import com.soywiz.korio.file.std.*
 
+const val PADDING = 5.0
+
 suspend fun main() = Korge(width = 512, height = 512) {
 	val spriteMap = resourcesVfs["character.png"].readBitmap()
 
@@ -49,50 +51,100 @@ suspend fun main() = Korge(width = 512, height = 512) {
 		rows = 1
 	)
 
-	val player1 = Sprite(spriteAnimationDown).apply {
+    data class KeyAssignment(
-		scale(3.0)
+        val key: Key,
-		xy(100, 200)
+        val animation: SpriteAnimation,
-	}
+        val block: (Double) -> Unit
-	val player2 = Sprite(spriteAnimationDown).apply {
+    )
-		scale(3.0)
-		xy(100, 100)
-	}
 
-	addChild(player1)
+    /**
-	addChild(player2)
+     * Extends Sprite with additional state to handle movement/animations
+     */
+    class PlayerCharacter(
+        spriteAnimation: SpriteAnimation,
+        upKey: Key, downKey: Key, leftKey: Key, rightKey: Key
+    ) : Sprite(spriteAnimation) {
 
-	addUpdater { time ->
+        private val assignments = listOf(
-		val scale = time / 16.milliseconds
+            KeyAssignment(upKey, spriteAnimationUp) { y -= it },
-		val disp = 2 * scale
+            KeyAssignment(downKey, spriteAnimationDown) { y += it },
-		val keys = views.input.keys
+            KeyAssignment(leftKey, spriteAnimationLeft) { x -= it },
-		if (keys[Key.LEFT]) { player1.playAnimation(spriteAnimationLeft); player1.x-=disp }
+            KeyAssignment(rightKey, spriteAnimationRight) { x += it },
-		if (keys[Key.RIGHT]) { player1.playAnimation(spriteAnimationRight); player1.x+=disp }
+        )
-		if (keys[Key.DOWN]) { player1.playAnimation(spriteAnimationDown); player1.y+=disp }
+
-		if (keys[Key.UP]) { player1.playAnimation(spriteAnimationUp); player1.y-=disp }
+        /** Allows to know the appropriate moment to stop the movement animation. */
-		if (keys[Key.A]) { player2.playAnimation(spriteAnimationLeft); player2.x-=disp }
+        private var isMoving = false
-		if (keys[Key.D]) { player2.playAnimation(spriteAnimationRight); player2.x+=disp }
+
-		if (keys[Key.S]) { player2.playAnimation(spriteAnimationDown); player2.y+=disp }
+        val assignedKeyDesc: String
-		if (keys[Key.W]) { player2.playAnimation(spriteAnimationUp); player2.y-=disp }
+            get() = assignments.map { it.key }.joinToString("/")
-		if (keys[Key.L]) { player1.playAnimationLooped(spriteAnimationDown, 100.milliseconds) }
+
-		if (keys[Key.T]) { player1.playAnimation(spriteAnimation = spriteAnimationDown, times = 3, spriteDisplayTime = 200.milliseconds) }
+        fun handleKeys(inputKeys: InputKeys, disp: Double) {
-		if (keys[Key.C]) { player1.playAnimationForDuration(1.seconds, spriteAnimationDown); player1.y-=2 }
+            // Let's check if any movement keys were pressed during this frame
-		if (keys[Key.ESCAPE]) { player1.stopAnimation() }
+            val anyMovement: Boolean = assignments // Iterate all registered movement keys
-	}
+                .filter { inputKeys[it.key] } // Check if this movement key was pressed
-	/*onKeyDown {
+                .onEach {
-		when (it.key) {
+                    // If yes, perform its corresponding action and play the corresponding animation
-			Key.LEFT -> {player1.playAnimation(spriteAnimationLeft); player1.x-=2}
+                    it.block(disp)
-			Key.RIGHT ->{player1.playAnimation(spriteAnimationRight); player1.x+=2}
+                    playAnimation(it.animation)
-			Key.DOWN -> {player1.playAnimation(spriteAnimationDown); player1.y+=2}
+                }
-			Key.UP -> {player1.playAnimation(spriteAnimationUp); player1.y-=2}
+                .any()
-			Key.A -> {player2.playAnimation(spriteAnimationLeft); player2.x-=2}
+
-			Key.D -> {player2.playAnimation(spriteAnimationRight); player2.x+=2}
+            if (anyMovement != isMoving) {
-			Key.S -> {player2.playAnimation(spriteAnimationDown); player2.y+=2}
+                if (isMoving) stopAnimation()
-			Key.W -> {player2.playAnimation(spriteAnimationUp); player2.y-=2}
+                isMoving = anyMovement
-			Key.L -> {player1.playAnimationLooped(spriteAnimationDown, 100.milliseconds)}
+            }
-			Key.T -> {player1.playAnimation(spriteAnimation = spriteAnimationDown, times = 3, spriteDisplayTime = 200.milliseconds)}
+        }
-			Key.C -> {player1.playAnimationForDuration(1.seconds, spriteAnimationDown); player1.y-=2}
+    }
-			Key.ESCAPE -> {player1.stopAnimation()}
+
-			else -> {}
+    val player1 = PlayerCharacter(spriteAnimationDown, Key.W, Key.S, Key.A, Key.D).apply {
-		}
+        scale(3.0)
-	}*/
+        xy(100, 100)
+    }
+
+    text("Player 1 controls: ${player1.assignedKeyDesc}") { position(PADDING, PADDING) }
+
+    val player2 = PlayerCharacter(spriteAnimationDown, Key.UP, Key.DOWN, Key.LEFT, Key.RIGHT).apply {
+        scale(3.0)
+        xy(300, 100)
+    }
+
+    text("Player 2 controls: ${player2.assignedKeyDesc}") {
+        positionY(PADDING)
+        alignRightToRightOf(parent!!, PADDING)
+    }
+
+
+    addChild(player1)
+    addChild(player2)
+
+    addUpdater { time ->
+        val scale = 16.milliseconds / time
+        val disp = 2 * scale
+        val keys = views.input.keys
+
+        player1.handleKeys(keys, disp)
+        player2.handleKeys(keys, disp)
+
+        if (keys[Key.L]) { player1.playAnimationLooped(spriteAnimationDown, 100.milliseconds) }
+        if (keys[Key.T]) { player1.playAnimation(spriteAnimation = spriteAnimationDown, times = 3, spriteDisplayTime = 200.milliseconds) }
+        if (keys[Key.C]) { player1.playAnimationForDuration(1.seconds, spriteAnimationDown); player1.y -= 2 }
+        if (keys[Key.ESCAPE]) { player1.stopAnimation() }
+    }
+    /*onKeyDown {
+        when (it.key) {
+            Key.LEFT -> {player1.playAnimation(spriteAnimationLeft); player1.x-=2}
+            Key.RIGHT ->{player1.playAnimation(spriteAnimationRight); player1.x+=2}
+            Key.DOWN -> {player1.playAnimation(spriteAnimationDown); player1.y+=2}
+            Key.UP -> {player1.playAnimation(spriteAnimationUp); player1.y-=2}
+            Key.A -> {player2.playAnimation(spriteAnimationLeft); player2.x-=2}
+            Key.D -> {player2.playAnimation(spriteAnimationRight); player2.x+=2}
+            Key.S -> {player2.playAnimation(spriteAnimationDown); player2.y+=2}
+            Key.W -> {player2.playAnimation(spriteAnimationUp); player2.y-=2}
+            Key.L -> {player1.playAnimationLooped(spriteAnimationDown, 100.milliseconds)}
+            Key.T -> {player1.playAnimation(spriteAnimation = spriteAnimationDown, times = 3, spriteDisplayTime = 200.milliseconds)}
+            Key.C -> {player1.playAnimationForDuration(1.seconds, spriteAnimationDown); player1.y-=2}
+            Key.ESCAPE -> {player1.stopAnimation()}
+            else -> {}
+        }
+    }*/
 }

samples/sprites10k/build.gradle.kts

@@ -3,8 +3,8 @@ import com.soywiz.korge.gradle.*
 apply<KorgeGradlePlugin>()
 
 korge {
-	id = "com.soywiz.sample10000Sprites"
+	id = "com.soywiz.spine"
-	name = "SampleSpriteAnimationWith10000Sprites"
+	name = "SpineSample"
 	description = "A sample using Korge and the gradle plugin"
 	orientation = com.soywiz.korge.gradle.Orientation.LANDSCAPE
 

samples/sprites10k/src/commonMain/kotlin/Main.kt

@@ -1,11 +1,12 @@
-import com.soywiz.klock.*
+import com.soywiz.klock.milliseconds
 import com.soywiz.korge.*
+import com.soywiz.korge.render.*
 import com.soywiz.korge.view.*
 import com.soywiz.korim.bitmap.*
 import com.soywiz.korim.format.*
 import com.soywiz.korio.file.std.*
 
-suspend fun main() = Korge(width = 1600, height = 1200, batchMaxQuads = com.soywiz.korge.render.BatchBuilder2D.MAX_BATCH_QUADS) {
+suspend fun main() = Korge(width = 1600, height = 1200, batchMaxQuads = BatchBuilder2D.MAX_BATCH_QUADS) {
 
 	val numberOfGreen = 5000
 	//val numberOfGreen = 20000
@@ -33,7 +34,7 @@ suspend fun main() = Korge(width = 1600, height = 1200, batchMaxQuads = com.soyw
 	}
 
 	addUpdater {
-		val scale = if (it == 0.milliseconds) 0.0 else (it / 16.666666.milliseconds)
+		val scale = if (it == 0.0.milliseconds) 0.0 else (it / 16.666666.milliseconds)
 
 		greenSprites.forEachIndexed { index, sprite ->
 			sprite.walkDirection(index % greenAnimations.size, scale)

samples/svg/src/commonMain/kotlin/main.kt

@@ -0,0 +1,12 @@
+import com.soywiz.korge.*
+import com.soywiz.korge.view.*
+import com.soywiz.korgw.*
+import com.soywiz.korim.vector.*
+import com.soywiz.korim.vector.format.*
+import com.soywiz.korio.file.std.*
+
+suspend fun main() = Korge(quality = GameWindow.Quality.PERFORMANCE, title = "SVG") {
+	val svg = SVG(resourcesVfs["tiger.svg"].readString())
+//	image(svg.render(native = false))
+	image(svg.render(native = true))
+}

samples/swf/src/commonMain/resources/simple1/DOMDocument.xml

@@ -0,0 +1,102 @@
+<DOMDocument xmlns="http://ns.adobe.com/xfl/2008/"
+			 currentTimeline="1" xflVersion="2.95" creatorInfo="Adobe Animate CC" platform="Windows"
+			 versionInfo="Saved by Animate Windows 16.5 build 104" majorVersion="16" minorVersion="5" buildNumber="104"
+			 nextSceneIdentifier="2" playOptionsPlayLoop="false" playOptionsPlayPages="false"
+			 playOptionsPlayFrameActions="false" filetypeGUID="3CE50BB6-55CF-47A6-B591-01286DDDC64C"
+			 fileGUID="2F6481179F773E4A913C5ED26633EB76">
+	<symbols>
+		<Include href="Símbolo 1.xml" loadImmediate="false" itemID="59875270-0000001c" lastModified="1502040688"/>
+	</symbols>
+	<timelines>
+		<DOMTimeline name="Escena 1">
+			<layers>
+				<DOMLayer name="Capa 1" color="#4F80FF" current="true" isSelected="true" animationType="motion object">
+					<frames>
+						<DOMFrame index="0" duration="9" tweenType="motion object" motionTweenRotate="none"
+								  motionTweenScale="false" isMotionObject="true" visibleAnimationKeyframes="4194303"
+								  keyMode="8195">
+							<motionObjectXML>
+								<AnimationCore TimeScale="24000" Version="1" duration="9000">
+									<TimeMap strength="0" type="Quadratic"/>
+									<metadata>
+										<names>
+											<name langID="es_ES" value=""/>
+										</names>
+										<Settings orientToPath="0" xformPtXOffsetPct="0.5" xformPtYOffsetPct="0.5"
+												  xformPtZOffsetPixels="0"/>
+									</metadata>
+									<PropertyContainer id="headContainer">
+										<PropertyContainer id="Basic_Motion">
+											<Property enabled="1" id="Motion_X" ignoreTimeMap="0" readonly="0"
+													  visible="1">
+												<Keyframe anchor="0,0" next="0,0" previous="0,0" roving="0"
+														  timevalue="0"/>
+												<Keyframe anchor="0,458.5" next="0,458.5" previous="0,458.5" roving="0"
+														  timevalue="8000"/>
+											</Property>
+											<Property enabled="1" id="Motion_Y" ignoreTimeMap="0" readonly="0"
+													  visible="1">
+												<Keyframe anchor="0,0" next="0,0" previous="0,0" roving="0"
+														  timevalue="0"/>
+												<Keyframe anchor="0,309.45" next="0,309.45" previous="0,309.45"
+														  roving="0" timevalue="8000"/>
+											</Property>
+											<Property enabled="1" id="Rotation_Z" ignoreTimeMap="0" readonly="0"
+													  visible="1">
+												<Keyframe anchor="0,0" next="0,0" previous="0,0" roving="0"
+														  timevalue="0"/>
+											</Property>
+											<Property enabled="1" id="Depth" ignoreTimeMap="0" readonly="0" visible="1">
+												<Keyframe anchor="0,0" next="0,0" previous="0,0" roving="0"
+														  timevalue="0"/>
+											</Property>
+										</PropertyContainer>
+										<PropertyContainer id="Transformation">
+											<Property enabled="1" id="Skew_X" ignoreTimeMap="0" readonly="0"
+													  visible="1">
+												<Keyframe anchor="0,0" next="0,0" previous="0,0" roving="0"
+														  timevalue="0"/>
+											</Property>
+											<Property enabled="1" id="Skew_Y" ignoreTimeMap="0" readonly="0"
+													  visible="1">
+												<Keyframe anchor="0,0" next="0,0" previous="0,0" roving="0"
+														  timevalue="0"/>
+											</Property>
+											<Property enabled="1" id="Scale_X" ignoreTimeMap="0" readonly="0"
+													  visible="1">
+												<Keyframe anchor="0,100" next="0,100" previous="0,100" roving="0"
+														  timevalue="0"/>
+											</Property>
+											<Property enabled="1" id="Scale_Y" ignoreTimeMap="0" readonly="0"
+													  visible="1">
+												<Keyframe anchor="0,100" next="0,100" previous="0,100" roving="0"
+														  timevalue="0"/>
+											</Property>
+										</PropertyContainer>
+										<PropertyContainer id="Colors"/>
+										<PropertyContainer id="Filters"/>
+									</PropertyContainer>
+								</AnimationCore>
+							</motionObjectXML>
+							<elements>
+								<DOMSymbolInstance libraryItemName="Símbolo 1">
+									<matrix>
+										<Matrix tx="1" ty="0.05"/>
+									</matrix>
+									<transformationPoint>
+										<Point x="45.25" y="45.25"/>
+									</transformationPoint>
+								</DOMSymbolInstance>
+							</elements>
+						</DOMFrame>
+					</frames>
+				</DOMLayer>
+			</layers>
+		</DOMTimeline>
+	</timelines>
+	<scripts>
+		<GlobalScripts language="Javascript"/>
+	</scripts>
+	<PrinterSettings/>
+	<publishHistory/>
+</DOMDocument>

samples/swf/src/commonMain/resources/simple1/LIBRARY/Símbolo 1.xml

@@ -0,0 +1,28 @@
+<DOMSymbolItem xmlns="http://ns.adobe.com/xfl/2008/"
+			   name="Símbolo 1" itemID="59875270-0000001c" lastModified="1502040688">
+	<timeline>
+		<DOMTimeline name="Símbolo 1">
+			<layers>
+				<DOMLayer name="Capa 1" color="#4F80FF" current="true" isSelected="true">
+					<frames>
+						<DOMFrame index="0" keyMode="9728">
+							<elements>
+								<DOMShape>
+									<fills>
+										<FillStyle index="1">
+											<SolidColor color="#0066CC"/>
+										</FillStyle>
+									</fills>
+									<edges>
+										<Edge fillStyle1="1"
+											  edges="!0 0S2|1810 0!1810 0|1810 1810!1810 1810|0 1810!0 1810|0 0"/>
+									</edges>
+								</DOMShape>
+							</elements>
+						</DOMFrame>
+					</frames>
+				</DOMLayer>
+			</layers>
+		</DOMTimeline>
+	</timeline>
+</DOMSymbolItem>

samples/swf/src/commonMain/resources/simple1/PublishSettings.xml

@@ -0,0 +1,88 @@
+<profiles>
+	<profile version="1.0" name="Predeterminado" current="true">
+		<PublishFormatProperties enabled="true">
+			<defaultNames>1</defaultNames>
+			<jpeg>0</jpeg>
+			<oam>0</oam>
+			<jpegDefaultName>1</jpegDefaultName>
+			<oamDefaultName>1</oamDefaultName>
+			<jpegFileName>Sin título 2.jpg</jpegFileName>
+			<oamFileName>Sin título 2.oam</oamFileName>
+			<publishFormat id="BBC1F406-65F2-4219-9304-FA48C7549E44">0</publishFormat>
+			<publishFormat id="C6B9CB0C-C6DC-4FBC-9805-93E9EB37A444">1</publishFormat>
+		</PublishFormatProperties>
+		<PublishJpegProperties enabled="true">
+			<Width>550</Width>
+			<Height>400</Height>
+			<Progressive>0</Progressive>
+			<DPI>4718592</DPI>
+			<Size>0</Size>
+			<Quality>80</Quality>
+			<MatchMovieDim>1</MatchMovieDim>
+		</PublishJpegProperties>
+		<PublishOamProperties enabled="true">
+			<Width>550</Width>
+			<Height>400</Height>
+			<CurrentFramePNG>1</CurrentFramePNG>
+			<CustomPNG>0</CustomPNG>
+			<PNGFilePath></PNGFilePath>
+			<Transparency>0</Transparency>
+		</PublishOamProperties>
+		<PublishProperties id="BBC1F406-65F2-4219-9304-FA48C7549E44" name="SVG Image" otf="true" enabled="true">
+			<Property name="copy">true</Property>
+			<Property name="default">true</Property>
+			<Property name="embed">false</Property>
+			<Property name="filename">Untitled-1.svg</Property>
+			<Property name="imagesPath">images</Property>
+			<Property name="includeHiddenLayers">true</Property>
+			<Property name="version">0.1</Property>
+		</PublishProperties>
+		<PublishProperties id="C6B9CB0C-C6DC-4FBC-9805-93E9EB37A444" name="JavaScript/HTML" otf="true" enabled="true">
+			<Property name="SiteUrl"></Property>
+			<Property name="bitDepth">8</Property>
+			<Property name="centerOption">2</Property>
+			<Property name="centerStage">false</Property>
+			<Property name="compactPaths">true</Property>
+			<Property name="componentsPath">components/</Property>
+			<Property name="createjsNS">createjs</Property>
+			<Property name="default">true</Property>
+			<Property name="embedJS">false</Property>
+			<Property name="exportAsSpritesheet">true</Property>
+			<Property name="exportHTML">true</Property>
+			<Property name="exportImages">true</Property>
+			<Property name="exportImagesToFolder">true</Property>
+			<Property name="exportLibs">true</Property>
+			<Property name="exportLibsToFolder">true</Property>
+			<Property name="exportSounds">true</Property>
+			<Property name="exportSoundsToFolder">true</Property>
+			<Property name="filename">Untitled-1</Property>
+			<Property name="frameBounds">false</Property>
+			<Property name="hostedLibs">true</Property>
+			<Property name="imageFormat">0</Property>
+			<Property name="imagesNS">images</Property>
+			<Property name="imagesPath">images/</Property>
+			<Property name="includeHiddenLayers">true</Property>
+			<Property name="includePreloader">false</Property>
+			<Property name="jpegBackground">#FFFFFF</Property>
+			<Property name="jpegMaxSheetHeight">8192</Property>
+			<Property name="jpegMaxSheetWidth">8192</Property>
+			<Property name="libNS">lib</Property>
+			<Property name="libraryPath">libs/</Property>
+			<Property name="loop">true</Property>
+			<Property name="makeResponsive">false</Property>
+			<Property name="optimizeExport">true</Property>
+			<Property name="pngBackground">#00000000</Property>
+			<Property name="pngMaxSheetHeight">8192</Property>
+			<Property name="pngMaxSheetWidth">8192</Property>
+			<Property name="preloaderName">Predeterminado</Property>
+			<Property name="quality">80</Property>
+			<Property name="responsiveOption">2</Property>
+			<Property name="scaleOption">0</Property>
+			<Property name="scaleStage">false</Property>
+			<Property name="soundsPath">sounds/</Property>
+			<Property name="templateTitle">Default Template</Property>
+			<Property name="version">0.1</Property>
+			<Property name="webfontEmbedCode">null</Property>
+		</PublishProperties>
+	</profile>
+</profiles>

samples/swf/src/commonMain/resources/simple1/mimetype

@@ -0,0 +1 @@
+application/vnd.adobe.xfl

samples/swf/src/commonMain/resources/simple1/simple1.xfl

@@ -0,0 +1 @@
+PROXY-CS5

samples/text/.gitignore

@@ -0,0 +1 @@
+/build

samples/text/build.gradle.kts

@@ -0,0 +1,13 @@
+import com.soywiz.korge.gradle.*
+
+apply<KorgeGradlePlugin>()
+
+korge {
+	id = "com.soywiz.samples.text"
+	name = "Text"
+	description = "Shows show to use Text"
+	orientation = com.soywiz.korge.gradle.Orientation.LANDSCAPE
+	jvmMainClassName = "MainKt"
+
+	targetDefault()
+}

samples/text/src/commonMain/kotlin/main.kt

@@ -0,0 +1,196 @@
+import com.soywiz.korev.*
+import com.soywiz.korge.*
+import com.soywiz.korge.scene.*
+import com.soywiz.korge.ui.*
+import com.soywiz.korge.view.*
+import com.soywiz.korgw.*
+import com.soywiz.korim.bitmap.effect.*
+import com.soywiz.korim.vector.*
+import com.soywiz.korim.color.*
+import com.soywiz.korim.font.*
+import com.soywiz.korim.text.*
+import com.soywiz.korio.async.*
+import com.soywiz.korio.file.std.*
+import com.soywiz.korma.geom.*
+import com.soywiz.korma.geom.vector.*
+import com.soywiz.korui.*
+import com.soywiz.korui.layout.*
+import kotlin.reflect.*
+
+val DEFAULT_BG = Colors["#2b2b2b"]
+
+suspend fun main() {
+    //GLOBAL_CHECK_GL = true
+    Korge(width = 960, height = 720, bgcolor = DEFAULT_BG, clipBorders = false, scaleAnchor = Anchor.TOP_LEFT) {
+        val font0 = resourcesVfs["clear_sans.fnt"].readFont()
+        val font1 = debugBmpFont
+        val font2 = DefaultTtfFont
+        val font3 = BitmapFont(DefaultTtfFont, 64.0)
+        val font4 = BitmapFont(DefaultTtfFont, 64.0, paint = Colors.BLUEVIOLET, effect = BitmapEffect(
+            blurRadius = 0,
+            dropShadowX = 2,
+            dropShadowY = 2,
+            dropShadowColor = Colors.GREEN,
+            dropShadowRadius = 1,
+            //borderSize = 1,
+            //borderColor = Colors.RED,
+        ))
+        val font5 = resourcesVfs["Pacifico.ttf"].readFont()
+        lateinit var text1: Text
+
+        val textStrs = mapOf(
+            "simple" to "01xXhjgÁEñÑ",
+            "UPPER" to "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+            "lower" to "abcdefghijklmnopqrstuvwxyz",
+            "number" to "0123456789",
+            "fox" to "The quick brown fox jumps over the lazy dog. 1234567890",
+        )
+        val fontSizes = listOf(8, 16, 32, 64, 128, 175)
+        val verticalAlignments = VerticalAlign.values().toList()
+        val horizontalAlignments = HorizontalAlign.values().toList()
+
+        val fonts = mapOf(
+            "DebugBMP" to font1,
+            "BMPFile" to font0,
+            "ExternalTTF" to font5,
+            "DefaultTTF" to font2,
+            "TTFtoBMP" to font3,
+            "TTFtoBMPEffect" to font4,
+        )
+
+        container {
+            xy(0, 500)
+            val leftPadding = 50
+            text1 = text(textStrs["simple"]!!, 175.0, Colors.WHITE, font2, alignment = TextAlignment.BASELINE_LEFT, autoScaling = true).xy(leftPadding, 0)
+            val gbounds = graphics {}.xy(leftPadding, 0)
+
+            val baseLineLine = solidRect(960 + 1200, 1, Colors.ORANGE)
+            val baseAscent = solidRect(960 + 1200, 1, Colors.BLUE)
+            val baseDescent = solidRect(960 + 1200, 1, Colors.PURPLE)
+
+            var cachedBounds: Rectangle? = null
+            fun updateBounds() {
+                val currentBounds = text1.getLocalBounds()
+                if (cachedBounds != currentBounds) {
+                    cachedBounds = currentBounds
+                    gbounds.clear()
+                    gbounds.stroke(Colors.RED, StrokeInfo(2.0)) {
+                        rect(text1.getLocalBounds())
+                    }
+                    gbounds.stroke(Colors.BLUE, StrokeInfo(2.0)) {
+                        line(-5, 0, +5, 0)
+                        line(0, -5, 0, +5)
+                    }
+                    val metrics = text1.font.getOrNull()!!.getFontMetrics(text1.fontSize)
+                    baseLineLine.xy(0.0, -metrics.baseline)
+                    baseAscent.xy(0.0, -metrics.ascent)
+                    baseDescent.xy(0.0, -metrics.descent)
+                }
+            }
+
+            addUpdater {
+                updateBounds()
+            }
+            updateBounds()
+
+        }
+
+        data class SecInfo<T>(
+            val name: String,
+            val prop: KMutableProperty0<T>,
+            val items: List<T>,
+            val convert: (T) -> String = { it.toString().toLowerCase().capitalize() }
+        )
+
+        korui(width, 200) {
+            for (info in listOf(
+                SecInfo("Vertical", text1::verticalAlign, verticalAlignments),
+                SecInfo("Horizontal", text1::horizontalAlign, horizontalAlignments),
+                SecInfo("Size", text1::textSize, fontSizes.map { it.toDouble() }) { "${it.toInt()}" },
+            )) {
+                @Suppress("UNCHECKED_CAST") val rinfo = (info as SecInfo<Any>)
+                horizontal {
+                    label("${info.name}:")
+                    val prop = ObservableProperty(info.prop)
+                    @Suppress("UNCHECKED_CAST") val rprop = (prop as ObservableProperty<Any>)
+                    for (item in info.items) {
+                        toggleButton(rinfo.convert(item)) {
+                            prop.observeStart { this.pressed = (it == item) }
+                            onClick {
+                                rprop.value = item
+                            }
+                        }
+                    }
+                }
+            }
+            val fontProp = ObservableProperty(text1.font.getOrNull()!!).observeStart { text1.font = it }
+            horizontal {
+                label("Font:")
+                gameWindow.onDragAndDropFileEvent {
+                    when (it.type) {
+                        DropFileEvent.Type.START -> {
+                            views.clearColor = DEFAULT_BG.interpolateWith(0.2, Colors.RED)
+                        }
+                        DropFileEvent.Type.END -> {
+                            views.clearColor = DEFAULT_BG
+                        }
+                        DropFileEvent.Type.DROP -> {
+                            try {
+                                val file = it.files?.firstOrNull()?.jailParent()
+                                val font = file?.readFont()
+                                if (font != null) {
+                                    fontProp.value = font
+                                }
+                            } catch (e: Throwable) {
+                                gameWindow.alertError(e)
+                                throw e
+                            }
+                        }
+                    }
+                }
+                for ((key, value) in fonts) {
+                    toggleButton(key) {
+                        fontProp.observeStart { this.pressed = (it == value) }
+                        onClick { fontProp.value = value }
+                    }
+                }
+            }
+            horizontal {
+                label("Text:")
+                val prop = ObservableProperty(textStrs.values.first()).observeStart { text1.text = it }
+                for ((key, value) in textStrs) {
+                    toggleButton(key) {
+                        prop.observeStart { this.pressed = (it == value) }
+                        onClick { prop.value = value }
+                    }
+                }
+            }
+            horizontal {
+                checkBox("Autoscale") {
+                    checked = text1.autoScaling
+                    onChange { text1.autoScaling = it }
+                }
+                checkBox("Smooth") {
+                    checked = text1.smoothing
+                    onChange { text1.smoothing = it }
+                }
+                checkBox("Native Render") {
+                    checked = text1.useNativeRendering
+                    onChange { text1.useNativeRendering = it }
+                }
+            }
+            horizontal {
+                button("Select file...") {
+                    onClick {
+                        launchImmediately {
+                            val file = gameWindow.openFileDialog().firstOrNull()
+                            if (file != null) {
+                                fontProp.value = file.readFont()
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

samples/text/src/commonMain/resources/clear_sans.fnt

@@ -0,0 +1,99 @@
+info face="Clear Sans" size=64 bold=0 italic=0 charset="" unicode=1 stretchH=100 smooth=1 aa=1 padding=0,0,0,0 spacing=1,1 outline=0
+common lineHeight=62 base=48 scaleW=256 scaleH=256 pages=1 packed=0 alphaChnl=0 redChnl=4 greenChnl=4 blueChnl=4
+page id=0 file="clear_sans.png"
+chars count=95
+char id=32   x=100   y=41    width=1     height=1     xoffset=0     yoffset=0     xadvance=12    page=0  chnl=15
+char id=33   x=128   y=173   width=7     height=31    xoffset=2     yoffset=17    xadvance=12    page=0  chnl=15
+char id=34   x=95    y=230   width=13    height=13    xoffset=4     yoffset=17    xadvance=20    page=0  chnl=15
+char id=35   x=67    y=77    width=28    height=31    xoffset=2     yoffset=17    xadvance=32    page=0  chnl=15
+char id=36   x=221   y=0     width=21    height=34    xoffset=3     yoffset=17    xadvance=28    page=0  chnl=15
+char id=37   x=189   y=39    width=43    height=32    xoffset=1     yoffset=16    xadvance=46    page=0  chnl=15
+char id=38   x=124   y=75    width=27    height=31    xoffset=2     yoffset=17    xadvance=31    page=0  chnl=15
+char id=39   x=109   y=230   width=5     height=13    xoffset=4     yoffset=17    xadvance=12    page=0  chnl=15
+char id=40   x=38    y=0     width=14    height=42    xoffset=2     yoffset=15    xadvance=18    page=0  chnl=15
+char id=41   x=53    y=0     width=14    height=42    xoffset=1     yoffset=15    xadvance=18    page=0  chnl=15
+char id=42   x=50    y=230   width=18    height=16    xoffset=1     yoffset=15    xadvance=21    page=0  chnl=15
+char id=43   x=160   y=171   width=25    height=25    xoffset=3     yoffset=23    xadvance=31    page=0  chnl=15
+char id=44   x=115   y=230   width=7     height=12    xoffset=2     yoffset=43    xadvance=12    page=0  chnl=15
+char id=45   x=233   y=99    width=15    height=4     xoffset=1     yoffset=35    xadvance=18    page=0  chnl=15
+char id=46   x=160   y=222   width=7     height=5     xoffset=2     yoffset=43    xadvance=12    page=0  chnl=15
+char id=47   x=122   y=0     width=20    height=40    xoffset=0     yoffset=15    xadvance=22    page=0  chnl=15
+char id=48   x=96    y=141   width=23    height=31    xoffset=2     yoffset=17    xadvance=28    page=0  chnl=15
+char id=49   x=115   y=173   width=12    height=31    xoffset=6     yoffset=17    xadvance=28    page=0  chnl=15
+char id=50   x=167   y=139   width=22    height=31    xoffset=2     yoffset=17    xadvance=26    page=0  chnl=15
+char id=51   x=0     y=173   width=21    height=31    xoffset=1     yoffset=17    xadvance=26    page=0  chnl=15
+char id=52   x=27    y=109   width=26    height=31    xoffset=0     yoffset=17    xadvance=28    page=0  chnl=15
+char id=53   x=144   y=139   width=22    height=31    xoffset=1     yoffset=17    xadvance=26    page=0  chnl=15
+char id=54   x=233   y=35    width=22    height=31    xoffset=2     yoffset=17    xadvance=26    page=0  chnl=15
+char id=55   x=24    y=141   width=23    height=31    xoffset=2     yoffset=17    xadvance=28    page=0  chnl=15
+char id=56   x=48    y=141   width=23    height=31    xoffset=1     yoffset=17    xadvance=26    page=0  chnl=15
+char id=57   x=120   y=141   width=23    height=31    xoffset=1     yoffset=17    xadvance=26    page=0  chnl=15
+char id=58   x=19    y=230   width=7     height=23    xoffset=2     yoffset=25    xadvance=12    page=0  chnl=15
+char id=59   x=152   y=171   width=7     height=30    xoffset=2     yoffset=25    xadvance=12    page=0  chnl=15
+char id=60   x=0     y=205   width=26    height=24    xoffset=3     yoffset=24    xadvance=31    page=0  chnl=15
+char id=61   x=69    y=230   width=25    height=14    xoffset=3     yoffset=28    xadvance=31    page=0  chnl=15
+char id=62   x=27    y=205   width=25    height=24    xoffset=2     yoffset=24    xadvance=31    page=0  chnl=15
+char id=63   x=235   y=136   width=20    height=31    xoffset=1     yoffset=17    xadvance=23    page=0  chnl=15
+char id=64   x=156   y=0     width=38    height=38    xoffset=2     yoffset=17    xadvance=43    page=0  chnl=15
+char id=65   x=96    y=77    width=27    height=31    xoffset=0     yoffset=17    xadvance=28    page=0  chnl=15
+char id=66   x=190   y=137   width=22    height=31    xoffset=3     yoffset=17    xadvance=28    page=0  chnl=15
+char id=67   x=80    y=109   width=25    height=31    xoffset=2     yoffset=17    xadvance=29    page=0  chnl=15
+char id=68   x=233   y=67    width=22    height=31    xoffset=3     yoffset=17    xadvance=28    page=0  chnl=15
+char id=69   x=22    y=173   width=20    height=31    xoffset=3     yoffset=17    xadvance=25    page=0  chnl=15
+char id=70   x=43    y=173   width=20    height=31    xoffset=3     yoffset=17    xadvance=24    page=0  chnl=15
+char id=71   x=179   y=73    width=26    height=31    xoffset=2     yoffset=17    xadvance=31    page=0  chnl=15
+char id=72   x=132   y=107   width=24    height=31    xoffset=3     yoffset=17    xadvance=30    page=0  chnl=15
+char id=73   x=100   y=173   width=14    height=31    xoffset=1     yoffset=17    xadvance=17    page=0  chnl=15
+char id=74   x=84    y=173   width=15    height=31    xoffset=0     yoffset=17    xadvance=19    page=0  chnl=15
+char id=75   x=182   y=105   width=24    height=31    xoffset=3     yoffset=17    xadvance=28    page=0  chnl=15
+char id=76   x=64    y=173   width=19    height=31    xoffset=3     yoffset=17    xadvance=23    page=0  chnl=15
+char id=77   x=38    y=77    width=28    height=31    xoffset=3     yoffset=17    xadvance=35    page=0  chnl=15
+char id=78   x=232   y=104   width=23    height=31    xoffset=3     yoffset=17    xadvance=30    page=0  chnl=15
+char id=79   x=54    y=109   width=25    height=31    xoffset=2     yoffset=17    xadvance=30    page=0  chnl=15
+char id=80   x=213   y=136   width=21    height=31    xoffset=3     yoffset=17    xadvance=26    page=0  chnl=15
+char id=81   x=195   y=0     width=25    height=38    xoffset=2     yoffset=17    xadvance=30    page=0  chnl=15
+char id=82   x=72    y=141   width=23    height=31    xoffset=3     yoffset=17    xadvance=27    page=0  chnl=15
+char id=83   x=157   y=107   width=24    height=31    xoffset=1     yoffset=17    xadvance=27    page=0  chnl=15
+char id=84   x=152   y=75    width=26    height=31    xoffset=0     yoffset=17    xadvance=26    page=0  chnl=15
+char id=85   x=106   y=109   width=25    height=31    xoffset=3     yoffset=17    xadvance=31    page=0  chnl=15
+char id=86   x=206   y=72    width=26    height=31    xoffset=0     yoffset=17    xadvance=27    page=0  chnl=15
+char id=87   x=0     y=77    width=37    height=31    xoffset=1     yoffset=17    xadvance=39    page=0  chnl=15
+char id=88   x=0     y=109   width=26    height=31    xoffset=0     yoffset=17    xadvance=27    page=0  chnl=15
+char id=89   x=207   y=104   width=24    height=31    xoffset=0     yoffset=17    xadvance=25    page=0  chnl=15
+char id=90   x=0     y=141   width=23    height=31    xoffset=1     yoffset=17    xadvance=26    page=0  chnl=15
+char id=91   x=81    y=0     width=12    height=42    xoffset=3     yoffset=15    xadvance=18    page=0  chnl=15
+char id=92   x=100   y=0     width=21    height=40    xoffset=1     yoffset=15    xadvance=22    page=0  chnl=15
+char id=93   x=68    y=0     width=12    height=42    xoffset=2     yoffset=15    xadvance=18    page=0  chnl=15
+char id=94   x=27    y=230   width=22    height=19    xoffset=2     yoffset=17    xadvance=27    page=0  chnl=15
+char id=95   x=168   y=222   width=23    height=4     xoffset=0     yoffset=50    xadvance=23    page=0  chnl=15
+char id=96   x=123   y=230   width=10    height=9     xoffset=5     yoffset=14    xadvance=24    page=0  chnl=15
+char id=97   x=160   y=197   width=20    height=24    xoffset=1     yoffset=24    xadvance=24    page=0  chnl=15
+char id=98   x=89    y=43    width=20    height=33    xoffset=3     yoffset=15    xadvance=26    page=0  chnl=15
+char id=99   x=181   y=197   width=19    height=24    xoffset=2     yoffset=24    xadvance=23    page=0  chnl=15
+char id=100  x=67    y=43    width=21    height=33    xoffset=2     yoffset=15    xadvance=26    page=0  chnl=15
+char id=101  x=97    y=205   width=20    height=24    xoffset=2     yoffset=24    xadvance=24    page=0  chnl=15
+char id=102  x=172   y=39    width=16    height=33    xoffset=0     yoffset=15    xadvance=14    page=0  chnl=15
+char id=103  x=45    y=43    width=21    height=33    xoffset=2     yoffset=24    xadvance=26    page=0  chnl=15
+char id=104  x=131   y=41    width=20    height=33    xoffset=3     yoffset=15    xadvance=26    page=0  chnl=15
+char id=105  x=249   y=0     width=6     height=31    xoffset=2     yoffset=17    xadvance=11    page=0  chnl=15
+char id=106  x=143   y=0     width=12    height=40    xoffset=-3    yoffset=17    xadvance=12    page=0  chnl=15
+char id=107  x=152   y=41    width=19    height=33    xoffset=3     yoffset=15    xadvance=23    page=0  chnl=15
+char id=108  x=243   y=0     width=5     height=33    xoffset=3     yoffset=15    xadvance=12    page=0  chnl=15
+char id=109  x=186   y=171   width=32    height=24    xoffset=3     yoffset=24    xadvance=38    page=0  chnl=15
+char id=110  x=118   y=205   width=20    height=24    xoffset=3     yoffset=24    xadvance=26    page=0  chnl=15
+char id=111  x=139   y=204   width=20    height=24    xoffset=2     yoffset=24    xadvance=25    page=0  chnl=15
+char id=112  x=110   y=41    width=20    height=33    xoffset=3     yoffset=24    xadvance=26    page=0  chnl=15
+char id=113  x=23    y=43    width=21    height=33    xoffset=2     yoffset=24    xadvance=26    page=0  chnl=15
+char id=114  x=241   y=193   width=14    height=24    xoffset=3     yoffset=24    xadvance=18    page=0  chnl=15
+char id=115  x=0     y=230   width=18    height=24    xoffset=1     yoffset=24    xadvance=22    page=0  chnl=15
+char id=116  x=136   y=173   width=15    height=30    xoffset=0     yoffset=18    xadvance=16    page=0  chnl=15
+char id=117  x=201   y=196   width=19    height=24    xoffset=3     yoffset=24    xadvance=26    page=0  chnl=15
+char id=118  x=53    y=205   width=21    height=24    xoffset=0     yoffset=24    xadvance=22    page=0  chnl=15
+char id=119  x=219   y=168   width=31    height=24    xoffset=0     yoffset=24    xadvance=32    page=0  chnl=15
+char id=120  x=75    y=205   width=21    height=24    xoffset=0     yoffset=24    xadvance=22    page=0  chnl=15
+char id=121  x=0     y=43    width=22    height=33    xoffset=0     yoffset=24    xadvance=23    page=0  chnl=15
+char id=122  x=221   y=193   width=19    height=24    xoffset=1     yoffset=24    xadvance=21    page=0  chnl=15
+char id=123  x=0     y=0     width=19    height=42    xoffset=1     yoffset=15    xadvance=21    page=0  chnl=15
+char id=124  x=94    y=0     width=5     height=42    xoffset=7     yoffset=15    xadvance=19    page=0  chnl=15
+char id=125  x=20    y=0     width=17    height=42    xoffset=2     yoffset=15    xadvance=21    page=0  chnl=15
+char id=126  x=134   y=230   width=25    height=7     xoffset=3     yoffset=29    xadvance=31    page=0  chnl=15

samples/text2/src/commonMain/kotlin/main.kt

@@ -12,27 +12,27 @@ import com.soywiz.korma.geom.*
 
 @OptIn(KorgeExperimental::class)
 suspend fun main() = Korge(quality = GameWindow.Quality.PERFORMANCE, width = 512, height = 160, title = "Korge's Text2!", bgcolor = Colors["#112"]) {
-	val font = BitmapFont(
+    val font = BitmapFont(
-		DefaultTtfFont, 64.0,
+        DefaultTtfFont, 64.0,
-		paint = LinearGradientPaint(0, 0, 0, 50).add(0.0, Colors.CADETBLUE).add(1.0, Colors.PURPLE),
+        paint = LinearGradientPaint(0, 0, 0, 50).add(0.0, Colors.CADETBLUE).add(1.0, Colors.PURPLE),
-		effect = BitmapEffect(
+        effect = BitmapEffect(
-			dropShadowX = 2,
+            dropShadowX = 2,
-			dropShadowY = 2,
+            dropShadowY = 2,
-			dropShadowRadius = 2,
+            dropShadowRadius = 2,
-			dropShadowColor = Colors["#5f005f"]
+            dropShadowColor = Colors["#5f005f"]
-		)
+        )
-	)
+    )
 
-	var offset = 0.degrees
+    var offset = 0.degrees
-	addFixedUpdater(60.timesPerSecond) { offset += 10.degrees }
+    addFixedUpdater(60.timesPerSecond) { offset += 10.degrees }
-	var version = 0
+    var version = 0
-	text("Hello World!", font = font, textSize = 64.0, alignment = TextAlignment.BASELINE_LEFT, renderer = CreateStringTextRenderer({ version++ }) { text, n, c, c1, g, advance ->
+    text("Hello World!", font = font, textSize = 64.0, alignment = TextAlignment.BASELINE_LEFT, renderer = CreateStringTextRenderer({ version++ }) { text, n, c, c1, g, advance ->
-		transform.identity()
+        transform.identity()
-		val sin = sin(offset + (n * 360 / text.length).degrees)
+        val sin = sin(offset + (n * 360 / text.length).degrees)
-		transform.rotate(15.degrees)
+        transform.rotate(15.degrees)
-		transform.translate(0.0, sin * 16)
+        transform.translate(0.0, sin * 16)
-		transform.scale(1.0, 1.0 + sin * 0.1)
+        transform.scale(1.0, 1.0 + sin * 0.1)
-		put(c)
+        put(c)
-		advance(advance)
+        advance(advance)
-	}).position(100, 100)
+    }).position(100, 100)
 }

samples/tictactoe-swf/src/commonMain/kotlin/BoardMediator.kt

@@ -24,8 +24,8 @@ suspend fun Board.Cell.setAnimate(type: Chip) {
 	set(type)
 	launchImmediately(coroutineContext) {
 		view.tween(
-			(view["chip"]!!::alpha[0.7, 1.0]).linear(),
+			(view["chip"]::alpha[0.7, 1.0]).linear(),
-			(view["chip"]!!::scale[0.8, 1.0]).easeOutElastic(),
+			(view["chip"]::scale[0.8, 1.0]).easeOutElastic(),
 			time = 300.milliseconds
 		)
 	}
@@ -34,7 +34,7 @@ suspend fun Board.Cell.setAnimate(type: Chip) {
 var Board.Cell.highlighting by Extra.Property { false }
 
 suspend fun Board.Cell.highlight(highlight: Boolean) {
-	view["highlight"].play(if (highlight) "highlight" else "none")
+	view["highlight"].first.play(if (highlight) "highlight" else "none")
 	this.highlighting = highlight
 	if (highlight) {
 		launchImmediately(coroutineContext) {

samples/tiled-background/src/commonMain/kotlin/main.kt

@@ -1,7 +1,5 @@
-import com.soywiz.klock.*
 import com.soywiz.korge.*
 import com.soywiz.korge.time.*
-import com.soywiz.korge.view.*
 import com.soywiz.korge.view.tiles.*
 import com.soywiz.korim.bitmap.*
 import com.soywiz.korim.format.*
@@ -11,10 +9,12 @@ import com.soywiz.korio.file.std.*
 suspend fun main() = Korge(width = 512, height = 512) {
 	val tileset = TileSet(mapOf(0 to bitmap("korge.png").toBMP32().scaleLinear(0.5, 0.5).slice()))
 	val tilemap = tileMap(Bitmap32(1, 1), repeatX = TileMap.Repeat.REPEAT, repeatY = TileMap.Repeat.REPEAT, tileset = tileset)
-	tilemap.addUpdater {
+	launchImmediately {
-		val rate = it / 16.milliseconds
+		while (true) {
-		tilemap.x += 1 * rate
+			tilemap.x += 1
-		tilemap.y += 0.25 * rate
+			tilemap.y += 0.25
+			delayFrame()
+		}
 	}
 }
 

samples/tilemap/src/commonMain/kotlin/main.kt

@@ -1,5 +1,4 @@
 import com.soywiz.klock.*
-import com.soywiz.klock.hr.*
 import com.soywiz.kmem.*
 import com.soywiz.korev.*
 import com.soywiz.korge.*
@@ -30,7 +29,7 @@ suspend fun main() = Korge(width = 512, height = 512) {
 		//}
 		addUpdater {
 			//val scale = 1.0 / (it / 16.666666.hrMilliseconds)
-			val scale = if (it == 0.milliseconds) 0.0 else (it / 16.666666.milliseconds)
+			val scale = if (it == 0.0.milliseconds) 0.0 else (it / 16.666666.milliseconds)
 			if (views.input.keys[Key.RIGHT]) dx -= 1.0
 			if (views.input.keys[Key.LEFT]) dx += 1.0
 			if (views.input.keys[Key.UP]) dy += 1.0

samples/triangulation/src/commonMain/kotlin/main.kt

@@ -9,7 +9,7 @@ import com.soywiz.korma.triangle.triangulate.*
 
 suspend fun main() = Korge(width = 512, height = 512) {
 	val stage = this
-	text("Add Points by clicking with the mouse", 14.0).position(5.0, 5.0)
+	textOld("Add Points by clicking with the mouse", 14.0).position(5.0, 5.0)
 	graphics {
 		val graphics = this
 		graphics.useNativeRendering = false
@@ -64,7 +64,7 @@ suspend fun main() = Korge(width = 512, height = 512) {
 		}
 
 		stage.mouse {
-			onUp {
+			onClick {
 				points.add(graphics.localMouseXY(views))
 				repaint(finished = true)
 				//println("CLICK")

samples/tweens/.gitignore

@@ -0,0 +1 @@
+/build

samples/tweens/build.gradle.kts

@@ -0,0 +1,10 @@
+import com.soywiz.korge.gradle.*
+
+apply<KorgeGradlePlugin>()
+
+korge {
+	id = "com.soywiz.samples.tweens"
+	supportShape()
+
+	targetDefault()
+}

samples/tweens/src/commonMain/kotlin/main.kt

@@ -0,0 +1,45 @@
+import com.soywiz.klock.seconds
+import com.soywiz.korge.Korge
+import com.soywiz.korge.tween.get
+import com.soywiz.korge.tween.tween
+import com.soywiz.korge.view.position
+import com.soywiz.korge.view.solidRect
+import com.soywiz.korim.color.Colors
+import com.soywiz.korio.async.delay
+
+suspend fun main() = Korge(width = 512, height = 512, virtualWidth = 512, virtualHeight = 512, title = "Tweens") {
+    val rect1 = solidRect(100, 100, Colors.RED)
+    val rect2 = solidRect(100, 100, Colors.BLUE)
+
+    while (true) {
+        tween(
+            rect1::x[width - 100],
+            rect2::y[height - 200],
+            time = 1.seconds
+        )
+
+        tween(
+            rect1::y[height - 100],
+            rect2::x[width - 100],
+            rect2::y[height - 100],
+            time = 1.seconds,
+        )
+
+        tween(
+            rect1::alpha[0],
+            rect2::alpha[0],
+            time = 1.seconds
+        )
+
+        rect1.position(0, 0)
+        rect2.position(0, 0)
+
+        tween(
+            rect1::alpha[1],
+            rect2::alpha[1],
+            time = 0.5.seconds
+        )
+
+        delay(0.25.seconds)
+    }
+}

samples/ui/src/commonMain/kotlin/main.kt

@@ -0,0 +1,115 @@
+import com.soywiz.klock.*
+import com.soywiz.korge.*
+import com.soywiz.korge.debug.*
+import com.soywiz.korge.html.*
+import com.soywiz.korge.input.*
+import com.soywiz.korge.service.process.*
+import com.soywiz.korge.tween.*
+import com.soywiz.korge.ui.*
+import com.soywiz.korge.view.*
+import com.soywiz.korgw.*
+import com.soywiz.korim.bitmap.*
+import com.soywiz.korim.color.*
+import com.soywiz.korim.font.*
+import com.soywiz.korim.format.*
+import com.soywiz.korio.file.std.*
+import com.soywiz.korio.util.*
+import com.soywiz.korma.interpolation.*
+
+suspend fun main3() = Korge(quality = GameWindow.Quality.PERFORMANCE, title = "UI", bgcolor = Colors["#1c1e0e"]) {
+    val container = fixedSizeContainer(width, height, clip = true) { }
+    container.korui {
+        addChild(UiEditProperties(app, container, views))
+        /*
+        vertical {
+            horizontal {
+                preferredWidth = 100.percent
+                //minimumWidth = 100.percent
+                button("HELLO", {
+                    //minimumWidth = 50.percent
+                    preferredWidth = 70.percent
+                    //preferredHeight = 32.pt
+                })
+                button("WORLD", {
+                    preferredWidth = 30.percent
+                    preferredHeight = 32.pt
+                })
+            }
+            button("DEMO").apply {
+                visible = false
+            }
+            button("TEST")
+            checkBox("CheckBox", checked = true)
+            comboBox("test", listOf("test", "demo"))
+        }
+        */
+    }
+}
+
+suspend fun main() = Korge(quality = GameWindow.Quality.PERFORMANCE, title = "UI") {
+	val nativeProcess = NativeProcess(views)
+
+    uiSkin = UISkin {
+        val colorTransform = ColorTransform(0.7, 0.9, 1.0)
+        this.uiSkinBitmap = this.uiSkinBitmap.withColorTransform(colorTransform)
+        this.buttonBackColor = this.buttonBackColor.transform(colorTransform)
+        this.textFont = resourcesVfs["uifont.fnt"].readBitmapFont()
+    }
+
+    uiButton(256.0, 32.0) {
+		text = "Disabled Button"
+		position(128, 128)
+		onClick {
+			println("CLICKED!")
+		}
+		disable()
+	}
+    uiButton(256.0, 32.0) {
+		text = "Enabled Button"
+		position(128, 128 + 32)
+		onClick {
+			println("CLICKED!")
+			nativeProcess.close()
+		}
+		enable()
+	}
+
+	uiScrollBar(256.0, 32.0, 0.0, 32.0, 64.0) {
+		position(64, 64)
+		onChange {
+			println(it.ratio)
+		}
+	}
+	uiScrollBar(32.0, 256.0, 0.0, 16.0, 64.0) {
+		position(64, 128)
+		onChange {
+			println(it.ratio)
+		}
+	}
+
+	uiCheckBox {
+		position(128, 128 + 64)
+	}
+
+	uiComboBox(items = listOf("ComboBox", "World", "this", "is", "a", "list", "of", "elements")) {
+		position(128, 128 + 64 + 32)
+	}
+
+	uiScrollableArea(config = {
+		position(480, 128)
+	}) {
+		for (n in 0 until 16) {
+            uiButton(text = "HELLO $n").position(0, n * 64)
+		}
+	}
+
+	val progress = uiProgressBar {
+		position(64, 32)
+		current = 0.5
+	}
+
+	while (true) {
+		tween(progress::ratio[1.0], time = 1.seconds, easing = Easing.EASE_IN_OUT)
+		tween(progress::ratio[1.0, 0.0], time = 1.seconds, easing = Easing.EASE_IN_OUT)
+	}
+}

samples/vector/.gitignore

@@ -0,0 +1 @@
+/build

samples/vector/build.gradle.kts

@@ -0,0 +1,10 @@
+import com.soywiz.korge.gradle.*
+
+apply<KorgeGradlePlugin>()
+
+korge {
+	id = "com.soywiz.samples.vector"
+	supportShape()
+
+	targetDefault()
+}

samples/vector/src/commonMain/kotlin/main.kt

@@ -0,0 +1,71 @@
+import com.soywiz.klock.*
+import com.soywiz.korge.*
+import com.soywiz.korge.view.*
+import com.soywiz.korim.bitmap.*
+import com.soywiz.korim.color.*
+import com.soywiz.korim.format.*
+import com.soywiz.korim.paint.*
+import com.soywiz.korim.vector.*
+import com.soywiz.korio.file.std.*
+import com.soywiz.korma.geom.*
+import com.soywiz.korma.geom.vector.*
+
+const val N_STEPS = 32
+
+suspend fun main() = Korge(width = 1280, height = 720, bgcolor = Colors["#2b2b2b"]) {
+    val native = true
+    //val native = false
+    val image = resourcesVfs["korge.png"].readBitmap()
+    val bmpResult = measureTimeWithResult {
+        NativeImageOrBitmap32(1280, 720, premultiplied = false, native = native).context2d {
+            listOf(LineCap.ROUND, LineCap.SQUARE, LineCap.BUTT).forEachIndexed { index, lineCap ->
+                keep {
+                    translate(128 + 256 * index, 128)
+
+                    for (n in 0 until N_STEPS) {
+                        val ratio = n.toDouble() / N_STEPS
+                        val angle = 360.degrees * ratio
+                        val radius = 96 - ratio * 16
+                        //clip({ circle(0.0, 0.0, 64.0) }) {
+                        stroke(
+                            RGBA.interpolate(Colors.GREEN, Colors.BLUE, ratio),
+                            StrokeInfo(thickness = 1.0 + ratio * 6, startCap = lineCap, endCap = lineCap)
+                        ) {
+                            moveTo(0, 0)
+                            lineTo(angle.cosine * radius, angle.sine * radius)
+                        }
+                        //}
+                    }
+                }
+            }
+            keep {
+                translate(32, 320)
+                fill(
+                    LinearGradientPaint(0, 0, 128, 128)
+                        .add(0.0, Colors.BLUE)
+                        .add(1.0, Colors.GREEN)
+                ) {
+                    rect(0, 0, 128, 128)
+                }
+            }
+            keep {
+                translate(192, 320)
+                fill(
+                    RadialGradientPaint(64, 64, 16, 64, 64, 64)
+                        .add(0.0, Colors.BLUE)
+                        .add(1.0, Colors.PURPLE)
+                ) {
+                    rect(0, 0, 128, 128)
+                }
+            }
+            keep {
+                translate(356, 320)
+                fill(BitmapPaint(image, Matrix().scale(0.25, 0.25))) {
+                    rect(0, 0, 128, 128)
+                }
+            }
+        }
+    }
+    println("Time to render: ${bmpResult.time}")
+    image(bmpResult.result)
+}

samples/video/build.gradle.kts

@@ -13,4 +13,5 @@ korge {
 
 dependencies {
 	add("commonMainApi", "com.soywiz.korlibs.korvi:korvi:2.0.7")
+	//add("commonMainApi", "com.soywiz.korlibs.korvi:korvi:2.1.1")
 }

samples/video/src/commonMain/kotlin/main.kt

@@ -9,16 +9,16 @@ import com.soywiz.korim.color.*
 import com.soywiz.korio.async.*
 import com.soywiz.korio.file.*
 import com.soywiz.korio.file.std.*
-import com.soywiz.korio.lang.*
+import com.soywiz.korio.lang.Cancellable
 import com.soywiz.korio.util.*
 import com.soywiz.korvi.*
-import kotlin.coroutines.coroutineContext
+import com.soywiz.korio.lang.*
 
 suspend fun main() = Korge(width = 1280, height = 720, bgcolor = Colors["#2b2b2b"]) {
 	//addUpdaterOnce {
 		val view = korviView(views, resourcesVfs["video.mp4"])
 		if (OS.isJs) {
-			val text = text("Click to start playing the video...")
+			val text = textOld("Click to start playing the video...")
 			mouse.click.once {
 				text.removeFromParent()
 				view.play()