diff --git a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/DisplayListManager.java b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/DisplayListManager.java index 03f55bd72..46e1f0c0d 100644 --- a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/DisplayListManager.java +++ b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/DisplayListManager.java @@ -846,7 +846,12 @@ public class DisplayListManager { if (hasCommands) { DisplayListVBO compiledBuffers = null; try { - compiledBuffers = new DisplayListVBOBuilder().addDraws(accumulatedDraws).build(); + final CommandRecorder pausedVbo = pauseRecording(); + try { + compiledBuffers = new DisplayListVBOBuilder().addDraws(accumulatedDraws).build(); + } finally { + resumeRecording(pausedVbo); + } final IndexedDrawBatchBuilder indexedBuilder = commandBuffer.getIndexedDraws(); final List indexedBatches; if (indexedBuilder.isEmpty()) { diff --git a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/GLContextState.java b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/GLContextState.java index eac31cae9..593588235 100644 --- a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/GLContextState.java +++ b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/GLContextState.java @@ -1,6 +1,10 @@ package com.gtnewhorizons.angelica.glsm; import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack; +import it.unimi.dsi.fastutil.ints.Int2IntMap; +import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap; +import it.unimi.dsi.fastutil.ints.IntOpenHashSet; +import it.unimi.dsi.fastutil.ints.IntSet; import com.gtnewhorizons.angelica.glsm.stacks.AlphaStateStack; import com.gtnewhorizons.angelica.glsm.stacks.BlendStateStack; import com.gtnewhorizons.angelica.glsm.stacks.BooleanStateStack; @@ -180,6 +184,10 @@ class GLContextState { public int boundVAO; public int boundPixelUnpackBuffer; public int boundPixelPackBuffer; + public int boundCopyReadBuffer; + public int boundCopyWriteBuffer; + public final Int2IntMap boundOtherBuffers = new Int2IntOpenHashMap(); + public final IntSet writeMappedBuffers = new IntOpenHashSet(); public PixelUnpackState pixelUnpackState = PixelUnpackState.DEFAULT; public final int[] clientAttribSavedTextureUnit = new int[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH]; public final int[] clientAttribSavedVertexFlags = new int[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH]; diff --git a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/GLStateManager.java b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/GLStateManager.java index a94c92342..48f9d5cb1 100644 --- a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/GLStateManager.java +++ b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/GLStateManager.java @@ -11,6 +11,7 @@ import com.gtnewhorizons.angelica.glsm.DisplayListManager.RecordMode; import com.gtnewhorizons.angelica.glsm.backend.BackendManager; import com.gtnewhorizons.angelica.glsm.backend.GLDebugMessageListener; import com.gtnewhorizons.angelica.glsm.backend.VSyncMode; +import com.gtnewhorizons.angelica.glsm.ffp.FfpExtendedAttribs; import com.gtnewhorizons.angelica.glsm.profiling.Tracy; import com.gtnewhorizons.angelica.glsm.ffp.ShaderManager; import com.gtnewhorizons.angelica.glsm.ffp.VAOManager; @@ -56,6 +57,7 @@ import com.gtnewhorizons.angelica.glsm.states.TextureBinding; import com.gtnewhorizons.angelica.glsm.states.TextureUnitArray; import com.gtnewhorizons.angelica.glsm.texture.TextureInfo; import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache; +import it.unimi.dsi.fastutil.ints.Int2IntMap; import it.unimi.dsi.fastutil.ints.IntArrayList; import it.unimi.dsi.fastutil.ints.IntOpenHashSet; import it.unimi.dsi.fastutil.ints.IntStack; @@ -2577,12 +2579,17 @@ public class GLStateManager { return; } try { - if (mode == GL11.GL_QUADS) { - QuadConverter.drawQuadElementsAsTriangles(indices_count, type, indices_buffer_offset); - return; + final boolean ffpExt = FfpExtendedAttribs.maybeBindIndexed(mode, indices_count, type, indices_buffer_offset); + try { + if (mode == GL11.GL_QUADS) { + QuadConverter.drawQuadElementsAsTriangles(indices_count, type, indices_buffer_offset); + return; + } + preDraw(mode); + RENDER_BACKEND.drawElements(mode, indices_count, type, indices_buffer_offset); + } finally { + if (ffpExt) FfpExtendedAttribs.unbind(); } - preDraw(mode); - RENDER_BACKEND.drawElements(mode, indices_count, type, indices_buffer_offset); } finally { if (savedRecorder != null) DisplayListManager.resumeRecording(savedRecorder); } @@ -2692,19 +2699,24 @@ public class GLStateManager { FeedbackManager.processDrawArrays(mode, first, count); return; } - if (mode == GL11.GL_QUADS) { - QuadConverter.drawQuadsAsTriangles(first, count); - } else if (mode == GL11.GL_QUAD_STRIP) { - preDraw(); - RENDER_BACKEND.drawArrays(GL11.GL_TRIANGLE_STRIP, first, count & ~1); - } else if (mode == GL11.GL_POLYGON) { - preDraw(); - RENDER_BACKEND.drawArrays(GL11.GL_TRIANGLE_FAN, first, count); - } else { - preDraw(mode); - RENDER_BACKEND.drawArrays(mode, first, count); + final boolean ffpExt = FfpExtendedAttribs.maybeBind(mode, first, count); + try { + if (mode == GL11.GL_QUADS) { + QuadConverter.drawQuadsAsTriangles(first, count); + } else if (mode == GL11.GL_QUAD_STRIP) { + preDraw(); + RENDER_BACKEND.drawArrays(GL11.GL_TRIANGLE_STRIP, first, count & ~1); + } else if (mode == GL11.GL_POLYGON) { + preDraw(); + RENDER_BACKEND.drawArrays(GL11.GL_TRIANGLE_FAN, first, count); + } else { + preDraw(mode); + RENDER_BACKEND.drawArrays(mode, first, count); + } + } finally { + if (ffpExt) FfpExtendedAttribs.unbind(); + if (savedRecorder != null) DisplayListManager.resumeRecording(savedRecorder); } - if (savedRecorder != null) DisplayListManager.resumeRecording(savedRecorder); } private static void ffpClientArrayPointer(int index, int size, int type, boolean normalized, int stride, long offset) { @@ -5886,10 +5898,19 @@ public class GLStateManager { if (buffer == 0) return; final boolean locked = acquireDrawLock(); try { + FfpExtendedAttribs.onDeleteBuffer(buffer); if (glCtx.boundVBO == buffer) glBindBuffer(GL15.GL_ARRAY_BUFFER, 0); if (VAOManager.boundEBO == buffer) glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0); if (glCtx.boundPixelUnpackBuffer == buffer) glBindBuffer(GL21.GL_PIXEL_UNPACK_BUFFER, 0); if (glCtx.boundPixelPackBuffer == buffer) glBindBuffer(GL21.GL_PIXEL_PACK_BUFFER, 0); + if (glCtx.boundCopyReadBuffer == buffer) glBindBuffer(GL31.GL_COPY_READ_BUFFER, 0); + if (glCtx.boundCopyWriteBuffer == buffer) glBindBuffer(GL31.GL_COPY_WRITE_BUFFER, 0); + for (Int2IntMap.Entry e : glCtx.boundOtherBuffers.int2IntEntrySet()) { + if (e.getIntValue() != buffer) continue; + e.setValue(0); + RENDER_BACKEND.bindBuffer(e.getIntKey(), 0); + } + glCtx.writeMappedBuffers.remove(buffer); VAOManager.onDeleteBuffer(buffer); } finally { @@ -5897,20 +5918,30 @@ public class GLStateManager { } } + /** glBindBufferBase/Range also set the generic binding point, so they share this. */ + private static void trackBufferBinding(GLContextState glCtx, int target, int buffer) { + if (target == GL15.GL_ARRAY_BUFFER) { + // if (boundVBO == buffer) return; TODO figure out why this breaks switching async occlusion mode + glCtx.boundVBO = buffer; + } else if (target == GL15.GL_ELEMENT_ARRAY_BUFFER) { + VAOManager.onBindEBO(buffer); + } else if (target == GL21.GL_PIXEL_UNPACK_BUFFER) { + glCtx.boundPixelUnpackBuffer = buffer; + } else if (target == GL21.GL_PIXEL_PACK_BUFFER) { + glCtx.boundPixelPackBuffer = buffer; + } else if (target == GL31.GL_COPY_READ_BUFFER) { + glCtx.boundCopyReadBuffer = buffer; + } else if (target == GL31.GL_COPY_WRITE_BUFFER) { + glCtx.boundCopyWriteBuffer = buffer; + } else { + glCtx.boundOtherBuffers.put(target, buffer); + } + } + public static void glBindBuffer(int target, int buffer) { - final GLContextState glCtx = ctx(); final boolean locked = acquireDrawLock(); try { - if (target == GL15.GL_ARRAY_BUFFER) { - // if (boundVBO == buffer) return; TODO figure out why this breaks switching async occlusion mode - glCtx.boundVBO = buffer; - } else if (target == GL15.GL_ELEMENT_ARRAY_BUFFER) { - VAOManager.onBindEBO(buffer); - } else if (target == GL21.GL_PIXEL_UNPACK_BUFFER) { - glCtx.boundPixelUnpackBuffer = buffer; - } else if (target == GL21.GL_PIXEL_PACK_BUFFER) { - glCtx.boundPixelPackBuffer = buffer; - } + trackBufferBinding(ctx(), target, buffer); RENDER_BACKEND.bindBuffer(target, buffer); } finally { if (locked) releaseDrawLock(); @@ -5989,15 +6020,78 @@ public class GLStateManager { 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); } + private static final int MAP_PERSISTENT_BIT = 0x40; + + private static int bufferForTarget(int target) { + final GLContextState glCtx = ctx(); + if (target == GL15.GL_ARRAY_BUFFER) return glCtx.boundVBO; + if (target == GL15.GL_ELEMENT_ARRAY_BUFFER) return VAOManager.boundEBO; + if (target == GL31.GL_COPY_READ_BUFFER) return glCtx.boundCopyReadBuffer; + if (target == GL31.GL_COPY_WRITE_BUFFER) return glCtx.boundCopyWriteBuffer; + if (target == GL21.GL_PIXEL_UNPACK_BUFFER) return glCtx.boundPixelUnpackBuffer; + if (target == GL21.GL_PIXEL_PACK_BUFFER) return glCtx.boundPixelPackBuffer; + return glCtx.boundOtherBuffers.get(target); + } + + private static void onBufferRespec(int target) { + if (FfpExtendedAttribs.isEmpty()) return; + final int buffer = bufferForTarget(target); + if (buffer != 0) FfpExtendedAttribs.onBufferRespecified(buffer); + } + + private static void onBufferMap(int target, int access) { + if (access == GL15.GL_READ_ONLY) return; + markWriteMapped(target); + onBufferRespec(target); + } + + private static void onBufferMapRange(int target, int access) { + if ((access & GL30.GL_MAP_WRITE_BIT) == 0) return; + if ((access & MAP_PERSISTENT_BIT) != 0) { + markPersistentlyMapped(target); + return; + } + markWriteMapped(target); + onBufferRespec(target); + } + + private static void markWriteMapped(int target) { + final int buffer = bufferForTarget(target); + if (buffer != 0) ctx().writeMappedBuffers.add(buffer); + } + + private static void onBufferUnmap(int target) { + final int buffer = bufferForTarget(target); + if (buffer == 0 || !ctx().writeMappedBuffers.remove(buffer)) return; + onBufferRespec(target); + } + + private static void onBufferStorage(int target, int flags) { + if ((flags & MAP_PERSISTENT_BIT) != 0) { + markPersistentlyMapped(target); + return; + } + onBufferRespec(target); + } + + private static void markPersistentlyMapped(int target) { + FfpExtendedAttribs.markPersistent(bufferForTarget(target)); + } + + private static void onNamedBufferRespec(int buffer) { + if (FfpExtendedAttribs.isEmpty()) return; + FfpExtendedAttribs.onBufferRespecified(buffer); + } + + public static void glBufferData(int target, long size, int usage) { onBufferRespec(target); RENDER_BACKEND.bufferData(target, size, usage); } + public static void glBufferData(int target, ByteBuffer data, int usage) { onBufferRespec(target); RENDER_BACKEND.bufferData(target, data, usage); } + public static void glBufferData(int target, ShortBuffer data, int usage) { onBufferRespec(target); RENDER_BACKEND.bufferData(target, data, usage); } + public static void glBufferData(int target, IntBuffer data, int usage) { onBufferRespec(target); RENDER_BACKEND.bufferData(target, data, usage); } + public static void glBufferData(int target, FloatBuffer data, int usage) { onBufferRespec(target); RENDER_BACKEND.bufferData(target, data, usage); } + public static void glBufferData(int target, DoubleBuffer data, int usage) { onBufferRespec(target); 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, int[] data, int usage) { onBufferRespec(target); RENDER_BACKEND.bufferData(target, data, usage); } + public static void glBufferData(int target, float[] data, int usage) { onBufferRespec(target); 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); @@ -6022,11 +6116,11 @@ public class GLStateManager { 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, ByteBuffer data) { onBufferRespec(target); RENDER_BACKEND.bufferSubData(target, offset, data); } + public static void glBufferSubData(int target, long offset, ShortBuffer data) { onBufferRespec(target); RENDER_BACKEND.bufferSubData(target, offset, data); } + public static void glBufferSubData(int target, long offset, IntBuffer data) { onBufferRespec(target); RENDER_BACKEND.bufferSubData(target, offset, data); } + public static void glBufferSubData(int target, long offset, FloatBuffer data) { onBufferRespec(target); RENDER_BACKEND.bufferSubData(target, offset, data); } + public static void glBufferSubData(int target, long offset, DoubleBuffer data) { onBufferRespec(target); 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); @@ -6056,13 +6150,13 @@ public class GLStateManager { public static void nglBufferSubData(int target, long offset, long size, long data) { glBufferSubData(target, offset, MemoryUtilities.memByteBuffer(data, checkedSize(size))); } - public static ByteBuffer glMapBuffer(int target, int access) { return RENDER_BACKEND.mapBuffer(target, access); } + public static ByteBuffer glMapBuffer(int target, int access) { onBufferMap(target, 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 glMapBuffer(int target, int access, long length, ByteBuffer old_buffer) { onBufferMap(target, access); return RENDER_BACKEND.mapBuffer(target, access, length, old_buffer); } + public static ByteBuffer glMapBufferRange(int target, long offset, long length, int access) { onBufferMapRange(target, 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 boolean glUnmapBuffer(int target) { onBufferUnmap(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); } @@ -6109,8 +6203,8 @@ public class GLStateManager { 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, 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, long size, int flags) { onBufferStorage(target, flags); RENDER_BACKEND.bufferStorage(target, size, flags); } + public static void glBufferStorage(int target, ByteBuffer data, int flags) { onBufferStorage(target, 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); } @@ -6136,9 +6230,9 @@ public class GLStateManager { 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, long size, int usage) { onNamedBufferRespec(buffer); RENDER_BACKEND.namedBufferData(buffer, size, usage); } + public static void glNamedBufferData(int buffer, ByteBuffer data, int usage) { onNamedBufferRespec(buffer); RENDER_BACKEND.namedBufferData(buffer, data, usage); } + public static void glNamedBufferData(int buffer, FloatBuffer data, int usage) { onNamedBufferRespec(buffer); 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); } @@ -6169,7 +6263,7 @@ public class GLStateManager { 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, ByteBuffer data) { onNamedBufferRespec(buffer); 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)); } @@ -6201,15 +6295,15 @@ public class GLStateManager { 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 glClearBufferData(int target, int internalformat, int format, int type, ByteBuffer data) { RENDER_BACKEND.clearBufferData(target, internalformat, format, type, data); } + public static void glClearBufferSubData(int target, int internalFormat, long offset, long size, int format, int type, ByteBuffer data) { onBufferRespec(target); RENDER_BACKEND.clearBufferSubData(target, internalFormat, offset, size, format, type, data); } + public static void glClearBufferData(int target, int internalformat, int format, int type, ByteBuffer data) { onBufferRespec(target); RENDER_BACKEND.clearBufferData(target, internalformat, format, type, data); } public static boolean glIsBuffer(int buffer) { return RENDER_BACKEND.isBuffer(buffer); } public static boolean glIsTexture(int texture) { return RENDER_BACKEND.isTexture(texture); } public static boolean glIsFramebuffer(int framebuffer) { return RENDER_BACKEND.isFramebuffer(framebuffer); } public static boolean glIsRenderbuffer(int renderbuffer) { return RENDER_BACKEND.isRenderbuffer(renderbuffer); } public static boolean glIsSampler(int sampler) { return RENDER_BACKEND.isSampler(sampler); } public static boolean glIsQuery(int query) { return RENDER_BACKEND.isQuery(query); } - public static void glCopyBufferSubData(int readTarget, int writeTarget, long readOffset, long writeOffset, long size) { RENDER_BACKEND.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); } + public static void glCopyBufferSubData(int readTarget, int writeTarget, long readOffset, long writeOffset, long size) { onBufferRespec(writeTarget); RENDER_BACKEND.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); } private static int checkedSize(long size) { if (size < 0 || size > Integer.MAX_VALUE) { @@ -6373,7 +6467,26 @@ public class GLStateManager { public static void glGetQueryObjectui(int id, int pname, IntBuffer params) { RENDER_BACKEND.getQueryObjectui(id, pname, params); } public static int glGetQueryObjecti(int id, int pname) { return RENDER_BACKEND.getQueryObjecti(id, pname); } - public static void glBindBufferBase(int target, int index, int buffer) { RENDER_BACKEND.bindBufferBase(target, index, buffer); } + public static void glBindBufferBase(int target, int index, int buffer) { + final boolean locked = acquireDrawLock(); + try { + trackBufferBinding(ctx(), target, buffer); + RENDER_BACKEND.bindBufferBase(target, index, buffer); + } finally { + if (locked) releaseDrawLock(); + } + } + + public static void glBindBufferRange(int target, int index, int buffer, long offset, long size) { + final boolean locked = acquireDrawLock(); + try { + trackBufferBinding(ctx(), target, buffer); + RENDER_BACKEND.bindBufferRange(target, index, buffer, offset, size); + } finally { + if (locked) releaseDrawLock(); + } + } + public static int glGetUniformBlockIndex(int program, CharSequence name) { return RENDER_BACKEND.getUniformBlockIndex(program, name); } public static void glUniformBlockBinding(int program, int blockIndex, int binding) { RENDER_BACKEND.uniformBlockBinding(program, blockIndex, binding); } public static void glBindFragDataLocation(int program, int colorNumber, CharSequence name) { RENDER_BACKEND.bindFragDataLocation(program, colorNumber, name); } @@ -6411,6 +6524,7 @@ public class GLStateManager { } } public static long nglMapBuffer(int target, int access) { + onBufferMap(target, access); final ByteBuffer buf = RENDER_BACKEND.mapBuffer(target, access); return buf == null ? 0L : MemoryUtilities.memAddress0(buf); } @@ -7728,6 +7842,14 @@ public class GLStateManager { return ctx().boundVBO; } + public static int getBoundCopyReadBuffer() { + return ctx().boundCopyReadBuffer; + } + + public static int getBoundCopyWriteBuffer() { + return ctx().boundCopyWriteBuffer; + } + public static int getBoundVAO() { return ctx().boundVAO; } diff --git a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/RenderSystem.java b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/RenderSystem.java index a35cb5ccf..0f43dbf9a 100644 --- a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/RenderSystem.java +++ b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/RenderSystem.java @@ -559,7 +559,7 @@ public class RenderSystem { } public static void bindBufferBase(int target, int index, int buffer) { - RENDER_BACKEND.bindBufferBase(target, index, buffer); + GLStateManager.glBindBufferBase(target, index, buffer); } public static void bufferStorage(int target, long size, int flags) { diff --git a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/FfpExtendedAttribs.java b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/FfpExtendedAttribs.java new file mode 100644 index 000000000..33a3cabbf --- /dev/null +++ b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/FfpExtendedAttribs.java @@ -0,0 +1,583 @@ +package com.gtnewhorizons.angelica.glsm.ffp; + +import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.NormI8; +import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormatElement.Usage; +import com.gtnewhorizons.angelica.glsm.GLStateManager; +import com.gtnewhorizons.angelica.glsm.hooks.GLSMHooks; +import com.gtnewhorizons.angelica.glsm.hooks.ImmediateExtendedAttribHandler; +import it.unimi.dsi.fastutil.ints.Int2IntMap; +import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap; +import it.unimi.dsi.fastutil.ints.Int2ObjectMap; +import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap; +import it.unimi.dsi.fastutil.ints.IntArrayList; +import it.unimi.dsi.fastutil.ints.IntOpenHashSet; +import it.unimi.dsi.fastutil.ints.IntSet; +import it.unimi.dsi.fastutil.longs.LongOpenHashSet; +import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet; +import it.unimi.dsi.fastutil.objects.ObjectSet; +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL15; +import org.lwjgl.opengl.GL31; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.HashMap; + +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAddress0; +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAlloc; +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memCalloc; +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memFree; +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetByte; +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt; +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetShort; +import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND; + +/** + * Supplies {@code mc_midTexCoord}/{@code at_tangent} for mod geometry drawn through the FFPclient-array path + * ({@code glVertexPointer}/{@code glTexCoordPointer} + {@code glDrawArrays}) out of a VBO, which bypasses the + * Tessellator and display-list ext-injection paths. + * + *

Tangents are reconstructed from the flat face normal (handler's {@code normalOffset < 0} path). + */ +public final class FfpExtendedAttribs { + + private FfpExtendedAttribs() {} + + private static final int POSITION_LOC = Usage.POSITION.getAttributeLocation(); + private static final int UV_LOC = Usage.PRIMARY_UV.getAttributeLocation(); + private static final int NORMAL_LOC = Usage.NORMAL.getAttributeLocation(); + private static final int SRC_TEX_OFFSET = 12; + private static final int SRC_NORMAL_OFFSET = 20; + private static final int SRC_STRIDE_FLAT = 20; + private static final int SRC_STRIDE_SMOOTH = 24; + private static final int MAX_CACHE = 1024; + private static final int MAX_EXT_VERTS = 1 << 20; + private static final int MAX_RESPECS = 8; + private static final int RESPEC_DECAY_FRAMES = 2; + private static final int MIN_STREAM_SPAN_FRAMES = 4; + private static final int STREAM_EXPIRE_FRAMES = 60; + + private static final HashMap cache = new HashMap<>(); + private static final Key lookup = new Key(); + private static int internalGlDepth = 0; + + private static final HashMap eboPatternCache = new HashMap<>(); + private static final EboKey eboLookup = new EboKey(); + + private static final Int2ObjectMap> keysBySource = new Int2ObjectOpenHashMap<>(); + private static final Int2ObjectMap> eboKeysBySource = new Int2ObjectOpenHashMap<>(); + private static final Int2IntMap respecCounts = new Int2IntOpenHashMap(); + private static final Int2IntMap respecFrames = new Int2IntOpenHashMap(); + private static final Int2IntMap respecRunStart = new Int2IntOpenHashMap(); + private static final IntSet streamingSources = new IntOpenHashSet(); + private static final IntSet persistentSources = new IntOpenHashSet(); + private static int frame; + + public static void endFrame() { frame++; } + + public static boolean isEmpty() { + return cache.isEmpty() && eboPatternCache.isEmpty(); + } + + private static int internalDrawDepth = 0; + + public static void beginInternalDraw() { internalDrawDepth++; } + + public static void endInternalDraw() { if (internalDrawDepth > 0) internalDrawDepth--; } + + private static void beginInternalGl() { internalGlDepth++; } + + private static void endInternalGl() { if (internalGlDepth > 0) internalGlDepth--; } + + private static boolean isNotConventionalTexturedArray(VAOManager.Attrib a) { + return a == null || !a.enabled || a.genericPointer || a.vboId == 0 || a.size < 2; + } + + private static boolean isStreaming(int vboId) { + if (vboId == 0 || !streamingSources.contains(vboId)) return false; + if (persistentSources.contains(vboId)) return true; + if (frame - respecFrames.get(vboId) > STREAM_EXPIRE_FRAMES) { + streamingSources.remove(vboId); + respecFrames.remove(vboId); + return false; + } + return true; + } + + public static boolean maybeBind(int mode, int first, int count) { + final ImmediateExtendedAttribHandler h = GLSMHooks.immediateExtendedHandler; + if (h == null) return false; + if (internalDrawDepth > 0) return false; + final int extPrim = ImmediateExtendedAttribHandler.extPrimVerts(mode, count); + if (extPrim == 0 || first < 0) return false; + if (!h.wantsExtended()) return false; + + final VAOManager.Attrib pos = VAOManager.get(POSITION_LOC); + final VAOManager.Attrib uv = VAOManager.get(UV_LOC); + if (isNotConventionalTexturedArray(pos) || isNotConventionalTexturedArray(uv)) return false; + if (isStreaming(pos.vboId) || isStreaming(uv.vboId)) return false; + + VAOManager.Attrib normal = extPrim == 3 ? VAOManager.get(NORMAL_LOC) : null; + if (normal != null && (!normal.enabled || normal.genericPointer || normal.vboId == 0 || normal.size < 3 + || isStreaming(normal.vboId))) { + normal = null; + } + + return bindExt(h, mode, first, count, extPrim, pos, uv, normal); + } + + public static boolean maybeBindIndexed(int mode, int indexCount, int indexType, long indicesOffset) { + final ImmediateExtendedAttribHandler h = GLSMHooks.immediateExtendedHandler; + if (h == null) return false; + if (internalDrawDepth > 0) return false; + if (mode != GL11.GL_TRIANGLES || indexCount <= 0 || indexCount % 6 != 0) return false; + if (!h.wantsExtended()) return false; + + final VAOManager.Attrib pos = VAOManager.get(POSITION_LOC); + final VAOManager.Attrib uv = VAOManager.get(UV_LOC); + if (isNotConventionalTexturedArray(pos) || isNotConventionalTexturedArray(uv)) return false; + if (isStreaming(pos.vboId) || isStreaming(uv.vboId) || isStreaming(VAOManager.boundEBO)) return false; + + final int indexSize = indexTypeBytes(indexType); + if (indexSize == 0) return false; + if (indicesOffset % (6L * indexSize) != 0) return false; + final int first = (int) (indicesOffset / indexSize) / 6 * 4; + final int count = indexCount / 6 * 4; + + if (!isQuadPatternEbo(VAOManager.boundEBO, indicesOffset, indexCount, indexType, indexSize, first)) return false; + + // Build/bind as GL_QUADS (the real primitive): face-normal tangents, 4-vertex tiles, no per-vertex normal. + return bindExt(h, GL11.GL_QUADS, first, count, 4, pos, uv, null); + } + + private static boolean isQuadPatternEbo(int ebo, long offset, int indexCount, int indexType, int indexSize, int firstVertex) { + if (ebo == 0) return false; + eboLookup.set(ebo, offset, indexCount, indexType); + final Boolean cached = eboPatternCache.get(eboLookup); + if (cached != null) return cached; + if (eboPatternCache.size() >= MAX_CACHE) { + eboPatternCache.clear(); + eboKeysBySource.clear(); + } + + final ByteBuffer buf = memCalloc(indexCount, indexSize); + RENDER_BACKEND.getBufferSubData(GL15.GL_ELEMENT_ARRAY_BUFFER, offset, buf); + final long addr = memAddress0(buf); + boolean match = true; + for (int q = 0, quadCount = indexCount / 6; q < quadCount; q++) { + final int base = firstVertex + q * 4; + final long p = addr + (long) q * 6 * indexSize; + if (readIndex(p, 0, indexSize) != base + || readIndex(p, 1, indexSize) != base + 1 + || readIndex(p, 2, indexSize) != base + 2 + || readIndex(p, 3, indexSize) != base + 2 + || readIndex(p, 4, indexSize) != base + 3 + || readIndex(p, 5, indexSize) != base) { + match = false; + break; + } + } + memFree(buf); + final EboKey stored = eboLookup.copy(); + eboPatternCache.put(stored, match); + ObjectSet ebos = eboKeysBySource.get(stored.ebo); + if (ebos == null) eboKeysBySource.put(stored.ebo, ebos = new ObjectOpenHashSet<>()); + ebos.add(stored); + return match; + } + + private static long readIndex(long base, int i, int indexSize) { + return switch (indexSize) { + case 1 -> memGetByte(base + i) & 0xFFL; + case 2 -> memGetShort(base + (long) i * 2) & 0xFFFFL; + default -> memGetInt(base + (long) i * 4) & 0xFFFFFFFFL; + }; + } + + private static int indexTypeBytes(int indexType) { + return switch (indexType) { + case GL11.GL_UNSIGNED_BYTE -> 1; + case GL11.GL_UNSIGNED_SHORT -> 2; + case GL11.GL_UNSIGNED_INT -> 4; + default -> 0; + }; + } + + private static boolean bindExt(ImmediateExtendedAttribHandler h, int mode, int first, int count, int extPrim, + VAOManager.Attrib pos, VAOManager.Attrib uv, VAOManager.Attrib normal) { + final int extVbo = getOrBuild(h, pos, uv, normal, first, count, extPrim, mode); + if (extVbo == 0) return false; + + final int savedVBO = GLStateManager.getBoundVBO(); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, extVbo); + ImmediateExtendedAttribHandler.setupExtAttribPointers(0L, ImmediateExtendedAttribHandler.EXT_STRIDE); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, savedVBO); + return true; + } + + public static void unbind() { + GLStateManager.glDisableVertexAttribArray(ImmediateExtendedAttribHandler.LOC_MID_TEX); + GLStateManager.glDisableVertexAttribArray(ImmediateExtendedAttribHandler.LOC_TANGENT); + setNeutralCurrentValues(); + } + + public static void setNeutralCurrentValues() { + GLStateManager.glVertexAttrib2f(ImmediateExtendedAttribHandler.LOC_MID_TEX, 0.5f, 0.5f); + GLStateManager.glVertexAttrib4f(ImmediateExtendedAttribHandler.LOC_TANGENT, 1.0f, 0.0f, 0.0f, 1.0f); + } + + public static void onDeleteBuffer(int vboId) { + if (internalGlDepth > 0 || vboId == 0) return; + dropDerivedFrom(vboId); + respecCounts.remove(vboId); + respecFrames.remove(vboId); + respecRunStart.remove(vboId); + streamingSources.remove(vboId); + persistentSources.remove(vboId); + } + + public static void onBufferRespecified(int vboId) { + if (internalGlDepth > 0 || vboId == 0) return; + if (streamingSources.contains(vboId)) { + respecFrames.put(vboId, frame); + return; + } + if (!dropDerivedFrom(vboId)) return; + final boolean sameRun = respecCounts.containsKey(vboId) && frame - respecFrames.get(vboId) <= RESPEC_DECAY_FRAMES; + if (!sameRun) { + startRespecRun(vboId); + return; + } + final int respecs = respecCounts.get(vboId) + 1; + final int span = frame - respecRunStart.get(vboId); + if (respecs >= MAX_RESPECS && span >= MIN_STREAM_SPAN_FRAMES && span <= respecs) { + markStreaming(vboId); + return; + } + if (span > respecs) { + startRespecRun(vboId); + return; + } + respecCounts.put(vboId, respecs); + respecFrames.put(vboId, frame); + } + + private static void startRespecRun(int vboId) { + respecCounts.put(vboId, 1); + respecRunStart.put(vboId, frame); + respecFrames.put(vboId, frame); + } + + public static void markStreaming(int vboId) { + if (internalGlDepth > 0 || vboId == 0) return; + respecCounts.remove(vboId); + respecRunStart.remove(vboId); + respecFrames.put(vboId, frame); + if (streamingSources.add(vboId)) dropDerivedFrom(vboId); + } + + public static void markPersistent(int vboId) { + if (internalGlDepth > 0 || vboId == 0) return; + markStreaming(vboId); + persistentSources.add(vboId); + } + + public static void reset() { + invalidateAll(); + respecCounts.clear(); + respecFrames.clear(); + respecRunStart.clear(); + streamingSources.clear(); + persistentSources.clear(); + } + + private static boolean dropDerivedFrom(int srcId) { + final ObjectSet ebos = eboKeysBySource.remove(srcId); + if (ebos != null) { + for (EboKey k : ebos) eboPatternCache.remove(k); + } + final ObjectSet keys = keysBySource.get(srcId); + if (keys == null || keys.isEmpty()) return ebos != null; + IntArrayList toFree = null; + for (Key k : keys.toArray(new Key[0])) { + final ExtBuffer buf = cache.remove(k); + if (buf != null && buf.vbo != 0) { + if (toFree == null) toFree = new IntArrayList(); + toFree.add(buf.vbo); + } + unindexKey(k); + } + freeExtVbos(toFree); + return true; + } + + private static void indexKey(Key k) { + addToBucket(k.posVBO, k); + if (k.uvVBO != k.posVBO) addToBucket(k.uvVBO, k); + if (k.normalVBO != k.posVBO && k.normalVBO != k.uvVBO) addToBucket(k.normalVBO, k); + } + + private static void unindexKey(Key k) { + removeFromBucket(k.posVBO, k); + if (k.uvVBO != k.posVBO) removeFromBucket(k.uvVBO, k); + if (k.normalVBO != k.posVBO && k.normalVBO != k.uvVBO) removeFromBucket(k.normalVBO, k); + } + + private static void addToBucket(int src, Key k) { + if (src == 0) return; + ObjectSet set = keysBySource.get(src); + if (set == null) keysBySource.put(src, set = new ObjectOpenHashSet<>()); + set.add(k); + } + + private static void removeFromBucket(int src, Key k) { + if (src == 0) return; + final ObjectSet set = keysBySource.get(src); + if (set != null && set.remove(k) && set.isEmpty()) keysBySource.remove(src); + } + + private static int getOrBuild(ImmediateExtendedAttribHandler h, VAOManager.Attrib pos, VAOManager.Attrib uv, + VAOManager.Attrib normal, int first, int count, int extPrim, int mode) { + if (first + count > MAX_EXT_VERTS) return 0; + lookup.set(pos, uv, normal, mode, first % extPrim); + ExtBuffer buf = cache.get(lookup); + if (buf == null) { + if (cache.size() >= MAX_CACHE) invalidateExtBuffers(); + buf = new ExtBuffer(); + final Key stored = lookup.copy(); + cache.put(stored, buf); + indexKey(stored); + } + + final long range = (long) first << 32 | (count & 0xFFFFFFFFL); + if (buf.vbo != 0 && buf.builtRanges.contains(range)) return buf.vbo; + if (!ensureCapacity(buf, first + count)) return 0; + buildRange(h, buf.vbo, pos, uv, normal, first, count, extPrim); + buf.builtRanges.add(range); + return buf.vbo; + } + + private static boolean ensureCapacity(ExtBuffer buf, int neededVerts) { + if (buf.vbo != 0 && buf.capacityVerts >= neededVerts) return true; + final int extStride = ImmediateExtendedAttribHandler.EXT_STRIDE; + final int newCap = Math.min(MAX_EXT_VERTS, Math.max(neededVerts, buf.capacityVerts * 2)); + beginInternalGl(); + try { + final int vbo = GLStateManager.glGenBuffers(); + if (vbo == 0) return false; + final int savedVBO = GLStateManager.getBoundVBO(); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo); + GLStateManager.glBufferData(GL15.GL_ARRAY_BUFFER, (long) newCap * extStride, GL15.GL_STATIC_DRAW); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, savedVBO); + if (buf.vbo != 0) { + final int savedRead = GLStateManager.getBoundCopyReadBuffer(); + final int savedWrite = GLStateManager.getBoundCopyWriteBuffer(); + GLStateManager.glBindBuffer(GL31.GL_COPY_READ_BUFFER, buf.vbo); + GLStateManager.glBindBuffer(GL31.GL_COPY_WRITE_BUFFER, vbo); + GLStateManager.glCopyBufferSubData(GL31.GL_COPY_READ_BUFFER, GL31.GL_COPY_WRITE_BUFFER, 0L, 0L, + (long) buf.capacityVerts * extStride); + GLStateManager.glBindBuffer(GL31.GL_COPY_READ_BUFFER, savedRead); + GLStateManager.glBindBuffer(GL31.GL_COPY_WRITE_BUFFER, savedWrite); + GLStateManager.glDeleteBuffers(buf.vbo); + } + buf.vbo = vbo; + buf.capacityVerts = newCap; + return true; + } finally { + endInternalGl(); + } + } + + private static void buildRange(ImmediateExtendedAttribHandler h, int extVbo, VAOManager.Attrib pos, + VAOManager.Attrib uv, VAOManager.Attrib normal, int first, int count, int extPrim) { + final int posStride = pos.effectiveStride(); + final int uvStride = uv.effectiveStride(); + final boolean smooth = normal != null; + final int normalStride = smooth ? normal.effectiveStride() : 0; + final int srcStride = smooth ? SRC_STRIDE_SMOOTH : SRC_STRIDE_FLAT; + final int srcNormalOffset = smooth ? SRC_NORMAL_OFFSET : -1; + + final ByteBuffer posBuf = readRange(pos, first, count, posStride); + final ByteBuffer uvBuf = readRange(uv, first, count, uvStride); + final ByteBuffer normalBuf = smooth ? readRange(normal, first, count, normalStride) : null; + + final ByteBuffer src = memAlloc(count * srcStride).order(ByteOrder.nativeOrder()); + for (int i = 0; i < count; i++) { + final int pb = i * posStride, ub = i * uvStride, d = i * srcStride; + src.putFloat(d, pos.readComponent(posBuf, pb, 0)); + src.putFloat(d + 4, pos.readComponent(posBuf, pb, 1)); + src.putFloat(d + 8, pos.size >= 3 ? pos.readComponent(posBuf, pb, 2) : 0f); + src.putFloat(d + SRC_TEX_OFFSET, uv.readComponent(uvBuf, ub, 0)); + src.putFloat(d + SRC_TEX_OFFSET + 4, uv.readComponent(uvBuf, ub, 1)); + if (smooth) { + final int nb = i * normalStride; + src.putInt(d + SRC_NORMAL_OFFSET, NormI8.pack( + normal.readComponent(normalBuf, nb, 0), + normal.readComponent(normalBuf, nb, 1), + normal.readComponent(normalBuf, nb, 2))); + } + } + + final int extStride = ImmediateExtendedAttribHandler.EXT_STRIDE; + final ByteBuffer ext = memCalloc(count, extStride); + h.buildPacked(memAddress0(src), srcStride, 0, SRC_TEX_OFFSET, srcNormalOffset, count, extPrim, memAddress0(ext), extStride); + + beginInternalGl(); + try { + final int savedVBO = GLStateManager.getBoundVBO(); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, extVbo); + ext.position(0).limit(count * extStride); + GLStateManager.glBufferSubData(GL15.GL_ARRAY_BUFFER, (long) first * extStride, ext); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, savedVBO); + } finally { + endInternalGl(); + } + + memFree(posBuf); + memFree(uvBuf); + if (normalBuf != null) memFree(normalBuf); + memFree(src); + memFree(ext); + } + + private static ByteBuffer readRange(VAOManager.Attrib a, int first, int count, int stride) { + final int elementBytes = a.size * a.typeSizeBytes(); + final int bytes = (count - 1) * stride + elementBytes; + final ByteBuffer dst = memAlloc(bytes).order(ByteOrder.nativeOrder()); + dst.position(0).limit(bytes); + final int savedVBO = GLStateManager.getBoundVBO(); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, a.vboId); + RENDER_BACKEND.getBufferSubData(GL15.GL_ARRAY_BUFFER, a.offset + (long) first * stride, dst); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, savedVBO); + dst.position(0).limit(bytes); + return dst; + } + + private static void invalidateAll() { + eboPatternCache.clear(); + eboKeysBySource.clear(); + invalidateExtBuffers(); + } + + private static void invalidateExtBuffers() { + if (cache.isEmpty()) return; + final IntArrayList toFree = new IntArrayList(cache.size()); + for (ExtBuffer buf : cache.values()) { + if (buf.vbo != 0) toFree.add(buf.vbo); + } + cache.clear(); + keysBySource.clear(); + freeExtVbos(toFree); + } + + private static void freeExtVbos(IntArrayList vbos) { + if (vbos == null || vbos.isEmpty()) return; + beginInternalGl(); + try { + for (int i = 0; i < vbos.size(); i++) { + GLStateManager.glDeleteBuffers(vbos.getInt(i)); + } + } finally { + endInternalGl(); + } + } + + private static final class ExtBuffer { + int vbo; + int capacityVerts; + final LongOpenHashSet builtRanges = new LongOpenHashSet(); + } + + private static final class EboKey { + int ebo, count, type; + long offset; + + void set(int ebo, long offset, int count, int type) { + this.ebo = ebo; + this.offset = offset; + this.count = count; + this.type = type; + } + + EboKey copy() { + final EboKey k = new EboKey(); + k.set(ebo, offset, count, type); + return k; + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof EboKey k)) return false; + return ebo == k.ebo && count == k.count && type == k.type && offset == k.offset; + } + + @Override + public int hashCode() { + int h = ebo; + h = h * 31 + count; + h = h * 31 + type; + h = h * 31 + Long.hashCode(offset); + return h; + } + } + + private static final class Key { + int posVBO, uvVBO, normalVBO, posStride, uvStride, normalStride, posFmt, uvFmt, normalFmt, mode, phase; + long posOffset, uvOffset, normalOffset; + + void set(VAOManager.Attrib pos, VAOManager.Attrib uv, VAOManager.Attrib normal, int mode, int phase) { + posVBO = pos.vboId; posOffset = pos.offset; posStride = pos.effectiveStride(); posFmt = fmt(pos); + uvVBO = uv.vboId; uvOffset = uv.offset; uvStride = uv.effectiveStride(); uvFmt = fmt(uv); + if (normal != null) { + normalVBO = normal.vboId; normalOffset = normal.offset; + normalStride = normal.effectiveStride(); normalFmt = fmt(normal); + } else { + normalVBO = 0; normalOffset = 0; normalStride = 0; normalFmt = 0; + } + this.mode = mode; + this.phase = phase; + } + + private static int fmt(VAOManager.Attrib a) { + return (a.size & 0x7F) | (a.normalized ? 0x80 : 0) | (a.type << 8); + } + + Key copy() { + final Key k = new Key(); + k.posVBO = posVBO; k.posOffset = posOffset; k.posStride = posStride; k.posFmt = posFmt; + k.uvVBO = uvVBO; k.uvOffset = uvOffset; k.uvStride = uvStride; k.uvFmt = uvFmt; + k.normalVBO = normalVBO; k.normalOffset = normalOffset; k.normalStride = normalStride; k.normalFmt = normalFmt; + k.mode = mode; k.phase = phase; + return k; + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof Key k)) return false; + return posVBO == k.posVBO && uvVBO == k.uvVBO && normalVBO == k.normalVBO + && posStride == k.posStride && uvStride == k.uvStride && normalStride == k.normalStride + && posFmt == k.posFmt && uvFmt == k.uvFmt && normalFmt == k.normalFmt + && mode == k.mode && phase == k.phase + && posOffset == k.posOffset && uvOffset == k.uvOffset && normalOffset == k.normalOffset; + } + + @Override + public int hashCode() { + int h = posVBO; + h = h * 31 + uvVBO; + h = h * 31 + normalVBO; + h = h * 31 + posStride; + h = h * 31 + uvStride; + h = h * 31 + normalStride; + h = h * 31 + posFmt; + h = h * 31 + uvFmt; + h = h * 31 + normalFmt; + h = h * 31 + mode; + h = h * 31 + phase; + h = h * 31 + Long.hashCode(posOffset); + h = h * 31 + Long.hashCode(uvOffset); + h = h * 31 + Long.hashCode(normalOffset); + return h; + } + } +} diff --git a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/InstancedAttribs.java b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/InstancedAttribs.java index 24e3ed24e..8fa664372 100644 --- a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/InstancedAttribs.java +++ b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/InstancedAttribs.java @@ -2,12 +2,12 @@ package com.gtnewhorizons.angelica.glsm.ffp; public final class InstancedAttribs { - public static final int LOC_MATRIX_COL0 = 7; - public static final int LOC_MATRIX_COL1 = 8; - public static final int LOC_MATRIX_COL2 = 9; - public static final int LOC_MATRIX_COL3 = 10; - public static final int LOC_COLOR = 11; - public static final int LOC_LIGHTMAP = 12; + public static final int LOC_MATRIX_COL0 = 5; + public static final int LOC_MATRIX_COL1 = 6; + public static final int LOC_MATRIX_COL2 = 7; + public static final int LOC_MATRIX_COL3 = 8; + public static final int LOC_COLOR = 9; + public static final int LOC_LIGHTMAP = 10; public static final int OFFSET_MATRIX = 0; public static final int OFFSET_COLOR = 64; diff --git a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/ShaderManager.java b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/ShaderManager.java index c4bdb0a00..b88c62394 100644 --- a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/ShaderManager.java +++ b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/ShaderManager.java @@ -179,6 +179,7 @@ public final class ShaderManager { sm.lastFramePreDrawCalls = sm.preDrawCalls; sm.preDrawCalls = 0; sm.uniforms.endFrame(); + FfpExtendedAttribs.endFrame(); } public static void setCurrentNormal(float x, float y, float z) { diff --git a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/Uniforms.java b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/Uniforms.java index 834e8c228..b11c589f0 100644 --- a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/Uniforms.java +++ b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/Uniforms.java @@ -27,7 +27,6 @@ import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memCalloc; import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memFree; import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt; import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memPutInt; -import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND; /** * Maintains the shared {@link FFPUniformBlock} image from GLSM cached state and streams it to the UBO ring. @@ -209,7 +208,7 @@ public class Uniforms { ring = new UniformRingBuffer(RING_CAPACITY, FFPUniformBlock.SIZE); } final int offset = ring.writeBlock(staging); - RENDER_BACKEND.bindBufferRange(GL31.GL_UNIFORM_BUFFER, FFPUniformBlock.BINDING_POINT, + GLStateManager.glBindBufferRange(GL31.GL_UNIFORM_BUFFER, FFPUniformBlock.BINDING_POINT, ring.getBufferId(), offset, FFPUniformBlock.SIZE); bound = true; blockWrites++; diff --git a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/GLSMConfig.java b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/GLSMConfig.java index 06ded9457..2044a9f88 100644 --- a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/GLSMConfig.java +++ b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/GLSMConfig.java @@ -16,6 +16,7 @@ public final class GLSMConfig { public static boolean hudCacheOverride; + public static boolean extendedAttribsExpected; public static volatile boolean expandVertexFormats; private GLSMConfig() {} diff --git a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/GLSMHooks.java b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/GLSMHooks.java index 0cf7a9188..9d0a1cf07 100644 --- a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/GLSMHooks.java +++ b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/GLSMHooks.java @@ -9,6 +9,7 @@ public final class GLSMHooks { public static DeferredAlphaHandler alphaHandler; public static DeferredDepthColorHandler depthColorHandler; public static GlintColorHandler glintColorHandler; + public static ImmediateExtendedAttribHandler immediateExtendedHandler; public static ShaderWorkSubmitter shaderWorkSubmitter; public static ShaderTransformPostProcessor postTransformProcessor; public static PerFrameUniformBlock perFrameUniformBlock; diff --git a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/ImmediateExtendedAttribHandler.java b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/ImmediateExtendedAttribHandler.java new file mode 100644 index 000000000..f15205f64 --- /dev/null +++ b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/ImmediateExtendedAttribHandler.java @@ -0,0 +1,64 @@ +package com.gtnewhorizons.angelica.glsm.hooks; + +import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat; +import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormatElement; +import com.gtnewhorizons.angelica.glsm.GLStateManager; +import org.lwjgl.opengl.GL11; + +public interface ImmediateExtendedAttribHandler { + + int EXT_STRIDE = 12; + int LOC_MC_ENTITY = 11; + int LOC_MID_TEX = 12; + int LOC_TANGENT = 13; + int LOC_MIDBLOCK = 14; + + int RAW_NORMAL_INDEX = 6; + + boolean wantsExtended(); + + boolean wantsTangent(); + + boolean wantsExtendedCapture(); + + void build(int[] rawBuffer, int vertexCount, int vertsPerPrim, int normalIntIndex, long dstAddr, int dstStride); + + void buildPacked(long srcBase, int stride, int posOffset, int texOffset, int normalOffset, + int vertexCount, int vertsPerPrim, long dstAddr, int dstStride); + + static int extPrimVerts(int drawMode) { + if (drawMode == GL11.GL_QUADS) return 4; + if (drawMode == GL11.GL_TRIANGLES) return 3; + return 0; + } + + static int extPrimVerts(int drawMode, int vertexCount) { + final int p = extPrimVerts(drawMode); + return (p != 0 && vertexCount > 0 && vertexCount % p == 0) ? p : 0; + } + + static int texOffset(VertexFormat format) { + int offset = 0; + for (VertexFormatElement element : format.elementsArray) { + if (element.getUsage() == VertexFormatElement.Usage.PRIMARY_UV) return offset; + offset += element.getByteSize(); + } + return -1; + } + + static int normalOffset(VertexFormat format) { + int offset = 0; + for (VertexFormatElement element : format.elementsArray) { + if (element.getUsage() == VertexFormatElement.Usage.NORMAL) return offset; + offset += element.getByteSize(); + } + return -1; + } + + static void setupExtAttribPointers(long baseOffset, int stride) { + GLStateManager.glEnableVertexAttribArray(LOC_MID_TEX); + GLStateManager.glVertexAttribPointer(LOC_MID_TEX, 2, GL11.GL_FLOAT, false, stride, baseOffset); + GLStateManager.glEnableVertexAttribArray(LOC_TANGENT); + GLStateManager.glVertexAttribPointer(LOC_TANGENT, 4, GL11.GL_BYTE, true, stride, baseOffset + 8); + } +} diff --git a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/recording/DisplayListVBO.java b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/recording/DisplayListVBO.java index 2b965c0b9..f4dd54644 100644 --- a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/recording/DisplayListVBO.java +++ b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/recording/DisplayListVBO.java @@ -1,6 +1,10 @@ package com.gtnewhorizons.angelica.glsm.recording; import com.gtnewhorizon.gtnhlib.client.renderer.vao.IVertexArrayObject; +import com.gtnewhorizons.angelica.glsm.GLStateManager; +import com.gtnewhorizons.angelica.glsm.hooks.ImmediateExtendedAttribHandler; +import org.lwjgl.opengl.GL15; +import com.gtnewhorizons.angelica.glsm.ffp.FfpExtendedAttribs; import com.gtnewhorizons.angelica.glsm.ffp.VAOManager; /** @@ -9,15 +13,26 @@ import com.gtnewhorizons.angelica.glsm.ffp.VAOManager; public final class DisplayListVBO { private final SubVBO[] vbos; + private final int[] extVbos; DisplayListVBO(SubVBO[] vbos) { + this(vbos, null); + } + + DisplayListVBO(SubVBO[] vbos, int[] extVbos) { this.vbos = vbos; + this.extVbos = extVbos; } public void delete() { for (SubVBO vbo : vbos) { vbo.delete(); } + if (extVbos != null) { + for (int extVbo : extVbos) { + if (extVbo != 0) GLStateManager.glDeleteBuffers(extVbo); + } + } } public SubVBO[] getVBOs() { @@ -39,6 +54,9 @@ public final class DisplayListVBO { private final int start; private final int count; private final int vertexFlags; + private int pendingExtVbo = 0; + + void setPendingExtVbo(int extVbo) { this.pendingExtVbo = extVbo; } public SubVBO(IVertexArrayObject vao, int drawMode, int start, int count, int vertexFlags) { this.vao = vao; @@ -67,9 +85,20 @@ public final class DisplayListVBO { public void render() { if (vao == null) return; vao.bind(); + if (pendingExtVbo != 0) { + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, pendingExtVbo); + ImmediateExtendedAttribHandler.setupExtAttribPointers(0L, ImmediateExtendedAttribHandler.EXT_STRIDE); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0); + pendingExtVbo = 0; + } if (count <= 0) { vao.unbind(); return; } VAOManager.setCurrentVertexFlags(vertexFlags); - vao.draw(drawMode, start, count); + FfpExtendedAttribs.beginInternalDraw(); + try { + vao.draw(drawMode, start, count); + } finally { + FfpExtendedAttribs.endInternalDraw(); + } vao.unbind(); } diff --git a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/recording/DisplayListVBOBuilder.java b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/recording/DisplayListVBOBuilder.java index f04a7af58..f9830e2fb 100644 --- a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/recording/DisplayListVBOBuilder.java +++ b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/recording/DisplayListVBOBuilder.java @@ -1,5 +1,6 @@ package com.gtnewhorizons.angelica.glsm.recording; +import com.gtnewhorizon.gtnhlib.client.renderer.vao.BaseVAO; import com.gtnewhorizon.gtnhlib.client.renderer.vao.IVertexArrayObject; import com.gtnewhorizon.gtnhlib.client.renderer.vao.IndexBuffer; import com.gtnewhorizon.gtnhlib.client.renderer.vao.IndexedVAO; @@ -8,7 +9,13 @@ import com.gtnewhorizon.gtnhlib.client.renderer.vbo.IVertexBuffer; import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat; import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFlags; import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat; +import com.gtnewhorizons.angelica.glsm.GLStateManager; +import com.gtnewhorizons.angelica.glsm.hooks.GLSMConfig; +import com.gtnewhorizons.angelica.glsm.hooks.GLSMHooks; +import com.gtnewhorizons.angelica.glsm.hooks.ImmediateExtendedAttribHandler; +import it.unimi.dsi.fastutil.ints.IntArrayList; import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL15; import java.nio.ByteBuffer; import java.util.ArrayList; @@ -16,6 +23,7 @@ import java.util.List; import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAddress0; import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAlloc; +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memCalloc; import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memCopy; import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memFree; import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.nmemFree; @@ -48,15 +56,29 @@ public final class DisplayListVBOBuilder { } public DisplayListVBO build() { + final ImmediateExtendedAttribHandler extHandler = GLSMHooks.immediateExtendedHandler; final DisplayListVBO.SubVBO[] vbos = new DisplayListVBO.SubVBO[count]; final ArrayList allBuffers = new ArrayList<>(); + final IntArrayList extVbos = new IntArrayList(); for (int i = 0; i < VertexFlags.BITSET_SIZE; i++) { List formatData = formats[i]; if (formatData == null) continue; final VertexFormat format = DefaultVertexFormat.ALL_FORMATS[i]; + final boolean wantExt = extHandler != null && format.hasTexture(); + if (extHandler == null && GLSMConfig.extendedAttribsExpected && format.hasTexture()) { + GLStateManager.warnOnce("dl-ext-no-handler", + "Textured display list compiled before the immediate ext-attribute handler was installed! POM data will be missing for this geometry."); + } int start = 0; final IVertexArrayObject vao = VAOManager.createStorageVAO(format, -1, 0); // drawMode will be ignored final IVertexBuffer vbo = vao.getVBO(); + + // SubVBO slots that need the ext attributes attached on their first draw. + final IntArrayList extDrawIndexes = wantExt ? new IntArrayList() : null; + final IntArrayList extStarts = wantExt ? new IntArrayList() : null; + final IntArrayList extCounts = wantExt ? new IntArrayList() : null; + final IntArrayList extPrims = wantExt ? new IntArrayList() : null; + for (FormatData data : formatData) { int vertexCount; final List drawBuffers = data.buffers; @@ -76,6 +98,23 @@ public final class DisplayListVBOBuilder { if (data.drawMode == GL11.GL_QUADS) { final IVertexArrayObject indexedVAO = new IndexedVAO(vbo, IndexBuffer.convertQuadsToTrigs(start, start + vertexCount)); vbos[data.drawIndex] = new DisplayListVBO.SubVBO(indexedVAO, GL11.GL_TRIANGLES, 0, vertexCount / 4 * 6, flags); + if (wantExt) { + extDrawIndexes.add(data.drawIndex); + extStarts.add(start); + extCounts.add(vertexCount); + extPrims.add(4); + } + } else if (data.drawMode == GL11.GL_TRIANGLES) { + if (wantExt) { + final IVertexArrayObject triVao = new BaseVAO(vbo); + vbos[data.drawIndex] = new DisplayListVBO.SubVBO(triVao, GL11.GL_TRIANGLES, start, vertexCount, flags); + extDrawIndexes.add(data.drawIndex); + extStarts.add(start); + extCounts.add(vertexCount); + extPrims.add(3); + } else { + vbos[data.drawIndex] = new DisplayListVBO.SubVBO(vao, GL11.GL_TRIANGLES, start, vertexCount, flags); + } } else if (data.drawMode == GL11.GL_QUAD_STRIP) { // GL_QUAD_STRIP is removed in core profile; an even-length GL_TRIANGLE_STRIP produces the same quads vbos[data.drawIndex] = new DisplayListVBO.SubVBO(vao, GL11.GL_TRIANGLE_STRIP, start, vertexCount & ~1, flags); @@ -91,11 +130,55 @@ public final class DisplayListVBOBuilder { } ByteBuffer bigBuffer = mergeAndDelete(allBuffers); vbo.allocate(bigBuffer, start); + + if (wantExt && !extDrawIndexes.isEmpty()) { + final int extVbo = buildExt(extHandler, format, bigBuffer, extStarts, extCounts, extPrims); + if (extVbo != 0) { + extVbos.add(extVbo); + for (int e = 0; e < extDrawIndexes.size(); e++) { + vbos[extDrawIndexes.getInt(e)].setPendingExtVbo(extVbo); + } + } + } + memFree(bigBuffer); allBuffers.clear(); } - return new DisplayListVBO(vbos); + return new DisplayListVBO(vbos, extVbos.toIntArray()); + } + + private static int buildExt(ImmediateExtendedAttribHandler handler, VertexFormat format, ByteBuffer bigBuffer, + IntArrayList extStarts, IntArrayList extCounts, IntArrayList extPrims) { + final int extStride = ImmediateExtendedAttribHandler.EXT_STRIDE; + final int stride = format.getVertexSize(); + final int posOffset = 0; + final int texOffset = ImmediateExtendedAttribHandler.texOffset(format); + final int normalOffset = ImmediateExtendedAttribHandler.normalOffset(format); + + int extVerts = 0; + for (int q = 0; q < extStarts.size(); q++) { + extVerts = Math.max(extVerts, extStarts.getInt(q) + extCounts.getInt(q)); + } + + final ByteBuffer ext = memCalloc(extVerts, extStride); + final long extAddr = memAddress0(ext); + final long srcBase = memAddress0(bigBuffer); + for (int q = 0; q < extStarts.size(); q++) { + final int rStart = extStarts.getInt(q); + final int rCount = extCounts.getInt(q); + final int rPrim = extPrims.getInt(q); + handler.buildPacked(srcBase + (long) rStart * stride, stride, posOffset, texOffset, normalOffset, rCount, rPrim, + extAddr + (long) rStart * extStride, extStride); + } + + final int extVbo = GLStateManager.glGenBuffers(); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, extVbo); + ext.position(0).limit(extVerts * extStride); + GLStateManager.glBufferData(GL15.GL_ARRAY_BUFFER, ext, GL15.GL_STATIC_DRAW); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0); + memFree(ext); + return extVbo; } private static ByteBuffer mergeAndDelete(List buffers) { diff --git a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/redirect/GLSMRedirector.java b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/redirect/GLSMRedirector.java index 0f8ef5f40..eba81ba36 100644 --- a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/redirect/GLSMRedirector.java +++ b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/redirect/GLSMRedirector.java @@ -517,7 +517,8 @@ public class GLSMRedirector { .add("glFramebufferRenderbuffer") .add("glIsFramebuffer") .add("glIsRenderbuffer") - .add("glBindBufferBase"); + .add("glBindBufferBase") + .add("glBindBufferRange"); final var gl31 = RedirectMap.newMap() .add("glDrawElementsInstanced") .add("glDrawArraysInstanced") @@ -722,6 +723,7 @@ public class GLSMRedirector { ); final var uniformBufferObject = RedirectMap.newMap() .add("glBindBufferBase") + .add("glBindBufferRange") .add("glGetUniformBlockIndex") .add("glUniformBlockBinding"); methodRedirects.put(ARBUniformBufferObject, uniformBufferObject); diff --git a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/streaming/TessellatorStreamingDrawer.java b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/streaming/TessellatorStreamingDrawer.java index f39a457b5..f2b5efca1 100644 --- a/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/streaming/TessellatorStreamingDrawer.java +++ b/glsm/src/main/java/com/gtnewhorizons/angelica/glsm/streaming/TessellatorStreamingDrawer.java @@ -4,12 +4,16 @@ import com.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator; import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat; import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFlags; import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat; +import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormatElement; import com.gtnewhorizons.angelica.config.SystemProperties; import com.gtnewhorizons.angelica.glsm.GLStateManager; import com.gtnewhorizons.angelica.glsm.QuadConverter; import com.gtnewhorizons.angelica.glsm.RenderSystem; +import com.gtnewhorizons.angelica.glsm.ffp.FfpExtendedAttribs; import com.gtnewhorizons.angelica.glsm.ffp.ShaderManager; import com.gtnewhorizons.angelica.glsm.hooks.GLSMConfig; +import com.gtnewhorizons.angelica.glsm.hooks.GLSMHooks; +import com.gtnewhorizons.angelica.glsm.hooks.ImmediateExtendedAttribHandler; import com.gtnewhorizons.angelica.glsm.profiling.Tracy; import net.minecraft.client.renderer.Tessellator; import org.apache.logging.log4j.LogManager; @@ -22,6 +26,7 @@ import java.nio.ByteBuffer; import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAddress0; import static org.joml.Math.clamp; import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAlloc; +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memCopy; import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memFree; /** @@ -36,6 +41,7 @@ public class TessellatorStreamingDrawer { private static final Tracy.ZoneId Z_SDL_STREAM_DRAW = Tracy.zoneId("sdlStreamDraw", Tracy.COLOR_FFP); private static final Logger LOGGER = LogManager.getLogger("TessellatorStreamingDrawer"); + private static final int FORMAT_COUNT = VertexFlags.BITSET_SIZE; // 16 private static PersistentStreamingBuffer persistentBuffer; @@ -44,6 +50,12 @@ public class TessellatorStreamingDrawer { private static final int[] persistentVAOs = new int[FORMAT_COUNT]; private static final int[] orphanVAOs = new int[FORMAT_COUNT]; + private static final int[] extendedPersistentVAOs = new int[FORMAT_COUNT]; + private static final int[] extendedOrphanVAOs = new int[FORMAT_COUNT]; + private static ByteBuffer extScratch; + private static long extScratchAddress; + private static int extScratchCapacity; + private static ByteBuffer repackBuffer; private static long repackAddress; private static int repackCapacity; @@ -153,7 +165,25 @@ public class TessellatorStreamingDrawer { repackBuffer.position(0); repackBuffer.limit((int)(writePtr - repackAddress)); - uploadAndDraw(repackBuffer, effectiveFlags, format, vertexSize, tess.drawMode, vertexCount); + final ImmediateExtendedAttribHandler extHandler = GLSMHooks.immediateExtendedHandler; + final int extPrim = extHandler == null ? 0 : ImmediateExtendedAttribHandler.extPrimVerts(tess.drawMode, vertexCount); + final boolean wantsExt = extHandler != null && extHandler.wantsExtended(); + final boolean doExt = extPrim != 0 && tess.hasTexture && wantsExt; + if (doExt) { + final int combinedStride = vertexSize + ImmediateExtendedAttribHandler.EXT_STRIDE; + final int combinedBytes = vertexCount * combinedStride; + ensureExtScratch(combinedBytes); + interleaveBase(repackAddress, extScratchAddress, vertexCount, vertexSize, combinedStride); + // format expansion backfills a normal into rawBuffer, so trust effectiveFlags rather than tess.hasNormals + final int normalIndex = (effectiveFlags & VertexFlags.NORMAL_BIT) != 0 ? ImmediateExtendedAttribHandler.RAW_NORMAL_INDEX : -1; + extHandler.build(tess.rawBuffer, vertexCount, extPrim, normalIndex, extScratchAddress + vertexSize, combinedStride); + extScratch.position(0); + extScratch.limit(combinedBytes); + uploadAndDrawExtended(extScratch, effectiveFlags, format, combinedStride, tess.drawMode, vertexCount); + shrinkExtScratchIfOversized(combinedBytes); + } else { + uploadAndDraw(repackBuffer, effectiveFlags, format, vertexSize, tess.drawMode, vertexCount); + } } finally { if (locked) GLStateManager.releaseDrawLock(); } @@ -184,6 +214,7 @@ public class TessellatorStreamingDrawer { final ByteBuffer buffer = dt.getWriteBuffer(); final int vertexSize = format.getVertexSize(); + if (tryExtendedPacked(buffer, flags, format, vertexSize, drawMode, vertexCount)) return; uploadAndDraw(buffer, flags, format, vertexSize, drawMode, vertexCount); } @@ -197,9 +228,37 @@ public class TessellatorStreamingDrawer { public static void drawPacked(ByteBuffer packedData, int drawMode, int flags, int vertexCount) { final VertexFormat format = DefaultVertexFormat.ALL_FORMATS[flags]; final int vertexSize = format.getVertexSize(); + if (tryExtendedPacked(packedData, flags, format, vertexSize, drawMode, vertexCount)) return; uploadAndDraw(packedData, flags, format, vertexSize, drawMode, vertexCount); } + private static boolean tryExtendedPacked(ByteBuffer packed, int flags, VertexFormat format, int vertexSize, int drawMode, int vertexCount) { + final ImmediateExtendedAttribHandler extHandler = GLSMHooks.immediateExtendedHandler; + if (extHandler == null || !extHandler.wantsExtended()) return false; + final int extPrim = ImmediateExtendedAttribHandler.extPrimVerts(drawMode, vertexCount); + if (extPrim == 0 || !format.hasTexture()) return false; + + final long srcBase = memAddress0(packed) + packed.position(); + final int texOffset = ImmediateExtendedAttribHandler.texOffset(format); + final int normalOffset = ImmediateExtendedAttribHandler.normalOffset(format); + final int combinedStride = vertexSize + ImmediateExtendedAttribHandler.EXT_STRIDE; + final int combinedBytes = vertexCount * combinedStride; + ensureExtScratch(combinedBytes); + interleaveBase(srcBase, extScratchAddress, vertexCount, vertexSize, combinedStride); + extHandler.buildPacked(srcBase, vertexSize, 0, texOffset, normalOffset, vertexCount, extPrim, extScratchAddress + vertexSize, combinedStride); + extScratch.position(0); + extScratch.limit(combinedBytes); + uploadAndDrawExtended(extScratch, flags, format, combinedStride, drawMode, vertexCount); + shrinkExtScratchIfOversized(combinedBytes); + return true; + } + + private static void interleaveBase(long src, long dst, int vertexCount, int vertexSize, int combinedStride) { + for (int i = 0; i < vertexCount; i++) { + memCopy(src + (long) i * vertexSize, dst + (long) i * combinedStride, vertexSize); + } + } + private static String cachedDebugInfo = "Stream: not initialized"; private static long lastDebugUpdateNanos; private static final long DEBUG_UPDATE_INTERVAL_NS = 500_000_000L; // 500ms @@ -294,10 +353,89 @@ public class TessellatorStreamingDrawer { } private static void drawWithQuadConversion(int drawMode, int firstVertex, int vertexCount) { - if (drawMode == GL11.GL_QUADS) { - QuadConverter.drawQuadsAsTriangles(firstVertex, vertexCount); + FfpExtendedAttribs.beginInternalDraw(); + try { + if (drawMode == GL11.GL_QUADS) { + QuadConverter.drawQuadsAsTriangles(firstVertex, vertexCount); + } else { + GLStateManager.glDrawArrays(drawMode, firstVertex, vertexCount); + } + } finally { + FfpExtendedAttribs.endInternalDraw(); + } + } + + private static void uploadAndDrawExtended(ByteBuffer combined, int flags, VertexFormat format, int combinedStride, int drawMode, int vertexCount) { + ensureVAO(flags, format); + ensureExtendedVAOs(flags, format); + + int firstVertex = -1; + + if (persistentBuffer != null) { + firstVertex = persistentBuffer.upload(combined, combinedStride); + } + + if (firstVertex >= 0) { + GLStateManager.glBindVertexArray(extendedPersistentVAOs[flags]); } else { - GLStateManager.glDrawArrays(drawMode, firstVertex, vertexCount); + GLStateManager.glBindVertexArray(extendedOrphanVAOs[flags]); + orphanBuffers[flags].upload(combined); + firstVertex = 0; + } + + drawWithQuadConversion(drawMode, firstVertex, vertexCount); + GLStateManager.glBindVertexArray(0); + } + + private static void ensureExtendedVAOs(int flags, VertexFormat format) { + if (extendedOrphanVAOs[flags] == 0) { + extendedOrphanVAOs[flags] = GLStateManager.glGenVertexArrays(); + GLStateManager.glBindVertexArray(extendedOrphanVAOs[flags]); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, orphanBuffers[flags].getBufferId()); + setupExtendedBufferState(format); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0); + GLStateManager.glBindVertexArray(0); + } + + if (persistentBuffer != null && extendedPersistentVAOs[flags] == 0) { + extendedPersistentVAOs[flags] = GLStateManager.glGenVertexArrays(); + GLStateManager.glBindVertexArray(extendedPersistentVAOs[flags]); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, persistentBuffer.getBufferId()); + setupExtendedBufferState(format); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0); + GLStateManager.glBindVertexArray(0); + } + } + + private static void setupExtendedBufferState(VertexFormat format) { + final int combinedStride = format.getVertexSize() + ImmediateExtendedAttribHandler.EXT_STRIDE; + long offset = 0; + for (final VertexFormatElement element : format.elementsArray) { + element.setupBufferState(offset, combinedStride); + offset += element.getByteSize(); + } + ImmediateExtendedAttribHandler.setupExtAttribPointers(offset, combinedStride); + } + + private static void ensureExtScratch(int requiredBytes) { + if (extScratch != null && requiredBytes <= extScratchCapacity) return; + + int newCapacity = Math.max(0x4000, extScratchCapacity); + while (newCapacity < requiredBytes) { + newCapacity *= 2; + } + if (extScratch != null) memFree(extScratch); + extScratch = memAlloc(newCapacity); + extScratchAddress = memAddress0(extScratch); + extScratchCapacity = newCapacity; + } + + private static void shrinkExtScratchIfOversized(int lastRequiredBytes) { + if (extScratchCapacity > 0x20000 && lastRequiredBytes < (extScratchCapacity >> 3)) { + memFree(extScratch); + extScratchCapacity = 0x4000; + extScratch = memAlloc(extScratchCapacity); + extScratchAddress = memAddress0(extScratch); } } @@ -358,8 +496,16 @@ public class TessellatorStreamingDrawer { for (int i = 0; i < FORMAT_COUNT; i++) { if (persistentVAOs[i] != 0) { GLStateManager.glDeleteVertexArrays(persistentVAOs[i]); persistentVAOs[i] = 0; } if (orphanVAOs[i] != 0) { GLStateManager.glDeleteVertexArrays(orphanVAOs[i]); orphanVAOs[i] = 0; } + if (extendedPersistentVAOs[i] != 0) { GLStateManager.glDeleteVertexArrays(extendedPersistentVAOs[i]); extendedPersistentVAOs[i] = 0; } + if (extendedOrphanVAOs[i] != 0) { GLStateManager.glDeleteVertexArrays(extendedOrphanVAOs[i]); extendedOrphanVAOs[i] = 0; } if (orphanBuffers[i] != null) { orphanBuffers[i].destroy(); orphanBuffers[i] = null; } } + if (extScratch != null) { + memFree(extScratch); + extScratch = null; + extScratchAddress = 0; + extScratchCapacity = 0; + } if (persistentBuffer != null) { persistentBuffer.destroy(); persistentBuffer = null; diff --git a/src/main/java/com/gtnewhorizons/angelica/compat/mojang/NativeImage.java b/src/main/java/com/gtnewhorizons/angelica/compat/mojang/NativeImage.java index ff94c8d35..04ae05d93 100644 --- a/src/main/java/com/gtnewhorizons/angelica/compat/mojang/NativeImage.java +++ b/src/main/java/com/gtnewhorizons/angelica/compat/mojang/NativeImage.java @@ -61,13 +61,17 @@ public class NativeImage extends BufferedImage { // final int width = GL11.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, level, GL11.GL_TEXTURE_WIDTH); // final int height = GL11.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, level, GL11.GL_TEXTURE_HEIGHT); - final IntBuffer buffer = MemoryUtilities.memAllocInt(size); + final int pixels = width * height; + final IntBuffer buffer = MemoryUtilities.memAllocInt(pixels); try { GLStateManager.glGetTexImage(GL11.GL_TEXTURE_2D, level, format.glFormat, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, buffer); - int[] data = new int[size]; - buffer.get(data); + int[] data = new int[pixels]; + buffer.get(data, 0, pixels); + for (int i = 0; i < pixels; i++) { + data[i] = swapRedBlue(data[i]); + } setRGB(0, 0, width, height, data, 0, width); } finally { MemoryUtilities.memFree(buffer); @@ -90,7 +94,7 @@ public class NativeImage extends BufferedImage { } public static int getR(int i) { - return i >> 0 & 255; + return i & 255; } public static int getG(int i) { @@ -102,11 +106,15 @@ public class NativeImage extends BufferedImage { } public int getPixelRGBA(int x, int y) { - return getRGB(x, y); + return swapRedBlue(getRGB(x, y)); } public void setPixelRGBA(int x, int y, int rgb) { - setRGB(x, y, rgb); + setRGB(x, y, swapRedBlue(rgb)); + } + + private static int swapRedBlue(int c) { + return (c & 0xFF00FF00) | ((c >>> 16) & 0xFF) | ((c & 0xFF) << 16); } diff --git a/src/main/java/com/gtnewhorizons/angelica/iris/ImmediateExtendedAttribs.java b/src/main/java/com/gtnewhorizons/angelica/iris/ImmediateExtendedAttribs.java new file mode 100644 index 000000000..a15376f10 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/iris/ImmediateExtendedAttribs.java @@ -0,0 +1,315 @@ +package com.gtnewhorizons.angelica.iris; + +import com.gtnewhorizons.angelica.glsm.GLStateManager; +import com.gtnewhorizons.angelica.glsm.ffp.FfpExtendedAttribs; +import com.gtnewhorizons.angelica.glsm.hooks.ImmediateExtendedAttribHandler; +import com.gtnewhorizons.angelica.rendering.items.ItemRenderListManager; +import com.gtnewhorizons.angelica.rendering.tesr.TesrBatchRenderer; +import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap; +import net.coderbot.iris.Iris; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.texture.ITextureObject; +import net.minecraft.client.renderer.texture.TextureMap; +import net.coderbot.iris.vertices.IrisQuadView; +import net.coderbot.iris.vertices.NormI8; +import net.coderbot.iris.vertices.NormalHelper; +import org.joml.Vector3f; + +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetFloat; +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt; +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memPutFloat; +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memPutInt; + +/** + * Supplies per-quad {@code mc_midTexCoord} + {@code at_tangent} for immediate-mode draws so parallax/POM shader packs + * reconstruct sprite bounds correctly. + */ +public final class ImmediateExtendedAttribs implements ImmediateExtendedAttribHandler { + + private static final int VERTEX_SIZE = 8; + private static final int X = 0, Y = 1, Z = 2, U = 3, V = 4; + + private static final float UV_EPS = 1.0e-5f; + private static final float POM_SUPPRESS_EPS = 1.0e-4f; + + private static final float POM_MAX_TILE_EXTENT = 0.125f; + + private static final int WANTS_MID = 1; + private static final int WANTS_TANGENT = 2; + + private static final int NEUTRAL_TANGENT = NormI8.pack(1.0f, 0.0f, 0.0f, 1.0f); + + private static volatile int currentProgramWants = 0; + + private static final Int2IntOpenHashMap programWantsExtCache = new Int2IntOpenHashMap(); + + public static void onProgramBound(int program) { + if (program == 0) { + currentProgramWants = 0; + return; + } + int wants; + if (programWantsExtCache.containsKey(program)) { + wants = programWantsExtCache.get(program); + } else { + wants = 0; + if (GLStateManager.glGetAttribLocation(program, "mc_midTexCoord") >= 0) wants |= WANTS_MID; + if (GLStateManager.glGetAttribLocation(program, "at_tangent") >= 0) wants |= WANTS_TANGENT; + programWantsExtCache.put(program, wants); + } + currentProgramWants = wants; + } + + public static void onProgramDeleted(int program) { + programWantsExtCache.remove(program); + } + + public static void onShaderPackChanged() { + currentProgramWants = 0; + programWantsExtCache.clear(); + ItemRenderListManager.clearCache(); + FfpExtendedAttribs.reset(); + TesrBatchRenderer.INSTANCE.clearRetained(); + } + + private final Vector3f normal = new Vector3f(); + private final QuadView quad = new QuadView(); + private final PackedQuadView packedQuad = new PackedQuadView(); + + private boolean limitTileExtent = true; + private boolean needTangent = true; + + @Override + public boolean wantsExtended() { + return Iris.enabled && currentProgramWants != 0 && GLStateManager.getActiveProgram() != 0; + } + + @Override + public boolean wantsTangent() { + return (currentProgramWants & WANTS_TANGENT) != 0; + } + + @Override + public boolean wantsExtendedCapture() { + return Iris.enabled && Iris.getCurrentPack().isPresent(); + } + + @Override + public void build(int[] rawBuffer, int vertexCount, int vertsPerPrim, int normalIntIndex, long dstAddr, int dstStride) { + final boolean smooth = normalIntIndex >= 0; + limitTileExtent = isAtlasNotBound(); + needTangent = wantsTangent(); + long ptr = dstAddr; + for (int v = 0; v < vertexCount; v += vertsPerPrim) { + quad.setup(rawBuffer, v, normalIntIndex); + if (vertsPerPrim == 4) { + writeQuadExt(quad, ptr, dstStride); + } else { + writeTriExt(quad, smooth, ptr, dstStride); + } + ptr += (long) dstStride * vertsPerPrim; + } + } + + @Override + public void buildPacked(long srcBase, int stride, int posOffset, int texOffset, int normalOffset, + int vertexCount, int vertsPerPrim, long dstAddr, int dstStride) { + final boolean smooth = normalOffset >= 0; + limitTileExtent = isAtlasNotBound(); + needTangent = wantsTangent(); + long ptr = dstAddr; + for (int v = 0; v < vertexCount; v += vertsPerPrim) { + packedQuad.setup(srcBase + (long) v * stride, stride, posOffset, texOffset, normalOffset); + if (vertsPerPrim == 4) { + writeQuadExt(packedQuad, ptr, dstStride); + } else { + writeTriExt(packedQuad, smooth, ptr, dstStride); + } + ptr += (long) dstStride * vertsPerPrim; + } + } + + private void writeQuadExt(IrisQuadView quad, long dstAddr, int dstStride) { + final float u0 = quad.u(0), u1 = quad.u(1), u2 = quad.u(2), u3 = quad.u(3); + final float v0 = quad.v(0), v1 = quad.v(1), v2 = quad.v(2), v3 = quad.v(3); + + final float umin = min4(u0, u1, u2, u3), umax = max4(u0, u1, u2, u3); + final float vmin = min4(v0, v1, v2, v3), vmax = max4(v0, v1, v2, v3); + + final boolean tileable = formsRectAxisQuad(u0, u1, u2, u3) && formsRectAxisQuad(v0, v1, v2, v3) + && (!limitTileExtent || ((umax - umin) <= POM_MAX_TILE_EXTENT && (vmax - vmin) <= POM_MAX_TILE_EXTENT)); + + final int tangent; + if (needTangent) { + NormalHelper.computeFaceNormal(normal, quad); + tangent = NormalHelper.computeTangent(normal.x, normal.y, normal.z, quad); + } else { + tangent = NEUTRAL_TANGENT; + } + + long ptr = dstAddr; + if (!tileable) { + for (int i = 0; i < 4; i++) { + memPutFloat(ptr, quad.u(i) + POM_SUPPRESS_EPS); + memPutFloat(ptr + 4, quad.v(i) + POM_SUPPRESS_EPS); + memPutInt(ptr + 8, tangent); + ptr += dstStride; + } + return; + } + + final float midU = (umin + umax) * 0.5f; + final float midV = (vmin + vmax) * 0.5f; + for (int i = 0; i < 4; i++) { + memPutFloat(ptr, midU); + memPutFloat(ptr + 4, midV); + memPutInt(ptr + 8, tangent); + ptr += dstStride; + } + } + + private void writeTriExt(NormalSource view, boolean smooth, long dstAddr, int dstStride) { + final float u0 = view.u(0), u1 = view.u(1), u2 = view.u(2); + final float v0 = view.v(0), v1 = view.v(1), v2 = view.v(2); + + final float umin = Math.min(u0, Math.min(u1, u2)), umax = Math.max(u0, Math.max(u1, u2)); + final float vmin = Math.min(v0, Math.min(v1, v2)), vmax = Math.max(v0, Math.max(v1, v2)); + + final boolean tileable = formsRectAxis(u0, u1, u2) && formsRectAxis(v0, v1, v2) + && (!limitTileExtent || ((umax - umin) <= POM_MAX_TILE_EXTENT && (vmax - vmin) <= POM_MAX_TILE_EXTENT)); + if (!tileable) { + writeTriSuppressed(view, dstAddr, dstStride); + return; + } + + final float midU = (umin + umax) * 0.5f; + final float midV = (vmin + vmax) * 0.5f; + + long ptr = dstAddr; + if (smooth) { + for (int i = 0; i < 3; i++) { + final int n = view.packedNormal(i); + final int tangent = needTangent + ? NormalHelper.computeTangentSmooth(NormI8.unpackX(n), NormI8.unpackY(n), NormI8.unpackZ(n), view) + : NEUTRAL_TANGENT; + memPutFloat(ptr, midU); + memPutFloat(ptr + 4, midV); + memPutInt(ptr + 8, tangent); + ptr += dstStride; + } + } else { + final int tangent; + if (needTangent) { + NormalHelper.computeFaceNormalTri(normal, view); + tangent = NormalHelper.computeTangent(normal.x, normal.y, normal.z, view); + } else { + tangent = NEUTRAL_TANGENT; + } + for (int i = 0; i < 3; i++) { + memPutFloat(ptr, midU); + memPutFloat(ptr + 4, midV); + memPutInt(ptr + 8, tangent); + ptr += dstStride; + } + } + } + + private void writeTriSuppressed(NormalSource view, long dstAddr, int dstStride) { + final int tangent; + if (needTangent) { + NormalHelper.computeFaceNormalTri(normal, view); + tangent = NormalHelper.computeTangent(normal.x, normal.y, normal.z, view); + } else { + tangent = NEUTRAL_TANGENT; + } + long ptr = dstAddr; + for (int i = 0; i < 3; i++) { + memPutFloat(ptr, view.u(i) + POM_SUPPRESS_EPS); + memPutFloat(ptr + 4, view.v(i) + POM_SUPPRESS_EPS); + memPutInt(ptr + 8, tangent); + ptr += dstStride; + } + } + + private static boolean formsRectAxis(float a, float b, float c) { + final boolean ab = Math.abs(a - b) <= UV_EPS; + final boolean ac = Math.abs(a - c) <= UV_EPS; + final boolean bc = Math.abs(b - c) <= UV_EPS; + return (ab || ac || bc) && !(ab && ac && bc); + } + + private static boolean formsRectAxisQuad(float a, float b, float c, float d) { + final float lo = min4(a, b, c, d), hi = max4(a, b, c, d); + if (hi - lo <= UV_EPS) return false; + return atEdge(a, lo, hi) && atEdge(b, lo, hi) && atEdge(c, lo, hi) && atEdge(d, lo, hi); + } + + private static boolean atEdge(float x, float lo, float hi) { + return Math.abs(x - lo) <= UV_EPS || Math.abs(x - hi) <= UV_EPS; + } + + private static boolean isAtlasNotBound() { + final int tex = GLStateManager.getBoundTextureForServerState(0); + if (tex <= 0) return true; + final Minecraft mc = Minecraft.getMinecraft(); + if (mc == null || mc.getTextureManager() == null) return true; + final ITextureObject blocks = mc.getTextureManager().getTexture(TextureMap.locationBlocksTexture); + if (blocks != null && blocks.getGlTextureId() == tex) return false; + final ITextureObject items = mc.getTextureManager().getTexture(TextureMap.locationItemsTexture); + return items == null || items.getGlTextureId() != tex; + } + + private static float min4(float a, float b, float c, float d) { + return Math.min(Math.min(a, b), Math.min(c, d)); + } + + private static float max4(float a, float b, float c, float d) { + return Math.max(Math.max(a, b), Math.max(c, d)); + } + + private interface NormalSource extends IrisQuadView { + int packedNormal(int i); + } + + private static final class QuadView implements NormalSource { + private int[] raw; + private int base; + private int normalIndex; + + void setup(int[] raw, int firstVertex, int normalIndex) { + this.raw = raw; + this.base = firstVertex; + this.normalIndex = normalIndex; + } + + @Override public float x(int i) { return Float.intBitsToFloat(raw[(base + i) * VERTEX_SIZE + X]); } + @Override public float y(int i) { return Float.intBitsToFloat(raw[(base + i) * VERTEX_SIZE + Y]); } + @Override public float z(int i) { return Float.intBitsToFloat(raw[(base + i) * VERTEX_SIZE + Z]); } + @Override public float u(int i) { return Float.intBitsToFloat(raw[(base + i) * VERTEX_SIZE + U]); } + @Override public float v(int i) { return Float.intBitsToFloat(raw[(base + i) * VERTEX_SIZE + V]); } + @Override public int packedNormal(int i) { return raw[(base + i) * VERTEX_SIZE + normalIndex]; } + } + + private static final class PackedQuadView implements NormalSource { + private long base; + private int stride; + private int posOffset; + private int texOffset; + private int normalOffset; + + void setup(long base, int stride, int posOffset, int texOffset, int normalOffset) { + this.base = base; + this.stride = stride; + this.posOffset = posOffset; + this.texOffset = texOffset; + this.normalOffset = normalOffset; + } + + @Override public float x(int i) { return memGetFloat(base + (long) i * stride + posOffset); } + @Override public float y(int i) { return memGetFloat(base + (long) i * stride + posOffset + 4); } + @Override public float z(int i) { return memGetFloat(base + (long) i * stride + posOffset + 8); } + @Override public float u(int i) { return memGetFloat(base + (long) i * stride + texOffset); } + @Override public float v(int i) { return memGetFloat(base + (long) i * stride + texOffset + 4); } + @Override public int packedNormal(int i) { return memGetInt(base + (long) i * stride + normalOffset); } + } +} diff --git a/src/main/java/com/gtnewhorizons/angelica/iris/IrisGLSMBridge.java b/src/main/java/com/gtnewhorizons/angelica/iris/IrisGLSMBridge.java index 04b312933..e9f2fde94 100644 --- a/src/main/java/com/gtnewhorizons/angelica/iris/IrisGLSMBridge.java +++ b/src/main/java/com/gtnewhorizons/angelica/iris/IrisGLSMBridge.java @@ -67,6 +67,10 @@ public class IrisGLSMBridge { StateUpdateNotifiers.colorModulatorNotifier = listener -> colorModulatorListener = listener; } + public static void installImmediateExtendedHandler() { + GLSMHooks.immediateExtendedHandler = new ImmediateExtendedAttribs(); + } + public static void installPostTransformHook() { if (GLSMHooks.postTransformProcessor != null) return; GLSMHooks.postTransformProcessor = new ShaderTransformPostProcessor() { @@ -298,6 +302,14 @@ public class IrisGLSMBridge { } }); + GLSMHooks.PROGRAM_CHANGE.addListener(event -> { + if (Iris.enabled && event.postBind) { + ImmediateExtendedAttribs.onProgramBound(event.newProgram); + } + }); + + GLSMHooks.PROGRAM_DELETE.addListener(event -> ImmediateExtendedAttribs.onProgramDeleted(event.program)); + GLSMHooks.PROGRAM_CHANGE.addListener(event -> { if (!Iris.enabled) return; if (event.postBind) return; diff --git a/src/main/java/com/gtnewhorizons/angelica/proxy/ClientProxy.java b/src/main/java/com/gtnewhorizons/angelica/proxy/ClientProxy.java index aacbb7e81..d7df082ae 100644 --- a/src/main/java/com/gtnewhorizons/angelica/proxy/ClientProxy.java +++ b/src/main/java/com/gtnewhorizons/angelica/proxy/ClientProxy.java @@ -97,6 +97,12 @@ import net.coderbot.iris.client.IrisDebugScreenHandler; public final class ClientProxy extends CommonProxy { + /** + * So you don't need to be in a dev env to have access to the commands. + * Do not commit with this set to true. + */ + private static final boolean FORCE_DEBUG_MODE = false; + public static BlockError blockError; public static final ManagedEnum animationsMode = new ManagedEnum<>(AnimationMode.VISIBLE_ONLY); private static final Logger LOGGER = LogManager.getLogger("Angelica"); @@ -136,6 +142,7 @@ public final class ClientProxy extends CommonProxy { ModelRegistry.registerModid(MOD_ID); blockError = new BlockError(); if (AngelicaConfig.enableIris) { + IrisGLSMBridge.installImmediateExtendedHandler(); Iris.warmupShaderTransforms(); } } @@ -190,7 +197,7 @@ public final class ClientProxy extends CommonProxy { } // Debug tooling - if (!AngelicaClientTweaker.isObfEnv()) { + if (FORCE_DEBUG_MODE || !AngelicaClientTweaker.isObfEnv()) { ClientCommandHandler.instance.registerCommand(new AngelicaCommand()); FMLCommonHandler.instance().bus().register(FlybyRunner.INSTANCE); diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/CeleritasWorldRenderer.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/CeleritasWorldRenderer.java index c7a28b1e8..4793c2f74 100644 --- a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/CeleritasWorldRenderer.java +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/CeleritasWorldRenderer.java @@ -45,6 +45,7 @@ import com.gtnewhorizons.angelica.compat.cubicchunks.CubicChunksAPI; import com.gtnewhorizons.angelica.dynamiclights.DynamicLights; import com.gtnewhorizons.angelica.dynamiclights.IDynamicLightWorldRenderer; import com.gtnewhorizons.angelica.glsm.GLStateManager; +import com.gtnewhorizons.angelica.glsm.ffp.FfpExtendedAttribs; import com.gtnewhorizons.angelica.glsm.profiling.Tracy; import com.gtnewhorizons.angelica.mixins.interfaces.ITileEntityBoundingBoxCache; import com.gtnewhorizons.angelica.mixins.interfaces.OverridesShouldRenderInPass; @@ -168,6 +169,7 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer { - for (CachedVBO value : vboCache.values()) { - value.delete(); - } - vboCache.clear(); - }); + resourceManager.registerReloadListener(_ -> clearCache()); + } + + public static void clearCache() { + for (CachedVBO value : vboCache.values()) { + value.delete(); + } + vboCache.clear(); } public static final class CachedVBO { private final IVertexArrayObject vertexBuffer; private final IndexBuffer ebo; private int expiry; + private int extVbo = 0; public CachedVBO() { this.ebo = new IndexBuffer(); @@ -126,6 +140,59 @@ public class ItemRenderListManager { private void allocate(DirectTessellator tessellator) { tessellator.allocateToVBO(vertexBuffer, ebo); + attachExtAttribs(tessellator); + } + + private void attachExtAttribs(DirectTessellator tessellator) { + final ImmediateExtendedAttribHandler handler = GLSMHooks.immediateExtendedHandler; + final VertexFormat format = tessellator.getVertexFormat(); + final int vertexCount = tessellator.getVertexCount(); + final int extPrim = handler == null ? 0 : ImmediateExtendedAttribHandler.extPrimVerts(tessellator.getDrawMode(), vertexCount); + final boolean capture = handler != null && format != null && format.hasTexture() + && extPrim != 0 + && (extVbo != 0 || handler.wantsExtendedCapture()); + if (!capture) { + detachExtAttribs(); + return; + } + + final int extStride = ImmediateExtendedAttribHandler.EXT_STRIDE; + final int stride = format.getVertexSize(); + final int texOffset = ImmediateExtendedAttribHandler.texOffset(format); + final int normalOffset = ImmediateExtendedAttribHandler.normalOffset(format); + final ByteBuffer packed = tessellator.getWriteBuffer(); + final long srcBase = memAddress0(packed) + packed.position(); + + final ByteBuffer ext = memCalloc(vertexCount, extStride); + handler.buildPacked(srcBase, stride, 0, texOffset, normalOffset, vertexCount, extPrim, memAddress0(ext), extStride); + + final boolean firstAttach = extVbo == 0; + if (firstAttach) { + extVbo = GLStateManager.glGenBuffers(); + } + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, extVbo); + ext.position(0).limit(vertexCount * extStride); + GLStateManager.glBufferData(GL15.GL_ARRAY_BUFFER, ext, GL15.GL_STATIC_DRAW); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0); + memFree(ext); + + if (firstAttach) { + vertexBuffer.bind(); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, extVbo); + ImmediateExtendedAttribHandler.setupExtAttribPointers(0L, extStride); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0); + vertexBuffer.unbind(); + } + } + + private void detachExtAttribs() { + if (extVbo == 0) return; + vertexBuffer.bind(); + GLStateManager.glDisableVertexAttribArray(ImmediateExtendedAttribHandler.LOC_MID_TEX); + GLStateManager.glDisableVertexAttribArray(ImmediateExtendedAttribHandler.LOC_TANGENT); + vertexBuffer.unbind(); + GLStateManager.glDeleteBuffers(extVbo); + extVbo = 0; } private void render(int elapsedTicks) { @@ -136,6 +203,10 @@ public class ItemRenderListManager { private void delete() { vertexBuffer.delete(); // EBO gets deleted by vertexBuffer.delete() + if (extVbo != 0) { + GLStateManager.glDeleteBuffers(extVbo); + extVbo = 0; + } } } diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/tesr/InstancedTemplateRenderer.java b/src/main/java/com/gtnewhorizons/angelica/rendering/tesr/InstancedTemplateRenderer.java index 7e0ca2d19..0b1c5aa0f 100644 --- a/src/main/java/com/gtnewhorizons/angelica/rendering/tesr/InstancedTemplateRenderer.java +++ b/src/main/java/com/gtnewhorizons/angelica/rendering/tesr/InstancedTemplateRenderer.java @@ -2,6 +2,9 @@ package com.gtnewhorizons.angelica.rendering.tesr; import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFlags; import com.gtnewhorizons.angelica.glsm.GLStateManager; +import com.gtnewhorizons.angelica.glsm.hooks.ImmediateExtendedAttribHandler; +import com.gtnewhorizons.angelica.glsm.hooks.GLSMHooks; +import com.gtnewhorizons.angelica.glsm.ffp.FfpExtendedAttribs; import com.gtnewhorizons.angelica.glsm.ffp.InstancedAttribs; import com.gtnewhorizons.angelica.glsm.ffp.VAOManager; import com.gtnewhorizons.angelica.glsm.streaming.OrphanStreamingBuffer; @@ -17,6 +20,8 @@ import org.lwjgl.opengl.GL15; import java.nio.ByteBuffer; import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAddress0; +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memCalloc; +import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memFree; import static com.gtnewhorizon.gtnhlib.client.renderer.cel.util.ModelQuadUtil.COLOR_INDEX; import static com.gtnewhorizon.gtnhlib.client.renderer.cel.util.ModelQuadUtil.NORMAL_INDEX; import static com.gtnewhorizon.gtnhlib.client.renderer.cel.util.ModelQuadUtil.TEX_X_INDEX; @@ -34,6 +39,7 @@ final class InstancedTemplateRenderer { private static final class TemplateMesh { int vao; int vbo; + int extVbo; int vertexCount; int drawMode; long lastUsedMs; @@ -96,6 +102,10 @@ final class InstancedTemplateRenderer { int draws = 0; long recordOffset = ringBase; final int ringId = uploadBufferId; + final ImmediateExtendedAttribHandler extHandler = GLSMHooks.immediateExtendedHandler; + if (extHandler != null && extHandler.wantsExtended()) { + FfpExtendedAttribs.setNeutralCurrentValues(); + } GLStateManager.instancedFfpDrawActive = true; for (int b = 0, n = liveBuckets.size(); b < n; b++) { final Bucket bucket = liveBuckets.get(b); @@ -179,6 +189,13 @@ final class InstancedTemplateRenderer { GLStateManager.glVertexAttribPointer(4, 3, GL11.GL_BYTE, true, TEMPLATE_STRIDE, NORMAL_INDEX * 4L); GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0); + mesh.extVbo = buildExt(template); + if (mesh.extVbo != 0) { + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, mesh.extVbo); + ImmediateExtendedAttribHandler.setupExtAttribPointers(0L, ImmediateExtendedAttribHandler.EXT_STRIDE); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0); + } + for (int loc = InstancedAttribs.LOC_MATRIX_COL0; loc <= InstancedAttribs.LOC_LIGHTMAP; loc++) { GLStateManager.glEnableVertexAttribArray(loc); GLStateManager.glVertexAttribDivisor(loc, 1); @@ -188,6 +205,25 @@ final class InstancedTemplateRenderer { return mesh; } + private static int buildExt(TemplateBuffer template) { + final ImmediateExtendedAttribHandler handler = GLSMHooks.immediateExtendedHandler; + if (handler == null || !handler.wantsExtendedCapture()) return 0; + final int extPrim = ImmediateExtendedAttribHandler.extPrimVerts(template.drawMode, template.vertexCount); + if (extPrim == 0) return 0; + + final int extStride = ImmediateExtendedAttribHandler.EXT_STRIDE; + final ByteBuffer ext = memCalloc(template.vertexCount, extStride); + handler.build(template.data, template.vertexCount, extPrim, + ImmediateExtendedAttribHandler.RAW_NORMAL_INDEX, memAddress0(ext), extStride); + + final int extVbo = GLStateManager.glGenBuffers(); + GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, extVbo); + ext.position(0).limit(template.vertexCount * extStride); + GLStateManager.glBufferData(GL15.GL_ARRAY_BUFFER, ext, GL15.GL_STATIC_DRAW); + memFree(ext); + return extVbo; + } + void endFrame() { if (ringUsedThisFrame && persistentRing != null) { persistentRing.postDraw(); @@ -215,6 +251,7 @@ final class InstancedTemplateRenderer { private static void delete(TemplateMesh mesh) { GLStateManager.glDeleteBuffers(mesh.vbo); + if (mesh.extVbo != 0) GLStateManager.glDeleteBuffers(mesh.extVbo); GLStateManager.glDeleteVertexArrays(mesh.vao); } diff --git a/src/main/java/com/prupe/mcpatcher/cc/ColorizeBlock.java b/src/main/java/com/prupe/mcpatcher/cc/ColorizeBlock.java index 2b4113edb..e85340368 100644 --- a/src/main/java/com/prupe/mcpatcher/cc/ColorizeBlock.java +++ b/src/main/java/com/prupe/mcpatcher/cc/ColorizeBlock.java @@ -250,8 +250,8 @@ public class ColorizeBlock { } colorMap = wrapBlockMap(colorMap); for (String idString : idList.split("\\s+")) { - BlockStateMatcher blockMatcher = BlockAPI.createMatcher(new PropertiesFile(logger, resource), idString); - if (blockMatcher != null) { + for (BlockStateMatcher blockMatcher : BlockAPI + .createMatchers(new PropertiesFile(logger, resource), idString)) { List maps = blockColorMaps .computeIfAbsent(blockMatcher.getBlock(), k -> new ArrayList<>()); blockMatcher.setData(colorMap); diff --git a/src/main/java/com/prupe/mcpatcher/ctm/CTMUtils.java b/src/main/java/com/prupe/mcpatcher/ctm/CTMUtils.java index 1fb87ea17..ae9510cfe 100644 --- a/src/main/java/com/prupe/mcpatcher/ctm/CTMUtils.java +++ b/src/main/java/com/prupe/mcpatcher/ctm/CTMUtils.java @@ -13,6 +13,7 @@ import java.util.function.Consumer; import com.github.bsideup.jabel.Desugar; import net.minecraft.block.Block; +import net.minecraft.client.resources.IResourcePack; import net.minecraft.util.IIcon; import net.minecraft.util.ResourceLocation; import net.minecraft.world.IBlockAccess; @@ -25,6 +26,7 @@ import com.prupe.mcpatcher.mal.block.RenderBlocksUtils; import com.prupe.mcpatcher.mal.block.RenderPassAPI; import com.prupe.mcpatcher.mal.resource.BlendMethod; import com.prupe.mcpatcher.mal.resource.ResourceList; +import com.prupe.mcpatcher.mal.resource.ResourceLocationWithSource; import com.prupe.mcpatcher.mal.resource.TexturePackAPI; import com.prupe.mcpatcher.mal.resource.TexturePackChangeHandler; import com.prupe.mcpatcher.mal.tile.TileLoader; @@ -128,8 +130,14 @@ public class CTMUtils { logger.info("loading CTM overrides"); newOverrides = new Overrides(); if (MCPatcherForgeConfig.ConnectedTextures.standard || MCPatcherForgeConfig.ConnectedTextures.nonStandard) { - for (ResourceLocation resource : ResourceList.getInstance() - .listResources(TexturePackAPI.MCPATCHER_SUBDIR + "ctm", ".properties", true)) { + final List ctmResources = new ArrayList<>(); + for (String subdir : new String[] { TexturePackAPI.MCPATCHER_SUBDIR, TexturePackAPI.OPTIFINE_SUBDIR }) { + ctmResources.addAll(ResourceList.getInstance() + .listResources(subdir + "ctm", ".properties", true)); + } + final Map> packPriority = new HashMap<>(); + ctmResources.sort((a, b) -> packPriorityOf(packPriority, b) - packPriorityOf(packPriority, a)); + for (ResourceLocation resource : ctmResources) { registerOverrideWithoutLock(newOverrides, TileOverride.create(resource, tileLoader)); } for (Consumer callback : ctmRegistrationCallbacks) { @@ -294,9 +302,7 @@ public class CTMUtils { Set matchingTiles = override.getMatchingTiles(); if (!MCPatcherUtils.isNullOrEmpty(matchingTiles)) { for (String name : matchingTiles) { - List list = overrides.tile.computeIfAbsent(name, k -> new ArrayList<>()); - list.add(override); - logger.fine("using %s for tile %s", override, name); + registerTileWithoutLock(overrides, name, override); registered = true; } } @@ -306,6 +312,30 @@ public class CTMUtils { } } + private static void registerTileWithoutLock(Overrides overrides, String name, TileOverride override) { + overrides.tile.computeIfAbsent(name, k -> new ArrayList<>()) + .add(override); + logger.fine("using %s for tile %s", override, name); + } + + private static Map getPackPriority(String namespace) { + final List packs = TexturePackAPI.getResourcePacks(namespace); + final Map priority = new IdentityHashMap<>(packs.size()); + for (int i = 0; i < packs.size(); i++) { + priority.put(packs.get(i), i); + } + return priority; + } + + + private static int packPriorityOf(Map> byDomain, ResourceLocation resource) { + if (!(resource instanceof ResourceLocationWithSource source)) return -1; + final Integer rank = byDomain + .computeIfAbsent(resource.getResourceDomain(), CTMUtils::getPackPriority) + .get(source.getSource()); + return rank == null ? -1 : rank; + } + private static void setBlankResourceWithoutLock() { RenderBlocksUtils.blankIcon = tileLoader.getIcon(RenderPassAPI.instance.getBlankResource()); } diff --git a/src/main/java/com/prupe/mcpatcher/ctm/TileOverride.java b/src/main/java/com/prupe/mcpatcher/ctm/TileOverride.java index 9fb45a114..3c6abdfba 100644 --- a/src/main/java/com/prupe/mcpatcher/ctm/TileOverride.java +++ b/src/main/java/com/prupe/mcpatcher/ctm/TileOverride.java @@ -33,11 +33,15 @@ public abstract class TileOverride implements Comparable { private static final MCLogger logger = MCLogger.getLogger(MCLogger.Category.CONNECTED_TEXTURES, "CTM"); + private static int nextRegistrationOrder; + public final PropertiesFile properties; private final String baseFilename; protected final TileLoader tileLoader; protected final int renderPass; private final int weight; + private boolean lostScope; + private final int registrationOrder = nextRegistrationOrder++; private final List matchBlocks; private final Set matchTiles; private final BlockFaceMatcher faceMatcher; @@ -274,19 +278,21 @@ public abstract class TileOverride implements Comparable { // nothing } else if (token.matches("\\d+-\\d+")) { for (int id : MCPatcherUtils.parseIntegerList(token, 0, 65535)) { - BlockStateMatcher matcher = BlockAPI.createMatcher(properties, id + defaultMetadata); - if (matcher == null) { - properties.warning("unknown block id %d", id); + List matchers = BlockAPI.createMatchers(properties, id + defaultMetadata); + if (matchers.isEmpty()) { + properties.fine("unknown block id %d", id); + lostScope = true; } else { - blocks.add(matcher); + blocks.addAll(matchers); } } } else { - BlockStateMatcher matcher = BlockAPI.createMatcher(properties, token + defaultMetadata); - if (matcher == null) { - properties.warning("unknown block %s", token); + List matchers = BlockAPI.createMatchers(properties, token + defaultMetadata); + if (matchers.isEmpty()) { + properties.fine("unknown block %s", token); + lostScope = true; } else { - blocks.add(matcher); + blocks.addAll(matchers); } } } @@ -334,7 +340,11 @@ public abstract class TileOverride implements Comparable { public final void registerIcons() { icons = new IIcon[tileNames.size()]; for (int i = 0; i < icons.length; i++) { - icons[i] = tileLoader.getIcon(tileNames.get(i)); + final ResourceLocation tileName = tileNames.get(i); + icons[i] = tileLoader.getIcon(tileName); + if (icons[i] == null && tileName != null) { + properties.warning("tile %s did not resolve to an icon, tile %d will not render", tileName, i); + } } } @@ -368,11 +378,11 @@ public abstract class TileOverride implements Comparable { if (result != 0) { return result; } - if (o instanceof TileOverride) { - return baseFilename.compareTo(((TileOverride) o).baseFilename); - } else { - return -1; + result = Boolean.compare(lostScope, o.lostScope); + if (result != 0) { + return result; } + return Integer.compare(registrationOrder, o.registrationOrder); } final boolean shouldConnect(RenderBlockState renderBlockState, IIcon icon, int relativeDirection) { diff --git a/src/main/java/com/prupe/mcpatcher/mal/block/BlockAPI.java b/src/main/java/com/prupe/mcpatcher/mal/block/BlockAPI.java index 90f36ce5b..f51a1ff0c 100644 --- a/src/main/java/com/prupe/mcpatcher/mal/block/BlockAPI.java +++ b/src/main/java/com/prupe/mcpatcher/mal/block/BlockAPI.java @@ -4,15 +4,20 @@ import java.io.File; import java.io.IOException; import java.io.PrintStream; import java.util.ArrayList; +import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; +import net.coderbot.iris.shaderpack.materialmap.BlockEntry; +import net.coderbot.iris.shaderpack.materialmap.FlatteningMap; +import net.coderbot.iris.shaderpack.materialmap.NamespacedId; import net.minecraft.block.Block; import com.prupe.mcpatcher.MCPatcherUtils; import com.prupe.mcpatcher.mal.resource.PropertiesFile; +import com.prupe.mcpatcher.mal.resource.TexturePackAPI; import cpw.mods.fml.common.registry.FMLControlledNamespacedRegistry; import cpw.mods.fml.common.registry.GameData; @@ -64,7 +69,7 @@ public class BlockAPI { return blocks; } - public static BlockStateMatcher createMatcher(PropertiesFile source, String matchString) { + public static List createMatchers(PropertiesFile source, String matchString) { Map propertyMap = new HashMap<>(); String namespace = null; String blockName = null; @@ -90,7 +95,7 @@ public class BlockAPI { appendThis = true; } else { source.warning("invalid token '%s' in %s", source, s, matchString); - return null; + return Collections.emptyList(); } if (appendThis) { metaString.append(':'); @@ -103,19 +108,73 @@ public class BlockAPI { } if (MCPatcherUtils.isNullOrEmpty(blockName)) { source.warning("cannot parse namespace/block name from %s", matchString); - return null; + return Collections.emptyList(); } - Block block = GameData.getBlockRegistry() - .getObject(namespace + ':' + blockName); - if (block == null) { - source.warning("unknown block %s:%s", namespace, blockName); - return null; + final Block block = GameData.getBlockRegistry() + .getRaw(namespace + ':' + blockName); + if (block != null) { + return Collections.singletonList( + new BlockStateMatcher( + metaString.toString(), + block, + metadata.toString() + .trim())); } - return new BlockStateMatcher( - metaString.toString(), - block, - metadata.toString() - .trim()); + if (!TexturePackAPI.DEFAULT_NAMESPACE.equals(namespace)) { + source.fine("unknown block %s:%s", namespace, blockName); + return Collections.emptyList(); + } + final List entries = FlatteningMap.toLegacy(blockName, propertyMap); + if (entries == null) { + source.fine("unknown block %s:%s", namespace, blockName); + return Collections.emptyList(); + } + if (!propertyMap.isEmpty() && entries.equals(FlatteningMap.toLegacy(blockName, Collections.emptyMap()))) { + source.fine("block %s has no 1.7.10 equivalent for %s, ignoring this match", blockName, propertyMap); + return Collections.emptyList(); + } + final String explicitMetadata = metadata.toString() + .trim(); + final List matchers = new ArrayList<>(entries.size()); + for (BlockEntry entry : entries) { + final NamespacedId id = entry.id(); + final Block legacy = GameData.getBlockRegistry() + .getRaw(id.getNamespace() + ':' + id.getName()); + final String entryMetadata = intersectMetadata(explicitMetadata, entry.metas()); + if (entryMetadata == null) { + continue; + } + matchers.add(new BlockStateMatcher(metaString.toString(), legacy, entryMetadata)); + } + if (matchers.isEmpty()) { + source.fine("unknown block %s:%s", namespace, blockName); + } + return matchers; + } + + private static String intersectMetadata(String explicitMetadata, Set entryMetas) { + if (MCPatcherUtils.isNullOrEmpty(explicitMetadata)) { + if (entryMetas.isEmpty()) { + return ""; + } + final StringBuilder sb = new StringBuilder(); + for (int meta : entryMetas) { + sb.append(' ') + .append(meta); + } + return sb.toString() + .trim(); + } + final StringBuilder sb = new StringBuilder(); + for (int meta : MCPatcherUtils.parseIntegerList(explicitMetadata, 0, 15)) { + if (entryMetas.isEmpty() || entryMetas.contains(meta)) { + sb.append(' ') + .append(meta); + } + } + return sb.length() == 0 ? null + : sb.toString() + .trim(); } } diff --git a/src/main/java/com/prupe/mcpatcher/mal/resource/TexturePackAPI.java b/src/main/java/com/prupe/mcpatcher/mal/resource/TexturePackAPI.java index 595ff1143..80e3aa56c 100644 --- a/src/main/java/com/prupe/mcpatcher/mal/resource/TexturePackAPI.java +++ b/src/main/java/com/prupe/mcpatcher/mal/resource/TexturePackAPI.java @@ -43,6 +43,7 @@ public class TexturePackAPI { public static final String DEFAULT_NAMESPACE = "minecraft"; public static final String MCPATCHER_SUBDIR = "mcpatcher/"; + public static final String OPTIFINE_SUBDIR = "optifine/"; public static final ResourceLocation ITEMS_PNG = new ResourceLocation("textures/atlas/items.png"); private static final String ASSETS = "assets/"; @@ -204,6 +205,11 @@ public class TexturePackAPI { return null; } + private static String subdirOf(ResourceLocation baseResource) { + return baseResource != null && baseResource.getResourcePath() + .startsWith(OPTIFINE_SUBDIR) ? OPTIFINE_SUBDIR : MCPATCHER_SUBDIR; + } + public static ResourceLocation parseResourceLocation(ResourceLocation baseResource, String path) { if (MCPatcherUtils.isNullOrEmpty(path)) { return null; @@ -232,8 +238,8 @@ public class TexturePackAPI { ResourceLocation resource; if (path.startsWith("~/")) { // Relative to namespace mcpatcher dir: - // ~/path -> assets/(namespace of base file)/mcpatcher/path - resource = new ResourceLocation(baseResource.getResourceDomain(), MCPATCHER_SUBDIR + path.substring(2)); + // ~/path -> assets/(namespace of base file)/(mcpatcher|optifine)/path + resource = new ResourceLocation(baseResource.getResourceDomain(), subdirOf(baseResource) + path.substring(2)); } else if (path.startsWith("./")) { // Relative to properties file: // ./path -> (dir of base file)/path diff --git a/src/main/java/net/coderbot/iris/Iris.java b/src/main/java/net/coderbot/iris/Iris.java index c791d7c04..73489b8d0 100644 --- a/src/main/java/net/coderbot/iris/Iris.java +++ b/src/main/java/net/coderbot/iris/Iris.java @@ -8,6 +8,7 @@ import com.gtnewhorizons.angelica.glsm.RenderSystem; import com.gtnewhorizons.angelica.glsm.backend.BackendManager; import com.gtnewhorizons.angelica.glsm.shader.GlslVulkanPreprocess; import com.gtnewhorizons.angelica.glsm.shader.SpirvCompiler; +import com.gtnewhorizons.angelica.iris.ImmediateExtendedAttribs; import com.gtnewhorizons.angelica.iris.IrisGLSMBridge; import com.gtnewhorizons.angelica.proxy.ClientProxy; import com.gtnewhorizons.angelica.rendering.StateAwareTessellator; @@ -802,6 +803,9 @@ public class Iris { // Load the new shaderpack loadShaderpack(); + // Drop the stale program probe and cached item geometry + ImmediateExtendedAttribs.onShaderPackChanged(); + // Very important - we need to re-create the pipeline straight away. // https://github.com/IrisShaders/Iris/issues/1330 if (Minecraft.getMinecraft().theWorld != null) { diff --git a/src/main/java/net/coderbot/iris/gl/shader/ProgramCreator.java b/src/main/java/net/coderbot/iris/gl/shader/ProgramCreator.java index f3e57ce06..a92c5a702 100644 --- a/src/main/java/net/coderbot/iris/gl/shader/ProgramCreator.java +++ b/src/main/java/net/coderbot/iris/gl/shader/ProgramCreator.java @@ -5,6 +5,7 @@ package net.coderbot.iris.gl.shader; import com.gtnewhorizons.angelica.glsm.GLDebug; import com.gtnewhorizons.angelica.glsm.GLStateManager; import com.gtnewhorizons.angelica.glsm.RenderSystem; +import com.gtnewhorizons.angelica.glsm.hooks.ImmediateExtendedAttribHandler; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.lwjgl.opengl.GL11; @@ -15,10 +16,10 @@ public class ProgramCreator { private static final Logger LOGGER = LogManager.getLogger("ProgramCreator"); - public static final int MC_ENTITY = 11; - public static final int MC_MID_TEX_COORD = 12; - public static final int AT_TANGENT = 13; - public static final int AT_MIDBLOCK = 14; + public static final int MC_ENTITY = ImmediateExtendedAttribHandler.LOC_MC_ENTITY; + public static final int MC_MID_TEX_COORD = ImmediateExtendedAttribHandler.LOC_MID_TEX; + public static final int AT_TANGENT = ImmediateExtendedAttribHandler.LOC_TANGENT; + public static final int AT_MIDBLOCK = ImmediateExtendedAttribHandler.LOC_MIDBLOCK; public static int create(String name, GlShader... shaders) { int program = GLStateManager.glCreateProgram(); diff --git a/src/main/java/net/coderbot/iris/layer/GbufferPrograms.java b/src/main/java/net/coderbot/iris/layer/GbufferPrograms.java index cf71a6a4f..8cd20aa34 100644 --- a/src/main/java/net/coderbot/iris/layer/GbufferPrograms.java +++ b/src/main/java/net/coderbot/iris/layer/GbufferPrograms.java @@ -4,6 +4,7 @@ import lombok.Getter; import net.coderbot.iris.Iris; import net.coderbot.iris.gbuffer_overrides.matching.SpecialCondition; import com.gtnewhorizons.angelica.glsm.GLStateManager; +import com.gtnewhorizons.angelica.glsm.ffp.FfpExtendedAttribs; import com.gtnewhorizons.angelica.glsm.states.AlphaState; import com.gtnewhorizons.angelica.glsm.states.BlendState; import net.coderbot.iris.gl.shader.ProgramCreator; @@ -240,8 +241,7 @@ public class GbufferPrograms { public static void setBlockEntityDefaults() { GLStateManager.glVertexAttrib2s(ProgramCreator.MC_ENTITY, (short)-1, (short)-1); - GLStateManager.glVertexAttrib2f(ProgramCreator.MC_MID_TEX_COORD, 0.5f, 0.5f); - GLStateManager.glVertexAttrib4f(ProgramCreator.AT_TANGENT, 1.0f, 0.0f, 0.0f, 1.0f); + FfpExtendedAttribs.setNeutralCurrentValues(); GLStateManager.glVertexAttrib4f(ProgramCreator.AT_MIDBLOCK, 0.0f, 0.0f, 0.0f, 0.0f); } diff --git a/src/main/java/net/coderbot/iris/pipeline/transform/AttributeTransformer.java b/src/main/java/net/coderbot/iris/pipeline/transform/AttributeTransformer.java index ae2b2aa8e..167a9f1ad 100644 --- a/src/main/java/net/coderbot/iris/pipeline/transform/AttributeTransformer.java +++ b/src/main/java/net/coderbot/iris/pipeline/transform/AttributeTransformer.java @@ -87,7 +87,6 @@ class AttributeTransformer { if (instancedVertex) { foldConstantAttribute(transformer, "mc_Entity", "-1.0", "vec2(-1.0, -1.0)", "vec3(-1.0, -1.0, 0.0)", "vec4(-1.0, -1.0, 0.0, 1.0)"); - foldConstantAttribute(transformer, "mc_midTexCoord", "0.5", "vec2(0.5, 0.5)", "vec3(0.5, 0.5, 0.0)", "vec4(0.5, 0.5, 0.0, 1.0)"); final StringBuilder init = new StringBuilder(256); init.append("{ iris_ModelViewMatrix = mat4(iris_InstMat0, iris_InstMat1, iris_InstMat2, iris_InstMat3);"); diff --git a/src/main/java/net/coderbot/iris/pipeline/transform/CoreTransformHelper.java b/src/main/java/net/coderbot/iris/pipeline/transform/CoreTransformHelper.java index 1e9b52015..23bbc0592 100644 --- a/src/main/java/net/coderbot/iris/pipeline/transform/CoreTransformHelper.java +++ b/src/main/java/net/coderbot/iris/pipeline/transform/CoreTransformHelper.java @@ -1,5 +1,6 @@ package net.coderbot.iris.pipeline.transform; +import com.gtnewhorizons.angelica.glsm.ffp.InstancedAttribs; import org.taumc.glsl.Transformer; import java.util.HashMap; @@ -20,12 +21,12 @@ class CoreTransformHelper { static void injectMatrixUniforms(Transformer transformer, boolean instancedVertex) { if (instancedVertex) { - transformer.injectVariable("layout(location = 7) in vec4 iris_InstMat0;"); - transformer.injectVariable("layout(location = 8) in vec4 iris_InstMat1;"); - transformer.injectVariable("layout(location = 9) in vec4 iris_InstMat2;"); - transformer.injectVariable("layout(location = 10) in vec4 iris_InstMat3;"); - transformer.injectVariable("layout(location = 11) in vec4 iris_InstColor;"); - transformer.injectVariable("layout(location = 12) in vec2 iris_InstLightmap;"); + transformer.injectVariable("layout(location = " + InstancedAttribs.LOC_MATRIX_COL0 + ") in vec4 iris_InstMat0;"); + transformer.injectVariable("layout(location = " + InstancedAttribs.LOC_MATRIX_COL1 + ") in vec4 iris_InstMat1;"); + transformer.injectVariable("layout(location = " + InstancedAttribs.LOC_MATRIX_COL2 + ") in vec4 iris_InstMat2;"); + transformer.injectVariable("layout(location = " + InstancedAttribs.LOC_MATRIX_COL3 + ") in vec4 iris_InstMat3;"); + transformer.injectVariable("layout(location = " + InstancedAttribs.LOC_COLOR + ") in vec4 iris_InstColor;"); + transformer.injectVariable("layout(location = " + InstancedAttribs.LOC_LIGHTMAP + ") in vec2 iris_InstLightmap;"); transformer.injectVariable("mat4 iris_ModelViewMatrix;"); transformer.injectVariable("mat4 iris_ModelViewMatrixInverse;"); transformer.injectVariable("mat3 iris_NormalMatrix;"); diff --git a/src/main/java/net/coderbot/iris/texture/pbr/PBRAtlasTexture.java b/src/main/java/net/coderbot/iris/texture/pbr/PBRAtlasTexture.java index 57a5a24fd..501653774 100644 --- a/src/main/java/net/coderbot/iris/texture/pbr/PBRAtlasTexture.java +++ b/src/main/java/net/coderbot/iris/texture/pbr/PBRAtlasTexture.java @@ -89,7 +89,7 @@ public class PBRAtlasTexture extends AutoClosableAbstractTexture { } if (AngelicaConfig.enablePBRDebug) { - TextureExporter.exportTextures("pbr_debug/atlas", id.getResourceDomain() + "_" + id.getResourcePath().replaceAll("/", "_"), glId, mipLevel, atlasWidth, atlasHeight); + TextureExporter.exportTextures("pbr_debug/atlas", id.getResourceDomain() + "_" + id.getResourcePath().replace("/", "_") + ".png", glId, mipLevel, atlasWidth, atlasHeight); } } diff --git a/src/main/java/net/coderbot/iris/texture/pbr/loader/AtlasPBRLoader.java b/src/main/java/net/coderbot/iris/texture/pbr/loader/AtlasPBRLoader.java index 4e3dbf4f1..90104de7d 100644 --- a/src/main/java/net/coderbot/iris/texture/pbr/loader/AtlasPBRLoader.java +++ b/src/main/java/net/coderbot/iris/texture/pbr/loader/AtlasPBRLoader.java @@ -2,10 +2,10 @@ package net.coderbot.iris.texture.pbr.loader; import com.google.common.collect.Lists; import com.gtnewhorizons.angelica.compat.mojang.NativeImage; +import com.gtnewhorizons.angelica.config.AngelicaConfig; import com.gtnewhorizons.angelica.glsm.texture.TextureInfo; import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache; import com.gtnewhorizons.angelica.mixins.interfaces.ISpriteExt; -import me.jellysquid.mods.sodium.client.gui.SodiumGameOptions; import net.coderbot.iris.Iris; import net.coderbot.iris.texture.format.TextureFormat; import net.coderbot.iris.texture.format.TextureFormatLoader; @@ -17,10 +17,13 @@ import net.coderbot.iris.texture.pbr.PBRSpriteHolder; import net.coderbot.iris.texture.pbr.PBRType; import net.coderbot.iris.texture.pbr.TextureAtlasSpriteExtension; import net.coderbot.iris.texture.util.ImageManipulationUtil; +import net.coderbot.iris.texture.util.TextureExporter; import net.minecraft.client.renderer.texture.TextureAtlasSprite; import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.client.renderer.texture.TextureUtil; import net.minecraft.client.resources.IResource; import net.minecraft.client.resources.IResourceManager; +import net.minecraft.client.resources.data.AnimationFrame; import net.minecraft.client.resources.data.AnimationMetadataSection; import net.minecraft.util.ResourceLocation; import org.apache.commons.lang3.tuple.Pair; @@ -28,7 +31,11 @@ import org.apache.commons.lang3.tuple.Pair; import javax.annotation.Nullable; import java.io.FileNotFoundException; import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; import java.util.Collection; +import java.util.List; +import java.util.Objects; public class AtlasPBRLoader implements PBRTextureLoader { public static final ChannelMipmapGenerator LINEAR_MIPMAP_GENERATOR = new ChannelMipmapGenerator( @@ -84,6 +91,45 @@ public class AtlasPBRLoader implements PBRTextureLoader { pbrTextureConsumer.acceptSpecularTexture(specularAtlas); } } + + if (AngelicaConfig.enablePBRDebug && (normalAtlas != null || specularAtlas != null)) { + TextureExporter.exportTextures("pbr_debug/atlas", "base_atlas.png", texMap.getGlTextureId(), mipLevel, atlasWidth, atlasHeight); + } + } + + @Nullable + private static NativeImage padAnisotropic(NativeImage image, int frameWidth, int frameHeight) { + final int width = image.getWidth(); + final int height = image.getHeight(); + final int frames = (frameWidth == width && frameHeight > 0) ? height / frameHeight : 0; + if (frames < 1) { + return null; + } + + final int paddedWidth = frameWidth + 16; + final int paddedHeight = frameHeight + 16; + final int framePixels = paddedWidth * paddedHeight; + + final NativeImage padded = new NativeImage(paddedWidth, paddedHeight * frames, false); + final int[] frame = new int[framePixels]; + for (int f = 0; f < frames; f++) { + Arrays.fill(frame, 0); + image.getRGB(0, f * frameHeight, frameWidth, frameHeight, frame, 0, frameWidth); + TextureUtil.prepareAnisotropicData(frame, frameWidth, frameHeight, 8); + padded.setRGB(0, f * paddedHeight, paddedWidth, paddedHeight, frame, 0, paddedWidth); + } + return padded; + } + + private static AnimationMetadataSection withFrameSize(AnimationMetadataSection src, int frameWidth, int frameHeight) { + final List frames = new ArrayList<>(src.getFrameCount()); + for (int f = 0; f < src.getFrameCount(); f++) { + frames.add(new AnimationFrame(src.getFrameIndex(f), src.frameHasTime(f) ? src.getFrameTimeSingle(f) : -1)); + } + return new AnimationMetadataSection(frames, + src.getFrameWidth() != -1 ? frameWidth : -1, + src.getFrameHeight() != -1 ? frameHeight : -1, + src.getFrameTime()); } protected static int fetchAtlasMipLevel(TextureMap texMap) { @@ -104,18 +150,15 @@ public class AtlasPBRLoader implements PBRTextureLoader { NativeImage nativeImage = NativeImage.read(resource.getInputStream()); AnimationMetadataSection animationMetadata = (AnimationMetadataSection) resource.getMetadata("animation"); if (animationMetadata == null) { - final IResource resourceOriginal = resourceManager.getResource(imageLocation); - animationMetadata = (AnimationMetadataSection) resourceOriginal.getMetadata("animation"); - if (animationMetadata == null) { - animationMetadata = new AnimationMetadataSection(Lists.newArrayList(), -1, -1, -1); - } + animationMetadata = new AnimationMetadataSection(Lists.newArrayList(), -1, -1, -1); } final Pair frameSize = this.getFrameSize(nativeImage.getWidth(), nativeImage.getHeight(), animationMetadata); int frameWidth = frameSize.getLeft(); int frameHeight = frameSize.getRight(); - final int targetFrameWidth = sprite.getIconWidth(); - final int targetFrameHeight = sprite.getIconHeight(); + final int spritePadding = sprite.useAnisotropicFiltering ? 16 : 0; + final int targetFrameWidth = sprite.getIconWidth() - spritePadding; + final int targetFrameHeight = sprite.getIconHeight() - spritePadding; if (frameWidth != targetFrameWidth || frameHeight != targetFrameHeight) { final int imageWidth = nativeImage.getWidth(); final int imageHeight = nativeImage.getHeight(); @@ -139,15 +182,8 @@ public class AtlasPBRLoader implements PBRTextureLoader { frameWidth = targetFrameWidth; frameHeight = targetFrameHeight; - if (!animationMetadata.equals(new AnimationMetadataSection(Lists.newArrayList(), -1, -1, -1))) { - final int internalFrameWidth = animationMetadata.frameHeight; - final int internalFrameHeight = animationMetadata.frameWidth; - if (internalFrameWidth != -1) { - animationMetadata.frameWidth = frameWidth; - } - if (internalFrameHeight != -1) { - animationMetadata.frameHeight = frameHeight; - } + if (animationMetadata.getFrameWidth() != -1 || animationMetadata.getFrameHeight() != -1) { + animationMetadata = withFrameSize(animationMetadata, frameWidth, frameHeight); } } @@ -156,7 +192,15 @@ public class AtlasPBRLoader implements PBRTextureLoader { final int x = sprite.getOriginX(); final int y = sprite.getOriginY(); - pbrSprite = new PBRTextureAtlasSprite(pbrSpriteInfo, animationMetadata, atlasWidth, atlasHeight, x, y, nativeImage, texMap, mipLevel); + boolean padInLoadSprite = sprite.useAnisotropicFiltering; + if (padInLoadSprite) { + final NativeImage padded = padAnisotropic(nativeImage, frameWidth, frameHeight); + if (padded != null) { + nativeImage = padded; + padInLoadSprite = false; + } + } + pbrSprite = new PBRTextureAtlasSprite(pbrSpriteInfo, animationMetadata, atlasWidth, atlasHeight, x, y, nativeImage, padInLoadSprite, mipLevel); syncAnimation(sprite, pbrSprite); } catch (FileNotFoundException e) { // @@ -217,12 +261,10 @@ public class AtlasPBRLoader implements PBRTextureLoader { public static class PBRTextureAtlasSprite extends TextureAtlasSprite implements CustomMipmapGenerator.Provider { // This feels super janky - protected PBRTextureAtlasSprite(TextureAtlasSpriteInfo info, AnimationMetadataSection animationMetaDataSection, int atlasWidth, int atlasHeight, int x, int y, NativeImage nativeImage, TextureMap texMap, int miplevel) { + protected PBRTextureAtlasSprite(TextureAtlasSpriteInfo info, AnimationMetadataSection animationMetaDataSection, int atlasWidth, int atlasHeight, int x, int y, NativeImage nativeImage, boolean useAnisotropicFiltering, int miplevel) { super(info.name().toString()); + super.loadSprite(Objects.requireNonNull(getMipmapGenerator(info, atlasWidth, atlasHeight)).generateMipLevels(nativeImage, miplevel), animationMetaDataSection, useAnisotropicFiltering); super.initSprite(atlasWidth, atlasHeight, x, y, false); - final boolean useAnisotropicFiltering = texMap.anisotropicFiltering > 1 - || SodiumGameOptions.needsForcedSpritePadding(); - super.loadSprite(getMipmapGenerator(info, atlasWidth, atlasHeight).generateMipLevels(nativeImage, miplevel), animationMetaDataSection, useAnisotropicFiltering); } @Override diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/startup/MixinInitGLStateManager.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/startup/MixinInitGLStateManager.java index 2b2ec27ac..730b2226f 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/startup/MixinInitGLStateManager.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/startup/MixinInitGLStateManager.java @@ -9,6 +9,7 @@ import com.gtnewhorizons.angelica.glsm.streaming.TessellatorStreamingDrawer; import com.gtnewhorizons.angelica.compat.DriverCompatabilityCheck; import com.gtnewhorizons.angelica.glsm.GLStateManager; import com.gtnewhorizons.angelica.glsm.backend.BackendManager; +import com.gtnewhorizons.angelica.glsm.hooks.GLSMConfig; import com.gtnewhorizons.angelica.glsm.hooks.GLSMHooks; import com.gtnewhorizons.angelica.glsm.hooks.GLSMInitConfig; import com.gtnewhorizons.angelica.proxy.ClientProxy; @@ -51,6 +52,8 @@ public class MixinInitGLStateManager { .postInitCallback(SelectionBoxRenderer::init) .build()); + GLSMConfig.extendedAttribsExpected = AngelicaConfig.enableIris; + GLSMHooks.LIGHTMAP_COORDS.addListener(event -> { OpenGlHelper.lastBrightnessX = event.x; OpenGlHelper.lastBrightnessY = event.y; diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/shaders/MixinTextureManager_ReloadCount.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/shaders/MixinTextureManager_ReloadCount.java index 21fcbd94f..2da91a818 100644 --- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/shaders/MixinTextureManager_ReloadCount.java +++ b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/shaders/MixinTextureManager_ReloadCount.java @@ -1,5 +1,8 @@ package com.gtnewhorizons.angelica.mixins.early.shaders; +import net.coderbot.iris.Iris; +import net.coderbot.iris.texture.format.TextureFormatLoader; +import net.coderbot.iris.texture.pbr.PBRTextureManager; import net.coderbot.iris.uniforms.CapturedRenderingState; import net.minecraft.client.renderer.texture.TextureManager; import net.minecraft.client.resources.IResourceManager; @@ -9,13 +12,19 @@ import org.spongepowered.asm.mixin.injection.Inject; import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; /** - * Hook into TextureManger to increment the reload count. + * Hook into TextureManger to reload the PBR texture format and increment the reload count. */ @Mixin(TextureManager.class) public class MixinTextureManager_ReloadCount { @Inject(method = "onResourceManagerReload", at = @At("TAIL")) private void angelica$bumpTextureReloadCount(IResourceManager resourceManager, CallbackInfo ci) { + try { + TextureFormatLoader.reload(resourceManager); + } catch (Exception e) { + Iris.logger.error("Failed to reload the shader pipeline for a texture format change", e); + } + PBRTextureManager.INSTANCE.clear(); CapturedRenderingState.INSTANCE.incrementTextureReloadCount(); } } diff --git a/src/test/java/com/gtnewhorizons/angelica/rendering/VertexAttributeLayoutTest.java b/src/test/java/com/gtnewhorizons/angelica/rendering/VertexAttributeLayoutTest.java new file mode 100644 index 000000000..aa37cda14 --- /dev/null +++ b/src/test/java/com/gtnewhorizons/angelica/rendering/VertexAttributeLayoutTest.java @@ -0,0 +1,74 @@ +package com.gtnewhorizons.angelica.rendering; + +import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormatElement; +import com.gtnewhorizons.angelica.glsm.ffp.InstancedAttribs; +import net.coderbot.iris.gl.shader.ProgramCreator; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; +import java.util.Map; +import java.util.TreeSet; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Make sure we don't ever have collisions again, that was annoying. + */ +class VertexAttributeLayoutTest { + + private static final int MAX_VERTEX_ATTRIBS = 16; + + private final Map claimed = new HashMap<>(); + + private void claim(int location, String owner) { + assertTrue(location >= 0 && location < MAX_VERTEX_ATTRIBS, + owner + " uses location " + location + ", outside 0.." + (MAX_VERTEX_ATTRIBS - 1)); + final String previous = claimed.put(location, owner); + assertNull(previous, "location " + location + " claimed by both " + previous + " and " + owner); + } + + @Test + void reservedAttributeLocationsDoNotOverlap() { + for (VertexFormatElement.Usage usage : VertexFormatElement.Usage.values()) { + final int loc = usage.getAttributeLocation(); + if (loc < 0) continue; + claim(loc, "vertex format " + usage.name()); + } + + claim(InstancedAttribs.LOC_MATRIX_COL0, "InstancedAttribs.LOC_MATRIX_COL0"); + claim(InstancedAttribs.LOC_MATRIX_COL1, "InstancedAttribs.LOC_MATRIX_COL1"); + claim(InstancedAttribs.LOC_MATRIX_COL2, "InstancedAttribs.LOC_MATRIX_COL2"); + claim(InstancedAttribs.LOC_MATRIX_COL3, "InstancedAttribs.LOC_MATRIX_COL3"); + claim(InstancedAttribs.LOC_COLOR, "InstancedAttribs.LOC_COLOR"); + claim(InstancedAttribs.LOC_LIGHTMAP, "InstancedAttribs.LOC_LIGHTMAP"); + + claim(ProgramCreator.MC_ENTITY, "ProgramCreator.MC_ENTITY"); + claim(ProgramCreator.MC_MID_TEX_COORD, "ProgramCreator.MC_MID_TEX_COORD"); + claim(ProgramCreator.AT_TANGENT, "ProgramCreator.AT_TANGENT"); + claim(ProgramCreator.AT_MIDBLOCK, "ProgramCreator.AT_MIDBLOCK"); + } + + @Test + void instancedMatrixColumnsAreContiguous() { + final int[] columns = { + InstancedAttribs.LOC_MATRIX_COL0, InstancedAttribs.LOC_MATRIX_COL1, + InstancedAttribs.LOC_MATRIX_COL2, InstancedAttribs.LOC_MATRIX_COL3 + }; + for (int c = 1; c < columns.length; c++) { + assertEquals(columns[0] + c, columns[c], + "instance matrix column " + c + " must sit at LOC_MATRIX_COL0 + " + c); + } + } + + @Test + void reportsRemainingFreeLocations() { + reservedAttributeLocationsDoNotOverlap(); + final TreeSet free = new TreeSet<>(); + for (int i = 0; i < MAX_VERTEX_ATTRIBS; i++) { + if (!claimed.containsKey(i)) free.add(i); + } + System.out.println("free vertex attribute locations: " + free); + } +} diff --git a/src/test/java/net/coderbot/iris/pipeline/transform/AttributeTransformerInstancedTest.java b/src/test/java/net/coderbot/iris/pipeline/transform/AttributeTransformerInstancedTest.java index 567746033..e534d6117 100644 --- a/src/test/java/net/coderbot/iris/pipeline/transform/AttributeTransformerInstancedTest.java +++ b/src/test/java/net/coderbot/iris/pipeline/transform/AttributeTransformerInstancedTest.java @@ -1,5 +1,11 @@ package net.coderbot.iris.pipeline.transform; +import static org.junit.jupiter.api.Assertions.assertNull; +import java.util.HashMap; +import java.util.regex.Pattern; +import java.util.regex.Matcher; +import net.coderbot.iris.gl.shader.ProgramCreator; +import com.gtnewhorizons.angelica.glsm.ffp.InstancedAttribs; import com.gtnewhorizons.angelica.glsm.RenderSystem; import com.gtnewhorizons.angelica.glsm.testutil.Reflect; import net.coderbot.iris.gbuffer_overrides.matching.InputAvailability; @@ -93,15 +99,29 @@ class AttributeTransformerInstancedTest { return squash(shader).indexOf(squash(snippet)); } + @Test + void generatedInstancedShaderHasNoOverlappingAttributeLocations() { + final String v = instancedVertex(VERTEX); + final Matcher m = Pattern.compile("layout\\s*\\(\\s*location\\s*=\\s*(\\d+)\\s*\\)\\s*in\\s+\\w+\\s+(\\w+)").matcher(v); + final Map byLocation = new HashMap<>(); + while (m.find()) { + final int loc = Integer.parseInt(m.group(1)); + final String name = m.group(2); + final String previous = byLocation.put(loc, name); + assertNull(previous, "location " + loc + " declared twice: " + previous + " and " + name); + } + assertFalse(byLocation.isEmpty(), "expected the instanced variant to declare attribute locations"); + } + @Test void declaresInstanceAttribsAndGlobalMatrices() { final String v = instancedVertex(VERTEX); - assertHas(v, "layout(location = 7) in vec4 iris_InstMat0"); - assertHas(v, "layout(location = 8) in vec4 iris_InstMat1"); - assertHas(v, "layout(location = 9) in vec4 iris_InstMat2"); - assertHas(v, "layout(location = 10) in vec4 iris_InstMat3"); - assertHas(v, "layout(location = 11) in vec4 iris_InstColor"); - assertHas(v, "layout(location = 12) in vec2 iris_InstLightmap"); + assertHas(v, "layout(location = " + InstancedAttribs.LOC_MATRIX_COL0 + ") in vec4 iris_InstMat0"); + assertHas(v, "layout(location = " + InstancedAttribs.LOC_MATRIX_COL1 + ") in vec4 iris_InstMat1"); + assertHas(v, "layout(location = " + InstancedAttribs.LOC_MATRIX_COL2 + ") in vec4 iris_InstMat2"); + assertHas(v, "layout(location = " + InstancedAttribs.LOC_MATRIX_COL3 + ") in vec4 iris_InstMat3"); + assertHas(v, "layout(location = " + InstancedAttribs.LOC_COLOR + ") in vec4 iris_InstColor"); + assertHas(v, "layout(location = " + InstancedAttribs.LOC_LIGHTMAP + ") in vec2 iris_InstLightmap"); assertLacks(v, "uniform mat4 iris_ModelViewMatrix;"); assertLacks(v, "uniform mat3 iris_NormalMatrix;"); assertHas(v, "mat4 iris_ModelViewMatrix;"); @@ -123,12 +143,12 @@ class AttributeTransformerInstancedTest { } @Test - void foldsEntityAndMidTexCoordAttributes() { + void foldsEntityAttributeButKeepsMidTexCoord() { final String v = instancedVertex(VERTEX); assertLacks(v, "mc_Entity"); - assertLacks(v, "mc_midTexCoord"); assertHas(v, "vec4(-1.0, -1.0, 0.0, 1.0)"); - assertHas(v, "vec4(0.5, 0.5, 0.0, 1.0)"); + assertHas(v, "mc_midTexCoord"); + assertLacks(v, "vec4(0.5, 0.5, 0.0, 1.0)"); } @Test