Compare commits

..
Author SHA1 Message Date
Logan Phillips 5a9eb8dc55 Initial commit for modern bitmap and character providers 2026-07-14 20:07:02 -04:00
45 changed files with 862 additions and 1067 deletions

No files matched your search

+1 -1
View File
@@ -1,4 +1,4 @@
# Description of your *PR* and other info
# Description or your *PR* and other info
<!-- Please include a summary of the change -->
<!-- Any details that you think are important to review this PR? -->
<!-- Are there any Issues / PRs related to this one? -->
-1
View File
@@ -12,7 +12,6 @@ build/
/config/
/crash-reports/
/logs/
tmp/
options.txt
/saves/
usernamecache.json
+1 -1
View File
@@ -144,7 +144,7 @@ dependencies {
compileOnly(rfg.deobf("curse.maven:campfirebackport-387444:4611675"))
compileOnly(rfg.deobf("curse.maven:xaeros-minimap-263420:5060684"))
compileOnly(rfg.deobf("curse.maven:security-craft-64760:2818228"))
compileOnly("ganymedes01.etfuturum:Et-Futurum-Requiem:2.6.49-GTNH:dev")
compileOnly(rfg.deobf("curse.maven:et-futurum-requiem-441392:5873837"))
compileOnly(rfg.deobf("curse.maven:biomes-o-plenty-220318:2499612"))
devOnlyNonPublishable("com.github.GTNewHorizons:CosmeticArmorReworked:1.0.3-GTNH:dev")
@@ -877,14 +877,9 @@ public class DisplayListManager {
// Empty display list - per OpenGL spec, still valid after glNewList/glEndList
compiled = CompiledDisplayList.EMPTY;
}
final boolean locked = GLStateManager.acquireDrawLock();
try {
final CompiledDisplayList previous = displayListCache.put(glListId, compiled);
if (previous != null && previous != CompiledDisplayList.EMPTY && previous != compiled) {
previous.delete();
}
} finally {
if (locked) GLStateManager.releaseDrawLock();
final CompiledDisplayList previous = displayListCache.put(glListId, compiled);
if (previous != null && previous != CompiledDisplayList.EMPTY && previous != compiled) {
previous.delete();
}
// Log compilation details if enabled (before context restoration changes glListId)
@@ -1017,43 +1012,33 @@ public class DisplayListManager {
}
private static void executeDisplayList(int list) {
final boolean locked = GLStateManager.acquireDrawLock();
try {
final CompiledDisplayList compiled = displayListCache.get(list);
if (compiled != null) {
compiled.render(list);
return;
}
// Fall back to VBOManager or legacy display list
if (list < 0) {
// Negative IDs are VBOManager space (entity models, etc.)
final VertexBuffer vbo = VBOManager.get(list);
if (vbo != null) {
vbo.render();
}
// Per OpenGL spec: if list is undefined, glCallList has no effect
}
// An uncached positive-ID list = no-op (per OpenGL spec)
} finally {
if (locked) GLStateManager.releaseDrawLock();
final CompiledDisplayList compiled = displayListCache.get(list);
if (compiled != null) {
compiled.render(list);
return;
}
// Fall back to VBOManager or legacy display list
if (list < 0) {
// Negative IDs are VBOManager space (entity models, etc.)
final VertexBuffer vbo = VBOManager.get(list);
if (vbo != null) {
vbo.render();
}
// Per OpenGL spec: if list is undefined, glCallList has no effect
}
// An uncached positive-ID list = no-op (per OpenGL spec)
}
/**
* Delete display lists and free their VBO resources.
*/
public static void glDeleteLists(int list, int range) {
final boolean locked = GLStateManager.acquireDrawLock();
try {
for (int i = list; i < list + range; i++) {
CompiledDisplayList compiled = displayListCache.remove(i);
if (compiled != null) {
compiled.delete();
}
for (int i = list; i < list + range; i++) {
CompiledDisplayList compiled = displayListCache.remove(i);
if (compiled != null) {
compiled.delete();
}
} finally {
if (locked) GLStateManager.releaseDrawLock();
}
}
@@ -89,7 +89,6 @@ import java.nio.ByteBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ShortBuffer;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
@@ -97,7 +96,6 @@ import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.IntSupplier;
import static com.gtnewhorizons.angelica.glsm.Vendor.AMD;
@@ -253,18 +251,6 @@ public class GLStateManager {
// Reference to DrawableGL (main display context) - works with both FML and BLS splash
@Setter private static Drawable drawableGL = null;
private static final ReentrantLock DRAW_LOCK = new ReentrantLock();
public static boolean acquireDrawLock() {
if (splashComplete) return false;
DRAW_LOCK.lock();
return true;
}
public static void releaseDrawLock() {
DRAW_LOCK.unlock();
}
public static boolean isCachingEnabled() {
if (splashComplete) return true;
return Thread.currentThread() == drawableGLHolder;
@@ -2257,25 +2243,15 @@ public class GLStateManager {
}
public static void preDraw(int drawMode) {
final boolean locked = acquireDrawLock();
try {
prepareWideLineEmulation(drawMode);
ShaderManager.getInstance().preDraw();
prepareClientArrays();
} finally {
if (locked) releaseDrawLock();
}
prepareWideLineEmulation(drawMode);
ShaderManager.getInstance().preDraw();
prepareClientArrays();
}
public static void preDraw() {
final boolean locked = acquireDrawLock();
try {
disableWideLineEmulation();
ShaderManager.getInstance().preDraw();
prepareClientArrays();
} finally {
if (locked) releaseDrawLock();
}
disableWideLineEmulation();
ShaderManager.getInstance().preDraw();
prepareClientArrays();
}
public static void glDrawElements(int mode, ByteBuffer indices) {
@@ -3269,7 +3245,6 @@ public class GLStateManager {
splashComplete = true;
drawableGLHolder = null;
drawableGL = null;
ImmediateModeRecorder.cleanupOrphanTessellators();
}
public static void glNewList(int list, int mode) {
@@ -5199,12 +5174,6 @@ public class GLStateManager {
RENDER_BACKEND.deleteBuffers(buffers);
}
public static void glDeleteBuffers(int[] buffers) {
for (int buffer : buffers) {
glDeleteBuffers(buffer);
}
}
private static void invalidateDeletedBuffer(int buffer) {
if (buffer == 0) return;
if (boundVBO == buffer) boundVBO = 0;
@@ -5216,7 +5185,6 @@ public class GLStateManager {
for (VAOManager.VAOData data : VAOManager.vaoMap.values()) {
if (data.ebo == buffer) data.ebo = 0;
}
}
public static void glBindBuffer(int target, int buffer) {
@@ -5269,279 +5237,34 @@ public class GLStateManager {
return RENDER_BACKEND.genBuffers();
}
public static void glGenBuffers(IntBuffer buffers) {
for (int i = buffers.position(); i < buffers.limit(); i++) buffers.put(i, RENDER_BACKEND.genBuffers());
}
public static void glGenBuffers(int[] buffers) {
for (int i = 0; i < buffers.length; i++) buffers[i] = RENDER_BACKEND.genBuffers();
}
public static int glCreateBuffers() {
return RENDER_BACKEND.createBuffers();
}
public static void glCreateBuffers(IntBuffer buffers) {
for (int i = buffers.position(); i < buffers.limit(); i++) buffers.put(i, RENDER_BACKEND.createBuffers());
}
public static void glCreateBuffers(int[] buffers) {
for (int i = 0; i < buffers.length; i++) buffers[i] = RENDER_BACKEND.createBuffers();
}
public static void glBufferData(int target, long size, int usage) { RENDER_BACKEND.bufferData(target, size, usage); }
public static void glBufferData(int target, ByteBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
public static void glBufferData(int target, ShortBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
public static void glBufferData(int target, IntBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
public static void glBufferData(int target, FloatBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
public static void glBufferData(int target, DoubleBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
public static void glBufferData(int target, LongBuffer data, int usage) { glBufferData(target, MemoryUtilities.memByteBuffer(data), usage); }
public static void glBufferData(int target, int[] data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
public static void glBufferData(int target, float[] data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
public static void glBufferData(int target, short[] data, int usage) {
final ByteBuffer copy = copyOf(data);
glBufferData(target, copy, usage);
MemoryUtilities.memFree(copy);
}
public static void glBufferData(int target, long[] data, int usage) {
final ByteBuffer copy = copyOf(data);
glBufferData(target, copy, usage);
MemoryUtilities.memFree(copy);
}
public static void glBufferData(int target, double[] data, int usage) {
final ByteBuffer copy = copyOf(data);
glBufferData(target, copy, usage);
MemoryUtilities.memFree(copy);
}
public static void nglBufferData(int target, long size, long data, int usage) {
if (data == 0L) {
glBufferData(target, size, usage);
return;
}
glBufferData(target, MemoryUtilities.memByteBuffer(data, checkedSize(size)), usage);
}
public static void glBufferSubData(int target, long offset, ByteBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
public static void glBufferSubData(int target, long offset, ShortBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
public static void glBufferSubData(int target, long offset, IntBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
public static void glBufferSubData(int target, long offset, FloatBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
public static void glBufferSubData(int target, long offset, DoubleBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
public static void glBufferSubData(int target, long offset, LongBuffer data) { glBufferSubData(target, offset, MemoryUtilities.memByteBuffer(data)); }
public static void glBufferSubData(int target, long offset, short[] data) {
final ByteBuffer copy = copyOf(data);
glBufferSubData(target, offset, copy);
MemoryUtilities.memFree(copy);
}
public static void glBufferSubData(int target, long offset, int[] data) {
final ByteBuffer copy = copyOf(data);
glBufferSubData(target, offset, copy);
MemoryUtilities.memFree(copy);
}
public static void glBufferSubData(int target, long offset, long[] data) {
final ByteBuffer copy = copyOf(data);
glBufferSubData(target, offset, copy);
MemoryUtilities.memFree(copy);
}
public static void glBufferSubData(int target, long offset, float[] data) {
final ByteBuffer copy = copyOf(data);
glBufferSubData(target, offset, copy);
MemoryUtilities.memFree(copy);
}
public static void glBufferSubData(int target, long offset, double[] data) {
final ByteBuffer copy = copyOf(data);
glBufferSubData(target, offset, copy);
MemoryUtilities.memFree(copy);
}
public static void nglBufferSubData(int target, long offset, long size, long data) { glBufferSubData(target, offset, MemoryUtilities.memByteBuffer(data, checkedSize(size))); }
public static void glBufferData(int target, java.nio.ByteBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
public static void glBufferData(int target, java.nio.ShortBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
public static void glBufferData(int target, java.nio.IntBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
public static void glBufferData(int target, java.nio.FloatBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
public static void glBufferData(int target, java.nio.DoubleBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
public static void glBufferSubData(int target, long offset, java.nio.ByteBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
public static void glBufferSubData(int target, long offset, java.nio.ShortBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
public static void glBufferSubData(int target, long offset, java.nio.IntBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
public static void glBufferSubData(int target, long offset, java.nio.FloatBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
public static void glBufferSubData(int target, long offset, java.nio.DoubleBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
public static ByteBuffer glMapBuffer(int target, int access) { return RENDER_BACKEND.mapBuffer(target, access); }
public static ByteBuffer glMapBuffer(int target, int access, ByteBuffer old_buffer) { return glMapBuffer(target, access); }
public static ByteBuffer glMapBuffer(int target, int access, long length, ByteBuffer old_buffer) { return RENDER_BACKEND.mapBuffer(target, access, length, old_buffer); }
public static ByteBuffer glMapBufferRange(int target, long offset, long length, int access) { return RENDER_BACKEND.mapBufferRange(target, offset, length, access); }
public static ByteBuffer glMapBufferRange(int target, long offset, long length, int access, ByteBuffer old_buffer) { return glMapBufferRange(target, offset, length, access); }
public static void glFlushMappedBufferRange(int target, long offset, long length) { RENDER_BACKEND.flushMappedBufferRange(target, offset, length); }
public static boolean glUnmapBuffer(int target) { return RENDER_BACKEND.unmapBuffer(target); }
public static void glGetBufferSubData(int target, long offset, ByteBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
public static void glGetBufferSubData(int target, long offset, ShortBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
public static void glGetBufferSubData(int target, long offset, IntBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
public static void glGetBufferSubData(int target, long offset, FloatBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
public static void glGetBufferSubData(int target, long offset, DoubleBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
public static void glGetBufferSubData(int target, long offset, LongBuffer data) { glGetBufferSubData(target, offset, MemoryUtilities.memByteBuffer(data)); }
public static void glGetBufferSubData(int target, long offset, short[] data) {
final ByteBuffer copy = MemoryUtilities.memAlloc(data.length << 1);
glGetBufferSubData(target, offset, copy);
copy.asShortBuffer().get(data);
MemoryUtilities.memFree(copy);
}
public static void glGetBufferSubData(int target, long offset, int[] data) {
final ByteBuffer copy = MemoryUtilities.memAlloc(data.length << 2);
glGetBufferSubData(target, offset, copy);
copy.asIntBuffer().get(data);
MemoryUtilities.memFree(copy);
}
public static void glGetBufferSubData(int target, long offset, long[] data) {
final ByteBuffer copy = MemoryUtilities.memAlloc(data.length << 3);
glGetBufferSubData(target, offset, copy);
copy.asLongBuffer().get(data);
MemoryUtilities.memFree(copy);
}
public static void glGetBufferSubData(int target, long offset, float[] data) {
final ByteBuffer copy = MemoryUtilities.memAlloc(data.length << 2);
glGetBufferSubData(target, offset, copy);
copy.asFloatBuffer().get(data);
MemoryUtilities.memFree(copy);
}
public static void glGetBufferSubData(int target, long offset, double[] data) {
final ByteBuffer copy = MemoryUtilities.memAlloc(data.length << 3);
glGetBufferSubData(target, offset, copy);
copy.asDoubleBuffer().get(data);
MemoryUtilities.memFree(copy);
}
public static void nglGetBufferSubData(int target, long offset, long size, long data) { glGetBufferSubData(target, offset, MemoryUtilities.memByteBuffer(data, checkedSize(size))); }
public static void glGetBufferSubData(int target, long offset, java.nio.ByteBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
public static void glGetBufferSubData(int target, long offset, java.nio.ShortBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
public static void glGetBufferSubData(int target, long offset, java.nio.IntBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
public static void glGetBufferSubData(int target, long offset, java.nio.FloatBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
public static void glGetBufferSubData(int target, long offset, java.nio.DoubleBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
public static int glGetBufferParameteri(int target, int pname) { return RENDER_BACKEND.getBufferParameteri(target, pname); }
public static int glGetBufferParameter(int target, int pname) { return glGetBufferParameteri(target, pname); }
public static void glGetBufferParameter(int target, int pname, IntBuffer params) { params.put(params.position(), glGetBufferParameteri(target, pname)); }
public static void glGetBufferParameteriv(int target, int pname, IntBuffer params) { params.put(params.position(), glGetBufferParameteri(target, pname)); }
public static void glGetBufferParameteriv(int target, int pname, int[] params) { params[0] = glGetBufferParameteri(target, pname); }
public static void glBufferStorage(int target, java.nio.ByteBuffer data, int flags) { RENDER_BACKEND.bufferStorage(target, data, flags); }
public static void glBufferStorage(int target, long size, int flags) { RENDER_BACKEND.bufferStorage(target, size, flags); }
public static void glBufferStorage(int target, ByteBuffer data, int flags) { RENDER_BACKEND.bufferStorage(target, data, flags); }
public static void glBufferStorage(int target, ShortBuffer data, int flags) { glBufferStorage(target, MemoryUtilities.memByteBuffer(data), flags); }
public static void glBufferStorage(int target, IntBuffer data, int flags) { glBufferStorage(target, MemoryUtilities.memByteBuffer(data), flags); }
public static void glBufferStorage(int target, FloatBuffer data, int flags) { glBufferStorage(target, MemoryUtilities.memByteBuffer(data), flags); }
public static void glBufferStorage(int target, DoubleBuffer data, int flags) { glBufferStorage(target, MemoryUtilities.memByteBuffer(data), flags); }
public static void glBufferStorage(int target, short[] data, int flags) {
final ByteBuffer copy = copyOf(data);
glBufferStorage(target, copy, flags);
MemoryUtilities.memFree(copy);
}
public static void glBufferStorage(int target, int[] data, int flags) {
final ByteBuffer copy = copyOf(data);
glBufferStorage(target, copy, flags);
MemoryUtilities.memFree(copy);
}
public static void glBufferStorage(int target, float[] data, int flags) {
final ByteBuffer copy = copyOf(data);
glBufferStorage(target, copy, flags);
MemoryUtilities.memFree(copy);
}
public static void glBufferStorage(int target, double[] data, int flags) {
final ByteBuffer copy = copyOf(data);
glBufferStorage(target, copy, flags);
MemoryUtilities.memFree(copy);
}
public static void glNamedBufferData(int buffer, long size, int usage) { RENDER_BACKEND.namedBufferData(buffer, size, usage); }
public static void glNamedBufferData(int buffer, ByteBuffer data, int usage) { RENDER_BACKEND.namedBufferData(buffer, data, usage); }
public static void glNamedBufferData(int buffer, FloatBuffer data, int usage) { RENDER_BACKEND.namedBufferData(buffer, data, usage); }
public static void glNamedBufferData(int buffer, ShortBuffer data, int usage) { glNamedBufferData(buffer, MemoryUtilities.memByteBuffer(data), usage); }
public static void glNamedBufferData(int buffer, IntBuffer data, int usage) { glNamedBufferData(buffer, MemoryUtilities.memByteBuffer(data), usage); }
public static void glNamedBufferData(int buffer, LongBuffer data, int usage) { glNamedBufferData(buffer, MemoryUtilities.memByteBuffer(data), usage); }
public static void glNamedBufferData(int buffer, DoubleBuffer data, int usage) { glNamedBufferData(buffer, MemoryUtilities.memByteBuffer(data), usage); }
public static void glNamedBufferData(int buffer, short[] data, int usage) {
final ByteBuffer copy = copyOf(data);
glNamedBufferData(buffer, copy, usage);
MemoryUtilities.memFree(copy);
}
public static void glNamedBufferData(int buffer, int[] data, int usage) {
final ByteBuffer copy = copyOf(data);
glNamedBufferData(buffer, copy, usage);
MemoryUtilities.memFree(copy);
}
public static void glNamedBufferData(int buffer, long[] data, int usage) {
final ByteBuffer copy = copyOf(data);
glNamedBufferData(buffer, copy, usage);
MemoryUtilities.memFree(copy);
}
public static void glNamedBufferData(int buffer, float[] data, int usage) {
final ByteBuffer copy = copyOf(data);
glNamedBufferData(buffer, copy, usage);
MemoryUtilities.memFree(copy);
}
public static void glNamedBufferData(int buffer, double[] data, int usage) {
final ByteBuffer copy = copyOf(data);
glNamedBufferData(buffer, copy, usage);
MemoryUtilities.memFree(copy);
}
public static void glNamedBufferSubData(int buffer, long offset, ByteBuffer data) { RENDER_BACKEND.namedBufferSubData(buffer, offset, data); }
public static void glNamedBufferSubData(int buffer, long offset, ShortBuffer data) { glNamedBufferSubData(buffer, offset, MemoryUtilities.memByteBuffer(data)); }
public static void glNamedBufferSubData(int buffer, long offset, IntBuffer data) { glNamedBufferSubData(buffer, offset, MemoryUtilities.memByteBuffer(data)); }
public static void glNamedBufferSubData(int buffer, long offset, LongBuffer data) { glNamedBufferSubData(buffer, offset, MemoryUtilities.memByteBuffer(data)); }
public static void glNamedBufferSubData(int buffer, long offset, FloatBuffer data) { glNamedBufferSubData(buffer, offset, MemoryUtilities.memByteBuffer(data)); }
public static void glNamedBufferSubData(int buffer, long offset, DoubleBuffer data) { glNamedBufferSubData(buffer, offset, MemoryUtilities.memByteBuffer(data)); }
public static void glNamedBufferSubData(int buffer, long offset, short[] data) {
final ByteBuffer copy = copyOf(data);
glNamedBufferSubData(buffer, offset, copy);
MemoryUtilities.memFree(copy);
}
public static void glNamedBufferSubData(int buffer, long offset, int[] data) {
final ByteBuffer copy = copyOf(data);
glNamedBufferSubData(buffer, offset, copy);
MemoryUtilities.memFree(copy);
}
public static void glNamedBufferSubData(int buffer, long offset, long[] data) {
final ByteBuffer copy = copyOf(data);
glNamedBufferSubData(buffer, offset, copy);
MemoryUtilities.memFree(copy);
}
public static void glNamedBufferSubData(int buffer, long offset, float[] data) {
final ByteBuffer copy = copyOf(data);
glNamedBufferSubData(buffer, offset, copy);
MemoryUtilities.memFree(copy);
}
public static void glNamedBufferSubData(int buffer, long offset, double[] data) {
final ByteBuffer copy = copyOf(data);
glNamedBufferSubData(buffer, offset, copy);
MemoryUtilities.memFree(copy);
}
public static void glClearBufferSubData(int target, int internalFormat, long offset, long size, int format, int type, ByteBuffer data) { RENDER_BACKEND.clearBufferSubData(target, internalFormat, offset, size, format, type, data); }
public static void glClearBufferSubData(int target, int internalFormat, long offset, long size, int format, int type, java.nio.ByteBuffer data) { RENDER_BACKEND.clearBufferSubData(target, internalFormat, offset, size, format, type, data); }
public static boolean glIsBuffer(int buffer) { return RENDER_BACKEND.isBuffer(buffer); }
public static void glCopyBufferSubData(int readTarget, int writeTarget, long readOffset, long writeOffset, long size) { RENDER_BACKEND.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); }
private static int checkedSize(long size) {
if (size < 0 || size > Integer.MAX_VALUE) {
throw new IllegalArgumentException("Buffer range does not fit a ByteBuffer wrapper: " + size);
}
return (int) size;
}
private static ByteBuffer copyOf(short[] data) {
final ByteBuffer bb = MemoryUtilities.memAlloc(data.length << 1);
bb.asShortBuffer().put(data);
return bb;
}
private static ByteBuffer copyOf(int[] data) {
final ByteBuffer bb = MemoryUtilities.memAlloc(data.length << 2);
bb.asIntBuffer().put(data);
return bb;
}
private static ByteBuffer copyOf(long[] data) {
final ByteBuffer bb = MemoryUtilities.memAlloc(data.length << 3);
bb.asLongBuffer().put(data);
return bb;
}
private static ByteBuffer copyOf(float[] data) {
final ByteBuffer bb = MemoryUtilities.memAlloc(data.length << 2);
bb.asFloatBuffer().put(data);
return bb;
}
private static ByteBuffer copyOf(double[] data) {
final ByteBuffer bb = MemoryUtilities.memAlloc(data.length << 3);
bb.asDoubleBuffer().put(data);
return bb;
}
public static void glBindVertexArray(int array) {
if (DisplayListManager.isRecording()) {
DisplayListManager.recordBindVAO(array);
@@ -6442,7 +6165,7 @@ public class GLStateManager {
RENDER_BACKEND.getUniformiv(program, location, params);
}
public static void glGetTexImage(int target, int level, int format, int type, long pixels) {
RENDER_BACKEND.getTexImage(target, level, format, type, pixels);
GL11.glGetTexImage(target, level, format, type, pixels);
}
/**
@@ -91,26 +91,21 @@ public final class QuadConverter {
}
private static void drawSharedQuadEbo(int first, int vertexCount, int primcount, boolean instanced) {
final boolean locked = GLStateManager.acquireDrawLock();
try {
GLStateManager.preDraw();
assert first % 4 == 0 : "QuadConverter: first (" + first + ") must be a multiple of 4";
assert vertexCount % 4 == 0 : "QuadConverter: vertexCount (" + vertexCount + ") must be a multiple of 4";
final int quadCount = vertexCount / 4;
final int prevEbo = GLStateManager.getBoundEBO();
ensureCapacity(first / 4 + quadCount);
RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, eboId);
// Index offset: first vertex / 4 quads * 6 indices * 4 bytes per int
final long indexOffset = (long) (first / 4) * 6 * 4;
if (instanced) {
RENDER_BACKEND.drawElementsInstanced(GL11.GL_TRIANGLES, quadCount * 6, INDEX_TYPE, indexOffset, primcount);
} else {
RENDER_BACKEND.drawElements(GL11.GL_TRIANGLES, quadCount * 6, INDEX_TYPE, indexOffset);
}
RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, prevEbo);
} finally {
if (locked) GLStateManager.releaseDrawLock();
GLStateManager.preDraw();
assert first % 4 == 0 : "QuadConverter: first (" + first + ") must be a multiple of 4";
assert vertexCount % 4 == 0 : "QuadConverter: vertexCount (" + vertexCount + ") must be a multiple of 4";
final int quadCount = vertexCount / 4;
final int prevEbo = GLStateManager.getBoundEBO();
ensureCapacity(first / 4 + quadCount);
RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, eboId);
// Index offset: first vertex / 4 quads * 6 indices * 4 bytes per int
final long indexOffset = (long) (first / 4) * 6 * 4;
if (instanced) {
RENDER_BACKEND.drawElementsInstanced(GL11.GL_TRIANGLES, quadCount * 6, INDEX_TYPE, indexOffset, primcount);
} else {
RENDER_BACKEND.drawElements(GL11.GL_TRIANGLES, quadCount * 6, INDEX_TYPE, indexOffset);
}
RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, prevEbo);
}
/**
@@ -128,37 +123,32 @@ public final class QuadConverter {
}
private static void uploadAndDraw(ByteBuffer dst, int triIndexCount, int indexType, int bytesPerIndex, int primcount, boolean instanced) {
final boolean locked = GLStateManager.acquireDrawLock();
try {
GLStateManager.preDraw();
final int needed = triIndexCount * bytesPerIndex;
final int prevEbo = GLStateManager.getBoundEBO();
GLStateManager.preDraw();
final int needed = triIndexCount * bytesPerIndex;
final int prevEbo = GLStateManager.getBoundEBO();
if (scratchEboId == 0) {
scratchEboId = RENDER_BACKEND.genBuffers();
}
RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, scratchEboId);
if (needed > scratchEboCapacity) {
// Power-of-2 growth -- allocate full capacity, upload actual data
int newCap = Math.max(4096, scratchEboCapacity);
while (newCap < needed) newCap *= 2;
RENDER_BACKEND.bufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, newCap, GL15.GL_STREAM_DRAW);
scratchEboCapacity = newCap;
}
RENDER_BACKEND.bufferSubData(GL15.GL_ELEMENT_ARRAY_BUFFER, 0, dst);
if (instanced) {
RENDER_BACKEND.drawElementsInstanced(GL11.GL_TRIANGLES, triIndexCount, indexType, 0L, primcount);
} else {
RENDER_BACKEND.drawElements(GL11.GL_TRIANGLES, triIndexCount, indexType, 0L);
}
RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, prevEbo);
} finally {
if (locked) GLStateManager.releaseDrawLock();
if (scratchEboId == 0) {
scratchEboId = RENDER_BACKEND.genBuffers();
}
RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, scratchEboId);
if (needed > scratchEboCapacity) {
// Power-of-2 growth — allocate full capacity, upload actual data
int newCap = Math.max(4096, scratchEboCapacity);
while (newCap < needed) newCap *= 2;
RENDER_BACKEND.bufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, newCap, GL15.GL_STREAM_DRAW);
scratchEboCapacity = newCap;
}
RENDER_BACKEND.bufferSubData(GL15.GL_ELEMENT_ARRAY_BUFFER, 0, dst);
if (instanced) {
RENDER_BACKEND.drawElementsInstanced(GL11.GL_TRIANGLES, triIndexCount, indexType, 0L, primcount);
} else {
RENDER_BACKEND.drawElements(GL11.GL_TRIANGLES, triIndexCount, indexType, 0L);
}
RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, prevEbo);
memFree(dst);
}
@@ -146,9 +146,6 @@ public class RenderSystem {
coreProfile = true;
GLStateManager.LOGGER.info("GL 3.3 core profile detected, enabling FFP shader emulation.");
ShaderManager.getInstance().enable();
} else {
throw new IllegalStateException("Non-core GL context (profile mask 0x" + Integer.toHexString(profileMask)
+ "); FFP emulation requires a core profile and nothing would render. Context creation should have rejected this.");
}
}
@@ -304,7 +301,7 @@ public class RenderSystem {
}
public static void bufferData(int target, FloatBuffer data, int usage) {
GLStateManager.glBufferData(target, data, usage);
RENDER_BACKEND.bufferData(target, data, usage);
}
public static int bufferStorage(int target, FloatBuffer data, int usage) {
@@ -450,7 +447,7 @@ public class RenderSystem {
}
public static int createBuffers() {
return GLStateManager.glGenBuffers();
return RENDER_BACKEND.genBuffers();
}
public static void bindBufferBase(int target, int index, int buffer) {
@@ -458,13 +455,13 @@ public class RenderSystem {
}
public static void bufferStorage(int target, long size, int flags) {
GLStateManager.glBufferStorage(target, size, flags);
RENDER_BACKEND.bufferStorage(target, size, flags);
}
public static void clearBufferSubData(int target, int internalFormat, long offset, long size, int format, int type, int[] data) {
final ByteBuffer buf = BufferUtils.createByteBuffer(data.length * 4);
buf.asIntBuffer().put(data);
GLStateManager.glClearBufferSubData(target, internalFormat, offset, size, format, type, buf);
RENDER_BACKEND.clearBufferSubData(target, internalFormat, offset, size, format, type, buf);
}
public static void deleteBuffers(int buffer) {
@@ -552,7 +549,7 @@ public class RenderSystem {
}
}
/** Parse a GL version string (e.g. "4.6.0 NVIDIA ...") into concatenated digits "460" */
/** Parse a GL version string (e.g. "4.6.0 NVIDIA ...") into concatenated digits "460". Inlined from StandardMacros.getGlVersion(). */
static String parseGlVersionString(String info) {
final Matcher matcher = SEMVER_PATTERN.matcher(Objects.requireNonNull(info));
if (!matcher.matches()) {
@@ -564,18 +561,4 @@ public class RenderSystem {
if (bugfix == null || bugfix.isEmpty()) bugfix = "0";
return major + minor + bugfix;
}
/** Parse a GL version string into packed major*10+minor (e.g. "4.3.0 - Build ..." -> 43), or -1 if unparseable. */
public static int parseMajorMinor(String glVersion) {
if (glVersion == null) return -1;
final Matcher matcher = SEMVER_PATTERN.matcher(glVersion.trim());
if (!matcher.matches()) return -1;
return Integer.parseInt(matcher.group("major")) * 10 + Integer.parseInt(matcher.group("minor"));
}
public static boolean isContextValid(int requestedMajor, int requestedMinor, int actualVersion, boolean coreBitSet) {
if (!coreBitSet) return false;
if (actualVersion < 0) return true;
return actualVersion >= requestedMajor * 10 + requestedMinor;
}
}
@@ -327,7 +327,7 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
@Override
public void copyBufferSubData(int readTarget, int writeTarget, long readOffset, long writeOffset, long size) {
GL31.glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
throw new UnsupportedOperationException("GLRenderBackend.copyBufferSubData should not be called — LWJGL service handles this");
}
@Override
@@ -622,11 +622,6 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
GL11.glGetTexImage(target, level, format, type, pixels);
}
@Override
public void getTexImage(int target, int level, int format, int type, long pixelBufferOffset) {
GL11.glGetTexImage(target, level, format, type, pixelBufferOffset);
}
@Override
public int getFramebufferAttachmentParameteri(int target, int attachment, int pname) {
return GL30.glGetFramebufferAttachmentParameteri(target, attachment, pname);
@@ -1063,11 +1058,6 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
return GL30.glMapBufferRange(target, offset, length, access, null);
}
@Override
public void flushMappedBufferRange(int target, long offset, long length) {
GL30.glFlushMappedBufferRange(target, offset, length);
}
@Override
public int genVertexArrays() {
return GL30.glGenVertexArrays();
@@ -1259,11 +1249,6 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
return GL45.glCreateBuffers();
}
@Override
public void namedBufferData(int buffer, long size, int usage) {
GL45.glNamedBufferData(buffer, size, usage);
}
@Override
public void namedBufferData(int buffer, ByteBuffer data, int usage) {
GL45.glNamedBufferData(buffer, data, usage);
@@ -151,7 +151,6 @@ public abstract class RenderBackend {
public abstract void readPixels(int x, int y, int width, int height, int format, int type, IntBuffer pixels);
public abstract void getTexImage(int target, int level, int format, int type, ByteBuffer pixels);
public abstract void getTexImage(int target, int level, int format, int type, IntBuffer pixels);
public abstract void getTexImage(int target, int level, int format, int type, long pixelBufferOffset);
public abstract int getFramebufferAttachmentParameteri(int target, int attachment, int pname);
public abstract int createShader(int type);
@@ -250,7 +249,6 @@ public abstract class RenderBackend {
public abstract int getBufferParameteri(int target, int pname);
public abstract boolean isBuffer(int buffer);
public abstract ByteBuffer mapBufferRange(int target, long offset, long length, int access);
public abstract void flushMappedBufferRange(int target, long offset, long length);
public abstract int genVertexArrays();
public abstract void deleteVertexArrays(int array);
@@ -294,7 +292,6 @@ public abstract class RenderBackend {
public abstract void namedFramebufferDrawBuffers(int framebuffer, IntBuffer bufs);
public abstract void blitNamedFramebuffer(int readFramebuffer, int drawFramebuffer, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, int mask, int filter);
public abstract int createBuffers();
public abstract void namedBufferData(int buffer, long size, int usage);
public abstract void namedBufferData(int buffer, ByteBuffer data, int usage);
public abstract void namedBufferData(int buffer, FloatBuffer data, int usage);
public abstract void namedBufferSubData(int buffer, long offset, ByteBuffer data);
@@ -104,8 +104,8 @@ public class DSAARB extends DSAUnsupported {
@Override
public int bufferStorage(int target, FloatBuffer data, int usage) {
final int buffer = GLStateManager.glCreateBuffers();
GLStateManager.glNamedBufferData(buffer, data, usage);
final int buffer = RENDER_BACKEND.createBuffers();
RENDER_BACKEND.namedBufferData(buffer, data, usage);
return buffer;
}
@@ -121,9 +121,9 @@ public class DSAUnsupported implements DSAAccess {
@Override
public int bufferStorage(int target, FloatBuffer data, int usage) {
final int buffer = GLStateManager.glGenBuffers();
final int buffer = RENDER_BACKEND.genBuffers();
GLStateManager.glBindBuffer(target, buffer);
GLStateManager.glBufferData(target, data, usage);
RENDER_BACKEND.bufferData(target, data, usage);
GLStateManager.glBindBuffer(target, 0);
return buffer;
@@ -6,10 +6,8 @@ import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.hooks.DeferredBlendHandler;
import com.gtnewhorizons.angelica.glsm.hooks.GLSMHooks;
import com.gtnewhorizons.angelica.glsm.hooks.GLSMInitConfig;
import com.gtnewhorizons.angelica.glsm.QuadConverter;
import com.gtnewhorizons.angelica.glsm.stacks.Vec3fStack;
import com.gtnewhorizons.angelica.glsm.stacks.Vec4fStack;
import com.gtnewhorizons.angelica.glsm.streaming.TessellatorStreamingDrawer;
import lombok.Getter;
import org.joml.Vector3f;
import org.joml.Vector4f;
@@ -68,33 +66,11 @@ public final class ShaderManager {
}
public void enable() {
warmUp();
enabled = true;
GLStateManager.LOGGER.info("FFP shader emulation enabled");
}
// Force loading of classes before the SplashThread kicks off
// Ensure it's GL free
private static void warmUp() {
try {
final long[] fkScratch = new long[FragmentKey.MAX_UNITS];
final int fkLen = FragmentKey.packFromState(fkScratch);
final int fragMask = FragmentKey.unitMaskFromPacked(fkScratch, fkLen);
final long vkPacked = VertexKey.packFromState(true, true, true, true, fragMask);
final VertexKey vk = VertexKey.fromPacked(vkPacked);
VertexShaderGenerator.generate(vk);
FragmentShaderGenerator.generate(FragmentKey.fromPacked(fkScratch, fkLen));
GeometryShaderGenerator.generate(vk);
final Class<?>[] touched = { Program.class, ShaderCache.class, TessellatorStreamingDrawer.class, QuadConverter.class };
for (Class<?> c : touched) {
c.getName();
}
} catch (Throwable t) {
GLStateManager.LOGGER.warn("FFP warmup failed; draw-path classes will resolve lazily", t);
}
}
public void disable() {
enabled = false;
}
@@ -10,8 +10,6 @@ import org.lwjgl.opengl.GL11;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
/**
* Records immediate mode GL calls (glBegin/glEnd/glVertex) via {@link DirectTessellator}.
@@ -20,37 +18,28 @@ import java.util.concurrent.ConcurrentLinkedQueue;
public final class ImmediateModeRecorder {
private static final CallbackTessellator tessellator = new CallbackTessellator(TessellatorManager.DEFAULT_BUFFER_SIZE);
private record ThreadTessellator(Thread thread, DirectTessellator tessellator) {}
private static final Queue<ThreadTessellator> threadTessellators = new ConcurrentLinkedQueue<>();
private static final ThreadLocal<DirectTessellator> threadTessellator = ThreadLocal.withInitial(() -> {
final DirectTessellator t = new DirectTessellator(TessellatorManager.DEFAULT_BUFFER_SIZE);
threadTessellators.add(new ThreadTessellator(Thread.currentThread(), t));
cleanupOrphanTessellators();
return t;
});
/** Separate tessellator for the splash thread. Nulled after splash completes. */
private static DirectTessellator splashTessellator;
private ImmediateModeRecorder() {
}
public static int getThreadTessellatorCount() {
return threadTessellators.size();
public static void initSplashTessellator() {
splashTessellator = new DirectTessellator(TessellatorManager.DEFAULT_BUFFER_SIZE);
}
public static synchronized void cleanupOrphanTessellators() {
threadTessellators.removeIf(tt -> {
if (tt.thread().isAlive()) return false;
tt.tessellator().delete();
return true;
});
public static void destroySplashTessellator() {
splashTessellator.delete();
splashTessellator = null;
}
private static DirectTessellator tessellator() {
if (Thread.currentThread() == GLStateManager.getMainThread()) {
return tessellator;
final DirectTessellator splash = splashTessellator;
if (splash != null && Thread.currentThread() != GLStateManager.getMainThread()) {
return splash;
}
return threadTessellator.get();
return tessellator;
}
public static DirectTessellator getInternalTessellator() {
@@ -48,11 +48,6 @@ public class GLSMRedirector {
private static final String ARBInstancedArrays = "org/lwjgl/opengl/ARBInstancedArrays";
private static final String ARBDrawInstanced = "org/lwjgl/opengl/ARBDrawInstanced";
private static final String EXTDrawInstanced = "org/lwjgl/opengl/EXTDrawInstanced";
private static final String ARBBufferObject = "org/lwjgl/opengl/ARBBufferObject";
private static final String ARBVertexBufferObject = "org/lwjgl/opengl/ARBVertexBufferObject";
private static final String ARBBufferStorage = "org/lwjgl/opengl/ARBBufferStorage";
private static final String ARBCopyBuffer = "org/lwjgl/opengl/ARBCopyBuffer";
private static final String ARBMapBufferRange = "org/lwjgl/opengl/ARBMapBufferRange";
// Redirect VAO related calls from NHLib
private static final String UniversalVAO = "com/gtnewhorizon/gtnhlib/client/opengl/UniversalVAO";
@@ -290,16 +285,11 @@ public class GLSMRedirector {
.add("glBindBuffer")
.add("glDeleteBuffers")
.add("glBufferData")
.add("nglBufferData")
.add("glBufferSubData")
.add("nglBufferSubData")
.add("glMapBuffer")
.add("glUnmapBuffer")
.add("glGetBufferSubData")
.add("nglGetBufferSubData")
.add("glGetBufferParameteri")
.add("glGetBufferParameter")
.add("glGetBufferParameteriv")
.add("glIsBuffer");
final var gl20 = RedirectMap.newMap()
.add("glBlendEquationSeparate")
@@ -366,13 +356,10 @@ public class GLSMRedirector {
.add("glVertexAttribIPointer")
.add("glGenerateMipmap")
.add("glGetFramebufferAttachmentParameteri")
.add("glBlitFramebuffer")
.add("glMapBufferRange")
.add("glFlushMappedBufferRange");
.add("glBlitFramebuffer");
final var gl31 = RedirectMap.newMap()
.add("glDrawElementsInstanced")
.add("glDrawArraysInstanced")
.add("glCopyBufferSubData");
.add("glDrawArraysInstanced");
final var gl32 = RedirectMap.newMap()
.add("glFramebufferTexture");
final var gl33 = RedirectMap.newMap()
@@ -396,10 +383,6 @@ public class GLSMRedirector {
final var gl44 = RedirectMap.newMap()
.add("glBufferStorage")
.add("glClearTexImage");
final var gl45 = RedirectMap.newMap()
.add("glCreateBuffers")
.add("glNamedBufferData")
.add("glNamedBufferSubData");
// Merge all GL version maps into the flat lookup
glMethodRedirects.putAll(gl11);
@@ -415,7 +398,6 @@ public class GLSMRedirector {
glMethodRedirects.putAll(gl42);
glMethodRedirects.putAll(gl43);
glMethodRedirects.putAll(gl44);
glMethodRedirects.putAll(gl45);
// MINECRAFT
methodRedirects.put(OpenGlHelper, RedirectMap.newMap()
@@ -488,31 +470,6 @@ public class GLSMRedirector {
.add("glDrawArraysInstancedEXT", "glDrawArraysInstanced")
.add("glDrawElementsInstancedEXT", "glDrawElementsInstanced")
);
final var arbBufferObject = RedirectMap.newMap()
.add("glBindBufferARB", "glBindBuffer")
.add("glGenBuffersARB", "glGenBuffers")
.add("glDeleteBuffersARB", "glDeleteBuffers")
.add("glIsBufferARB", "glIsBuffer")
.add("glBufferDataARB", "glBufferData")
.add("glBufferSubDataARB", "glBufferSubData")
.add("glGetBufferSubDataARB", "glGetBufferSubData")
.add("glMapBufferARB", "glMapBuffer")
.add("glUnmapBufferARB", "glUnmapBuffer")
.add("glGetBufferParameterARB", "glGetBufferParameter")
.add("glGetBufferParameteriARB", "glGetBufferParameteri")
.add("glGetBufferParameterivARB", "glGetBufferParameteriv");
methodRedirects.put(ARBBufferObject, arbBufferObject);
methodRedirects.put(ARBVertexBufferObject, arbBufferObject);
methodRedirects.put(ARBBufferStorage, RedirectMap.newMap()
.add("glBufferStorage")
);
methodRedirects.put(ARBCopyBuffer, RedirectMap.newMap()
.add("glCopyBufferSubData")
);
methodRedirects.put(ARBMapBufferRange, RedirectMap.newMap()
.add("glMapBufferRange")
.add("glFlushMappedBufferRange")
);
// APPLE
methodRedirects.put(APPLEVertexArrayObject, RedirectMap.newMap()
@@ -88,18 +88,13 @@ public class TessellatorStreamingDrawer {
final int vertexSize = format.getVertexSize();
final int requiredBytes = vertexCount * vertexSize;
final boolean locked = GLStateManager.acquireDrawLock();
try {
ensureRepackCapacity(requiredBytes);
ensureRepackCapacity(requiredBytes);
final long writePtr = format.writeToBuffer0(repackAddress, tess.rawBuffer, tess.rawBufferIndex);
repackBuffer.position(0);
repackBuffer.limit((int)(writePtr - repackAddress));
final long writePtr = format.writeToBuffer0(repackAddress, tess.rawBuffer, tess.rawBufferIndex);
repackBuffer.position(0);
repackBuffer.limit((int)(writePtr - repackAddress));
uploadAndDraw(repackBuffer, flags, format, vertexSize, tess.drawMode, vertexCount);
} finally {
if (locked) GLStateManager.releaseDrawLock();
}
uploadAndDraw(repackBuffer, flags, format, vertexSize, tess.drawMode, vertexCount);
// Shrink rawBuffer if oversized
if (tess.rawBufferSize > 0x20000 && tess.rawBufferIndex < (tess.rawBufferSize << 3)) {
@@ -192,29 +187,24 @@ public class TessellatorStreamingDrawer {
* Tries the persistent ring buffer first, falls back to orphan buffer on overflow.
*/
private static void uploadAndDraw(ByteBuffer packed, int flags, VertexFormat format, int vertexSize, int drawMode, int vertexCount) {
final boolean locked = GLStateManager.acquireDrawLock();
try {
ensureVAO(flags, format);
ensureVAO(flags, format);
int firstVertex = -1;
int firstVertex = -1;
if (persistentBuffer != null) {
firstVertex = persistentBuffer.upload(packed, vertexSize);
}
if (firstVertex >= 0) {
GLStateManager.glBindVertexArray(persistentVAOs[flags]);
} else {
GLStateManager.glBindVertexArray(orphanVAOs[flags]);
orphanBuffers[flags].upload(packed);
firstVertex = 0;
}
drawWithQuadConversion(drawMode, firstVertex, vertexCount);
GLStateManager.glBindVertexArray(0);
} finally {
if (locked) GLStateManager.releaseDrawLock();
if (persistentBuffer != null) {
firstVertex = persistentBuffer.upload(packed, vertexSize);
}
if (firstVertex >= 0) {
GLStateManager.glBindVertexArray(persistentVAOs[flags]);
} else {
GLStateManager.glBindVertexArray(orphanVAOs[flags]);
orphanBuffers[flags].upload(packed);
firstVertex = 0;
}
drawWithQuadConversion(drawMode, firstVertex, vertexCount);
GLStateManager.glBindVertexArray(0);
}
private static void drawWithQuadConversion(int drawMode, int firstVertex, int vertexCount) {
@@ -1,34 +0,0 @@
package com.gtnewhorizons.angelica.glsm;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
class GLVersionParseTest {
@Test
void parseMajorMinor() {
assertEquals(43, RenderSystem.parseMajorMinor("4.3.0 - Build 20.19.15.4835"));
assertEquals(46, RenderSystem.parseMajorMinor("4.6.0 NVIDIA 551.61"));
assertEquals(41, RenderSystem.parseMajorMinor("4.1 Metal - 88"));
assertEquals(33, RenderSystem.parseMajorMinor("3.3"));
assertEquals(46, RenderSystem.parseMajorMinor("4.6 (Core Profile) Mesa 24.0.3"));
assertEquals(-1, RenderSystem.parseMajorMinor(null));
assertEquals(-1, RenderSystem.parseMajorMinor(""));
assertEquals(-1, RenderSystem.parseMajorMinor("garbage"));
assertEquals(-1, RenderSystem.parseMajorMinor("OpenGL ES 3.2"));
}
@Test
void isContextValid() {
assertTrue(RenderSystem.isContextValid(4, 4, 46, true));
assertTrue(RenderSystem.isContextValid(4, 4, 44, true));
assertFalse(RenderSystem.isContextValid(4, 4, 43, true));
assertFalse(RenderSystem.isContextValid(4, 4, 44, false));
assertTrue(RenderSystem.isContextValid(4, 4, -1, true));
assertFalse(RenderSystem.isContextValid(4, 4, -1, false));
assertTrue(RenderSystem.isContextValid(3, 3, 33, true));
}
}
@@ -1,125 +0,0 @@
package com.gtnewhorizons.angelica.glsm;
import com.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator;
import com.gtnewhorizons.angelica.glsm.recording.CompiledDisplayList;
import com.gtnewhorizons.angelica.glsm.recording.GLCommand;
import com.gtnewhorizons.angelica.glsm.recording.ImmediateModeRecorder;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.lwjgl.opengl.GL11;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
@ExtendWith(GLSMCoreExtension.class)
class ImmediateModeThreadIsolationTest {
@Test
void backgroundThreadsGetDistinctTessellators() throws Exception {
final DirectTessellator mainTess = ImmediateModeRecorder.getInternalTessellator();
final AtomicReference<DirectTessellator> bg1 = new AtomicReference<>();
final AtomicReference<DirectTessellator> bg2 = new AtomicReference<>();
final Thread t1 = new Thread(() -> bg1.set(ImmediateModeRecorder.getInternalTessellator()), "iso-test-1");
final Thread t2 = new Thread(() -> bg2.set(ImmediateModeRecorder.getInternalTessellator()), "iso-test-2");
t1.start(); t2.start();
t1.join(); t2.join();
assertNotNull(bg1.get());
assertNotNull(bg2.get());
assertNotSame(mainTess, bg1.get(), "background thread must not share the main-thread tessellator");
assertNotSame(mainTess, bg2.get(), "background thread must not share the main-thread tessellator");
assertNotSame(bg1.get(), bg2.get(), "background threads must not share a tessellator");
}
@Test
void concurrentImmediateModeDoesNotCorruptRecording() throws Exception {
final List<Throwable> failures = new CopyOnWriteArrayList<>();
final CountDownLatch start = new CountDownLatch(1);
final AtomicBoolean stop = new AtomicBoolean(false);
final Runnable spam = () -> {
try {
start.await();
while (!stop.get()) {
GLStateManager.glBegin(GL11.GL_QUADS);
GLStateManager.glVertex3f(0, 0, 0);
GLStateManager.glVertex3f(1, 0, 0);
GLStateManager.glVertex3f(1, 1, 0);
GLStateManager.glVertex3f(0, 1, 0);
GLStateManager.glEnd();
}
} catch (Throwable t) {
failures.add(t);
}
};
final Thread t1 = new Thread(spam, "iso-spam-1");
final Thread t2 = new Thread(spam, "iso-spam-2");
t1.start(); t2.start();
start.countDown();
final List<Integer> lists = new ArrayList<>();
try {
for (int i = 0; i < 50; i++) {
final int list = GLStateManager.glGenLists(1);
GLStateManager.glNewList(list, GL11.GL_COMPILE);
GLStateManager.glBegin(GL11.GL_QUADS);
GLStateManager.glVertex3f(0, 0, 0);
GLStateManager.glVertex3f(1, 0, 0);
GLStateManager.glVertex3f(1, 1, 0);
GLStateManager.glVertex3f(0, 1, 0);
GLStateManager.glEnd();
GLStateManager.glEndList();
lists.add(list);
}
} finally {
stop.set(true);
t1.join(5000); t2.join(5000);
}
assertTrue(failures.isEmpty(), "background immediate mode threw: " + failures);
for (int list : lists) {
final CompiledDisplayList compiled = DisplayListManager.getDisplayList(list);
assertNotNull(compiled, "list " + list + " should be compiled");
assertEquals(1, compiled.getCommandCounts().getOrDefault(GLCommand.DRAW_RANGE, 0), "list " + list + " should contain exactly the main thread's draw");
GLStateManager.glDeleteLists(list, 1);
}
}
@Test
void sweepFreesDeadThreadTessellators() throws Exception {
final Thread t = new Thread(() -> ImmediateModeRecorder.getInternalTessellator(), "iso-sweep");
t.start();
t.join();
final int before = ImmediateModeRecorder.getThreadTessellatorCount();
assertTrue(before >= 1);
ImmediateModeRecorder.cleanupOrphanTessellators();
assertTrue(ImmediateModeRecorder.getThreadTessellatorCount() < before, "dead thread's tessellator should be swept");
}
@Test
void drawLockGatesOnSplashComplete() throws Exception {
assertFalse(GLStateManager.acquireDrawLock(), "post-splash acquire must be a no-op");
final Field f = GLStateManager.class.getDeclaredField("splashComplete");
f.setAccessible(true);
f.set(null, false);
try {
assertTrue(GLStateManager.acquireDrawLock(), "during splash the lock must engage");
GLStateManager.releaseDrawLock();
} finally {
f.set(null, true);
}
}
}
@@ -659,11 +659,6 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
GL11C.glGetTexImage(target, level, format, type, pixels);
}
@Override
public void getTexImage(int target, int level, int format, int type, long pixelBufferOffset) {
GL11C.glGetTexImage(target, level, format, type, pixelBufferOffset);
}
@Override
public int getFramebufferAttachmentParameteri(int target, int attachment, int pname) {
return GL30C.glGetFramebufferAttachmentParameteri(target, attachment, pname);
@@ -1101,11 +1096,6 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
return GL30C.glMapBufferRange(target, offset, length, access);
}
@Override
public void flushMappedBufferRange(int target, long offset, long length) {
GL30C.glFlushMappedBufferRange(target, offset, length);
}
@Override
public int genVertexArrays() {
return GL30C.glGenVertexArrays();
@@ -1291,11 +1281,6 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
return GL45C.glCreateBuffers();
}
@Override
public void namedBufferData(int buffer, long size, int usage) {
GL45C.glNamedBufferData(buffer, size, usage);
}
@Override
public void namedBufferData(int buffer, ByteBuffer data, int usage) {
GL45C.glNamedBufferData(buffer, data, usage);
@@ -1,9 +0,0 @@
package com.gtnewhorizons.angelica.api;
public interface ExtCeleritasRenderBlocks {
boolean angelica$shouldApplyCeleritasAO();
void angelica$setApplyingCeleritasAO(boolean val);
}
@@ -10,6 +10,7 @@ import static com.gtnewhorizons.angelica.client.font.ColorCodeUtils.SECTION_X_LE
import static com.gtnewhorizons.angelica.client.font.ColorCodeUtils.SECTION_X_PAYLOAD;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.compat.etfuturum.EtFuturumFontCompat;
import com.gtnewhorizons.angelica.config.FontConfig;
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
@@ -327,15 +328,6 @@ public class BatchingFontRenderer {
private int fontAAStrengthLast = -1;
private void flushBatch() {
final boolean locked = GLStateManager.acquireDrawLock();
try {
flushBatchInner();
} finally {
if (locked) GLStateManager.releaseDrawLock();
}
}
private void flushBatchInner() {
if (vertexDataPos == 0) {
clearBatch();
return;
@@ -711,30 +703,79 @@ public class BatchingFontRenderer {
if (chr == ColorCodeUtils.ESCAPED_AMPERSAND) { chr = '&'; }
if (FontConfig.enableCustomFont && FontConfig.enableGlyphReplacements) {
final char replacement = GlyphReplacements.getReplacementGlyph(chr);
if (replacement != 0) {
if (FontProviderCustom.getPrimary().isGlyphAvailable(replacement)
|| FontProviderCustom.getFallback().isGlyphAvailable(replacement)
) {
chr = replacement;
final boolean surrogatePair = EtFuturumFontCompat.MODERN_FONT_ENABLED && !unicodeFlag
&& Character.isHighSurrogate(chr) && (charIdx + 1) < stringEnd
&& Character.isLowSurrogate(string.charAt(charIdx + 1));
final int codepoint = surrogatePair ? Character.toCodePoint(chr, string.charAt(charIdx + 1)) : chr;
final SupplementaryGlyphSource supGlyph = surrogatePair ? supplementarySource(codepoint) : null;
final boolean supplementary = supGlyph != null;
if (!supplementary) {
if (EtFuturumFontCompat.MODERN_FONT_ENABLED && Character.isSurrogate(chr)) {
// Substitute U+FFFD for a bad malformed glyph
final boolean pairedHigh = Character.isHighSurrogate(chr) && charIdx + 1 < stringEnd
&& Character.isLowSurrogate(string.charAt(charIdx + 1));
final boolean pairedLow = Character.isLowSurrogate(chr) && charIdx > stringOffset
&& Character.isHighSurrogate(string.charAt(charIdx - 1));
if (!pairedHigh && !pairedLow) { warnIsolatedSurrogate(chr, string); }
chr = REPLACEMENT_GLYPH;
}
if (FontConfig.enableCustomFont && FontConfig.enableGlyphReplacements) {
final char replacement = GlyphReplacements.getReplacementGlyph(chr);
if (replacement != 0) {
if (FontProviderCustom.getPrimary().isGlyphAvailable(replacement)
|| FontProviderCustom.getFallback().isGlyphAvailable(replacement)
) {
chr = replacement;
}
}
}
if (curRandom) {
chr = FontProviderMC.get(this.isSGA).getRandomReplacement(chr);
}
}
if (curRandom) {
chr = FontProviderMC.get(this.isSGA).getRandomReplacement(chr);
float uStart, vStart, xAdvance, glyphW, uSz, vSz, shadowOffset, provYScale, provBaselineShift;
ResourceLocation texture;
boolean unifontGlyph;
if (supplementary) {
unifontGlyph = supGlyph.isUnifont();
uStart = supGlyph.getUStartCp(codepoint);
vStart = supGlyph.getVStartCp(codepoint);
xAdvance = supGlyph.getXAdvanceCp(codepoint) * glyphScaleX;
if (unifontGlyph) { xAdvance = (int) xAdvance; }
glyphW = supGlyph.getGlyphWCp(codepoint) * glyphScaleX;
uSz = supGlyph.getUSizeCp(codepoint);
vSz = supGlyph.getVSizeCp(codepoint);
shadowOffset = supGlyph.getShadowOffset();
provYScale = supGlyph.getYScaleMultiplier();
provBaselineShift = supGlyph.getBaselineShift();
texture = supGlyph.getTextureCp(codepoint);
} else {
final FontProvider fontProvider = FontStrategist.getFontProvider(this, chr, FontConfig.enableCustomFont, unicodeFlag);
unifontGlyph = fontProvider == FontProviderUnicode.get();
uStart = fontProvider.getUStart(chr);
vStart = fontProvider.getVStart(chr);
xAdvance = fontProvider.getXAdvance(chr) * glyphScaleX;
if (unifontGlyph) { xAdvance = (int) xAdvance; }
glyphW = fontProvider.getGlyphW(chr) * glyphScaleX;
uSz = fontProvider.getUSize(chr);
vSz = fontProvider.getVSize(chr);
shadowOffset = fontProvider.getShadowOffset();
provYScale = fontProvider.getYScaleMultiplier();
provBaselineShift = fontProvider.getBaselineShift();
texture = fontProvider.getTexture(chr);
}
FontProvider fontProvider = FontStrategist.getFontProvider(this, chr, FontConfig.enableCustomFont, unicodeFlag);
heightNorth = anchorY + (underlying.FONT_HEIGHT - 1.0f) * (0.5f - glyphScaleY * fontProvider.getYScaleMultiplier() / 2);
float heightSouth = (underlying.FONT_HEIGHT - 1.0f) * glyphScaleY * fontProvider.getYScaleMultiplier();
heightNorth = anchorY + (underlying.FONT_HEIGHT - 1.0f) * (0.5f - glyphScaleY * provYScale / 2)
+ provBaselineShift * glyphScaleY;
float heightSouth = (underlying.FONT_HEIGHT - 1.0f) * glyphScaleY * provYScale;
visibleCharIndex++;
// Check ASCII space, NBSP, NNBSP
if (chr == ' ' || chr == '\u00A0' || chr == '\u202F') {
if (!supplementary && (chr == ' ' || chr == '\u00A0' || chr == '\u202F')) {
curX += 4 * this.getWhitespaceScale() + (curBold ? 1 : 0);
continue;
}
@@ -756,17 +797,9 @@ public class BatchingFontRenderer {
gradientCharIndex++;
}
final float uStart = fontProvider.getUStart(chr);
final float vStart = fontProvider.getVStart(chr);
final float xAdvance = fontProvider.getXAdvance(chr) * glyphScaleX;
final float glyphW = fontProvider.getGlyphW(chr) * glyphScaleX;
final float uSz = fontProvider.getUSize(chr);
final float vSz = fontProvider.getVSize(chr);
final float itOff = curItalic ? 1.0F : 0.0F; // italic offset
final float shadowOffset = fontProvider.getShadowOffset();
final int shadowCopies = FontConfig.shadowCopies;
final int boldCopies = FontConfig.boldCopies;
final ResourceLocation texture = fontProvider.getTexture(chr);
final int idxId = idxWriterIndex;
// Wave: Y offset via sine wave
@@ -811,7 +844,7 @@ public class BatchingFontRenderer {
if (drawShadow) { charCount += shadowCopies * (curBold ? 2 : 1); }
if (curBold) { charCount += boldCopies; }
final int vtxCount = 4 * charCount;
pushDrawCmd(idxId, vtxCount / 2 * 3, texture, chr > 255);
pushDrawCmd(idxId, vtxCount / 2 * 3, texture, unifontGlyph);
curX += (xAdvance + (curBold ? 1.0f : 0.0f)) + getGlyphSpacing();
if (bookMode) { curX = (int) curX; }
@@ -830,6 +863,7 @@ public class BatchingFontRenderer {
pushDrawCmd(stIdx, 6, null, false);
strikethroughStartX = strikethroughEndX;
}
if (supplementary) { charIdx++; }
}
if (curUnderline && underlineStartX != underlineEndX) {
@@ -854,9 +888,64 @@ public class BatchingFontRenderer {
return curX + (enableShadow ? 1.0f : 0.0f);
}
public int getStringWidthBatched(String text) {
if (text == null) return 0;
text = ColorCodeUtils.convertAmpersandToSectionX(text);
final boolean unicodeFlag = underlying.getUnicodeFlag();
final float glyphScaleX = getGlyphScaleX();
final int len = text.length();
boolean bold = false;
int width = 0;
for (int i = 0; i < len; i++) {
final char c0 = text.charAt(i);
if (EtFuturumFontCompat.MODERN_FONT_ENABLED && !unicodeFlag && Character.isHighSurrogate(c0)
&& i + 1 < len && Character.isLowSurrogate(text.charAt(i + 1))) {
final int cp = Character.toCodePoint(c0, text.charAt(i + 1));
final SupplementaryGlyphSource src = supplementarySource(cp);
if (src != null) {
final int w = (int) (src.getXAdvanceCp(cp) * glyphScaleX);
width += w;
if (bold && w > 0) width += 1;
i++;
continue;
}
}
int k = (int) getCharWidthFine(c0);
if (k < 0 && i < len - 1) {
// §-format code
i++;
final char code = text.charAt(i);
if (code == 'l' || code == 'L') {
bold = true;
} else if (code == 'r' || code == 'R') {
bold = false;
}
k = 0;
}
width += k;
if (bold && k > 0) width += 1;
}
return width;
}
private static final char REPLACEMENT_GLYPH = '\uFFFD';
private static boolean warnedIsolatedSurrogate;
private static void warnIsolatedSurrogate(char chr, CharSequence string) {
if (warnedIsolatedSurrogate) { return; }
warnedIsolatedSurrogate = true;
FontStrategist.LOGGER.warn(
"Split emoji/extended char U+{} in \"{}\". A GUI split a supplementary character into separate Java chars during cursor/text ops. Rendering U+FFFD instead.",
Integer.toHexString(chr).toUpperCase(), string, new Throwable("isolated-surrogate draw site"));
}
public float getCharWidthFine(char chr) {
if (chr == ColorCodeUtils.ESCAPED_AMPERSAND) { chr = '&'; }
if (chr == FORMATTING_CHAR) { return -1; }
if (EtFuturumFontCompat.MODERN_FONT_ENABLED && Character.isSurrogate(chr)) { chr = REPLACEMENT_GLYPH; }
if (chr == ' ' || chr == '\u00A0' || chr == '\u202F') {
return 4 * this.getWhitespaceScale();
@@ -867,6 +956,20 @@ public class BatchingFontRenderer {
return fp.getXAdvance(chr) * this.getGlyphScaleX();
}
public int supplementaryAdvance(int codepoint) {
if (!EtFuturumFontCompat.MODERN_FONT_ENABLED) return -1;
final SupplementaryGlyphSource src = supplementarySource(codepoint);
return src != null ? (int) (src.getXAdvanceCp(codepoint) * getGlyphScaleX()) : -1;
}
private SupplementaryGlyphSource supplementarySource(int codepoint) {
final FontProviderBitmap bitmap = (!bookMode && !isSplash) ? FontStrategist.findSupplementaryBitmap(codepoint) : null;
if (bitmap != null) return bitmap;
final FontProviderUnicode unicode = FontProviderUnicode.get();
return unicode.hasCodepoint(codepoint) ? unicode : null;
}
public void overrideBlendFunc(int srcRgb, int dstRgb) {
blendSrcRGB = srcRgb;
blendDstRGB = dstRgb;
@@ -0,0 +1,8 @@
package com.gtnewhorizons.angelica.client.font;
import net.minecraft.util.ResourceLocation;
public record BitmapGlyph(ResourceLocation texture, float uStart, float vStart, float uSize, float vSize, float glyphW,
float advance) {
}
@@ -18,4 +18,6 @@ public interface FontProvider {
float getShadowOffset();
ResourceLocation getTexture(char chr);
float getYScaleMultiplier();
default float getBaselineShift() { return 0.0f; }
}
@@ -0,0 +1,211 @@
package com.gtnewhorizons.angelica.client.font;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.gtnewhorizons.angelica.config.FontConfig;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import net.minecraft.client.Minecraft;
import net.minecraft.client.resources.IResourceManager;
import net.minecraft.util.ResourceLocation;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
/**
* A backported modern hand-drawn bitmap font provider.
* Et Futurum: Requium provides the resources.
*/
public final class FontProviderBitmap implements SupplementaryGlyphSource {
private static final Logger LOGGER = LogManager.getLogger("Angelica");
private static final ResourceLocation HANDDRAWN_DEFINITION = new ResourceLocation("etfuturum", "font/handdrawn.json");
private static final float ASCII_CELL = 8.0f;
private static final float ASCII_ASCENT = 7.0f;
private final Int2ObjectOpenHashMap<BitmapGlyph> glyphs = new Int2ObjectOpenHashMap<>();
private final float yScale;
private final float baselineShift;
private FontProviderBitmap(int renderHeight, int ascent) {
this.yScale = renderHeight / ASCII_CELL;
this.baselineShift = (ASCII_ASCENT - 4.0f) + 4.0f * this.yScale - ascent;
}
public static List<FontProviderBitmap> loadProviders() {
final List<FontProviderBitmap> providers = new ArrayList<>();
final IResourceManager rm = Minecraft.getMinecraft().getResourceManager();
try (InputStreamReader reader = new InputStreamReader(
rm.getResource(HANDDRAWN_DEFINITION).getInputStream(), StandardCharsets.UTF_8)) {
final JsonObject root = new JsonParser().parse(reader).getAsJsonObject();
final JsonArray defs = root.getAsJsonArray("providers");
int glyphCount = 0;
for (int i = 0; i < defs.size(); i++) {
final FontProviderBitmap p = fromDefinition(defs.get(i).getAsJsonObject(), rm);
if (p != null && !p.glyphs.isEmpty()) {
providers.add(p);
glyphCount += p.glyphs.size();
}
}
if (!providers.isEmpty()) {
LOGGER.info("Loaded {} modern hand-drawn font glyph(s) across {} provider(s)", glyphCount, providers.size());
}
} catch (Exception e) {
LOGGER.debug("Modern hand-drawn font sheets not loaded ({})", e.toString());
}
return providers;
}
private static FontProviderBitmap fromDefinition(JsonObject def, IResourceManager rm) {
try {
final String file = def.get("file").getAsString();
final int height = def.has("height") ? def.get("height").getAsInt() : (int) ASCII_CELL;
final int ascent = def.get("ascent").getAsInt();
final JsonArray charRows = def.getAsJsonArray("chars");
// "namespace:font/x.png" -> "namespace:textures/font/x.png"
final int colon = file.indexOf(':');
final String namespace = colon >= 0 ? file.substring(0, colon) : "minecraft";
final String path = colon >= 0 ? file.substring(colon + 1) : file;
final ResourceLocation texture = new ResourceLocation(namespace, "textures/" + path);
final BufferedImage image = ImageIO.read(rm.getResource(texture).getInputStream());
final int texW = image.getWidth();
final int texH = image.getHeight();
final int rows = charRows.size();
final String firstRow = charRows.get(0).getAsString();
final int cols = firstRow.codePointCount(0, firstRow.length());
final int cellW = texW / cols;
final int cellH = texH / rows;
final float scale = (float) height / cellH;
final FontProviderBitmap provider = new FontProviderBitmap(height, ascent);
for (int row = 0; row < rows; row++) {
final String line = charRows.get(row).getAsString();
int col = 0;
for (int offset = 0; offset < line.length(); ) {
final int cp = line.codePointAt(offset);
offset += Character.charCount(cp);
if (cp != 0 && !provider.glyphs.containsKey(cp)) {
final int cellX = col * cellW;
final int cellY = row * cellH;
final int ink = inkWidth(image, cellX, cellY, cellW, cellH);
final float advance = (int) (0.5F + ink * scale) + 1.0f;
final float glyphW = cellW * scale + 1.0f;
provider.glyphs.put(cp, new BitmapGlyph(texture,
(float) cellX / texW, (float) cellY / texH, (float) cellW / texW, (float) cellH / texH,
glyphW, advance));
}
col++;
}
}
return provider;
} catch (Exception e) {
LOGGER.debug("Skipping a hand-drawn font provider ({})", e.toString());
return null;
}
}
/** Rightmost inked column + 1 within a cell. */
private static int inkWidth(BufferedImage image, int cellX, int cellY, int cellW, int cellH) {
for (int x = cellW - 1; x >= 0; x--) {
for (int y = 0; y < cellH; y++) {
if ((image.getRGB(cellX + x, cellY + y) >>> 24) != 0) {
return x + 1;
}
}
}
return 0;
}
private int lastCp = -1;
private BitmapGlyph lastGlyph;
private BitmapGlyph glyph(int cp) {
if (cp == this.lastCp && this.lastGlyph != null) {
return this.lastGlyph;
}
final BitmapGlyph g = this.glyphs.get(cp);
this.lastCp = cp;
this.lastGlyph = g;
return g;
}
public boolean hasGlyph(int cp) { return this.glyphs.containsKey(cp); }
@Override
public float getUStartCp(int cp) { return glyph(cp).uStart(); }
@Override
public float getVStartCp(int cp) { return glyph(cp).vStart(); }
@Override
public float getXAdvanceCp(int cp) { return glyph(cp).advance(); }
@Override
public float getGlyphWCp(int cp) { return glyph(cp).glyphW(); }
@Override
public float getUSizeCp(int cp) { return glyph(cp).uSize(); }
@Override
public float getVSizeCp(int cp) { return glyph(cp).vSize(); }
@Override
public ResourceLocation getTextureCp(int cp) { return glyph(cp).texture(); }
@Override
public boolean isUnifont() { return false; }
@Override
public boolean isGlyphAvailable(char chr) { return hasGlyph(chr); }
@Override
public char getRandomReplacement(char chr) {
return chr;
}
@Override
public float getUStart(char chr) { return getUStartCp(chr); }
@Override
public float getVStart(char chr) { return getVStartCp(chr); }
@Override
public float getXAdvance(char chr) { return getXAdvanceCp(chr); }
@Override
public float getGlyphW(char chr) { return getGlyphWCp(chr); }
@Override
public float getUSize(char chr) { return getUSizeCp(chr); }
@Override
public float getVSize(char chr) { return getVSizeCp(chr); }
@Override
public float getShadowOffset() {
return FontConfig.fontShadowOffset;
}
@Override
public ResourceLocation getTexture(char chr) { return getTextureCp(chr); }
@Override
public float getYScaleMultiplier() {
return this.yScale;
}
@Override
public float getBaselineShift() {
return this.baselineShift;
}
}
@@ -2,52 +2,105 @@ package com.gtnewhorizons.angelica.client.font;
import com.gtnewhorizons.angelica.config.FontConfig;
import net.minecraft.client.Minecraft;
import net.minecraft.client.resources.IReloadableResourceManager;
import net.minecraft.client.resources.IResourceManager;
import net.minecraft.client.resources.IResourceManagerReloadListener;
import net.minecraft.util.ResourceLocation;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.io.IOException;
import java.io.InputStream;
public final class FontProviderUnicode implements FontProvider, IResourceManagerReloadListener {
public final class FontProviderUnicode implements SupplementaryGlyphSource {
private static final Logger LOGGER = LogManager.getLogger("Angelica");
private FontProviderUnicode() {
onResourceManagerReload(Minecraft.getMinecraft().getResourceManager());
((IReloadableResourceManager) Minecraft.getMinecraft().getResourceManager()).registerReloadListener(this);
}
@Override
public void onResourceManagerReload(IResourceManager resourceManager) {
try {
InputStream inputstream = resourceManager.getResource(new ResourceLocation("font/glyph_sizes.bin")).getInputStream();
//noinspection ResultOfMethodCallIgnored
inputstream.read(this.glyphWidth);
private void loadBmpWidths() {
try (InputStream in = Minecraft.getMinecraft().getResourceManager()
.getResource(new ResourceLocation("font/glyph_sizes.bin")).getInputStream()) {
readWidths(in, this.glyphWidth);
} catch (IOException e) {
LOGGER.warn("Failed to load font/glyph_sizes.bin; BMP glyph widths default to 0", e);
}
catch (IOException ioexception) {
throw new RuntimeException(ioexception);
}
public static void readWidths(InputStream in, byte[] dest) throws IOException {
int off = 0, n;
while (off < dest.length && (n = in.read(dest, off, dest.length - off)) != -1) {
off += n;
}
}
private static class InstLoader { static final FontProviderUnicode instance = new FontProviderUnicode(); }
public static FontProviderUnicode get() { return FontProviderUnicode.InstLoader.instance; }
private static final ResourceLocation[] unicodePageLocations = new ResourceLocation[256];
private static final int SUPPLEMENTARY_BASE = 0x10000;
private static final ResourceLocation[] unicodePageLocations = new ResourceLocation[0x1100];
private final byte[] glyphWidth = new byte[65536];
private boolean bmpLoaded;
private byte[] hiGlyphWidth;
private boolean hiLoaded;
private ResourceLocation getUnicodePageLocation(int page) {
final ResourceLocation lookup = unicodePageLocations[page];
if (lookup == null) {
final ResourceLocation rl = new ResourceLocation(String.format(
"textures/font/unicode_page_%02x.png",
page));
if (page >= 0 && page < unicodePageLocations.length) {
final ResourceLocation lookup = unicodePageLocations[page];
if (lookup != null) return lookup;
// %02x is a minimum width, so supplementary pages still format correctly
final ResourceLocation rl = new ResourceLocation(String.format("textures/font/unicode_page_%02x.png", page));
unicodePageLocations[page] = rl;
return rl;
} else {
return lookup;
}
return new ResourceLocation(String.format("textures/font/unicode_page_%02x.png", page));
}
private int widthByte(int codepoint) {
if (codepoint < SUPPLEMENTARY_BASE) {
ensureBmpWidths();
return this.glyphWidth[codepoint];
}
ensureHiWidths();
final int idx = codepoint - SUPPLEMENTARY_BASE;
return idx < this.hiGlyphWidth.length ? this.hiGlyphWidth[idx] : 0;
}
private void ensureBmpWidths() {
if (this.bmpLoaded) return;
this.bmpLoaded = true;
loadBmpWidths();
}
private void ensureHiWidths() {
if (this.hiLoaded) return;
this.hiLoaded = true;
this.hiGlyphWidth = new byte[0];
try (InputStream in = Minecraft.getMinecraft().getResourceManager()
.getResource(new ResourceLocation("font/glyph_sizes_hi.bin")).getInputStream()) {
java.io.ByteArrayOutputStream buf = new java.io.ByteArrayOutputStream();
byte[] chunk = new byte[8192];
int n;
while ((n = in.read(chunk)) != -1) buf.write(chunk, 0, n);
this.hiGlyphWidth = buf.toByteArray();
} catch (IOException e) {
LOGGER.debug("font/glyph_sizes_hi.bin not loaded ({}); supplementary glyph widths default to 0", e.toString());
}
}
public void reload() {
this.bmpLoaded = false;
this.hiLoaded = false;
this.hiGlyphWidth = null;
}
public boolean hasCodepoint(int codepoint) {
return widthByte(codepoint) != 0;
}
@Override
public boolean isUnifont() { return true; }
@Override
public boolean isGlyphAvailable(char chr) {
return true;
@@ -58,46 +111,61 @@ public final class FontProviderUnicode implements FontProvider, IResourceManager
return chr;
}
@Override
public float getUStart(char chr) {
final float startColumnF = (float)((this.glyphWidth[chr] >>> 4) & 15);
return ((float) (chr % 16 * 16) + startColumnF + 0.21f) / 256.0f;
public float getUStartCp(int cp) {
final float startColumnF = (float) ((widthByte(cp) >>> 4) & 15);
return ((float) ((cp & 15) * 16) + startColumnF + 0.21f) / 256.0f;
}
@Override
public float getVStart(char chr) {
return ((float) ((chr & 255) / 16 * 16) + 0.21f) / 256.0f;
public float getVStartCp(int cp) {
return ((float) (((cp & 255) >> 4) * 16) + 0.21f) / 256.0f;
}
@Override
public float getXAdvance(char chr) {
final int startColumn = (this.glyphWidth[chr] >>> 4) & 15;
final int endColumn = this.glyphWidth[chr] & 15;
final float startColumnF = (float) startColumn;
final float endColumnF = (float) (endColumn + 1);
return (endColumnF - startColumnF) / 2.0F + 1.0F;
public float getXAdvanceCp(int cp) {
final int w = widthByte(cp);
final int startColumn = (w >>> 4) & 15;
final int endColumn = w & 15;
return ((endColumn + 1) - startColumn) / 2.0F + 1.0F;
}
@Override
public float getGlyphW(char chr) {
final int startColumn = (this.glyphWidth[chr] >>> 4) & 15;
final int endColumn = this.glyphWidth[chr] & 15;
final float startColumnF = (float) startColumn;
final float endColumnF = (float) (endColumn + 1);
final float chrWidth = endColumnF - startColumnF - 0.02F;
public float getGlyphWCp(int cp) {
final int w = widthByte(cp);
final int startColumn = (w >>> 4) & 15;
final int endColumn = w & 15;
final float chrWidth = (endColumn + 1) - startColumn - 0.02F;
return chrWidth / 2.0f + 1.0f;
}
@Override
public float getUSize(char chr) {
final int startColumn = (this.glyphWidth[chr] >>> 4) & 15;
final int endColumn = this.glyphWidth[chr] & 15;
final float startColumnF = (float) startColumn;
final float endColumnF = (float) (endColumn + 1);
final float chrWidth = endColumnF - startColumnF - 0.02F;
public float getUSizeCp(int cp) {
final int w = widthByte(cp);
final int startColumn = (w >>> 4) & 15;
final int endColumn = w & 15;
final float chrWidth = (endColumn + 1) - startColumn - 0.02F;
return (chrWidth - 0.42f) / 256.0f;
}
public float getVSizeCp(int cp) {
return getVSize((char) 0);
}
public ResourceLocation getTextureCp(int cp) {
return getUnicodePageLocation(cp >>> 8);
}
@Override
public float getUStart(char chr) { return getUStartCp(chr); }
@Override
public float getVStart(char chr) { return getVStartCp(chr); }
@Override
public float getXAdvance(char chr) { return getXAdvanceCp(chr); }
@Override
public float getGlyphW(char chr) { return getGlyphWCp(chr); }
@Override
public float getUSize(char chr) { return getUSizeCp(chr); }
@Override
public float getVSize(char chr) {
return (16.0f - 0.42f) / 256.0f;
@@ -110,8 +178,7 @@ public final class FontProviderUnicode implements FontProvider, IResourceManager
@Override
public ResourceLocation getTexture(char chr) {
final int uniPage = chr / 256;
return getUnicodePageLocation(uniPage);
return getTextureCp(chr);
}
@Override
@@ -1,6 +1,7 @@
package com.gtnewhorizons.angelica.client.font;
import com.google.common.collect.HashMultiset;
import com.gtnewhorizons.angelica.compat.etfuturum.EtFuturumFontCompat;
import com.gtnewhorizons.angelica.config.FontConfig;
import com.gtnewhorizons.angelica.mixins.interfaces.ResourceAccessor;
import cpw.mods.fml.client.SplashProgress;
@@ -8,6 +9,7 @@ import lombok.Getter;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.resources.DefaultResourcePack;
import net.minecraft.util.ResourceLocation;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@@ -17,7 +19,10 @@ import java.awt.Font;
import java.awt.FontFormatException;
import java.awt.GraphicsEnvironment;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
@@ -70,13 +75,28 @@ public class FontStrategist {
availableFonts = fontSet.values().stream().sorted(Comparator.comparing(Font::getFontName)).toArray(Font[]::new);
// create and add the resource pack that provides fonts
HashMap<String, File> packMap = new HashMap<>();
final HashMap<String, File> packMap = new HashMap<>();
for (int i = 0; i < FontProviderCustom.ATLAS_COUNT; i++) {
packMap.put(FontProviderCustom.getPrimary().getAtlasResourceName(i), new File(FontProviderCustom.getPrimary().getAtlasFullPath(i)));
packMap.put(FontProviderCustom.getFallback().getAtlasResourceName(i), new File(FontProviderCustom.getFallback().getAtlasFullPath(i)));
}
DefaultResourcePack fontResourcePack = new DefaultResourcePack(packMap);
// Override vanilla resource pack with our textures
DefaultResourcePack fontResourcePack = new DefaultResourcePack(packMap) {
@Override
public InputStream getInputStream(ResourceLocation location) throws IOException {
final File file = packMap.get(location.toString());
if (file != null && file.isFile()) {
return new FileInputStream(file);
}
throw new FileNotFoundException(location.getResourcePath());
}
@Override
public boolean resourceExists(ResourceLocation location) {
return packMap.containsKey(location.toString());
}
};
List defaultResourcePacks = ((ResourceAccessor) Minecraft.getMinecraft()).angelica$getDefaultResourcePacks();
defaultResourcePacks.add(fontResourcePack);
}
@@ -119,6 +139,43 @@ public class FontStrategist {
if (loaded > 0) LOGGER.info("Loaded {} bundled font(s) from the pack", loaded);
}
private static volatile List<FontProviderBitmap> bitmapProviders;
private static List<FontProviderBitmap> bitmapProviders() {
List<FontProviderBitmap> local = bitmapProviders;
if (local == null) {
synchronized (FontStrategist.class) {
local = bitmapProviders;
if (local == null) {
local = FontProviderBitmap.loadProviders();
bitmapProviders = local;
}
}
}
return local;
}
private static FontProviderBitmap findBitmap(int codepoint) {
final List<FontProviderBitmap> providers = bitmapProviders();
for (final FontProviderBitmap provider : providers) {
if (provider.hasGlyph(codepoint)) {
return provider;
}
}
return null;
}
public static FontProviderBitmap findSupplementaryBitmap(int codepoint) {
return EtFuturumFontCompat.MODERN_FONT_ENABLED ? findBitmap(codepoint) : null;
}
public static void reloadFontResources() {
synchronized (FontStrategist.class) {
bitmapProviders = null;
}
FontProviderUnicode.get().reload();
}
/**
Lets you get a FontProvider per char while respecting font priority and fallbacks, the unicode flag, whether
SGA is on, if we're in a splash screen, if a font can even display a character in the first place, etc.
@@ -136,8 +193,16 @@ public class FontStrategist {
if (fp.isGlyphAvailable(chr)) { return fp; }
fp = FontProviderCustom.getFallback();
if (fp.isGlyphAvailable(chr)) { return fp; }
if (!forceUnicode && EtFuturumFontCompat.MODERN_FONT_ENABLED) {
final FontProviderBitmap bitmap = findBitmap(chr);
if (bitmap != null) { return bitmap; }
}
return FontProviderUnicode.get();
} else {
if (!forceUnicode && !me.isSplash && EtFuturumFontCompat.MODERN_FONT_ENABLED) {
final FontProviderBitmap bitmap = findBitmap(chr);
if (bitmap != null) { return bitmap; }
}
if (!forceUnicode && FontProviderMC.get(false).isGlyphAvailable(chr)) {
return FontProviderMC.get(false);
} else {
@@ -0,0 +1,16 @@
package com.gtnewhorizons.angelica.client.font;
import net.minecraft.util.ResourceLocation;
public interface SupplementaryGlyphSource extends FontProvider {
float getUStartCp(int cp);
float getVStartCp(int cp);
float getXAdvanceCp(int cp);
float getGlyphWCp(int cp);
float getUSizeCp(int cp);
float getVSizeCp(int cp);
ResourceLocation getTextureCp(int cp);
boolean isUnifont();
}
@@ -1,30 +0,0 @@
package com.gtnewhorizons.angelica.compat.etfuturum;
import cpw.mods.fml.common.Loader;
import ganymedes01.etfuturum.api.client.EndFlashAPI;
/**
* Use EFR to power End flash uniforms.
*/
public final class EndFlashCompat {
private static final boolean AVAILABLE = Loader.isModLoaded("etfuturum") && EndFlashCompat.class.getResource("/ganymedes01/etfuturum/api/client/EndFlashAPI.class") != null;
private EndFlashCompat() {}
public static boolean isAvailable() {
return AVAILABLE;
}
public static float getIntensity(float partialTicks) {
return AVAILABLE ? EndFlashAPI.getIntensity(partialTicks) : 0.0F;
}
public static float getXAngle() {
return AVAILABLE ? EndFlashAPI.getXAngle() : 0.0F;
}
public static float getYAngle() {
return AVAILABLE ? EndFlashAPI.getYAngle() : 0.0F;
}
}
@@ -0,0 +1,19 @@
package com.gtnewhorizons.angelica.compat.etfuturum;
import ganymedes01.etfuturum.configuration.configs.ConfigMixins;
public final class EtFuturumFontCompat {
public static final boolean MODERN_FONT_ENABLED = detect();
private EtFuturumFontCompat() {
}
private static boolean detect() {
try {
return ConfigMixins.unicodeFontPages;
} catch (LinkageError e) {
return false;
}
}
}
@@ -170,7 +170,6 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
private final CloudSetting cloudSetting;
private final boolean shouldRenderUnderwaterOverlay;
private final boolean shouldRenderVignette;
private final boolean supportsEndFlash;
private final boolean shouldRenderSun;
private final boolean shouldRenderMoon;
private final boolean shouldRenderStars;
@@ -232,7 +231,6 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
this.cloudSetting = programs.getPackDirectives().getCloudSetting();
this.shouldRenderUnderwaterOverlay = programs.getPackDirectives().underwaterOverlay();
this.shouldRenderVignette = programs.getPackDirectives().vignette();
this.supportsEndFlash = programs.getPackDirectives().isSupportsEndFlash();
this.shouldRenderSun = programs.getPackDirectives().shouldRenderSun();
this.shouldRenderMoon = programs.getPackDirectives().shouldRenderMoon();
this.shouldRenderStars = programs.getPackDirectives().shouldRenderStars();
@@ -653,11 +651,6 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
return shouldRenderVignette;
}
@Override
public boolean supportsEndFlash() {
return supportsEndFlash;
}
@Override
public boolean shouldRenderSun() {
return shouldRenderSun;
@@ -152,11 +152,6 @@ public class FixedFunctionWorldRenderingPipeline implements WorldRenderingPipeli
return false;
}
@Override
public boolean supportsEndFlash() {
return false;
}
@Override
public CloudSetting getCloudSetting() {
return CloudSetting.DEFAULT;
@@ -49,7 +49,6 @@ public interface WorldRenderingPipeline {
boolean shouldDisableVanillaEntityShadows();
boolean shouldDisableDirectionalShading();
boolean supportsEndFlash();
CloudSetting getCloudSetting();
boolean shouldRenderUnderwaterOverlay();
boolean shouldRenderVignette();
@@ -48,7 +48,6 @@ public class PackDirectives {
@Getter private boolean oldHandLight;
@Getter private boolean prepareBeforeShadow;
@Getter private boolean supportsColorCorrection;
@Getter private boolean supportsEndFlash;
@Getter private int fallbackTex;
private Object2ObjectMap<String, Object2BooleanMap<String>> explicitFlips = new Object2ObjectOpenHashMap<>();
private Object2ObjectMap<String, TextureScaleOverride> scaleOverrides = new Object2ObjectOpenHashMap<>();
@@ -94,7 +93,6 @@ public class PackDirectives {
oldLighting = properties.getOldLighting().orElse(false);
fallbackTex = properties.getFallbackTex();
supportsColorCorrection = properties.getSupportsColorCorrection().orElse(false);
supportsEndFlash = properties.getSupportsEndFlash().orElse(false);
concurrentCompute = properties.getConcurrentCompute().orElse(false);
oldHandLight = properties.getOldHandLight().orElse(true);
explicitFlips = properties.getExplicitFlips();
@@ -114,7 +112,6 @@ public class PackDirectives {
frustumCulling = directives.frustumCulling;
occlusionCulling = directives.occlusionCulling;
oldLighting = directives.oldLighting;
supportsEndFlash = directives.supportsEndFlash;
concurrentCompute = directives.concurrentCompute;
explicitFlips = directives.explicitFlips;
scaleOverrides = directives.scaleOverrides;
@@ -70,7 +70,6 @@ public class ShaderProperties {
@Getter private OptionalBoolean shadowPlayer = OptionalBoolean.DEFAULT;
@Getter private OptionalBoolean shadowBlockEntities = OptionalBoolean.DEFAULT;
@Getter private OptionalBoolean shadowLightBlockEntities = OptionalBoolean.DEFAULT;
@Getter private OptionalBoolean supportsEndFlash = OptionalBoolean.DEFAULT;
@Getter private OptionalBoolean underwaterOverlay = OptionalBoolean.DEFAULT;
@Getter private OptionalBoolean sun = OptionalBoolean.DEFAULT;
@Getter private OptionalBoolean moon = OptionalBoolean.DEFAULT;
@@ -206,7 +205,6 @@ public class ShaderProperties {
handleBooleanDirective(key, value, "shadowPlayer", bool -> shadowPlayer = bool);
handleBooleanDirective(key, value, "shadowBlockEntities", bool -> shadowBlockEntities = bool);
handleBooleanDirective(key, value, "shadowLightBlockEntities", bool -> shadowLightBlockEntities = bool);
handleBooleanDirective(key, value, "endFlashShadows", bool -> supportsEndFlash = bool);
handleBooleanDirective(key, value, "underwaterOverlay", bool -> underwaterOverlay = bool);
handleBooleanDirective(key, value, "sun", bool -> sun = bool);
handleBooleanDirective(key, value, "moon", bool -> moon = bool);
@@ -1,12 +1,6 @@
package net.coderbot.iris.shadow;
import com.gtnewhorizons.angelica.compat.etfuturum.EndFlashCompat;
import com.gtnewhorizons.angelica.compat.toremove.MatrixStack;
import net.coderbot.iris.Iris;
import net.coderbot.iris.pipeline.WorldRenderingPipeline;
import net.minecraft.client.Minecraft;
import net.minecraft.client.multiplayer.WorldClient;
import net.minecraft.world.WorldProviderEnd;
import org.joml.Matrix4f;
import static com.gtnewhorizons.angelica.compat.mojang.Constants.DEGREES_TO_RADIANS;
@@ -46,41 +40,23 @@ public class ShadowMatrices {
}
public static void createBaselineModelViewMatrix(MatrixStack target, float shadowAngle, float sunPathRotation) {
final float skyAngle;
if (shadowAngle < 0.25f) {
skyAngle = shadowAngle + 0.75f;
} else {
skyAngle = shadowAngle - 0.25f;
}
target.peek().getNormal().identity();
target.peek().getModel().identity();
target.peek().getModel().translate(0.0f, 0.0f, -100.0f);
if (isEndFlashShadow()) {
// Project shadows from the End flash direction instead of the sun/moon.
target.rotateX((0.0f - EndFlashCompat.getXAngle()) * DEGREES_TO_RADIANS);
target.rotateY(EndFlashCompat.getYAngle() * DEGREES_TO_RADIANS);
} else {
final float skyAngle;
if (shadowAngle < 0.25f) {
skyAngle = shadowAngle + 0.75f;
} else {
skyAngle = shadowAngle - 0.25f;
}
target.rotateX(90F * DEGREES_TO_RADIANS);
target.rotateZ(skyAngle * -360.0f * DEGREES_TO_RADIANS);
target.rotateX(sunPathRotation * DEGREES_TO_RADIANS);
}
target.rotateX(90F * DEGREES_TO_RADIANS);
target.rotateZ(skyAngle * -360.0f * DEGREES_TO_RADIANS);
target.rotateX(sunPathRotation * DEGREES_TO_RADIANS);
}
private static boolean isEndFlashShadow() {
final Minecraft mc = Minecraft.getMinecraft();
if (mc == null) {
return false;
}
final WorldClient world = mc.theWorld;
return world != null && world.provider instanceof WorldProviderEnd
&& EndFlashCompat.isAvailable()
&& Iris.getPipelineManager().getPipeline().map(WorldRenderingPipeline::supportsEndFlash).orElse(false);
}
public static void snapModelViewToGrid(MatrixStack target, float shadowIntervalSize, double cameraX, double cameraY, double cameraZ) {
if (Math.abs(shadowIntervalSize) == 0.0F) {
// Avoid a division by zero - semantically, this just means that the snapping does not take place,
@@ -1,14 +1,10 @@
package net.coderbot.iris.uniforms;
import com.gtnewhorizons.angelica.compat.etfuturum.EndFlashCompat;
import com.gtnewhorizons.angelica.compat.mojang.Constants;
import com.gtnewhorizons.angelica.rendering.RenderingState;
import net.coderbot.iris.Iris;
import net.coderbot.iris.gl.uniform.UniformHolder;
import net.coderbot.iris.pipeline.WorldRenderingPipeline;
import net.minecraft.client.Minecraft;
import net.minecraft.client.multiplayer.WorldClient;
import net.minecraft.world.WorldProviderEnd;
import org.joml.Matrix4f;
import org.joml.Vector4f;
@@ -22,12 +18,9 @@ import static net.coderbot.iris.gl.uniform.UniformUpdateFrequency.PER_FRAME;
public final class CelestialUniforms {
private static final Vector4f upPositionCache = new Vector4f();
private static final Matrix4f upMatrixCache = new Matrix4f();
private static final Vector4f ZERO_VECTOR_4f = new Vector4f(0.0F, 0.0F, 0.0F, 0.0F);
private final Vector4f positionCache = new Vector4f();
private final Matrix4f celestialMatrixCache = new Matrix4f();
private final Vector4f endFlashPositionCache = new Vector4f();
private final Matrix4f endFlashMatrixCache = new Matrix4f();
private final float sunPathRotation;
public CelestialUniforms(float sunPathRotation) {
@@ -41,46 +34,9 @@ public final class CelestialUniforms {
.uniformTruncated3f(PER_FRAME, "moonPosition", this::getMoonPosition)
.uniform1f(PER_FRAME, "shadowAngle", CelestialUniforms::getShadowAngle)
.uniformTruncated3f(PER_FRAME, "shadowLightPosition", this::getShadowLightPosition)
.uniformTruncated3f(PER_FRAME, "endFlashPosition", this::getEndFlashPosition)
.uniformTruncated3f(PER_FRAME, "upPosition", CelestialUniforms::getUpPosition);
}
private Vector4f getEndFlashPosition() {
final WorldClient world = Minecraft.getMinecraft().theWorld;
if (world == null || !(world.provider instanceof WorldProviderEnd) || !EndFlashCompat.isAvailable()) {
return ZERO_VECTOR_4f;
}
final float yAngle = EndFlashCompat.getYAngle();
final float xAngle = EndFlashCompat.getXAngle();
endFlashPositionCache.set(0.0F, 100.0F, 0.0F, 0.0F);
endFlashMatrixCache.set(RenderingState.INSTANCE.getModelViewMatrix());
endFlashMatrixCache.rotateY((180.0F - yAngle) * Constants.DEGREES_TO_RADIANS);
endFlashMatrixCache.rotateX((-90.0F - xAngle) * Constants.DEGREES_TO_RADIANS);
endFlashMatrixCache.transform(endFlashPositionCache);
return endFlashPositionCache;
}
private Vector4f getEndFlashPositionInWorldSpace() {
final float yAngle = EndFlashCompat.getYAngle();
final float xAngle = EndFlashCompat.getXAngle();
endFlashPositionCache.set(0.0F, 100.0F, 0.0F, 0.0F);
endFlashMatrixCache.identity();
endFlashMatrixCache.rotateY((180.0F - yAngle) * Constants.DEGREES_TO_RADIANS);
endFlashMatrixCache.rotateX((-90.0F - xAngle) * Constants.DEGREES_TO_RADIANS);
endFlashMatrixCache.transform(endFlashPositionCache);
return endFlashPositionCache;
}
private static boolean isEndFlashShadowActive() {
final WorldClient world = Minecraft.getMinecraft().theWorld;
return world != null && world.provider instanceof WorldProviderEnd
&& EndFlashCompat.isAvailable()
&& Iris.getPipelineManager().getPipeline().map(WorldRenderingPipeline::supportsEndFlash).orElse(false);
}
public static float getSunAngle() {
final float skyAngle = getSkyAngle();
@@ -110,16 +66,10 @@ public final class CelestialUniforms {
}
public Vector4f getShadowLightPosition() {
if (isEndFlashShadowActive()) {
return getEndFlashPosition();
}
return isDay() ? getSunPosition() : getMoonPosition();
}
public Vector4f getShadowLightPositionInWorldSpace() {
if (isEndFlashShadowActive()) {
return getEndFlashPositionInWorldSpace();
}
return isDay() ? getCelestialPositionInWorldSpace(100.0F) : getCelestialPositionInWorldSpace(-100.0F);
}
@@ -58,7 +58,7 @@ public final class CommonUniforms {
SystemTimeUniforms.addSystemTimeUniforms(uniforms);
BiomeUniforms.addBiomeUniforms(uniforms);
new CelestialUniforms(directives.getSunPathRotation()).addCelestialUniforms(uniforms);
IrisExclusiveUniforms.addIrisExclusiveUniforms(uniforms, updateNotifier);
IrisExclusiveUniforms.addIrisExclusiveUniforms(uniforms);
IdMapUniforms.addIdMapUniforms(updateNotifier, uniforms, idMap, directives.isOldHandLight());
MatrixUniforms.addMatrixUniforms(uniforms, directives);
@@ -1,19 +0,0 @@
package net.coderbot.iris.uniforms;
import com.gtnewhorizons.angelica.compat.etfuturum.EndFlashCompat;
import lombok.Getter;
/**
* Holds the current and previous-frame End flash intensity.
*/
@Getter
public class EndFlashStorage {
private float lastEndFlash;
private float currentEndFlash;
public void tick() {
lastEndFlash = currentEndFlash;
currentEndFlash = EndFlashCompat.getIntensity(CapturedRenderingState.INSTANCE.getTickDelta());
}
}
@@ -1,6 +1,5 @@
package net.coderbot.iris.uniforms;
import com.gtnewhorizons.angelica.compat.etfuturum.EndFlashCompat;
import com.gtnewhorizons.angelica.compat.etfuturum.EtFuturumCompat;
import com.gtnewhorizons.angelica.compat.mojang.Camera;
import com.gtnewhorizons.angelica.compat.mojang.GameModeUtil;
@@ -42,15 +41,9 @@ public class IrisExclusiveUniforms {
private static int cachedSelectedFrame = -1;
private static int cachedSelectedBlockId;
public static void addIrisExclusiveUniforms(UniformHolder uniforms, FrameUpdateNotifier updateNotifier) {
public static void addIrisExclusiveUniforms(UniformHolder uniforms) {
WorldInfoUniforms.addWorldInfoUniforms(uniforms);
// Et Futurum Requiem backports the End Flash
final EndFlashStorage endFlashStorage = new EndFlashStorage();
if (EndFlashCompat.isAvailable()) {
updateNotifier.addListener(endFlashStorage::tick);
}
//All Iris-exclusive uniforms (uniforms which do not exist in either OptiFine or ShadersMod) should be registered here.
uniforms.uniform1f(UniformUpdateFrequency.PER_FRAME, "thunderStrength", IrisExclusiveUniforms::getThunderStrength);
uniforms.uniform1f(UniformUpdateFrequency.PER_TICK, "currentPlayerHealth", IrisExclusiveUniforms::getCurrentHealth);
@@ -66,8 +59,6 @@ public class IrisExclusiveUniforms {
uniforms.uniform3d(UniformUpdateFrequency.PER_FRAME, "relativeEyePosition", IrisExclusiveUniforms::getRelativeEyePosition);
uniforms.uniform4f(UniformUpdateFrequency.PER_TICK, "lightningBoltPosition", IrisExclusiveUniforms::getLightningBoltPosition);
uniforms.uniform1f(UniformUpdateFrequency.PER_FRAME, "cloudTime", IrisExclusiveUniforms::getCloudTime);
uniforms.uniform1f(UniformUpdateFrequency.PER_TICK, "endFlashIntensity", endFlashStorage::getCurrentEndFlash);
uniforms.uniform1f(UniformUpdateFrequency.PER_TICK, "previousEndFlashIntensity", endFlashStorage::getLastEndFlash);
uniforms.uniform1b(UniformUpdateFrequency.PER_TICK, "feetInWater", IrisExclusiveUniforms::isFeetInWater);
uniforms.uniform1b(UniformUpdateFrequency.PER_TICK, "isRiding", IrisExclusiveUniforms::isRiding);
uniforms.uniform1b(UniformUpdateFrequency.PER_TICK, "vehicleInWater", IrisExclusiveUniforms::isVehicleInWater);
@@ -12,9 +12,9 @@ public final class ExtendedDataHelper {
public static int computeMidBlock(float x, float y, float z, int localPosX, int localPosY, int localPosZ) {
return packMidBlock(
(localPosX & 0xFFFF) + 0.5f - x,
(localPosY & 0xFFFF) + 0.5f - y,
(localPosZ & 0xFFFF) + 0.5f - z
localPosX + 0.5f - x,
localPosY + 0.5f - y,
localPosZ + 0.5f - z
);
}
}
@@ -3,7 +3,6 @@ package com.gtnewhorizons.angelica.mixins.early.angelica;
import com.gtnewhorizon.gtnhlib.config.ConfigurationManager;
import com.gtnewhorizons.angelica.AngelicaMod;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.glsm.RenderSystem;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import net.minecraftforge.client.ForgeHooksClient;
import org.apache.logging.log4j.LogManager;
@@ -12,7 +11,6 @@ import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.ContextAttribs;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL32;
import org.lwjgl.opengl.PixelFormat;
import org.lwjgl.LWJGLUtil;
import org.spongepowered.asm.mixin.Mixin;
@@ -65,22 +63,15 @@ public abstract class MixinForgeHooksClient_CoreProfile {
final int platformMaxMinor = (LWJGLUtil.getPlatform() == LWJGLUtil.PLATFORM_MACOSX) ? 1 : 6;
final int platformMax = platformMaxMajor * 10 + platformMaxMinor;
int maxProbe = platformMax;
// Try pinned version first if configured
final int pinned = angelica$clampPinned(AngelicaConfig.pinnedGLVersion, platformMax);
if (pinned >= 33) {
final Exception e = angelica$tryCreate(attribs, format, setMajor, setMinor, pinned / 10, pinned % 10);
if (e == null) {
final int cap = angelica$validateContext(pinned / 10, pinned % 10);
if (cap == 0) {
LOGGER.info("Created GL {}.{} core profile context (pinned)", pinned / 10, pinned % 10);
return;
}
maxProbe = Math.min(maxProbe, cap);
} else {
LOGGER.warn("Pinned GL version {}.{} failed, probing from highest", pinned / 10, pinned % 10);
LOGGER.info("Created GL {}.{} core profile context (pinned)", pinned / 10, pinned % 10);
return;
}
LOGGER.warn("Pinned GL version {}.{} failed, probing from highest", pinned / 10, pinned % 10);
}
// Probe from highest to lowest
@@ -89,14 +80,8 @@ public abstract class MixinForgeHooksClient_CoreProfile {
final int maxMinor = (major == 4) ? platformMaxMinor : 3;
final int minMinor = (major == 3) ? 3 : 0;
for (int minor = maxMinor; minor >= minMinor; --minor) {
if (major * 10 + minor > maxProbe) continue;
final Exception e = angelica$tryCreate(attribs, format, setMajor, setMinor, major, minor);
if (e == null) {
final int cap = angelica$validateContext(major, minor);
if (cap != 0) {
maxProbe = Math.min(maxProbe, cap);
continue;
}
final int version = major * 10 + minor;
LOGGER.info("Created GL {}.{} core profile context", major, minor);
// Auto-pin if below platform max, or update a stale pin
@@ -142,20 +127,6 @@ public abstract class MixinForgeHooksClient_CoreProfile {
}
}
@Unique
private static int angelica$validateContext(int major, int minor) {
final String glVersion = GLStateManager.glGetString(GL11.GL_VERSION);
final int actual = RenderSystem.parseMajorMinor(glVersion);
final boolean core = (GLStateManager.glGetInteger(GL32.GL_CONTEXT_PROFILE_MASK) & GL32.GL_CONTEXT_CORE_PROFILE_BIT) != 0;
if (RenderSystem.isContextValid(major, minor, actual, core)) {
return 0;
}
LOGGER.warn("Requested GL {}.{} core context but driver returned \"{}\" (core profile: {}, GPU: {}); falling back to a lower version", major, minor, glVersion, core, GLStateManager.glGetString(GL11.GL_RENDERER));
try { Display.destroy(); } catch (Exception ignored) {}
final int requested = major * 10 + minor;
return (actual >= 0 && actual < requested) ? actual : requested - 1;
}
@Unique
private static void angelica$savePin(int version) {
AngelicaConfig.pinnedGLVersion = version;
@@ -2,6 +2,12 @@ package com.gtnewhorizons.angelica.mixins.early.angelica.fontrenderer;
import com.gtnewhorizon.gtnhlib.util.font.IFontParameters;
import com.gtnewhorizons.angelica.client.font.BatchingFontRenderer;
import com.gtnewhorizons.angelica.client.font.FontProviderUnicode;
import com.gtnewhorizons.angelica.client.font.FontStrategist;
import com.gtnewhorizons.angelica.compat.etfuturum.EtFuturumFontCompat;
import net.minecraft.client.resources.IResourceManager;
import java.io.IOException;
import java.io.InputStream;
import static com.gtnewhorizons.angelica.client.font.ColorCodeUtils.FORMATTING_CHAR;
import static com.gtnewhorizons.angelica.client.font.ColorCodeUtils.GRADIENT_LENGTH;
import static com.gtnewhorizons.angelica.client.font.ColorCodeUtils.SECTION_X_LENGTH;
@@ -127,6 +133,17 @@ public abstract class MixinFontRenderer implements FontRendererAccessor, IFontPa
}
}
@Inject(method = "onResourceManagerReload", at = @At("TAIL"))
private void angelica$reloadModernFont(IResourceManager manager, CallbackInfo ci) {
// FML's SplashFontRenderer calls onResourceManagerReload(null) on the splash thread
if (manager == null) return;
FontStrategist.reloadFontResources();
try (InputStream in = manager.getResource(new ResourceLocation("font/glyph_sizes.bin")).getInputStream()) {
FontProviderUnicode.readWidths(in, this.glyphWidth);
} catch (IOException ignored) {
}
}
@Unique
private static boolean angelica$charInRange(char what, char fromInclusive, char toInclusive) {
return (what >= fromInclusive) && (what <= toInclusive);
@@ -311,15 +328,115 @@ public abstract class MixinFontRenderer implements FontRendererAccessor, IFontPa
}
}
if (styles.length() == 0 && effects.length() == 0) return lastColor;
if (styles.isEmpty() && effects.isEmpty()) return lastColor;
final StringBuilder result = EXTRACT_RESULT; result.setLength(0);
result.append(lastColor).append(styles).append(effects);
return result.toString();
}
@ModifyVariable(method = "getStringWidth", at = @At("HEAD"), argsOnly = true, ordinal = 0)
private String angelica$convertBeforeWidth(String str) {
return ColorCodeUtils.convertAmpersandToSectionX(str);
@Inject(method = "getStringWidth", at = @At("HEAD"), cancellable = true)
private void angelica$batchedStringWidth(String text, CallbackInfoReturnable<Integer> cir) {
cir.setReturnValue(angelica$getBatcher().getStringWidthBatched(text));
}
@Unique
private static boolean angelica$isFormatColor(char c) {
return angelica$charInRange(c, '0', '9') || angelica$charInRange(c, 'a', 'f') || angelica$charInRange(c, 'A', 'F');
}
@Unique
private boolean angelica$doesNotNeedsSurrogateWidth(String str) {
if (str == null || !EtFuturumFontCompat.MODERN_FONT_ENABLED || this.unicodeFlag) return true;
final int len = str.length();
for (int i = 0; i + 1 < len; i++) {
if (Character.isHighSurrogate(str.charAt(i)) && Character.isLowSurrogate(str.charAt(i + 1))) {
return false;
}
}
return true;
}
@Inject(method = "sizeStringToWidth", at = @At("HEAD"), cancellable = true)
private void angelica$surrogateAwareSize(String str, int wrapWidth, CallbackInfoReturnable<Integer> cir) {
if (angelica$doesNotNeedsSurrogateWidth(str)) return;
final BatchingFontRenderer batcher = angelica$getBatcher();
final int len = str.length();
int width = 0;
int lastSpace = -1;
boolean bold = false;
int idx = 0;
for (; idx < len; idx++) {
final char c0 = str.charAt(idx);
if (c0 == '\n') {
lastSpace = idx;
break;
} else if (c0 == FORMATTING_CHAR) {
if (idx < len - 1) {
final char code = str.charAt(idx + 1);
idx++;
if (code == 'l' || code == 'L') bold = true;
else if (code == 'r' || code == 'R' || angelica$isFormatColor(code)) bold = false;
}
continue;
} else {
if (c0 == ' ') lastSpace = idx;
if (EtFuturumFontCompat.MODERN_FONT_ENABLED && !this.unicodeFlag && Character.isHighSurrogate(c0)
&& idx + 1 < len && Character.isLowSurrogate(str.charAt(idx + 1))) {
final int sup = batcher.supplementaryAdvance(Character.toCodePoint(c0, str.charAt(idx + 1)));
if (sup >= 0) {
width += sup;
if (bold) width++;
if (width > wrapWidth) break;
idx++;
continue;
}
}
width += (int) batcher.getCharWidthFine(c0);
if (bold) width++;
}
if (width > wrapWidth) break;
}
cir.setReturnValue(idx != len && lastSpace != -1 && lastSpace < idx ? lastSpace : idx);
}
@Inject(method = "trimStringToWidth(Ljava/lang/String;IZ)Ljava/lang/String;", at = @At("HEAD"), cancellable = true)
private void angelica$surrogateAwareTrim(String str, int width, boolean reverse, CallbackInfoReturnable<String> cir) {
if (reverse || angelica$doesNotNeedsSurrogateWidth(str)) return;
final BatchingFontRenderer batcher = angelica$getBatcher();
final StringBuilder sb = new StringBuilder();
final int len = str.length();
int accum = 0;
boolean prevFormat = false;
boolean bold = false;
for (int i = 0; i < len && accum < width; i++) {
final char c0 = str.charAt(i);
if (prevFormat) {
// Vanilla trim only toggles bold on §l / §r here; color codes do not reset it
prevFormat = false;
if (c0 == 'l' || c0 == 'L') bold = true;
else if (c0 == 'r' || c0 == 'R') bold = false;
} else if (c0 == FORMATTING_CHAR) {
prevFormat = true;
} else {
boolean pair = false;
int adv;
if (EtFuturumFontCompat.MODERN_FONT_ENABLED && !this.unicodeFlag && Character.isHighSurrogate(c0)
&& i + 1 < len && Character.isLowSurrogate(str.charAt(i + 1))) {
final int sup = batcher.supplementaryAdvance(Character.toCodePoint(c0, str.charAt(i + 1)));
if (sup >= 0) { adv = sup; pair = true; } else adv = (int) batcher.getCharWidthFine(c0);
} else {
adv = (int) batcher.getCharWidthFine(c0);
}
accum += adv;
if (bold) accum++;
if (accum > width) break;
sb.append(c0);
if (pair) { sb.append(str.charAt(i + 1)); i++; }
continue;
}
sb.append(c0);
}
cir.setReturnValue(sb.toString());
}
@ModifyVariable(method = "listFormattedStringToWidth", at = @At("HEAD"), argsOnly = true, ordinal = 0)
@@ -1,6 +1,7 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.glsm;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.recording.ImmediateModeRecorder;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.spongepowered.asm.mixin.Mixin;
@@ -26,6 +27,14 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
public class MixinSplashProgressCaching {
private static final Logger LOGGER = LogManager.getLogger("Angelica");
/**
* Before splash starts, create a separate DirectTessellator for the splash thread.
*/
@Inject(method = "start", at = @At("HEAD"))
private static void angelica$initSplashTessellator(CallbackInfo ci) {
ImmediateModeRecorder.initSplashTessellator();
}
// VAOs aren't shared across GL contexts; the SharedDrawable the client thread just swapped
// onto has none. Core profile (macOS) rejects glValidateProgram without one.
@Inject(method = "start", at = @At("RETURN"))
@@ -33,8 +42,12 @@ public class MixinSplashProgressCaching {
GLStateManager.glBindVertexArray(GLStateManager.glGenVertexArrays());
}
/**
* On return from finish() - destroy splash tessellator and mark splash complete
*/
@Inject(method = "finish", at = @At("RETURN"))
private static void angelica$enableCachingOnFinish(CallbackInfo ci) {
ImmediateModeRecorder.destroySplashTessellator();
GLStateManager.markSplashComplete();
LOGGER.info("Splash Complete");
}
@@ -27,7 +27,6 @@ package com.gtnewhorizons.angelica.mixins.early.angelica.itemrenderer;
import com.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator;
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.rendering.items.ItemRenderListManager;
import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod;
import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
@@ -44,10 +43,6 @@ public abstract class MixinItemRenderer {
@WrapMethod(method = "renderItemIn2D")
private static void angelica$cacheItem(Tessellator tessellator, float minU, float minV, float maxU, float maxV, int widthSubdivisions, int heightSubdivisions, float thickness, Operation<Void> original) {
if (GLStateManager.isRecordingDisplayList() || TessellatorManager.isCurrentlyCapturing() || TessellatorManager.shouldInterceptDraw(Tessellator.instance)) {
original.call(tessellator, minU, minV, maxU, maxV, widthSubdivisions, heightSubdivisions, thickness);
return;
}
final ItemRenderListManager.CachedVBO vbo = ItemRenderListManager.pre(minU, minV, maxU, maxV, widthSubdivisions, heightSubdivisions, thickness);
if (vbo != null) {
final DirectTessellator tess = TessellatorManager.startCapturingDirect();
@@ -1,15 +1,12 @@
package com.gtnewhorizons.angelica.mixins.early.angelica.itemrenderer;
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.rendering.items.BlockRenderListManager;
import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod;
import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
@@ -26,15 +23,6 @@ public abstract class MixinRenderBlocks {
@Shadow
public IIcon overrideBlockTexture;
@Shadow public IBlockAccess blockAccess;
@Shadow public int uvRotateEast;
@Shadow public int uvRotateWest;
@Shadow public int uvRotateSouth;
@Shadow public int uvRotateNorth;
@Shadow public int uvRotateTop;
@Shadow public int uvRotateBottom;
@WrapMethod(method = "renderBlockAsItem")
private void angelica$cacheBlockItemRenderer(Block block, int meta, float brightness, Operation<Void> original) {
if (BlockRenderListManager.isISBRH(block.getRenderType())
@@ -42,11 +30,6 @@ public abstract class MixinRenderBlocks {
|| this.overrideBlockTexture != null
|| brightness != 1.0F
|| !this.useInventoryTint
|| this.blockAccess != null
|| (uvRotateEast | uvRotateWest | uvRotateSouth | uvRotateNorth | uvRotateTop | uvRotateBottom) != 0
|| GLStateManager.isRecordingDisplayList()
|| TessellatorManager.isCurrentlyCapturing()
|| TessellatorManager.shouldInterceptDraw(Tessellator.instance)
) {
// Do not cache those
original.call(block, meta, brightness);
@@ -1,6 +1,5 @@
package com.gtnewhorizons.angelica.mixins.early.rendering;
import com.gtnewhorizons.angelica.api.ExtCeleritasRenderBlocks;
import com.gtnewhorizons.angelica.common.BlockError;
import com.gtnewhorizons.angelica.loading.AngelicaClientTweaker;
import com.gtnewhorizons.angelica.proxy.ClientProxy;
@@ -34,7 +33,7 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
@Mixin(RenderBlocks.class)
public abstract class MixinRenderBlocks implements ExtCeleritasRenderBlocks {
public abstract class MixinRenderBlocks {
@Shadow
public abstract boolean renderStandardBlockWithColorMultiplier(Block p_147736_1_, int p_147736_2_, int p_147736_3_, int p_147736_4_, float p_147736_5_, float p_147736_6_, float p_147736_7_);
@@ -110,7 +109,8 @@ public abstract class MixinRenderBlocks implements ExtCeleritasRenderBlocks {
*/
@Inject(method = { "renderStandardBlockWithAmbientOcclusion", "renderStandardBlockWithAmbientOcclusionPartial" }, at = @At("HEAD"), cancellable = true)
private void handleCeleritasAo(Block block, int x, int y, int z, float r, float g, float b, CallbackInfoReturnable<Boolean> cir) {
if (angelica$shouldApplyCeleritasAO()) {
if ((this.isRenderingByType && Minecraft.isAmbientOcclusionEnabled() && ClientProxy.options().quality.useCeleritasSmoothLighting) ||
(Iris.enabled && BlockRenderingSettings.INSTANCE.shouldUseSeparateAo())) {
this.applyingCeleritasAO = true;
try {
cir.setReturnValue(this.renderStandardBlockWithColorMultiplier(block, x, y, z, r, g, b));
@@ -120,17 +120,6 @@ public abstract class MixinRenderBlocks implements ExtCeleritasRenderBlocks {
}
}
@Override
public boolean angelica$shouldApplyCeleritasAO() {
return (this.isRenderingByType && Minecraft.isAmbientOcclusionEnabled() && ClientProxy.options().quality.useCeleritasSmoothLighting) ||
(Iris.enabled && BlockRenderingSettings.INSTANCE.shouldUseSeparateAo());
}
@Override
public void angelica$setApplyingCeleritasAO(boolean val) {
this.applyingCeleritasAO = val;
}
/**
* Widen the grass identity check ({@code block != Blocks.grass}) to cover any BlockGrass subclass
* (e.g. BOP's loamy/sandy/silty grass). When the block being rendered IS a BlockGrass, we return
@@ -248,9 +237,4 @@ public abstract class MixinRenderBlocks implements ExtCeleritasRenderBlocks {
private void compactCtm_resetAfterBlock(Block block, int x, int y, int z, CallbackInfoReturnable<Boolean> cir) {
CTMUtils.clearCurrentCompact();
}
@Inject(method = "renderBlockAsItem", at = @At("HEAD"))
private void compactCtm_resetBeforeItem(Block block, int meta, float brightness, CallbackInfo ci) {
CTMUtils.clearCurrentCompact();
}
}