From 5ac60652052f7d5dc6cbcf45769c199440f014ae Mon Sep 17 00:00:00 2001 From: PepperCode1 <44146161+PepperCode1@users.noreply.github.com> Date: Wed, 24 Aug 2022 17:51:24 -0700 Subject: [PATCH] Memcpy: Batching Edition - Add BatchedMeshPool - Rename MeshPool to InstancedMeshPool - Rename/remove/add methods to VertexList/ReusableVertexList --- .../api/vertex/ReusableVertexList.java | 4 +- .../flywheel/api/vertex/VertexList.java | 6 +- .../instancing/batching/BatchedMeshPool.java | 208 ++++++++++++++++++ .../batching/BatchingTransformManager.java | 21 +- .../instancing/batching/DrawBuffer.java | 9 +- .../instancing/batching/TransformCall.java | 32 +-- .../instancing/instancing/DrawCall.java | 4 +- .../{MeshPool.java => InstancedMeshPool.java} | 124 ++++++----- .../instancing/InstancingDrawManager.java | 8 +- .../com/jozufozu/flywheel/core/Materials.java | 2 +- .../flywheel/core/hardcoded/ModelPart.java | 2 +- .../flywheel/core/model/ModelUtil.java | 4 +- .../flywheel/core/model/SimpleMesh.java | 2 +- .../core/structs/oriented/OrientedType.java | 2 +- .../structs/transformed/TransformedType.java | 2 +- .../core/vertex/AbstractVertexList.java | 4 +- .../flywheel/core/vertex/BlockVertexList.java | 4 +- .../core/vertex/InferredVertexListImpl.java | 4 +- .../core/vertex/PosTexNormalVertexList.java | 4 +- 19 files changed, 341 insertions(+), 105 deletions(-) create mode 100644 src/main/java/com/jozufozu/flywheel/backend/instancing/batching/BatchedMeshPool.java rename src/main/java/com/jozufozu/flywheel/backend/instancing/instancing/{MeshPool.java => InstancedMeshPool.java} (68%) diff --git a/src/main/java/com/jozufozu/flywheel/api/vertex/ReusableVertexList.java b/src/main/java/com/jozufozu/flywheel/api/vertex/ReusableVertexList.java index c4f9c4b70..6cff3b6d5 100644 --- a/src/main/java/com/jozufozu/flywheel/api/vertex/ReusableVertexList.java +++ b/src/main/java/com/jozufozu/flywheel/api/vertex/ReusableVertexList.java @@ -5,7 +5,7 @@ public interface ReusableVertexList extends MutableVertexList { void ptr(long ptr); - void shiftPtr(int vertices); + int vertexStride(); - void setVertexCount(int vertexCount); + void vertexCount(int vertexCount); } diff --git a/src/main/java/com/jozufozu/flywheel/api/vertex/VertexList.java b/src/main/java/com/jozufozu/flywheel/api/vertex/VertexList.java index ec47c17c8..1b11a9bee 100644 --- a/src/main/java/com/jozufozu/flywheel/api/vertex/VertexList.java +++ b/src/main/java/com/jozufozu/flywheel/api/vertex/VertexList.java @@ -70,12 +70,12 @@ public interface VertexList { } default void writeAll(MutableVertexList dst) { - write(dst, 0, 0, getVertexCount()); + write(dst, 0, 0, vertexCount()); } - int getVertexCount(); + int vertexCount(); default boolean isEmpty() { - return getVertexCount() == 0; + return vertexCount() == 0; } } diff --git a/src/main/java/com/jozufozu/flywheel/backend/instancing/batching/BatchedMeshPool.java b/src/main/java/com/jozufozu/flywheel/backend/instancing/batching/BatchedMeshPool.java new file mode 100644 index 000000000..896077b4d --- /dev/null +++ b/src/main/java/com/jozufozu/flywheel/backend/instancing/batching/BatchedMeshPool.java @@ -0,0 +1,208 @@ +package com.jozufozu.flywheel.backend.instancing.batching; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.jetbrains.annotations.Nullable; +import org.lwjgl.system.MemoryUtil; + +import com.jozufozu.flywheel.Flywheel; +import com.jozufozu.flywheel.api.vertex.ReusableVertexList; +import com.jozufozu.flywheel.api.vertex.VertexListProvider; +import com.jozufozu.flywheel.backend.memory.MemoryBlock; +import com.jozufozu.flywheel.core.model.Mesh; +import com.mojang.blaze3d.vertex.VertexFormat; + +public class BatchedMeshPool { + private final VertexFormat vertexFormat; + private final ReusableVertexList vertexList; + private final int growthMargin; + + private final Map meshes = new HashMap<>(); + private final List allBuffered = new ArrayList<>(); + private final List pendingUpload = new ArrayList<>(); + + private MemoryBlock memory; + private long byteSize; + + private boolean dirty; + private boolean anyToRemove; + + /** + * Create a new mesh pool. + */ + public BatchedMeshPool(VertexFormat vertexFormat) { + this.vertexFormat = vertexFormat; + vertexList = VertexListProvider.get(vertexFormat).createVertexList(); + growthMargin = vertexList.vertexStride() * 32; + } + + /** + * Allocate a mesh in the arena. + * + * @param mesh The mesh to allocate. + * @return A handle to the allocated mesh. + */ + public BufferedMesh alloc(Mesh mesh) { + return meshes.computeIfAbsent(mesh, m -> { + BufferedMesh bufferedMesh = new BufferedMesh(m, byteSize, m.getVertexCount() * vertexList.vertexStride()); + byteSize += bufferedMesh.size(); + allBuffered.add(bufferedMesh); + pendingUpload.add(bufferedMesh); + + dirty = true; + return bufferedMesh; + }); + } + + @Nullable + public BufferedMesh get(Mesh mesh) { + return meshes.get(mesh); + } + + public void flush() { + if (dirty) { + if (anyToRemove) { + processDeletions(); + } + + realloc(); + uploadPending(); + + dirty = false; + pendingUpload.clear(); + } + } + + private void processDeletions() { + // remove deleted meshes + allBuffered.removeIf(bufferedMesh -> { + boolean deleted = bufferedMesh.isDeleted(); + if (deleted) { + meshes.remove(bufferedMesh.mesh); + } + return deleted; + }); + + // re-evaluate first vertex for each mesh + int byteIndex = 0; + for (BufferedMesh mesh : allBuffered) { + if (mesh.byteIndex != byteIndex) { + pendingUpload.add(mesh); + } + + mesh.byteIndex = byteIndex; + + byteIndex += mesh.size(); + } + + this.byteSize = byteIndex; + this.anyToRemove = false; + } + + private void realloc() { + if (byteSize < 0) { + throw new IllegalArgumentException("Size " + byteSize + " < 0"); + } + + if (byteSize == 0) { + return; + } + + if (memory == null) { + memory = MemoryBlock.malloc(byteSize); + } else if (byteSize > memory.size()) { + memory = memory.realloc(byteSize + growthMargin); + } + } + + private void uploadPending() { + try { + for (BufferedMesh mesh : pendingUpload) { + mesh.buffer(vertexList); + } + + pendingUpload.clear(); + } catch (Exception e) { + Flywheel.LOGGER.error("Error uploading pooled meshes:", e); + } + } + + public void delete() { + if (memory != null) { + memory.free(); + } + meshes.clear(); + allBuffered.clear(); + pendingUpload.clear(); + } + + public VertexFormat getVertexFormat() { + return vertexFormat; + } + + @Override + public String toString() { + return "BatchedMeshPool{" + "vertexFormat=" + vertexFormat + ", byteSize=" + byteSize + ", meshCount=" + meshes.size() + '}'; + } + + public class BufferedMesh { + private final Mesh mesh; + private long byteIndex; + private int byteSize; + private boolean deleted; + + private BufferedMesh(Mesh mesh, long byteIndex, int byteSize) { + this.mesh = mesh; + this.byteIndex = byteIndex; + this.byteSize = byteSize; + } + + private void buffer(ReusableVertexList vertexList) { + vertexList.ptr(ptr()); + vertexList.vertexCount(mesh.getVertexCount()); + + mesh.write(vertexList); + } + + public void copyTo(long ptr) { + if (isEmpty()) { + return; + } + + MemoryUtil.memCopy(ptr(), ptr, byteSize); + } + + private boolean isEmpty() { + return mesh.isEmpty() || isDeleted(); + } + + private long ptr() { + return BatchedMeshPool.this.memory.ptr() + byteIndex; + } + + public void delete() { + deleted = true; + BatchedMeshPool.this.dirty = true; + BatchedMeshPool.this.anyToRemove = true; + } + + public Mesh getMesh() { + return mesh; + } + + public int size() { + return byteSize; + } + + public VertexFormat getVertexFormat() { + return vertexFormat; + } + + public boolean isDeleted() { + return deleted; + } + } +} diff --git a/src/main/java/com/jozufozu/flywheel/backend/instancing/batching/BatchingTransformManager.java b/src/main/java/com/jozufozu/flywheel/backend/instancing/batching/BatchingTransformManager.java index ac44e9028..7452b7da3 100644 --- a/src/main/java/com/jozufozu/flywheel/backend/instancing/batching/BatchingTransformManager.java +++ b/src/main/java/com/jozufozu/flywheel/backend/instancing/batching/BatchingTransformManager.java @@ -4,6 +4,7 @@ import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.EnumMap; +import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; @@ -14,7 +15,9 @@ import com.google.common.collect.ArrayListMultimap; import com.google.common.collect.ImmutableListMultimap; import com.google.common.collect.ListMultimap; import com.jozufozu.flywheel.api.RenderStage; +import com.jozufozu.flywheel.core.model.Mesh; import com.jozufozu.flywheel.core.model.Model; +import com.mojang.blaze3d.vertex.VertexFormat; import net.minecraft.client.renderer.RenderType; @@ -23,6 +26,7 @@ public class BatchingTransformManager { private final List> allInstancers = new ArrayList<>(); private final Map transformSets = new EnumMap<>(RenderStage.class); private final Map transformSetsView = Collections.unmodifiableMap(transformSets); + private final Map meshPools = new HashMap<>(); public TransformSet get(RenderStage stage) { return transformSets.getOrDefault(stage, TransformSet.EMPTY); @@ -41,9 +45,17 @@ public class BatchingTransformManager { add(model.instancer(), model.model()); } uninitializedModels.clear(); + + for (var pool : meshPools.values()) { + pool.flush(); + } } public void delete() { + meshPools.values() + .forEach(BatchedMeshPool::delete); + meshPools.clear(); + allInstancers.forEach(CPUInstancer::delete); allInstancers.clear(); } @@ -55,9 +67,9 @@ public class BatchingTransformManager { private void add(CPUInstancer instancer, Model model) { var meshes = model.getMeshes(); for (var entry : meshes.entrySet()) { - TransformCall transformCall = new TransformCall<>(instancer, entry.getKey(), entry.getValue()); - var material = transformCall.getMaterial(); + var material = entry.getKey(); var renderType = material.getBatchingRenderType(); + TransformCall transformCall = new TransformCall<>(instancer, material, alloc(entry.getValue(), renderType.format())); transformSets.computeIfAbsent(material.getRenderStage(), TransformSet::new) .put(renderType, transformCall); @@ -65,6 +77,11 @@ public class BatchingTransformManager { allInstancers.add(instancer); } + private BatchedMeshPool.BufferedMesh alloc(Mesh mesh, VertexFormat format) { + return meshPools.computeIfAbsent(format, BatchedMeshPool::new) + .alloc(mesh); + } + public static class TransformSet implements Iterable>>> { public static final TransformSet EMPTY = new TransformSet(ImmutableListMultimap.of()); diff --git a/src/main/java/com/jozufozu/flywheel/backend/instancing/batching/DrawBuffer.java b/src/main/java/com/jozufozu/flywheel/backend/instancing/batching/DrawBuffer.java index a50d52430..edce69fc0 100644 --- a/src/main/java/com/jozufozu/flywheel/backend/instancing/batching/DrawBuffer.java +++ b/src/main/java/com/jozufozu/flywheel/backend/instancing/batching/DrawBuffer.java @@ -72,9 +72,8 @@ public class DrawBuffer { } ReusableVertexList vertexList = provider.createVertexList(); - vertexList.ptr(memory.ptr()); - vertexList.shiftPtr(startVertex); - vertexList.setVertexCount(vertexCount); + vertexList.ptr(memory.ptr() + startVertex * vertexList.vertexStride()); + vertexList.vertexCount(vertexCount); return vertexList; } @@ -91,6 +90,10 @@ public class DrawBuffer { bufferBuilder.flywheel$injectForRender(buffer, format, vertexCount); } + public VertexFormat getVertexFormat() { + return format; + } + public boolean isPrepared() { return prepared; } diff --git a/src/main/java/com/jozufozu/flywheel/backend/instancing/batching/TransformCall.java b/src/main/java/com/jozufozu/flywheel/backend/instancing/batching/TransformCall.java index 8060cb176..caac1a4f4 100644 --- a/src/main/java/com/jozufozu/flywheel/backend/instancing/batching/TransformCall.java +++ b/src/main/java/com/jozufozu/flywheel/backend/instancing/batching/TransformCall.java @@ -8,8 +8,8 @@ import com.jozufozu.flywheel.api.struct.StructType; import com.jozufozu.flywheel.api.vertex.MutableVertexList; import com.jozufozu.flywheel.api.vertex.ReusableVertexList; import com.jozufozu.flywheel.backend.instancing.TaskEngine; -import com.jozufozu.flywheel.core.model.Mesh; import com.mojang.blaze3d.vertex.PoseStack; +import com.mojang.blaze3d.vertex.VertexFormat; import com.mojang.math.Matrix3f; import com.mojang.math.Matrix4f; import com.mojang.math.Vector3f; @@ -18,23 +18,22 @@ import com.mojang.math.Vector4f; import net.minecraft.client.multiplayer.ClientLevel; public class TransformCall { - private final CPUInstancer instancer; private final Material material; - private final Mesh mesh; + private final BatchedMeshPool.BufferedMesh bufferedMesh; - public TransformCall(CPUInstancer instancer, Material material, Mesh mesh) { + public TransformCall(CPUInstancer instancer, Material material, BatchedMeshPool.BufferedMesh mesh) { this.instancer = instancer; this.material = material; - this.mesh = mesh; + this.bufferedMesh = mesh; } public Material getMaterial() { return material; } - public Mesh getMesh() { - return mesh; + public VertexFormat getVertexFormat() { + return bufferedMesh.getVertexFormat(); } void submitTasks(TaskEngine pool, DrawBuffer buffer, int startVertex, PoseStack stack, ClientLevel level) { @@ -47,7 +46,7 @@ public class TransformCall { instances -= 512; int start = Math.max(instances, 0); - int vertexCount = mesh.getVertexCount() * (end - start); + int vertexCount = bufferedMesh.getMesh().getVertexCount() * (end - start); ReusableVertexList sub = buffer.slice(startVertex, vertexCount); startVertex += vertexCount; @@ -65,23 +64,24 @@ public class TransformCall { private void transformList(ReusableVertexList vertexList, List parts, PoseStack stack, ClientLevel level) { long anchorPtr = vertexList.ptr(); - int totalVertexCount = vertexList.getVertexCount(); + int totalVertexCount = vertexList.vertexCount(); - int meshVertexCount = mesh.getVertexCount(); - vertexList.setVertexCount(meshVertexCount); + int meshVertexCount = bufferedMesh.getMesh().getVertexCount(); + int meshByteSize = bufferedMesh.size(); + vertexList.vertexCount(meshVertexCount); StructType.VertexTransformer structVertexTransformer = instancer.type.getVertexTransformer(); for (D d : parts) { - mesh.write(vertexList); + bufferedMesh.copyTo(vertexList.ptr()); structVertexTransformer.transform(vertexList, d, level); - vertexList.shiftPtr(meshVertexCount); + vertexList.ptr(vertexList.ptr() + meshByteSize); } vertexList.ptr(anchorPtr); - vertexList.setVertexCount(totalVertexCount); + vertexList.vertexCount(totalVertexCount); material.getVertexTransformer().transform(vertexList, level); applyPoseStack(vertexList, stack); } @@ -93,7 +93,7 @@ public class TransformCall { Matrix4f modelMatrix = stack.last().pose(); Matrix3f normalMatrix = stack.last().normal(); - for (int i = 0; i < vertexList.getVertexCount(); i++) { + for (int i = 0; i < vertexList.vertexCount(); i++) { pos.set( vertexList.x(i), vertexList.y(i), @@ -119,6 +119,6 @@ public class TransformCall { } public int getTotalVertexCount() { - return mesh.getVertexCount() * instancer.getInstanceCount(); + return bufferedMesh.getMesh().getVertexCount() * instancer.getInstanceCount(); } } diff --git a/src/main/java/com/jozufozu/flywheel/backend/instancing/instancing/DrawCall.java b/src/main/java/com/jozufozu/flywheel/backend/instancing/instancing/DrawCall.java index 37db2049b..19362548c 100644 --- a/src/main/java/com/jozufozu/flywheel/backend/instancing/instancing/DrawCall.java +++ b/src/main/java/com/jozufozu/flywheel/backend/instancing/instancing/DrawCall.java @@ -10,10 +10,10 @@ public class DrawCall { final GPUInstancer instancer; final Material material; private final int meshAttributes; - MeshPool.BufferedMesh bufferedMesh; + InstancedMeshPool.BufferedMesh bufferedMesh; GlVertexArray vao; - DrawCall(GPUInstancer instancer, Material material, MeshPool.BufferedMesh mesh) { + DrawCall(GPUInstancer instancer, Material material, InstancedMeshPool.BufferedMesh mesh) { this.instancer = instancer; this.material = material; this.vao = new GlVertexArray(); diff --git a/src/main/java/com/jozufozu/flywheel/backend/instancing/instancing/MeshPool.java b/src/main/java/com/jozufozu/flywheel/backend/instancing/instancing/InstancedMeshPool.java similarity index 68% rename from src/main/java/com/jozufozu/flywheel/backend/instancing/instancing/MeshPool.java rename to src/main/java/com/jozufozu/flywheel/backend/instancing/instancing/InstancedMeshPool.java index 739eda2f9..3fd0ad738 100644 --- a/src/main/java/com/jozufozu/flywheel/backend/instancing/instancing/MeshPool.java +++ b/src/main/java/com/jozufozu/flywheel/backend/instancing/instancing/InstancedMeshPool.java @@ -19,16 +19,14 @@ import com.jozufozu.flywheel.backend.gl.buffer.GlBufferType; import com.jozufozu.flywheel.backend.gl.buffer.MappedBuffer; import com.jozufozu.flywheel.core.model.Mesh; -public class MeshPool { - +public class InstancedMeshPool { private final VertexType vertexType; + private final Map meshes = new HashMap<>(); private final List allBuffered = new ArrayList<>(); - private final List pendingUpload = new ArrayList<>(); private final GlBuffer vbo; - private long byteSize; private boolean dirty; @@ -37,7 +35,7 @@ public class MeshPool { /** * Create a new mesh pool. */ - public MeshPool(VertexType vertexType) { + public InstancedMeshPool(VertexType vertexType) { this.vertexType = vertexType; int stride = vertexType.getStride(); this.vbo = new GlBuffer(GlBufferType.ARRAY_BUFFER); @@ -46,10 +44,10 @@ public class MeshPool { } /** - * Allocate a model in the arena. + * Allocate a mesh in the arena. * - * @param mesh The model to allocate. - * @return A handle to the allocated model. + * @param mesh The mesh to allocate. + * @return A handle to the allocated mesh. */ public BufferedMesh alloc(Mesh mesh) { return meshes.computeIfAbsent(mesh, m -> { @@ -57,13 +55,13 @@ public class MeshPool { throw new IllegalArgumentException("Mesh has wrong vertex type"); } - BufferedMesh bufferedModel = new BufferedMesh(m, byteSize); - byteSize += m.size(); - allBuffered.add(bufferedModel); - pendingUpload.add(bufferedModel); + BufferedMesh bufferedMesh = new BufferedMesh(m, byteSize); + byteSize += bufferedMesh.size(); + allBuffered.add(bufferedMesh); + pendingUpload.add(bufferedMesh); dirty = true; - return bufferedModel; + return bufferedMesh; }); } @@ -90,7 +88,6 @@ public class MeshPool { } private void processDeletions() { - // remove deleted meshes allBuffered.removeIf(bufferedMesh -> { boolean deleted = bufferedMesh.isDeleted(); @@ -100,16 +97,16 @@ public class MeshPool { return deleted; }); - // re-evaluate first vertex for each model + // re-evaluate first vertex for each mesh int byteIndex = 0; - for (BufferedMesh model : allBuffered) { - if (model.byteIndex != byteIndex) { - pendingUpload.add(model); + for (BufferedMesh mesh : allBuffered) { + if (mesh.byteIndex != byteIndex) { + pendingUpload.add(mesh); } - model.byteIndex = byteIndex; + mesh.byteIndex = byteIndex; - byteIndex += model.mesh.size(); + byteIndex += mesh.size(); } this.byteSize = byteIndex; @@ -130,14 +127,13 @@ public class MeshPool { long ptr = mapped.getPtr(); int byteIndex = 0; - for (BufferedMesh model : allBuffered) { - model.byteIndex = byteIndex; + for (BufferedMesh mesh : allBuffered) { + mesh.byteIndex = byteIndex; - model.buffer(ptr); + mesh.buffer(ptr); - byteIndex += model.mesh.size(); + byteIndex += mesh.size(); } - } catch (Exception e) { Flywheel.LOGGER.error("Error uploading pooled meshes:", e); } @@ -145,10 +141,12 @@ public class MeshPool { private void uploadPending() { try (MappedBuffer mapped = vbo.map()) { - long buffer = mapped.getPtr(); - for (BufferedMesh model : pendingUpload) { - model.buffer(buffer); + long ptr = mapped.getPtr(); + + for (BufferedMesh mesh : pendingUpload) { + mesh.buffer(ptr); } + pendingUpload.clear(); } catch (Exception e) { Flywheel.LOGGER.error("Error uploading pooled meshes:", e); @@ -162,32 +160,41 @@ public class MeshPool { pendingUpload.clear(); } + public VertexType getVertexType() { + return vertexType; + } + @Override public String toString() { - return "MeshPool{" + "vertexType=" + vertexType + ", byteSize=" + byteSize + ", meshCount=" + meshes.size() + '}'; + return "InstancedMeshPool{" + "vertexType=" + vertexType + ", byteSize=" + byteSize + ", meshCount=" + meshes.size() + '}'; } public class BufferedMesh { - - private final ElementBuffer ebo; private final Mesh mesh; + private final ElementBuffer ebo; private long byteIndex; private boolean deleted; private final Set boundTo = new HashSet<>(); - public BufferedMesh(Mesh mesh, long byteIndex) { + private BufferedMesh(Mesh mesh, long byteIndex) { this.mesh = mesh; this.byteIndex = byteIndex; this.ebo = mesh.createEBO(); } + private void buffer(long ptr) { + mesh.write(ptr + byteIndex); + + boundTo.clear(); + } + public void drawCall(GlVertexArray vao) { drawInstances(vao, 1); } public void drawInstances(GlVertexArray vao, int instanceCount) { - if (hasAnythingToRender()) { + if (isEmpty()) { return; } @@ -196,50 +203,51 @@ public class MeshPool { draw(instanceCount); } - private boolean hasAnythingToRender() { + private boolean isEmpty() { return mesh.isEmpty() || isDeleted(); } + private void setup(GlVertexArray vao) { + if (boundTo.add(vao)) { + vao.enableArrays(getAttributeCount()); + vao.bindAttributes(InstancedMeshPool.this.vbo, 0, vertexType.getLayout(), byteIndex); + } + vao.bindElementArray(ebo.buffer); + vao.bind(); + } + private void draw(int instanceCount) { if (instanceCount > 1) { - GL32.glDrawElementsInstanced(GlPrimitive.TRIANGLES.glEnum, this.ebo.elementCount, this.ebo.eboIndexType.getGlEnum(), 0, instanceCount); + GL32.glDrawElementsInstanced(GlPrimitive.TRIANGLES.glEnum, ebo.elementCount, ebo.eboIndexType.getGlEnum(), 0, instanceCount); } else { - GL32.glDrawElements(GlPrimitive.TRIANGLES.glEnum, this.ebo.elementCount, this.ebo.eboIndexType.getGlEnum(), 0); + GL32.glDrawElements(GlPrimitive.TRIANGLES.glEnum, ebo.elementCount, ebo.eboIndexType.getGlEnum(), 0); } } - private void setup(GlVertexArray vao) { - if (this.boundTo.add(vao)) { - vao.enableArrays(getAttributeCount()); - vao.bindAttributes(MeshPool.this.vbo, 0, vertexType.getLayout(), this.byteIndex); - } - vao.bindElementArray(this.ebo.buffer); - vao.bind(); - } - - public boolean isDeleted() { - return this.deleted; - } - public void delete() { - MeshPool.this.dirty = true; - MeshPool.this.anyToRemove = true; - this.deleted = true; + deleted = true; + InstancedMeshPool.this.dirty = true; + InstancedMeshPool.this.anyToRemove = true; } - private void buffer(long ptr) { - this.mesh.write(ptr + byteIndex); + public Mesh getMesh() { + return mesh; + } - this.boundTo.clear(); + public int size() { + return mesh.size(); + } + + public VertexType getVertexType() { + return vertexType; } public int getAttributeCount() { return vertexType.getLayout().getAttributeCount(); } - public VertexType getVertexType() { - return vertexType; + public boolean isDeleted() { + return deleted; } } - } diff --git a/src/main/java/com/jozufozu/flywheel/backend/instancing/instancing/InstancingDrawManager.java b/src/main/java/com/jozufozu/flywheel/backend/instancing/instancing/InstancingDrawManager.java index d790be99a..27afd6743 100644 --- a/src/main/java/com/jozufozu/flywheel/backend/instancing/instancing/InstancingDrawManager.java +++ b/src/main/java/com/jozufozu/flywheel/backend/instancing/instancing/InstancingDrawManager.java @@ -23,7 +23,7 @@ public class InstancingDrawManager { private final List uninitializedModels = new ArrayList<>(); private final List> allInstancers = new ArrayList<>(); private final Map renderLists = new EnumMap<>(RenderStage.class); - private final Map meshPools = new HashMap<>(); + private final Map meshPools = new HashMap<>(); public DrawSet get(RenderStage stage) { return renderLists.getOrDefault(stage, DrawSet.EMPTY); @@ -49,7 +49,7 @@ public class InstancingDrawManager { public void delete() { meshPools.values() - .forEach(MeshPool::delete); + .forEach(InstancedMeshPool::delete); meshPools.clear(); renderLists.values() @@ -77,8 +77,8 @@ public class InstancingDrawManager { allInstancers.add(instancer); } - private MeshPool.BufferedMesh alloc(Mesh mesh) { - return meshPools.computeIfAbsent(mesh.getVertexType(), MeshPool::new) + private InstancedMeshPool.BufferedMesh alloc(Mesh mesh) { + return meshPools.computeIfAbsent(mesh.getVertexType(), InstancedMeshPool::new) .alloc(mesh); } diff --git a/src/main/java/com/jozufozu/flywheel/core/Materials.java b/src/main/java/com/jozufozu/flywheel/core/Materials.java index 393ee2126..fcc72a3cc 100644 --- a/src/main/java/com/jozufozu/flywheel/core/Materials.java +++ b/src/main/java/com/jozufozu/flywheel/core/Materials.java @@ -25,7 +25,7 @@ public final class Materials { } DiffuseLightCalculator diffuseCalc = DiffuseLightCalculator.forLevel(level); - for (int i = 0; i < vertexList.getVertexCount(); i++) { + for (int i = 0; i < vertexList.vertexCount(); i++) { float diffuse = diffuseCalc.getDiffuse(vertexList.normalX(i), vertexList.normalY(i), vertexList.normalZ(i), true); vertexList.r(i, (byte) Mth.clamp((int) (Byte.toUnsignedInt(vertexList.r(i)) * diffuse), 0, 255)); vertexList.g(i, (byte) Mth.clamp((int) (Byte.toUnsignedInt(vertexList.g(i)) * diffuse), 0, 255)); diff --git a/src/main/java/com/jozufozu/flywheel/core/hardcoded/ModelPart.java b/src/main/java/com/jozufozu/flywheel/core/hardcoded/ModelPart.java index 4dc301213..354cbf4cf 100644 --- a/src/main/java/com/jozufozu/flywheel/core/hardcoded/ModelPart.java +++ b/src/main/java/com/jozufozu/flywheel/core/hardcoded/ModelPart.java @@ -35,7 +35,7 @@ public class ModelPart implements Mesh { vertexList = getVertexType().createVertexList(); vertexList.ptr(ptr); - vertexList.setVertexCount(vertexCount); + vertexList.vertexCount(vertexCount); } public static PartBuilder builder(String name, int sizeU, int sizeV) { diff --git a/src/main/java/com/jozufozu/flywheel/core/model/ModelUtil.java b/src/main/java/com/jozufozu/flywheel/core/model/ModelUtil.java index 3163b0298..0a5b64809 100644 --- a/src/main/java/com/jozufozu/flywheel/core/model/ModelUtil.java +++ b/src/main/java/com/jozufozu/flywheel/core/model/ModelUtil.java @@ -62,8 +62,8 @@ public class ModelUtil { ReusableVertexList dstList = dstVertexType.createVertexList(); srcList.ptr(srcPtr); dstList.ptr(dstPtr); - srcList.setVertexCount(vertexCount); - dstList.setVertexCount(vertexCount); + srcList.vertexCount(vertexCount); + dstList.vertexCount(vertexCount); srcList.writeAll(dstList); diff --git a/src/main/java/com/jozufozu/flywheel/core/model/SimpleMesh.java b/src/main/java/com/jozufozu/flywheel/core/model/SimpleMesh.java index d184a05d6..f847b9f10 100644 --- a/src/main/java/com/jozufozu/flywheel/core/model/SimpleMesh.java +++ b/src/main/java/com/jozufozu/flywheel/core/model/SimpleMesh.java @@ -26,7 +26,7 @@ public class SimpleMesh implements Mesh { vertexList = getVertexType().createVertexList(); vertexList.ptr(contents.ptr()); - vertexList.setVertexCount(vertexCount); + vertexList.vertexCount(vertexCount); } @Override diff --git a/src/main/java/com/jozufozu/flywheel/core/structs/oriented/OrientedType.java b/src/main/java/com/jozufozu/flywheel/core/structs/oriented/OrientedType.java index 66f2653f5..cf3ec8e03 100644 --- a/src/main/java/com/jozufozu/flywheel/core/structs/oriented/OrientedType.java +++ b/src/main/java/com/jozufozu/flywheel/core/structs/oriented/OrientedType.java @@ -56,7 +56,7 @@ public class OrientedType implements StructType { Matrix3f normalMatrix = new Matrix3f(q); int light = struct.getPackedLight(); - for (int i = 0; i < vertexList.getVertexCount(); i++) { + for (int i = 0; i < vertexList.vertexCount(); i++) { pos.set( vertexList.x(i), vertexList.y(i), diff --git a/src/main/java/com/jozufozu/flywheel/core/structs/transformed/TransformedType.java b/src/main/java/com/jozufozu/flywheel/core/structs/transformed/TransformedType.java index 8eb36eeb6..d39b73161 100644 --- a/src/main/java/com/jozufozu/flywheel/core/structs/transformed/TransformedType.java +++ b/src/main/java/com/jozufozu/flywheel/core/structs/transformed/TransformedType.java @@ -43,7 +43,7 @@ public class TransformedType implements StructType { Vector3f normal = new Vector3f(); int light = struct.getPackedLight(); - for (int i = 0; i < vertexList.getVertexCount(); i++) { + for (int i = 0; i < vertexList.vertexCount(); i++) { pos.set( vertexList.x(i), vertexList.y(i), diff --git a/src/main/java/com/jozufozu/flywheel/core/vertex/AbstractVertexList.java b/src/main/java/com/jozufozu/flywheel/core/vertex/AbstractVertexList.java index 3319f7a1e..75f679a19 100644 --- a/src/main/java/com/jozufozu/flywheel/core/vertex/AbstractVertexList.java +++ b/src/main/java/com/jozufozu/flywheel/core/vertex/AbstractVertexList.java @@ -17,12 +17,12 @@ public abstract class AbstractVertexList implements ReusableVertexList { } @Override - public int getVertexCount() { + public int vertexCount() { return vertexCount; } @Override - public void setVertexCount(int vertexCount) { + public void vertexCount(int vertexCount) { this.vertexCount = vertexCount; } } diff --git a/src/main/java/com/jozufozu/flywheel/core/vertex/BlockVertexList.java b/src/main/java/com/jozufozu/flywheel/core/vertex/BlockVertexList.java index ecfa8f277..2b8129ae5 100644 --- a/src/main/java/com/jozufozu/flywheel/core/vertex/BlockVertexList.java +++ b/src/main/java/com/jozufozu/flywheel/core/vertex/BlockVertexList.java @@ -153,7 +153,7 @@ public class BlockVertexList extends AbstractVertexList { } @Override - public void shiftPtr(int vertices) { - ptr += vertices * STRIDE; + public int vertexStride() { + return STRIDE; } } diff --git a/src/main/java/com/jozufozu/flywheel/core/vertex/InferredVertexListImpl.java b/src/main/java/com/jozufozu/flywheel/core/vertex/InferredVertexListImpl.java index 0b18204ff..f4d1a0353 100644 --- a/src/main/java/com/jozufozu/flywheel/core/vertex/InferredVertexListImpl.java +++ b/src/main/java/com/jozufozu/flywheel/core/vertex/InferredVertexListImpl.java @@ -203,7 +203,7 @@ public class InferredVertexListImpl extends AbstractVertexList implements Reusab } @Override - public void shiftPtr(int vertices) { - ptr += vertices * stride; + public int vertexStride() { + return stride; } } diff --git a/src/main/java/com/jozufozu/flywheel/core/vertex/PosTexNormalVertexList.java b/src/main/java/com/jozufozu/flywheel/core/vertex/PosTexNormalVertexList.java index 4ac841c04..52506ac66 100644 --- a/src/main/java/com/jozufozu/flywheel/core/vertex/PosTexNormalVertexList.java +++ b/src/main/java/com/jozufozu/flywheel/core/vertex/PosTexNormalVertexList.java @@ -148,7 +148,7 @@ public class PosTexNormalVertexList extends AbstractVertexList { } @Override - public void shiftPtr(int vertices) { - ptr += vertices * STRIDE; + public int vertexStride() { + return STRIDE; } }