baked face: pre transform uv coordinates

src/integration-test/kotlin/de/bixilon/minosoft/gui/rendering/models/baked/BakedFaceTest.kt

@@ -61,7 +61,7 @@ class BakedFaceTest {
 
         val mesh = mesh()
 
-        face.render(floatArrayOf(0.0f, 0.0f, 0.0f), mesh, byteArrayOf(0, 0, 0, 0, 0, 0, 0), null, FloatArray(2))
+        face.render(floatArrayOf(0.0f, 0.0f, 0.0f), mesh, byteArrayOf(0, 0, 0, 0, 0, 0, 0), null)
 
         val texture = 0.buffer()
         val lightTint = 0xFFFFFF.buffer()
@@ -83,7 +83,7 @@ class BakedFaceTest {
 
         val mesh = mesh()
 
-        face.render(floatArrayOf(0.0f, 0.0f, 0.0f), mesh, byteArrayOf(0, 0, 0, 0, 0, 0, 0), null, FloatArray(2))
+        face.render(floatArrayOf(0.0f, 0.0f, 0.0f), mesh, byteArrayOf(0, 0, 0, 0, 0, 0, 0), null)
 
         val texture = 0.buffer()
         val lightTint = 0xFFFFFF.buffer()

src/main/java/de/bixilon/minosoft/gui/rendering/chunk/entities/renderer/sign/SignBlockEntityRenderer.kt

@@ -58,7 +58,7 @@ class SignBlockEntityRenderer(
         return rotation * 22.5f
     }
 
-    override fun render(position: BlockPosition, offset: FloatArray, mesh: ChunkMesh, random: Random?, state: BlockState, neighbours: Array<BlockState?>, light: ByteArray, tints: IntArray?, temp: FloatArray): Boolean {
+    override fun render(position: BlockPosition, offset: FloatArray, mesh: ChunkMesh, random: Random?, state: BlockState, neighbours: Array<BlockState?>, light: ByteArray, tints: IntArray?): Boolean {
         val block = this.blockState.block
         if (block is StandingSignBlock) {
             renderStandingText(offset, mesh, light[SELF_LIGHT_INDEX].toInt())

src/main/java/de/bixilon/minosoft/gui/rendering/chunk/mesh/SingleChunkMesh.kt

@@ -38,12 +38,13 @@ class SingleChunkMesh(context: RenderContext, initialCacheSize: Int, onDemand: B
         )
     }
 
-    fun addVertex(x: Float, y: Float, z: Float, uv: FloatArray, texture: Texture, shaderTextureId: Float, lightTint: Float) {
+    fun addVertex(x: Float, y: Float, z: Float, u: Float, v: Float, shaderTextureId: Float, lightTint: Float) {
         data.ensureSize(WorldMeshStruct.FLOATS_PER_VERTEX)
-        val transformedUV = texture.renderData.transformUV(uv)
+        data.add(
-        data.add(x, y, z)
+            x, y, z,
-        data.add(transformedUV)
+            u, v,
-        data.add(shaderTextureId, lightTint)
+            shaderTextureId, lightTint,
+        )
     }
 
     override fun compareTo(other: SingleChunkMesh): Int {

src/main/java/de/bixilon/minosoft/gui/rendering/chunk/mesher/SolidSectionMesher.kt

@@ -65,7 +65,6 @@ class SolidSectionMesher(
         val entities: MutableList<BlockEntityRenderer<*>> = ArrayList()
 
         val position = BlockPosition()
-        val temp = FloatArray(2)
         val neighbourBlocks: Array<BlockState?> = arrayOfNulls(Directions.SIZE)
         val light = ByteArray(Directions.SIZE + 1) // last index (6) for the current block
 
@@ -148,10 +147,10 @@ class SolidSectionMesher(
 
 
                     val tints = tints.getAverageBlockTint(chunk, neighbourChunks, state, x, y, z)
-                    var rendered = model.render(position, floatOffset, mesh, random, state, neighbourBlocks, light, tints, temp)
+                    var rendered = model.render(position, floatOffset, mesh, random, state, neighbourBlocks, light, tints)
 
                     if (entity is BlockRender) {
-                        rendered = entity.render(position, floatOffset, mesh, random, state, neighbourBlocks, light, tints, temp) || rendered
+                        rendered = entity.render(position, floatOffset, mesh, random, state, neighbourBlocks, light, tints) || rendered
                     }
 
                     if (offset != null) {

src/main/java/de/bixilon/minosoft/gui/rendering/models/block/BlockModelPrototype.kt

@@ -31,7 +31,7 @@ import de.bixilon.minosoft.gui.rendering.models.loader.legacy.ModelChooser
 import java.util.*
 
 class BlockModelPrototype(val model: DirectBlockModel) : BlockRender {
-    override fun render(position: BlockPosition, offset: FloatArray, mesh: ChunkMesh, random: Random?, state: BlockState, neighbours: Array<BlockState?>, light: ByteArray, tints: IntArray?, temp: FloatArray) = prototype()
+    override fun render(position: BlockPosition, offset: FloatArray, mesh: ChunkMesh, random: Random?, state: BlockState, neighbours: Array<BlockState?>, light: ByteArray, tints: IntArray?) = prototype()
     override fun getParticleTexture(random: Random?, position: Vec3i) = prototype()
     override fun getProperties(direction: Directions) = prototype()
     override fun render(gui: GUIRenderer, offset: Vec2, consumer: GUIVertexConsumer, options: GUIVertexOptions?, size: Vec2, stack: ItemStack) = prototype()

src/main/java/de/bixilon/minosoft/gui/rendering/models/block/state/apply/SingleBlockStateApply.kt

@@ -168,6 +168,14 @@ data class SingleBlockStateApply(
                 uv = uv.pushRight(2, getTextureRotation(direction, rotatedX))
             }
 
+            val vec = Vec2(0, uv)
+            for (ofs in 0 until 4) {
+                vec.ofs = ofs * 2
+                val transformed = texture.transformUV(vec)
+                uv[ofs * 2 + 0] = transformed.x
+                uv[ofs * 2 + 1] = transformed.y
+            }
+
             val faceProperties = if (rotation == null && this@SingleBlockStateApply.rotation == null) positions.properties(rotatedXY, texture) else null
             val bakedFace = BakedFace(positions, uv, this.shade, face.tintIndex, texture, rotatedXY, faceProperties)
 

src/main/java/de/bixilon/minosoft/gui/rendering/models/block/state/baked/BakedFace.kt

@@ -21,6 +21,7 @@ import de.bixilon.minosoft.gui.rendering.models.block.element.FaceVertexData
 import de.bixilon.minosoft.gui.rendering.models.block.state.baked.Shades.Companion.shade
 import de.bixilon.minosoft.gui.rendering.models.block.state.baked.cull.side.FaceProperties
 import de.bixilon.minosoft.gui.rendering.system.base.MeshUtil.buffer
+import de.bixilon.minosoft.gui.rendering.system.base.texture.TextureStates
 import de.bixilon.minosoft.gui.rendering.system.base.texture.TextureTransparencies
 import de.bixilon.minosoft.gui.rendering.system.base.texture.texture.Texture
 import de.bixilon.minosoft.gui.rendering.tint.TintUtil
@@ -36,6 +37,10 @@ class BakedFace(
 ) {
     private val lightIndex = cull?.ordinal ?: SELF_LIGHT_INDEX
 
+    init {
+        check(texture.state == TextureStates.LOADED)
+    }
+
 
     constructor(positions: FaceVertexData, uv: FaceVertexData, shade: Boolean, tintIndex: Int, texture: Texture, direction: Directions, properties: FaceProperties?) : this(positions, uv, if (shade) direction.shade else Shades.NONE, tintIndex, if (properties == null) null else direction, texture, properties)
 
@@ -44,7 +49,7 @@ class BakedFace(
         return TintUtil.calculateTint(tint, shade)
     }
 
-    fun render(offset: FloatArray, mesh: ChunkMesh, light: ByteArray, tints: IntArray?, temp: FloatArray) {
+    fun render(offset: FloatArray, mesh: ChunkMesh, light: ByteArray, tints: IntArray?) {
         val tint = color(tints?.getOrNull(tintIndex) ?: 0)
         val lightTint = ((light[lightIndex].toInt() shl 24) or tint).buffer()
         val textureId = this.texture.shaderId.buffer()
@@ -52,20 +57,16 @@ class BakedFace(
 
         val mesh = mesh.mesh(texture)
 
-        val uv = temp
-
         var index = 0
         val size = mesh.order.size
         while (index < size) {
             val vertexOffset = mesh.order[index] * 3
             val uvOffset = mesh.order[index + 1] * 2
-            uv[0] = this.uv[uvOffset]
-            uv[1] = this.uv[uvOffset + 1]
 
             mesh.addVertex(
                 x = offset[0] + positions[vertexOffset], y = offset[1] + positions[vertexOffset + 1], z = offset[2] + positions[vertexOffset + 2],
-                uv = uv,
+                u = this.uv[uvOffset],
-                texture = this.texture,
+                v = this.uv[uvOffset + 1],
                 shaderTextureId = textureId,
                 lightTint = lightTint,
             )

src/main/java/de/bixilon/minosoft/gui/rendering/models/block/state/baked/BakedModel.kt

@@ -45,7 +45,7 @@ class BakedModel(
 
     override fun getParticleTexture(random: Random?, position: Vec3i) = particle
 
-    override fun render(position: BlockPosition, offset: FloatArray, mesh: ChunkMesh, random: Random?, state: BlockState, neighbours: Array<BlockState?>, light: ByteArray, tints: IntArray?, temp: FloatArray): Boolean {
+    override fun render(position: BlockPosition, offset: FloatArray, mesh: ChunkMesh, random: Random?, state: BlockState, neighbours: Array<BlockState?>, light: ByteArray, tints: IntArray?): Boolean {
         var rendered = false
 
         for ((directionIndex, faces) in faces.withIndex()) {
@@ -56,7 +56,7 @@ class BakedModel(
                 if (FaceCulling.canCull(state, face.properties, direction, neighbour)) {
                     continue
                 }
-                face.render(offset, mesh, light, tints, temp)
+                face.render(offset, mesh, light, tints)
 
                 rendered = true
             }

src/main/java/de/bixilon/minosoft/gui/rendering/models/block/state/builder/BuiltModel.kt

@@ -35,11 +35,11 @@ class BuiltModel(
     val dynamic: Array<BlockRender>,
 ) : BlockRender {
 
-    override fun render(position: BlockPosition, offset: FloatArray, mesh: ChunkMesh, random: Random?, state: BlockState, neighbours: Array<BlockState?>, light: ByteArray, tints: IntArray?, temp: FloatArray): Boolean {
+    override fun render(position: BlockPosition, offset: FloatArray, mesh: ChunkMesh, random: Random?, state: BlockState, neighbours: Array<BlockState?>, light: ByteArray, tints: IntArray?): Boolean {
-        var rendered = model.render(position, offset, mesh, random, state, neighbours, light, tints, temp)
+        var rendered = model.render(position, offset, mesh, random, state, neighbours, light, tints)
 
         for (dynamic in this.dynamic) {
-            if (dynamic.render(position, offset, mesh, random, state, neighbours, light, tints, temp)) {
+            if (dynamic.render(position, offset, mesh, random, state, neighbours, light, tints)) {
                 rendered = true
             }
         }

src/main/java/de/bixilon/minosoft/gui/rendering/models/block/state/render/BlockRender.kt

@@ -26,7 +26,7 @@ import java.util.*
 interface BlockRender : ItemRender {
     fun getParticleTexture(random: Random?, position: Vec3i): Texture? = null
 
-    fun render(position: BlockPosition, offset: FloatArray, mesh: ChunkMesh, random: Random?, state: BlockState, neighbours: Array<BlockState?>, light: ByteArray, tints: IntArray?, temp: FloatArray): Boolean
+    fun render(position: BlockPosition, offset: FloatArray, mesh: ChunkMesh, random: Random?, state: BlockState, neighbours: Array<BlockState?>, light: ByteArray, tints: IntArray?): Boolean
 
     fun getProperties(direction: Directions): SideProperties? = null
 }

src/main/java/de/bixilon/minosoft/gui/rendering/models/block/state/render/PickedBlockRender.kt

@@ -37,8 +37,8 @@ interface PickedBlockRender : BlockRender {
         default?.render(gui, offset, consumer, options, size, stack)
     }
 
-    override fun render(position: BlockPosition, offset: FloatArray, mesh: ChunkMesh, random: Random?, state: BlockState, neighbours: Array<BlockState?>, light: ByteArray, tints: IntArray?, temp: FloatArray): Boolean {
+    override fun render(position: BlockPosition, offset: FloatArray, mesh: ChunkMesh, random: Random?, state: BlockState, neighbours: Array<BlockState?>, light: ByteArray, tints: IntArray?): Boolean {
-        return pick(neighbours)?.render(position, offset, mesh, random, state, neighbours, light, tints, temp) ?: false
+        return pick(neighbours)?.render(position, offset, mesh, random, state, neighbours, light, tints) ?: false
     }
 
     override fun getProperties(direction: Directions): SideProperties? {

src/main/java/de/bixilon/minosoft/gui/rendering/models/block/state/render/WeightedBlockRender.kt

@@ -61,8 +61,8 @@ class WeightedBlockRender(
         return getModel(random, position).getParticleTexture(random, position)
     }
 
-    override fun render(position: BlockPosition, offset: FloatArray, mesh: ChunkMesh, random: Random?, state: BlockState, neighbours: Array<BlockState?>, light: ByteArray, tints: IntArray?, temp: FloatArray): Boolean {
+    override fun render(position: BlockPosition, offset: FloatArray, mesh: ChunkMesh, random: Random?, state: BlockState, neighbours: Array<BlockState?>, light: ByteArray, tints: IntArray?): Boolean {
-        return getModel(random, position).render(position, offset, mesh, random, state, neighbours, light, tints, temp)
+        return getModel(random, position).render(position, offset, mesh, random, state, neighbours, light, tints)
     }
 
     override fun render(gui: GUIRenderer, offset: Vec2, consumer: GUIVertexConsumer, options: GUIVertexOptions?, size: Vec2, stack: ItemStack) {

src/main/java/de/bixilon/minosoft/util/collections/floats/FragmentedArrayFloatList.kt

@@ -99,6 +99,21 @@ class FragmentedArrayFloatList(
         invalidateOutput()
     }
 
+    fun add(value1: Float, value2: Float, value3: Float, value4: Float, value5: Float, value6: Float, value7: Float) {
+        var buffer = grow(7)
+        buffer.put(value1); if (tryPush(buffer)) buffer = grow(6)
+        buffer.put(value2); if (tryPush(buffer)) buffer = grow(5)
+        buffer.put(value3); if (tryPush(buffer)) buffer = grow(4)
+        buffer.put(value4); if (tryPush(buffer)) buffer = grow(3)
+        buffer.put(value5); if (tryPush(buffer)) buffer = grow(2)
+        buffer.put(value6); if (tryPush(buffer)) buffer = grow(1)
+        buffer.put(value7)
+
+        size += 7
+        tryPush(buffer)
+        invalidateOutput()
+    }
+
     private fun tryPush(fragment: FloatBuffer): Boolean {
         if (fragment.position() != fragment.limit()) {
             return false