Optimize in-world item rendering (#1034)

This commit is contained in:
sisyphussy authored and GitHub committed 2025-10-01 09:05:06 -07:00
1 parent e8dd60e088
commit 8afe2e2ccf
6 files changed
+158 -89

No files matched your search

@@ -148,15 +148,15 @@ public class AngelicaConfig {
@Config.RequiresMcRestart
public static boolean enableZoom;
@Config.Comment("Optimizes in-world item rendering [Experimental]")
@Config.DefaultBoolean(false)
@Config.Comment("Optimizes in-world item rendering")
@Config.DefaultBoolean(true)
@Config.RequiresMcRestart
public static boolean optimizeInWorldItemRendering_WIP;
public static boolean optimizeInWorldItemRendering;
@Config.Comment("Max amount of display lists to cache for optimized item rendering. Higher number will use more VRAM")
@Config.DefaultInt(256)
@Config.RangeInt(min = 64, max = 1024)
public static int itemRendererDisplayListCacheSize;
@Config.Comment("Upper limit for the amount of VBO's to cache for optimized item rendering. Higher number can potentially use more VRAM.")
@Config.DefaultInt(512)
@Config.RangeInt(min = 256, max = 1024)
public static int itemRendererCacheSize;
@Config.Comment("Render distance for the spinning mob inside mod spawners")
@Config.DefaultDouble(16D)
@@ -88,10 +88,10 @@ public enum Mixins implements IMixins {
.addClientMixins("angelica.optimizations.MixinRenderGlobal_ItemRenderDist")
.setApplyIf(() -> AngelicaConfig.dynamicItemRenderDistance)),
ANGELICA_ITEM_DISPLAY_LIST_OPTIMIZATION(new MixinBuilder("Optimized item rendering by wrapping them with display lists")
ANGELICA_ITEM_RENDERER_OPTIMIZATION(new MixinBuilder("Optimizes in-world item rendering")
.setPhase(Phase.EARLY)
.addClientMixins("angelica.itemrenderer.MixinItemRenderer")
.setApplyIf(() -> AngelicaConfig.optimizeInWorldItemRendering_WIP)),
.setApplyIf(() -> AngelicaConfig.optimizeInWorldItemRendering)),
// Not compatible with the lwjgl debug callbacks, so disable if that's enabled
ARCHAIC_SPLASH(new MixinBuilder()
@@ -25,87 +25,161 @@
package com.gtnewhorizons.angelica.rendering;
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import lombok.AccessLevel;
import it.unimi.dsi.fastutil.HashCommon;
import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.val;
import net.minecraft.client.Minecraft;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.GL11;
import net.minecraft.client.renderer.GLAllocation;
import net.minecraft.client.resources.IResourceManager;
import net.minecraft.client.resources.IResourceManagerReloadListener;
import java.util.ArrayList;
import java.util.HashMap;
import java.nio.ByteBuffer;
import java.util.List;
import java.util.Map;
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class ItemRenderListManager implements IResourceManagerReloadListener {
public static final ItemRenderListManager INSTANCE = new ItemRenderListManager();
public class ItemRenderListManager {
// Least used element is at position 0. This is in theory slightly faster.
private static final Object2ObjectLinkedOpenHashMap<ItemProp, CachedVBO> vboCache = new Object2ObjectLinkedOpenHashMap<>(64);
private final Map<ItemProp, Integer> theMap = new HashMap<>();
private final List<ItemProp> propList = new ArrayList<>();
private final ItemProp prop = new ItemProp();
private int list = 0;
// Formula: (widthSubdivisions * 2 + heightSubdivisions * 2 + 2) * 4 * vertexSize
// Using 256 as both variables due to enchants, to prevent later re-allocations.
private static ByteBuffer quadBuffer = BufferUtils.createByteBuffer(
(1026 * DefaultVertexFormat.POSITION_TEXTURE_NORMAL.getVertexSize()) << 2
);
public boolean pre(float a, float b, float c, float d, int e, int f, float g) {
prop.set(a, b, c, d, e, f, g);
if (theMap.containsKey(prop)) {
val list = theMap.get(prop);
propList.add(propList.remove(propList.indexOf(prop)));
GL11.glCallList(list);
return true;
} else {
if (propList.size() >= AngelicaConfig.itemRendererDisplayListCacheSize) {
val oldProp = propList.remove(0);
GLAllocation.deleteDisplayLists(theMap.remove(oldProp));
// 1 minute
private static final int EXPIRY_TICKS = 1_200;
private static int smallestExpiry;
private static final ItemProp prop = new ItemProp();
public static VertexBuffer pre(float minU, float minV, float maxU, float maxV, int widthSubdivisions, int heightSubdivisions, float thickness) {
prop.set(minU, minV, maxU, maxV, widthSubdivisions, heightSubdivisions, thickness);
if (!vboCache.isEmpty()) {
final CachedVBO vbo = vboCache.getAndMoveToLast(prop);
if (vbo != null) {
final int time = getElapsedTicks();
vbo.render(time);
// Prevent constant map lookups by only storing the expiry of the least recently used entry
if (time > smallestExpiry && time > (smallestExpiry = (vboCache.get(vboCache.firstKey()).expiry + 20))) {
vboCache.removeFirst().delete();
if (!vboCache.isEmpty()) {
smallestExpiry = vboCache.get(vboCache.firstKey()).expiry + 20;
}
}
return null;
}
list = GLAllocation.generateDisplayLists(1);
val newProp = new ItemProp(prop);
theMap.put(newProp, list);
propList.add(newProp);
GL11.glNewList(list, GL11.GL_COMPILE);
return false;
}
final CachedVBO vbo;
if (vboCache.size() >= AngelicaConfig.itemRendererCacheSize) {
final ItemProp oldestProp = vboCache.firstKey();
vbo = vboCache.removeFirst();
oldestProp.set(prop);
vboCache.put(oldestProp, vbo);
} else {
vbo = new CachedVBO();
vboCache.put(new ItemProp(prop), vbo);
}
vbo.expiry = getElapsedTicks() + EXPIRY_TICKS;
TessellatorManager.startCapturing();
return vbo.vertexBuffer;
}
public void post() {
GL11.glEndList();
GL11.glCallList(list);
public static void post(CapturingTessellator tessellator, VertexBuffer vbo) {
final List<QuadView> quads = TessellatorManager.stopCapturingToPooledQuads();
final int size = quads.size();
final int needed = (DefaultVertexFormat.POSITION_TEXTURE_NORMAL.getVertexSize() * size) << 2;
if (quadBuffer.capacity() < needed) {
quadBuffer = BufferUtils.createByteBuffer(HashCommon.nextPowerOfTwo(needed));
}
for (int i = 0; i < size; i++) {
DefaultVertexFormat.POSITION_TEXTURE_NORMAL.writeQuad(quads.get(i), quadBuffer);
}
quadBuffer.flip();
vbo.upload(quadBuffer);
quadBuffer.clear();
tessellator.clearQuads();
vbo.render();
}
@Override
public void onResourceManagerReload(IResourceManager p_110549_1_) {
propList.clear();
theMap.forEach((key, value) -> GLAllocation.deleteDisplayLists(value));
theMap.clear();
private static int getElapsedTicks() {
return Minecraft.getMinecraft().thePlayer.ticksExisted;
}
private static final class CachedVBO {
private VertexBuffer vertexBuffer;
private int expiry;
public CachedVBO() {
this.vertexBuffer = new VertexBuffer(DefaultVertexFormat.POSITION_TEXTURE_NORMAL, GL11.GL_QUADS);
}
private void render(int elapsedTicks) {
vertexBuffer.render();
expiry = elapsedTicks + EXPIRY_TICKS;
}
private void delete() {
vertexBuffer.close();
vertexBuffer = null;
}
}
@NoArgsConstructor
@Data
public class ItemProp {
private float a;
private float b;
private float c;
private float d;
private int e;
private int f;
private float g;
private static final class ItemProp {
private float minU;
private float minV;
private float maxU;
private float maxV;
private int widthSubdivisions;
private int heightSubdivisions;
private float thickness;
public ItemProp(ItemProp old) {
set(old.a, old.b, old.c, old.d, old.e, old.f, old.g);
set(
old.minU, old.minV,
old.maxU, old.maxV,
old.widthSubdivisions, old.heightSubdivisions,
old.thickness
);
}
public void set(float a, float b, float c, float d, int e, int f, float g) {
this.a = a;
this.b = b;
this.c = c;
this.d = d;
this.e = e;
this.f = f;
this.g = g;
public void set(ItemProp other) {
set(
other.minU, other.minV,
other.maxU, other.maxV,
other.widthSubdivisions, other.heightSubdivisions,
other.thickness
);
}
public void set(float minU, float minV, float maxU, float maxV, int widthSubdivisions, int heightSubdivisions, float thickness) {
this.minU = minU;
this.minV = minV;
this.maxU = maxU;
this.maxV = maxV;
this.widthSubdivisions = widthSubdivisions;
this.heightSubdivisions = heightSubdivisions;
this.thickness = thickness;
}
}
}