修复模型闪烁问题

Author: fifth-light

blazerod/example/ball_block/src/main/java/top/fifthlight/blazerod/example/ballblock/BallBlockMod.java

@@ -51,7 +51,7 @@ private void loadModel() {
         var loader = new ModelLoader();
         BALL_SCENE = loader.loadModel(model);
         BALL_SCENE.increaseReferenceCount();
-        BALL_INSTANCE = new ModelInstance(BALL_SCENE, ModelBufferManager.INSTANCE.getEntry(BALL_SCENE));
+        BALL_INSTANCE = new ModelInstance(BALL_SCENE);
         BALL_INSTANCE.increaseReferenceCount();
         var rootTransformNodeIndex = BALL_SCENE.getRootTransformNodeIndex();
         var rootTransformNode = (RenderNode.Transform) BALL_SCENE.getNodes().get(rootTransformNodeIndex);

blazerod/render/src/main/kotlin/top/fifthlight/blazerod/debug/ResourceCountTracker.kt

@@ -13,7 +13,8 @@ class ResourceCountTracker {
 
     fun decrease(identifier: Identifier) {
         refCounts.compute(identifier) { key, value ->
-            check(value != null) { "Decrease zero count: $key" }
+            // Crash at here!
+            check(value != null && value > 0) { "Decrease null or zero count: $key" }
             value - 1
         }
     }

blazerod/render/src/main/kotlin/top/fifthlight/blazerod/model/ModelBufferManager.kt

@@ -11,40 +11,30 @@ import org.joml.Vector3f
 import top.fifthlight.blazerod.BlazeRod
 import top.fifthlight.blazerod.model.data.ModelMatricesBuffer
 import top.fifthlight.blazerod.model.data.RenderSkinBuffer
-import top.fifthlight.blazerod.model.data.RenderTargetBuffer
+import top.fifthlight.blazerod.model.data.MorphTargetBuffer
 import top.fifthlight.blazerod.util.AbstractRefCount
+import top.fifthlight.blazerod.util.CowBuffer
+import top.fifthlight.blazerod.util.CowBufferList
+import top.fifthlight.blazerod.util.copy
 import top.fifthlight.blazerod.util.mapToArray
 import top.fifthlight.blazerod.util.mapToArrayIndexed
 import java.util.function.Consumer
 
-class ModelInstance(
-    val scene: RenderScene,
-    bufferEntry: ModelBufferManager.BufferEntry,
-) : AbstractRefCount() {
+class ModelInstance(val scene: RenderScene) : AbstractRefCount() {
     companion object {
         private val TYPE_ID = Identifier.of("blazerod", "model_instance")
     }
 
     override val typeId: Identifier
         get() = TYPE_ID
 
-    val modelData = ModelData(
-        scene = scene,
-        bufferEntry = bufferEntry,
-    )
+    val modelData = ModelData(scene)
 
     init {
         scene.increaseReferenceCount()
     }
 
-    class ModelData(
-        scene: RenderScene,
-        private val bufferEntry: ModelBufferManager.BufferEntry,
-    ) : AutoCloseable {
-        init {
-            bufferEntry.increaseReferenceCount()
-        }
-
+    class ModelData(scene: RenderScene) : AutoCloseable {
         val defaultTransforms = scene.transformNodeIndices.mapToArray { nodeIndex ->
             val node = scene.nodes[nodeIndex] as RenderNode.Transform
             node.defaultTransform?.clone()
@@ -56,46 +46,41 @@ class ModelInstance(
 
         val transformsDirty = Array(scene.transformNodeIndices.size) { true }
 
-        val modelMatricesBuffer = ModelMatricesBuffer(scene, bufferEntry.modelMatricesBuffers.allocateSlot()).also {
-            it.clear()
+        val modelMatricesBuffer = run {
+            val buffer = ModelMatricesBuffer(scene)
+            buffer.clear()
+            CowBuffer.acquire(buffer).also { it.increaseReferenceCount() }
         }
 
-        val skinBuffers = scene.skins.mapToArrayIndexed { index, skin ->
-            RenderSkinBuffer(skin, bufferEntry.skinBuffers[index].allocateSlot()).also {
-                it.clear()
-            }
+        val skinBuffers = scene.skins.mapIndexed { index, skin ->
+            val skinBuffer = RenderSkinBuffer(skin)
+            skinBuffer.clear()
+            CowBuffer.acquire(skinBuffer).also { it.increaseReferenceCount() }
         }
 
-        val targetBuffers = scene.morphedPrimitiveNodeIndices.mapToArrayIndexed { index, nodeIndex ->
+        val targetBuffers = scene.morphedPrimitiveNodeIndices.mapIndexed { index, nodeIndex ->
             val node = scene.nodes[nodeIndex] as RenderNode.Primitive
             val primitive = node.primitive
             val targets = primitive.targets!!
-            val targetBuffers = RenderTargetBuffer(
-                targets = targets,
-                weightsSlot = bufferEntry.morphWeightBuffers[index].allocateSlot(),
-                indicesSlot = bufferEntry.morphIndicesBuffers[index].allocateSlot(),
-            )
+            val targetBuffers = MorphTargetBuffer(targets)
             for (targetGroup in primitive.targetGroups) {
-                fun processGroup(index: Int?, channel: RenderTargetBuffer.WeightChannel, weight: Float) =
+                fun processGroup(index: Int?, channel: MorphTargetBuffer.WeightChannel, weight: Float) =
                     index?.let {
                         channel[index] = weight
                     }
                 processGroup(targetGroup.position, targetBuffers.positionChannel, targetGroup.weight)
                 processGroup(targetGroup.color, targetBuffers.colorChannel, targetGroup.weight)
                 processGroup(targetGroup.texCoord, targetBuffers.texCoordChannel, targetGroup.weight)
             }
-            targetBuffers
+            CowBuffer.acquire(targetBuffers).also { it.increaseReferenceCount() }
         }
 
-        val cameraTransforms = scene.cameras.mapToArray { CameraTransform(it.camera) }
+        val cameraTransforms = scene.cameras.map { CameraTransform(it.camera) }
 
         override fun close() {
-            // release slots
-            modelMatricesBuffer.close()
-            skinBuffers.forEach { it.close() }
-            targetBuffers.forEach { it.close() }
-            // release underlying slot buffer
-            bufferEntry.decreaseReferenceCount()
+            modelMatricesBuffer.decreaseReferenceCount()
+            skinBuffers.forEach { it.decreaseReferenceCount() }
+            targetBuffers.forEach { it.decreaseReferenceCount() }
         }
     }
 
@@ -190,9 +175,11 @@ class ModelInstance(
         val weightsIndex =
             requireNotNull(node.morphedPrimitiveIndex) { "Node $nodeIndex don't have target? Check model loader" }
         val weights = modelData.targetBuffers[weightsIndex]
-        group.position?.let { weights.positionChannel[it] = weight }
-        group.color?.let { weights.colorChannel[it] = weight }
-        group.texCoord?.let { weights.texCoordChannel[it] = weight }
+        weights.edit {
+            group.position?.let { positionChannel[it] = weight }
+            group.color?.let { colorChannel[it] = weight }
+            group.texCoord?.let { texCoordChannel[it] = weight }
+        }
     }
 
     private val updateMatrixStack = Matrix4fStack(BlazeRod.MAX_TRANSFORM_DEPTH)
@@ -210,13 +197,29 @@ class ModelInstance(
     }
 
     fun render(modelViewMatrix: Matrix4fc, light: Int) {
-        scene.render(this, modelViewMatrix, light)
+        // Upload indices don't change the actual data
+        modelData.targetBuffers.forEach { it.content.uploadIndices() }
+        scene.render(
+            modelViewMatrix = modelViewMatrix,
+            light = light,
+            modelMatricesBuffer = modelData.modelMatricesBuffer.content,
+            skinBuffer = CowBufferList(modelData.skinBuffers),
+            morphTargetBuffer = CowBufferList(modelData.targetBuffers),
+        )
     }
 
-    fun schedule(modelViewMatrix: Matrix4fc, light: Int) = RenderTask.Instance.acquire(
+    fun schedule(modelViewMatrix: Matrix4fc, light: Int): RenderTask = RenderTask.acquire(
         instance = this,
         modelViewMatrix = modelViewMatrix,
         light = light,
+        modelMatricesBuffer = modelData.modelMatricesBuffer.copy(),
+        skinBuffer = modelData.skinBuffers.copy(),
+        morphTargetBuffer = modelData.targetBuffers.copy().also { buffer ->
+            // Upload indices don't change the actual data
+            buffer.forEach {
+                it.content.uploadIndices()
+            }
+        },
     )
 
     override fun onClosed() {

blazerod/render/src/main/kotlin/top/fifthlight/blazerod/model/ModelInstance.kt

@@ -259,8 +259,7 @@ class ModelLoader {
         check(accessor.type == Accessor.AccessorType.SCALAR)
         if (accessor.componentType == Accessor.ComponentType.UNSIGNED_BYTE) {
             // We need some workaround, because there is just no index type of BYTE
-            val byteBuffer = ByteBuffer.allocateDirect(2 * accessor.count)
-            byteBuffer.order(ByteOrder.nativeOrder())
+            val byteBuffer = ByteBuffer.allocateDirect(2 * accessor.count).order(ByteOrder.nativeOrder())
             accessor.read { input ->
                 val index = input.get().toUByte()
                 byteBuffer.putShort(index.toShort())
@@ -313,7 +312,7 @@ class ModelLoader {
             buffer.flip()
             val targetBuffer = if (!buffer.hasRemaining()) {
                 // No targets, but we can't create an empty buffer, so let's create a dummy one
-                ByteBuffer.allocateDirect(textureFormat.pixelSize())
+                ByteBuffer.allocateDirect(textureFormat.pixelSize()).order(ByteOrder.nativeOrder())
             } else {
                 buffer
             }

blazerod/render/src/main/kotlin/top/fifthlight/blazerod/model/ModelLoader.kt

@@ -111,7 +111,6 @@ abstract class RenderMaterial<Desc : RenderMaterial.Descriptor> : AbstractRefCou
                 withShaderDefine("MORPHED")
                 withShaderDefine("MAX_ENABLED_MORPH_TARGETS", BlazeRod.MAX_ENABLED_MORPH_TARGETS)
                 withUniform("MorphData", UniformType.UNIFORM_BUFFER)
-                withUniform("MorphModelIndices", UniformType.UNIFORM_BUFFER)
                 withUniform("MorphPositionData", UniformType.TEXEL_BUFFER, TextureFormatExt.RGB32F)
                 withUniform("MorphColorData", UniformType.TEXEL_BUFFER, TextureFormatExt.RGBA32F)
                 withUniform("MorphTexCoordData", UniformType.TEXEL_BUFFER, TextureFormatExt.RG32F)

blazerod/render/src/main/kotlin/top/fifthlight/blazerod/model/RenderMaterial.kt

@@ -1,14 +1,15 @@
 package top.fifthlight.blazerod.model
 
-import net.minecraft.client.gl.RenderPassImpl
 import net.minecraft.client.render.RenderLayer
 import net.minecraft.client.render.VertexConsumerProvider
 import net.minecraft.client.util.math.MatrixStack
 import net.minecraft.util.Colors
 import net.minecraft.util.Identifier
 import org.joml.*
+import top.fifthlight.blazerod.model.data.ModelMatricesBuffer
+import top.fifthlight.blazerod.model.data.MorphTargetBuffer
+import top.fifthlight.blazerod.model.data.RenderSkinBuffer
 import top.fifthlight.blazerod.util.AbstractRefCount
-import top.fifthlight.blazerod.util.SlottedGpuBuffer
 import top.fifthlight.blazerod.util.drawBox
 import top.fifthlight.blazerod.util.iteratorOf
 
@@ -93,46 +94,36 @@ sealed class RenderNode : AbstractRefCount(), Iterable<RenderNode> {
                 return
             }
             if (skinIndex == null) {
-                instance.modelData.modelMatricesBuffer.setMatrix(primitiveIndex, matrixStack)
+                instance.modelData.modelMatricesBuffer.edit {
+                    setMatrix(primitiveIndex, matrixStack)
+                }
             }
         }
 
-        fun render(instance: ModelInstance, modelViewMatrix: Matrix4fc, light: Int) {
-            val skinBuffer = skinIndex?.let { instance.modelData.skinBuffers[it] }
-            val targetBuffer = morphedPrimitiveIndex?.let { instance.modelData.targetBuffers[it] }
-            primitive.render(instance, primitiveIndex, modelViewMatrix, light, skinBuffer, targetBuffer)
+        fun render(
+            scene: RenderScene,
+            modelViewMatrix: Matrix4fc,
+            light: Int,
+            modelMatricesBuffer: ModelMatricesBuffer,
+            skinBuffer: List<RenderSkinBuffer>?,
+            morphTargetBuffer: List<MorphTargetBuffer>?,
+        ) {
+            primitive.render(
+                scene = scene,
+                primitiveIndex = primitiveIndex,
+                viewModelMatrix = modelViewMatrix,
+                light = light,
+                modelMatricesBuffer = modelMatricesBuffer,
+                skinBuffer = skinIndex?.let {
+                    (skinBuffer ?: error("Has skin but no skin buffer"))[it]
+                },
+                targetBuffer = morphedPrimitiveIndex?.let {
+                    (morphTargetBuffer ?: error("Has morph targets but no morph target buffer"))[it]
+                }
+            )
         }
 
-        fun renderInstanced(tasks: List<RenderTask.Instance>) {
-            if (RenderPassImpl.IS_DEVELOPMENT) {
-                val firstInstance = tasks.first().instance
-                skinIndex?.let {
-                    val firstBufferSlot = firstInstance.modelData.skinBuffers[it].slot
-                    require(firstBufferSlot is SlottedGpuBuffer.Slotted)
-                    val buffer = firstBufferSlot.buffer
-                    for (task in tasks) {
-                        val bufferSlot = task.instance.modelData.skinBuffers[it].slot
-                        require(bufferSlot is SlottedGpuBuffer.Slotted)
-                        require(bufferSlot.buffer == buffer)
-                    }
-                }
-                morphedPrimitiveIndex?.let {
-                    val firstWeightsBufferSlot = firstInstance.modelData.targetBuffers[it].weightsSlot
-                    val firstIndicesBufferSlot = firstInstance.modelData.targetBuffers[it].indicesSlot
-                    require(firstWeightsBufferSlot is SlottedGpuBuffer.Slotted)
-                    require(firstIndicesBufferSlot is SlottedGpuBuffer.Slotted)
-                    val weightsBuffer = firstWeightsBufferSlot.buffer
-                    val indicesBuffer = firstIndicesBufferSlot.buffer
-                    for (task in tasks) {
-                        val weightsBufferSlot = task.instance.modelData.targetBuffers[it].weightsSlot
-                        val indicesBufferSlot = task.instance.modelData.targetBuffers[it].indicesSlot
-                        require(weightsBufferSlot is SlottedGpuBuffer.Slotted)
-                        require(indicesBufferSlot is SlottedGpuBuffer.Slotted)
-                        require(weightsBufferSlot.buffer == weightsBuffer)
-                        require(indicesBufferSlot.buffer == indicesBuffer)
-                    }
-                }
-            }
+        fun renderInstanced(tasks: List<RenderTask>) {
             primitive.renderInstanced(tasks, this)
         }
 
@@ -276,11 +267,13 @@ sealed class RenderNode : AbstractRefCount(), Iterable<RenderNode> {
 
             val matrix = cacheMatrix
             matrix.set(matrixStack)
+            val skin = instance.scene.skins[skinIndex]
             val skinBuffer = instance.modelData.skinBuffers[skinIndex]
-
-            val inverseMatrix = skinBuffer.skin.inverseBindMatrices?.get(jointIndex)
-            inverseMatrix?.let { matrix.mul(it) }
-            skinBuffer.setMatrix(jointIndex, matrix)
+            val inverseMatrix = skin.inverseBindMatrices?.get(jointIndex)
+            skinBuffer.edit {
+                inverseMatrix?.let { matrix.mul(it) }
+                setMatrix(jointIndex, matrix)
+            }
         }
 
         override fun iterator() = iteratorOf<RenderNode>()