Merge pull request #12 from NiklasJohansen/dev-0.7.0

0.7.0 - Improved scene and asset API, bug fixes, shader reloading and more

Author: NiklasJohansen

build.gradle.kts

@@ -4,6 +4,7 @@ plugins {
     java
     `maven-publish`
     kotlin("jvm") version "1.6.10"
+    id("me.champeau.jmh") version "0.6.6"
 }
 
 val version: String by project
@@ -59,16 +60,24 @@ dependencies {
     implementation("net.sf.trove4j:trove4j:3.0.3")
     implementation("de.undercouch:bson4jackson:2.13.1")
     implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.13.3")
+
+    // Java Microbenchmark Harness
+    jmhAnnotationProcessor("org.openjdk.jmh:jmh-generator-annprocess:1.35")
+    jmh("org.openjdk.jmh:jmh-core:1.35")
+    jmh("org.openjdk.jmh:jmh-generator-annprocess:1.34")
+    jmh("com.github.biboudis:jmh-profilers:0.1.4")
 }
 
 val sourcesJar by tasks.creating(Jar::class) {
     group = JavaBasePlugin.DOCUMENTATION_GROUP
+    duplicatesStrategy = DuplicatesStrategy.INCLUDE
     archiveClassifier.set("sources")
     exclude("*.png", "*.jpg", "*.ttf", "*.ogg", "*.txt")
     from(sourceSets.main.get().allSource)
 }
 
 val jar by tasks.getting(Jar::class) {
+    duplicatesStrategy = DuplicatesStrategy.INCLUDE
     manifest {
         attributes["Main-Class"] = mainClass
     }
@@ -105,4 +114,11 @@ publishing {
         //     url = uri("$buildDir/repository")
         // }
     }
+}
+
+jmh {
+    duplicateClassesStrategy.set(DuplicatesStrategy.INCLUDE)
+    warmupIterations.set(2)
+    iterations.set(2)
+    fork.set(2)
 }

gradle.properties

@@ -1,4 +1,4 @@
-version=0.6.3
+version=0.7.0-SNAPSHOT
 group=no.njoh
 artifact=pulse-engine
 lwjglVersion=3.3.1

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 #Wed Jul 01 20:06:20 CEST 2020
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.5.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-all.zip
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStorePath=wrapper/dists

src/jmh/java/benchmarks/ForEachBenchmark.kt

@@ -0,0 +1,29 @@
+package benchmarks
+
+import no.njoh.pulseengine.core.shared.utils.Extensions.forEachFast
+import org.openjdk.jmh.annotations.Benchmark
+import org.openjdk.jmh.annotations.Scope
+import org.openjdk.jmh.annotations.State
+import org.openjdk.jmh.infra.Blackhole
+
+@State(Scope.Benchmark)
+open class ForEachBenchmark
+{
+    private var numbers = (0 .. 1000).shuffled()
+
+    @Benchmark
+    fun benchmarkForEachFast(bh: Blackhole)
+    {
+        var sum = 0
+        numbers.forEachFast { sum += it }
+        bh.consume(sum)
+    }
+
+    @Benchmark
+    fun benchmarkForEach(bh: Blackhole)
+    {
+        var sum = 0
+        numbers.forEach { sum += it }
+        bh.consume(sum)
+    }
+}

src/main/kotlin/no/njoh/pulseengine/core/PulseEngineImpl.kt

@@ -4,7 +4,6 @@ import no.njoh.pulseengine.core.asset.AssetManagerImpl
 import no.njoh.pulseengine.core.asset.AssetManagerInternal
 import no.njoh.pulseengine.core.asset.types.Font
 import no.njoh.pulseengine.core.asset.types.Sound
-import no.njoh.pulseengine.core.asset.types.Text
 import no.njoh.pulseengine.core.asset.types.Texture
 import no.njoh.pulseengine.core.audio.AudioImpl
 import no.njoh.pulseengine.core.audio.AudioInternal
@@ -21,7 +20,9 @@ import no.njoh.pulseengine.core.input.InputImpl
 import no.njoh.pulseengine.core.input.InputInternal
 import no.njoh.pulseengine.core.scene.SceneManagerImpl
 import no.njoh.pulseengine.core.scene.SceneManagerInternal
+import no.njoh.pulseengine.core.shared.utils.Extensions.forEachFast
 import no.njoh.pulseengine.core.shared.utils.Extensions.toNowFormatted
+import no.njoh.pulseengine.core.shared.utils.FileWatcher
 import no.njoh.pulseengine.core.shared.utils.FpsLimiter
 import no.njoh.pulseengine.core.shared.utils.Logger
 import no.njoh.pulseengine.core.widget.WidgetManagerImpl
@@ -105,7 +106,7 @@ class PulseEngineImpl(
 
         // Reload sound buffers to new OpenAL context
         audio.setOnOutputDeviceChanged {
-            asset.getAll(Sound::class.java).forEach { it.reloadBuffer() }
+            asset.getAllOfType<Sound>().forEachFast { it.reloadBuffer() }
         }
 
         // Notify gfx implementation about loaded textures
@@ -174,6 +175,7 @@ class PulseEngineImpl(
         data.measureAndUpdateTimeStats()
         {
             updateInput()
+            console.update()
             game.onUpdate()
             scene.update()
             widget.update(this)
@@ -251,6 +253,7 @@ class PulseEngineImpl(
 
     private fun destroy()
     {
+        FileWatcher.shutdown()
         scene.cleanUp()
         widget.cleanUp(this)
         audio.cleanUp()

src/main/kotlin/no/njoh/pulseengine/core/asset/AssetManager.kt

@@ -5,21 +5,69 @@ import kotlin.reflect.KClass
 
 abstract class AssetManager
 {
+    /**
+     * Adds the [asset] to the [AssetManager] and returns it.
+     */
     abstract fun <T : Asset> add(asset: T): T
-    abstract fun <T : Asset> get(assetName: String): T
-    abstract fun <T : Asset> getAll(type: Class<T>): List<T>
 
-    inline fun <reified T : Asset> getSafe(assetName: String): T? = getSafe(assetName, T::class)
-    @PublishedApi internal abstract fun <T : Asset> getSafe(assetName: String, type: KClass<T>): T?
+    /**
+     * Removes the [Asset] with given [assetName] and calls its delete function.
+     */
+    abstract fun delete(assetName: String)
 
+    /**
+     * Returns the [Asset] with name [assetName] and type [T] or null if not found.
+     */
+    inline fun <reified T : Asset> getOrNull(assetName: String): T? = getOrNull(assetName, T::class)
+
+    /**
+     * Returns a list of all [Asset]s with given type [T].
+     */
+    inline fun <reified T : Asset> getAllOfType(): List<T> = getAllOfType(T::class)
+
+    /**
+     * Loads all [Texture]s in the given [directory].
+     */
     abstract fun loadAllTextures(directory: String)
+
+    /**
+     * Loads the file with given [fileName] and ads it to the [AssetManager] as a [Texture].
+     */
     abstract fun loadTexture(fileName: String, assetName: String): Texture
+
+    /**
+     * Loads the file with given [fileName] and ads it to the [AssetManager] as a [SpriteSheet].
+     */
     abstract fun loadSpriteSheet(fileName: String, assetName: String, horizontalCells: Int, verticalCells: Int): SpriteSheet
+
+    /**
+     * Loads the file with given [fileName] and ads it to the [AssetManager] as a [Font].
+     */
     abstract fun loadFont(fileName: String, assetName: String, fontSizes: FloatArray): Font
+
+    /**
+     * Loads the file with given [fileName] and ads it to the [AssetManager] as a [Cursor].
+     */
     abstract fun loadCursor(fileName: String, assetName: String, xHotSpot: Int, yHotSpot: Int): Cursor
+
+    /**
+     * Loads the file with given [fileName] and ads it to the [AssetManager] as a [Sound].
+     */
     abstract fun loadSound(fileName: String, assetName: String): Sound
+
+    /**
+     * Loads the file with given [fileName] and ads it to the [AssetManager] as a [Text].
+     */
     abstract fun loadText(fileName: String, assetName: String): Text
+
+    /**
+     * Loads the file with given [fileName] and ads it to the [AssetManager] as a [Binary].
+     */
     abstract fun loadBinary(fileName: String, assetName: String): Binary
+
+    // Internal abstract versions of the public inline functions
+    @PublishedApi internal abstract fun <T : Asset> getAllOfType(type: KClass<T>): List<T>
+    @PublishedApi internal abstract fun <T : Asset> getOrNull(assetName: String, type: KClass<T>): T?
 }
 
 abstract class AssetManagerInternal : AssetManager()

src/main/kotlin/no/njoh/pulseengine/core/asset/AssetManagerImpl.kt

@@ -1,13 +1,15 @@
 package no.njoh.pulseengine.core.asset
 
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import no.njoh.pulseengine.core.asset.types.*
 import no.njoh.pulseengine.core.shared.utils.Logger
 import no.njoh.pulseengine.core.shared.utils.Extensions.forEachFast
-import no.njoh.pulseengine.core.shared.utils.Extensions.forEachFiltered
 import no.njoh.pulseengine.core.shared.utils.Extensions.loadFileNames
+import no.njoh.pulseengine.core.shared.utils.Extensions.toNowFormatted
 import kotlin.reflect.KClass
+import kotlin.reflect.safeCast
 
 open class AssetManagerImpl : AssetManagerInternal()
 {
@@ -17,15 +19,11 @@ open class AssetManagerImpl : AssetManagerInternal()
     private var onAssetRemovedCallbacks = mutableListOf<(Asset) -> Unit>()
 
     @Suppress("UNCHECKED_CAST")
-    override fun <T : Asset> get(assetName: String): T =
-        assets[assetName]?.let { it as T } ?: throw IllegalArgumentException("No asset loaded with name: $assetName")
+    override fun <T : Asset> getOrNull(assetName: String, type: KClass<T>): T? =
+        assets[assetName]?.let { type.safeCast(it) }
 
-    @Suppress("UNCHECKED_CAST")
-    override fun <T : Asset> getSafe(assetName: String, type: KClass<T>): T? =
-        assets[assetName]?.takeIf { it::class == type }?.let { it as T }
-
-    override fun <T : Asset> getAll(type: Class<T>): List<T> =
-        assets.values.filterIsInstance(type)
+    override fun <T : Asset> getAllOfType(type: KClass<T>): List<T> =
+        assets.values.filterIsInstance(type.java)
 
     override fun loadTexture(fileName: String, assetName: String): Texture =
         Texture(fileName, assetName).also { add(it)  }
@@ -51,16 +49,18 @@ open class AssetManagerImpl : AssetManagerInternal()
     override fun loadAllTextures(directory: String) =
         directory
             .loadFileNames()
-            .forEachFiltered(
-                { fileName -> Texture.SUPPORTED_FORMATS.any { fileName.endsWith(it) } },
-                { fileName -> loadTexture(fileName, fileName.substringAfterLast("/").substringBeforeLast(".")) }
-            )
+            .filter { fileName -> Texture.SUPPORTED_FORMATS.any { fileName.endsWith(it) } }
+            .forEachFast { fileName ->
+                val assetName = fileName.substringAfterLast("/").substringBeforeLast(".")
+                if (assets.none { it.value.name == assetName })
+                    loadTexture(fileName, assetName)
+            }
 
     override fun loadInitialAssets()
     {
         val startTime = System.nanoTime()
         add(Font.DEFAULT)
-        runBlocking()
+        runBlocking(Dispatchers.IO)
         {
             assets.values.forEach()
             {
@@ -69,23 +69,33 @@ open class AssetManagerImpl : AssetManagerInternal()
         }
         assets.values.forEach { asset -> onAssetLoadedCallbacks.forEachFast { it.invoke(asset)  } }
         initialAssetsLoaded = true
-        Logger.debug("Loaded ${assets.size} assets in ${(System.nanoTime() - startTime) / 1_000_000} ms. [${assets.values.joinToString { it.name }}]")
+        Logger.debug("Loaded ${assets.size} assets in ${startTime.toNowFormatted()}. [${assets.values.joinToString { it.name }}]")
     }
 
     override fun <T: Asset> add(asset: T): T
     {
-        if (assets.containsKey(asset.name))
-            Logger.warn("Asset with name: ${asset.name} already exists and will be overridden")
+        val existingAsset = assets[asset.name]
+        if (existingAsset != null)
+        {
+            Logger.warn("Asset with name: ${existingAsset.name} already exists and will be deleted and overridden")
+            existingAsset.delete()
+        }
 
-        assets[asset.name] = asset
         if (initialAssetsLoaded)
         {
             asset.load()
             onAssetLoadedCallbacks.forEachFast { it.invoke(asset)  }
         }
+
+        assets[asset.name] = asset
         return asset
     }
 
+    override fun delete(assetName: String)
+    {
+        assets.remove(assetName)?.delete()
+    }
+
     override fun setOnAssetLoaded(callback: (Asset) -> Unit)
     {
         onAssetLoadedCallbacks.add(callback)

src/main/kotlin/no/njoh/pulseengine/core/console/CommandRegistry.kt

@@ -7,8 +7,13 @@ import no.njoh.pulseengine.core.shared.primitives.Subscription
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import no.njoh.pulseengine.core.console.MessageType.WARN
+import no.njoh.pulseengine.core.graphics.api.Shader
+import no.njoh.pulseengine.core.graphics.api.Shader.Companion.getShaderFromAbsolutePath
 import no.njoh.pulseengine.core.graphics.api.ShaderProgram
 import no.njoh.pulseengine.core.scene.SceneManagerInternal
+import no.njoh.pulseengine.core.shared.utils.FileWatcher
+import no.njoh.pulseengine.core.shared.utils.Logger
 import java.io.File
 import kotlin.reflect.KMutableProperty
 import kotlin.reflect.full.declaredMemberProperties
@@ -243,13 +248,46 @@ object CommandRegistry
             CommandResult("Reloaded entity types", showCommand = false)
         }
 
-        ///////////////////////////////////////////// RELOAD POST PROCESSING SHADERS /////////////////////////////////////////////
+        ///////////////////////////////////////////// RELOAD SHADERS /////////////////////////////////////////////
 
         engine.console.registerCommand(
-            "reloadShaders"
+            "reloadAllShaders"
         ) {
+            Logger.debug("\nReloading all shaders...")
+            Shader.reloadAll()
             ShaderProgram.reloadAll()
             CommandResult("Reloaded all shaders", showCommand = false)
         }
+
+        engine.console.registerCommand(
+            "reloadShader {fileName:String}"
+        ) {
+            val fileName = getString("fileName")
+            val shader = getShaderFromAbsolutePath(fileName)
+            if (shader != null)
+            {
+                val success = shader.reload(fileName)
+                if (success)
+                    ShaderProgram.reloadAll()
+                CommandResult("Reloaded shader: $fileName", showCommand = false)
+            }
+            else CommandResult("Found no shader with filename: $fileName", showCommand = false, type = WARN)
+        }
+
+        ///////////////////////////////////////////// WATCH FILE CHANGES /////////////////////////////////////////////
+
+        engine.console.registerCommand(
+            "watchFileChange {path:String} {triggerCommand:String} {interval:Int?} {fileTypes:String?} {maxDepth:Int?}"
+        ) {
+            val path = getString("path")
+            val command = getString("triggerCommand")
+            val interval = getOptionalInt("interval") ?: 10
+            val fileTypes = getOptionalString("fileTypes")?.split(";") ?: emptyList()
+            val maxDepth = getOptionalInt("maxDepth") ?: 5
+            FileWatcher.setOnFileChanged(path, fileTypes, maxDepth, interval) { fileName ->
+                engine.console.runLater("$command \"$fileName\"", showCommand = true)
+            }
+            CommandResult("Watching for file changes every $interval seconds in $path", showCommand = false)
+        }
     }
 }

src/main/kotlin/no/njoh/pulseengine/core/console/Console.kt

@@ -6,6 +6,7 @@ interface Console
 {
     fun log(text: String, type: MessageType = MessageType.INFO)
     fun run(commandString: String, showCommand: Boolean = true): List<CommandResult>
+    fun runLater(commandString: String, showCommand: Boolean = true)
     fun runScript(filename: String)
     fun registerCommand(template: String, description: String = "", isAlias: Boolean = false, block: CommandArguments.() -> CommandResult)
     fun getHistory(index: Int, type: MessageType): ConsoleEntry?
@@ -17,6 +18,7 @@ interface Console
 interface ConsoleInternal : Console
 {
     fun init(engine: PulseEngine)
+    fun update()
 }
 
 data class Command(