Added various default fonts

Added an engine specific loading icon

application-interface/src/main/kotlin/com/mechanica/engine/context/loader/FontLoader.kt

@@ -1,11 +1,10 @@
 package com.mechanica.engine.context.loader
 
-import com.mechanica.engine.text.Font
 import com.mechanica.engine.resources.Resource
+import com.mechanica.engine.text.Font
 import com.mechanica.engine.text.FontAtlasConfiguration
 
 interface FontLoader {
-    val defaultFont: Font
     fun font(res: Resource, initializer: FontAtlasConfiguration.() -> Unit): Font
 
 }

application-interface/src/main/kotlin/com/mechanica/engine/text/Font.kt

@@ -18,7 +18,14 @@ abstract class Font {
 
     companion object {
 
-        val defaultFont = GLLoader.fontLoader.defaultFont
+        val defaultFont by lazy { defaults.regular(false) }
+
+        val defaults: FontSet
+            get() = CachedFontSet("roboto/Roboto") {
+                width = 1024
+                height = 1024
+                characterSize = 175f
+            }
 
         fun create(resource: Resource, configureAtlas: FontAtlasConfiguration.() -> Unit = { }): Font {
             return GLLoader.fontLoader.font(resource, configureAtlas)

application-interface/src/main/kotlin/com/mechanica/engine/text/FontSet.kt

@@ -0,0 +1,81 @@
+package com.mechanica.engine.text
+
+import com.mechanica.engine.resources.Resource
+
+open class FontSet(protected val name: String, protected val configureAtlas: FontAtlasConfiguration.() -> Unit = { }) {
+    protected var modifier = Modifiers.REGULAR
+    protected var italic = ""
+
+    protected val fileName: String
+        get() = "res/fonts/${toString()}.ttf"
+
+    fun regular(italic: Boolean): Font {
+        if (italic) this.italic = italicString
+        modifier = Modifiers.REGULAR
+        return create()
+    }
+
+    fun bold(italic: Boolean): Font {
+        if (italic) this.italic = italicString
+        modifier = Modifiers.BOLD
+        return create()
+    }
+
+    fun medium(italic: Boolean): Font {
+        if (italic) this.italic = italicString
+        modifier = Modifiers.MEDIUM
+        return create()
+    }
+
+    fun black(italic: Boolean): Font {
+        if (italic) this.italic = italicString
+        modifier = Modifiers.BLACK
+        return create()
+    }
+
+    fun light(italic: Boolean): Font {
+        if (italic) this.italic = italicString
+        modifier = Modifiers.LIGHT
+        return create()
+    }
+
+    fun thin(italic: Boolean): Font {
+        if (italic) this.italic = italicString
+        modifier = Modifiers.THIN
+        return create()
+    }
+
+    open fun create() = Font.create(Resource(fileName), configureAtlas)
+
+    override fun toString(): String {
+        return "$name-$modifier$italic"
+    }
+
+    enum class Modifiers(val string: String) {
+        REGULAR("Regular"),
+        BOLD("Bold"),
+        BLACK("Black"),
+        LIGHT("Light"),
+        THIN("Thin"),
+        MEDIUM("Medium");
+
+        override fun toString(): String {
+            return string
+        }
+    }
+
+    companion object {
+        const val italicString = "Italic"
+    }
+}
+
+class CachedFontSet(name: String, configureAtlas: FontAtlasConfiguration.() -> Unit = { }) : FontSet(name, configureAtlas) {
+    override fun create(): Font {
+        val fileName = this.fileName
+        return fontMap[fileName] ?: super.create().also { fontMap[fileName] = it }
+    }
+
+    companion object {
+        private val fontMap = HashMap<String, Font>()
+    }
+}

application-interface/src/main/kotlin/com/mechanica/engine/text/Text.kt

@@ -1,12 +1,11 @@
 package com.mechanica.engine.text
 
-import com.mechanica.engine.context.loader.GLLoader
 import com.mechanica.engine.unit.vector.DynamicVector
 import com.mechanica.engine.util.extensions.constrain
 import kotlin.math.abs
 import kotlin.math.max
 
-class Text(text: String, font: Font = GLLoader.fontLoader.defaultFont) {
+class Text(text: String, font: Font = Font.defaultFont) {
 
     var string = text
         set(value) {

desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglFontLoader.kt

@@ -1,16 +1,9 @@
 package com.mechanica.engine.context.loader
 
-import com.mechanica.engine.text.LwjglStandardFont
-import com.mechanica.engine.text.Font
 import com.mechanica.engine.resources.Resource
 import com.mechanica.engine.text.FontAtlasConfiguration
+import com.mechanica.engine.text.LwjglStandardFont
 
 class LwjglFontLoader : FontLoader {
-    override val defaultFont: Font by lazy { LwjglStandardFont(Resource("res/fonts/Roboto-Regular.ttf")) {
-        width = 1024
-        height = 1024
-        characterSize = 200f
-    } }
-
     override fun font(res: Resource, initializer: FontAtlasConfiguration.() -> Unit) = LwjglStandardFont(res, initializer)
 }

mechanica/src/main/kotlin/com/mechanica/engine/animation/AnimationFormula.kt

@@ -20,8 +20,8 @@ class AnimationFormula(
     override var looped = false
     override var paused = false
 
-    var value = formula(formulas, 0.0)
-        private set
+    val value: Double
+        get() = formula(formulas, relativeTime)
 
     override var time = startTime
         private set(value) {
@@ -58,7 +58,6 @@ class AnimationFormula(
     override fun update(delta: Double) {
         if (!paused) {
             time += delta
-            value = formula(formulas, relativeTime)
         }
     }
 

mechanica/src/main/kotlin/com/mechanica/engine/animation/AnimationSequence.kt

@@ -1,5 +1,6 @@
 package com.mechanica.engine.animation
 
+import com.mechanica.engine.util.extensions.constrainLooped
 import com.mechanica.engine.util.extensions.fori
 
 class AnimationSequence(private vararg val animations: AnimationController): AnimationController {
@@ -9,7 +10,13 @@ class AnimationSequence(private vararg val animations: AnimationController): Ani
     override var looped: Boolean = false
 
     override var time: Double = 0.0
-        private set
+        private set(value) {
+            field = if (looped) {
+                value.constrainLooped(startTime, endTime)
+            } else {
+                value
+            }
+        }
 
     override var paused = false
         set(value) {
@@ -61,7 +68,6 @@ class AnimationSequence(private vararg val animations: AnimationController): Ani
         if (!paused) {
             animations.fori {
                 it.goTo(time)
-                it.update(delta)
             }
             time += delta
         }

mechanica/src/main/kotlin/com/mechanica/engine/game/delta/AdaptiveDeltaCalculator.kt

@@ -6,7 +6,7 @@ import kotlin.math.abs
 import kotlin.math.max
 import kotlin.math.roundToInt
 
-class AdaptiveDeltaCalculator(frameTime: Double) : DeltaCalculator {
+internal class AdaptiveDeltaCalculator(frameTime: Double) : DeltaCalculator {
     private var targetUpdateCount = 1.0
     private var dt = frameTime/targetUpdateCount
 

mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/LoadScene.kt

@@ -2,7 +2,7 @@ package com.mechanica.engine.scenes.scenes
 
 import com.mechanica.engine.scenes.processes.LoadProcess
 
-abstract class LoadScene(waitTime: Float = 0.2f, waitLoops: Int = 2) : Scene() {
+abstract class LoadScene(order: Int = 0, waitTime: Float = 0.2f, waitLoops: Int = 2) : Scene(order) {
 
     init {
         addProcess(object : LoadProcess(order = -1, waitTime, waitLoops) {

mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/logo/MechanicaLoadingIcon.kt

@@ -0,0 +1,41 @@
+package com.mechanica.engine.scenes.scenes.logo
+
+import com.mechanica.engine.animation.AnimationFormula
+import com.mechanica.engine.animation.AnimationFormulas
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.game.view.View
+import com.mechanica.engine.models.Image
+import com.mechanica.engine.resources.Res
+import com.mechanica.engine.scenes.addAnimationSequence
+import com.mechanica.engine.scenes.scenes.sprites.StaticSprite
+import com.mechanica.engine.unit.angle.degrees
+
+open class MechanicaLoadingIcon(view: View, order: Int = 0) : StaticSprite(view, order) {
+    private val mother = Image.loadImage(Res.image("logo/astrolabe-mother"))
+    private val rete = Image.loadImage(Res.image("logo/astrolabe-rete"))
+    private val rule = Image.loadImage(Res.image("logo/astrolabe-rule"))
+
+    private var buffer = AnimationFormula(-1.5, 0.0) { 1.0 }
+    private var ruleAngle = AnimationFormula(0.0, 2.5, AnimationFormulas.quadraticBump(0.0, 360.0))
+    private var reteAngle = AnimationFormula(0.0, 2.5, AnimationFormulas.quadraticAscending(360.0, 0.0))
+
+    val sequence = addAnimationSequence(buffer, reteAngle, ruleAngle)
+
+    constructor(
+            x: Double = 0.0,
+            y: Double = 0.0,
+            width: Double = 1.0,
+            height: Double = 1.0,
+            order: Int = 0) : this(View.create(x, y, width, height), order)
+
+    init {
+        sequence.play()
+        sequence.looped = true
+    }
+
+    override fun render(draw: Drawer) {
+        draw.inView.image(mother)
+        draw.inView.rotated(reteAngle.value.degrees).image(rete)
+        draw.inView.rotated(ruleAngle.value.degrees).image(rule)
+    }
+}

mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/logo/MechanicaStartupLoadingScreen.kt

@@ -0,0 +1,11 @@
+package com.mechanica.engine.scenes.scenes.logo
+
+import com.mechanica.engine.animation.AnimationSequence
+import com.mechanica.engine.color.Color
+import com.mechanica.engine.scenes.scenes.LoadScene
+
+abstract class MechanicaStartupLoadingScreen(textColor: Color = Color.black, order: Int = 0) : LoadScene(order) {
+    private val startupScreen = addScene(MechanicaStartupScreen(textColor))
+    val sequence: AnimationSequence
+        get() = startupScreen.sequence
+}

mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/logo/MechanicaStartupScreen.kt

@@ -0,0 +1,43 @@
+package com.mechanica.engine.scenes.scenes.logo
+
+import com.mechanica.engine.animation.AnimationFormula
+import com.mechanica.engine.animation.AnimationFormulas
+import com.mechanica.engine.color.Color
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.game.view.View
+import com.mechanica.engine.models.Image
+import com.mechanica.engine.models.ImageModel
+import com.mechanica.engine.resources.Res
+import com.mechanica.engine.scenes.addAnimationSequence
+import com.mechanica.engine.scenes.scenes.UIScene
+import com.mechanica.engine.text.Font
+import com.mechanica.engine.text.Text
+import kotlin.math.min
+
+class MechanicaStartupScreen(private val textColor: Color = Color.black, order: Int = 0) : UIScene(order) {
+    private val titleSize: Double = min(camera.width, camera.height)
+    private val title = ImageModel(Image.loadImage(Res.image("logo/mechanica-title")))
+
+    private val poweredBy = Text("Powered by", Font.defaults.bold(true))
+
+    private val logo = addScene(object : MechanicaLoadingIcon(0.0, -0.075*titleSize, 0.37*titleSize, 0.37*titleSize, 1){
+        override fun drawInView(draw: Drawer, view: View): Drawer {
+            return super.drawInView(draw, view).ui.color.alpha(logoFadeIn.value)
+        }
+    })
+
+    private val textFadeIn = AnimationFormula(2.0, 4.0, AnimationFormulas.linear(0.0, 1.0) )
+    private val logoFadeIn = AnimationFormula(-1.0, 1.0, AnimationFormulas.linear(0.0, 1.0) )
+    val sequence = addAnimationSequence(textFadeIn, logoFadeIn, logo.sequence)
+
+    init {
+        logo.sequence.looped = false
+        sequence.play()
+    }
+
+    override fun render(draw: Drawer) {
+        draw.darkGrey.alpha(textFadeIn.value).text(poweredBy, 0.04*titleSize, -0.47*titleSize, 0.225*titleSize)
+        draw.color(textColor).alpha(textFadeIn.value)
+        draw.centered.ui.transformed.scale(titleSize).model(title, 0f, 1f, true)
+    }
+}

mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/sprites/StaticSprite.kt

@@ -11,7 +11,7 @@ abstract class StaticSprite(override val view: View, order: Int = 0) : Scene(ord
             y: Double = 0.0,
             width: Double = 1.0,
             height: Double = 1.0,
-            priority: Int = 0) : this(View.create(x, y, width, height), priority)
+            order: Int = 0) : this(View.create(x, y, width, height), order)
 
     abstract override fun render(draw: Drawer)
 }

samples/src/main/kotlin/com/mechanica/engine/samples/scenes/LoadSceneDemo.kt

@@ -0,0 +1,52 @@
+package com.mechanica.engine.samples.scenes
+
+import com.mechanica.engine.color.Color
+import com.mechanica.engine.config.configure
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.game.Game
+import com.mechanica.engine.scenes.scenes.LoadScene
+import com.mechanica.engine.scenes.scenes.Scene
+import com.mechanica.engine.scenes.scenes.logo.MechanicaStartupScreen
+import com.mechanica.engine.scenes.setNewMainScene
+import com.mechanica.engine.text.Font
+import com.mechanica.engine.text.Text
+
+fun main() {
+    Game.configure {
+        setViewport(height = 10.0)
+        setStartingScene { LoadSceneDemo() }
+        setFullscreen(true)
+    }
+
+    Game.loop()
+}
+
+
+class LoadSceneDemo : LoadScene() {
+
+    init {
+        addScene(MechanicaStartupScreen(Color.white))
+    }
+
+    override fun load() {
+        // Assets can be loaded here
+        Thread.sleep(6000)
+    }
+
+    override fun onFinish() {
+        setNewMainScene { ExampleGameScene() }
+    }
+
+    override fun render(draw: Drawer) {
+        draw.black.background()
+    }
+}
+
+
+class ExampleGameScene : Scene() {
+    val text = Text("Example Game Scene", Font.defaults.black(true))
+    override fun render(draw: Drawer) {
+        draw.white.background()
+        draw.centered.darkGrey.text(text)
+    }
+}