skeletal: pack matrices async

src/main/java/de/bixilon/minosoft/gui/rendering/entities/EntitiesRenderer.kt

@@ -65,6 +65,7 @@ class EntitiesRenderer(
                 visibility.update(it, millis)
                 if (!it.visible) return@iterate
                 it.update(millis)
+                it.prepare()
                 visibility.collect(it)
             } catch (error: Throwable) {
                 error.printStackTrace()

src/main/java/de/bixilon/minosoft/gui/rendering/entities/feature/EntityRenderFeature.kt

@@ -36,6 +36,7 @@ abstract class EntityRenderFeature(val renderer: EntityRenderer<*>) : Comparable
     }
 
     open fun reset() = Unit
+    open fun prepare() = Unit
     open fun update(millis: Long, delta: Float) = Unit
     open fun unload() = Unit
 

src/main/java/de/bixilon/minosoft/gui/rendering/entities/feature/FeatureManager.kt

@@ -37,6 +37,13 @@ class FeatureManager(val renderer: EntityRenderer<*>) : Iterable<EntityRenderFea
         }
     }
 
+    fun prepare() {
+        for (feature in features) {
+            if (feature.isInvisible()) continue
+            feature.prepare()
+        }
+    }
+
     fun unload() {
         for (feature in features) {
             feature.unload()

src/main/java/de/bixilon/minosoft/gui/rendering/entities/feature/SkeletalFeature.kt

@@ -67,6 +67,10 @@ open class SkeletalFeature(
         instance.animation.draw(delta)
     }
 
+    override fun prepare() {
+        instance.transform.pack(instance.matrix)
+    }
+
     override fun draw() {
         var tint = renderer.light.value
         if (renderer is LivingEntityRenderer<*>) {

src/main/java/de/bixilon/minosoft/gui/rendering/entities/model/human/PlayerModel.kt

@@ -48,7 +48,7 @@ open class PlayerModel(
         shader.skinParts = this.skinParts
 
 
-        manager.upload(instance, instance.matrix)
+        manager.upload(instance)
         instance.model.mesh.draw()
     }
 }

src/main/java/de/bixilon/minosoft/gui/rendering/entities/renderer/EntityRenderer.kt

@@ -79,6 +79,10 @@ abstract class EntityRenderer<E : Entity>(
         features.update(millis, delta)
     }
 
+    open fun prepare() {
+        features.prepare()
+    }
+
     open fun updateRenderInfo(millis: Long) {
         entity.draw(millis)
         this.distance = (entity.renderInfo.eyePosition - renderer.connection.camera.entity.renderInfo.eyePosition).length2()

src/main/java/de/bixilon/minosoft/gui/rendering/skeletal/SkeletalManager.kt

@@ -24,7 +24,6 @@ import org.lwjgl.system.MemoryUtil.memAllocFloat
 class SkeletalManager(
     val context: RenderContext,
 ) {
-    private val cache: Array<Mat4> = Array(MAX_TRANSFORMS) { Mat4() } // reusing matrices
     val buffer = context.system.createFloatUniformBuffer(memAllocFloat(MAX_TRANSFORMS * Mat4.length))
     val shader = context.system.createShader(minosoft("skeletal/normal")) { SkeletalShader(it, buffer) }
     val lightmapShader = context.system.createShader(minosoft("skeletal/lightmap")) { LightmapSkeletalShader(it, buffer) }
@@ -38,8 +37,8 @@ class SkeletalManager(
         lightmapShader.load()
     }
 
-    fun upload(instance: SkeletalInstance, matrix: Mat4) {
-        instance.transform.pack(buffer.buffer, matrix, cache)
+    fun upload(instance: SkeletalInstance) {
+        instance.transform.pack(buffer.buffer)
         buffer.upload(0, instance.model.transformCount * Mat4.length)
     }
 

src/main/java/de/bixilon/minosoft/gui/rendering/skeletal/instance/SkeletalInstance.kt

@@ -53,13 +53,14 @@ class SkeletalInstance(
     fun draw(shader: Shader) {
         shader.use()
 
-        context.skeletal.upload(this, matrix)
+        context.skeletal.upload(this)
         model.mesh.draw()
     }
 
     fun update(time: Long = millis()) {
         transform.reset()
         animation.draw(time)
+        transform.pack(matrix)
     }
 
     fun update(position: Vec3, rotation: Vec3, pivot: Vec3 = Vec3.EMPTY_INSTANCE, matrix: Mat4? = null) {

src/main/java/de/bixilon/minosoft/gui/rendering/skeletal/instance/TransformInstance.kt

@@ -36,17 +36,24 @@ class TransformInstance(
         }
     }
 
-    fun pack(buffer: FloatBuffer, parent: Mat4, cache: Array<Mat4>) {
-        val temp = cache[this.id]
-        parent.times(value, temp) // TODO: don't multiply them on the rendering thread
+    fun pack(parent: Mat4) {
+        parent.times(value, value)
+
+        for (child in array) {
+            child.pack(this.value)
+        }
+    }
+
+    fun pack(buffer: FloatBuffer) {
+        val array = value.array
 
         val offset = this.id * Mat4.length
         for (index in 0 until Mat4.length) {
-            buffer.put(offset + index, temp.array[index])
+            buffer.put(offset + index, array[index])
         }
 
-        for (child in array) {
-            child.pack(buffer, temp, cache)
+        for (child in this.array) {
+            child.pack(buffer)
         }
     }