diff --git a/src/main/java/com/gtnewhorizons/angelica/compat/lwjgl/CompatMemoryUtil.java b/src/main/java/com/gtnewhorizons/angelica/compat/lwjgl/CompatMemoryUtil.java index 6b311ca88..9d027f736 100644 --- a/src/main/java/com/gtnewhorizons/angelica/compat/lwjgl/CompatMemoryUtil.java +++ b/src/main/java/com/gtnewhorizons/angelica/compat/lwjgl/CompatMemoryUtil.java @@ -1,12 +1,58 @@ package com.gtnewhorizons.angelica.compat.lwjgl; -import org.lwjgl.BufferUtils; +import static com.gtnewhorizons.angelica.compat.lwjgl.Pointer.BITS64; +import it.unimi.dsi.fastutil.longs.LongPredicate; +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; import java.nio.ByteBuffer; +import java.nio.ByteOrder; import java.nio.FloatBuffer; import java.nio.IntBuffer; +import org.lwjgl.BufferUtils; +/** + * Backported from LWJGL3 under the BSD 3-Clause "New" or "Revised" License license + * + *

This class provides functionality for managing native memory. + * + *

All methods in this class will make use of {@link sun.misc.Unsafe} if it's available, for performance. If Unsafe is not available, the fallback + * implementations make use of reflection and, in the worst-case, JNI.

+ * + *

Method names in this class are prefixed with {@code mem} to avoid ambiguities when used with static imports.

+ */ public class CompatMemoryUtil { + public static final long NULL = 0; + + static final sun.misc.Unsafe UNSAFE; + + private static final Class BUFFER_BYTE; + private static final Class BUFFER_INT; + private static final Class BUFFER_FLOAT; + + private static final long MARK; + private static final long POSITION; + private static final long LIMIT; + private static final long CAPACITY; + + private static final long ADDRESS; + + static { + ByteBuffer bb = ByteBuffer.allocateDirect(0).order(ByteOrder.nativeOrder()); + BUFFER_BYTE = bb.getClass(); + BUFFER_INT = bb.asIntBuffer().getClass(); + BUFFER_FLOAT = bb.asFloatBuffer().getClass(); + + UNSAFE = getUnsafeInstance(); + + MARK = getMarkOffset(); + POSITION = getPositionOffset(); + LIMIT = getLimitOffset(); + CAPACITY = getCapacityOffset(); + + ADDRESS = getAddressOffset(); + } + public static ByteBuffer memReallocDirect(ByteBuffer old, int capacity) { ByteBuffer newBuf = BufferUtils.createByteBuffer(capacity); int oldPos = old.position(); @@ -34,22 +80,100 @@ public class CompatMemoryUtil { return newBuf; } + /* ------------------------------------- + ------------------------------------- + UNSAFE MEMORY ACCESS API + ------------------------------------- + ------------------------------------- */ + + private static final int FILL_PATTERN_32 = Integer.divideUnsigned(-1, 255); + private static final long FILL_PATTERN_64 = Long.divideUnsigned(-1L, 255L); + /** - * Backported from LWJGL3 under the BSD 3-Clause "New" or "Revised" License license + * Sets all bytes in a specified block of memory to a fixed value (usually zero). * - *

This class provides functionality for managing native memory. - * - *

All methods in this class will make use of {@link sun.misc.Unsafe} if it's available, for performance. If Unsafe is not available, the fallback - * implementations make use of reflection and, in the worst-case, JNI.

- * - *

Method names in this class are prefixed with {@code mem} to avoid ambiguities when used with static imports.

+ * @param ptr the starting memory address + * @param value the value to set (memSet will convert it to unsigned byte) + * @param bytes the number of bytes to set */ + public static void memSet(long ptr, int value, long bytes) { + if (/*DEBUG*/ false && (ptr == NULL || bytes < 0)) { + throw new IllegalArgumentException(); + } - static final sun.misc.Unsafe UNSAFE; + /* + - Unsafe.setMemory is very slow. + - A custom Java loop is fastest at small sizes, approximately up to 256 bytes. + - The native memset becomes fastest at bigger sizes, when the JNI overhead becomes negligible. + TODO: verify this + */ - static { - UNSAFE = getUnsafeInstance(); + //UNSAFE.setMemory(ptr, bytes, (byte)(value & 0xFF)); + //if (bytes < 256L) { + int p = (int)ptr; + if (BITS64) { + if ((p & 7) == 0) { + memSet64(ptr, value, (int)bytes & 0xFF); + return; + } + } else { + if ((p & 3) == 0) { + memSet32(p, value, (int)bytes & 0xFF); + return; + } + } + //} + //nmemset(ptr, value, bytes); } + private static void memSet64(long ptr, int value, int bytes) { + int aligned = bytes & ~7; + + // Aligned body + long valuel = (value & 0xFF) * FILL_PATTERN_64; + for (int i = 0; i < aligned; i += 8) { + UNSAFE.putLong(null, ptr + i, valuel); + } + + // Unaligned tail + byte valueb = (byte)(value & 0xFF); + for (int i = aligned; i < bytes; i++) { + UNSAFE.putByte(null, ptr + i, valueb); + } + } + private static void memSet32(int ptr, int value, int bytes) { + int aligned = bytes & ~3; + + // Aligned body + int vi = (value & 0xFF) * FILL_PATTERN_32; + for (int i = 0; i < aligned; i += 4) { + UNSAFE.putInt(null, (ptr + i) & 0xFFFF_FFFFL, vi); + } + + // Unaligned tail + byte vb = (byte)(value & 0xFF); + for (int i = aligned; i < bytes; i++) { + UNSAFE.putByte(null, (ptr + i) & 0xFFFF_FFFFL, vb); + } + } + + public static boolean memGetBoolean(long ptr) { return UNSAFE.getByte(null, ptr) != 0; } + public static byte memGetByte(long ptr) { return UNSAFE.getByte(null, ptr); } + public static short memGetShort(long ptr) { return UNSAFE.getShort(null, ptr); } + public static int memGetInt(long ptr) { return UNSAFE.getInt(null, ptr); } + public static long memGetLong(long ptr) { return UNSAFE.getLong(null, ptr); } + public static float memGetFloat(long ptr) { return UNSAFE.getFloat(null, ptr); } + public static double memGetDouble(long ptr) { return UNSAFE.getDouble(null, ptr); } + + public static void memPutByte(long ptr, byte value) { UNSAFE.putByte(null, ptr, value); } + public static void memPutShort(long ptr, short value) { UNSAFE.putShort(null, ptr, value); } + public static void memPutInt(long ptr, int value) { UNSAFE.putInt(null, ptr, value); } + public static void memPutLong(long ptr, long value) { UNSAFE.putLong(null, ptr, value); } + public static void memPutFloat(long ptr, float value) { UNSAFE.putFloat(null, ptr, value); } + public static void memPutDouble(long ptr, double value) { UNSAFE.putDouble(null, ptr, value); } + + // ------------------------------------------------- + // ------------------------------------------------- + // ------------------------------------------------- private static sun.misc.Unsafe getUnsafeInstance() { java.lang.reflect.Field[] fields = sun.misc.Unsafe.class.getDeclaredFields(); @@ -83,20 +207,121 @@ public class CompatMemoryUtil { throw new UnsupportedOperationException("LWJGL requires sun.misc.Unsafe to be available."); } + /** + * Recursively searches an object and its superclasses for a field with the same name and type. If the field isn't + * public, it may not be stable across library/JVM versions, and these calls are likely not portable. You have been + * warned! + */ + private static long getFieldOffset(Class containerType, Class fieldType, String name) { + Class c = containerType; + while (c != Object.class) { + Field[] fields = c.getDeclaredFields(); + for (Field field : fields) { + if (!field.getType().isAssignableFrom(fieldType) || Modifier.isStatic(field.getModifiers()) || field.isSynthetic()) { + continue; + } - public static void memPutByte(long ptr, byte value) { UNSAFE.putByte(null, ptr, value); } - public static void memPutShort(long ptr, short value) { UNSAFE.putShort(null, ptr, value); } - public static void memPutInt(long ptr, int value) { UNSAFE.putInt(null, ptr, value); } - public static void memPutLong(long ptr, long value) { UNSAFE.putLong(null, ptr, value); } - public static void memPutFloat(long ptr, float value) { UNSAFE.putFloat(null, ptr, value); } - public static void memPutDouble(long ptr, double value) { UNSAFE.putDouble(null, ptr, value); } + long offset = UNSAFE.objectFieldOffset(field); + if (field.getName().equals(name)) { + return offset; + } + } + c = c.getSuperclass(); + } + throw new UnsupportedOperationException("Failed to find field offset in class."); + } - public static boolean memGetBoolean(long ptr) { return UNSAFE.getByte(null, ptr) != 0; } - public static byte memGetByte(long ptr) { return UNSAFE.getByte(null, ptr); } - public static short memGetShort(long ptr) { return UNSAFE.getShort(null, ptr); } - public static int memGetInt(long ptr) { return UNSAFE.getInt(null, ptr); } - public static long memGetLong(long ptr) { return UNSAFE.getLong(null, ptr); } - public static float memGetFloat(long ptr) { return UNSAFE.getFloat(null, ptr); } - public static double memGetDouble(long ptr) { return UNSAFE.getDouble(null, ptr); } + private static long getFieldOffset(Class containerType, Class fieldType, LongPredicate predicate) { + Class c = containerType; + while (c != Object.class) { + Field[] fields = c.getDeclaredFields(); + for (Field field : fields) { + if (!field.getType().isAssignableFrom(fieldType) || Modifier.isStatic(field.getModifiers()) || field.isSynthetic()) { + continue; + } + long offset = UNSAFE.objectFieldOffset(field); + if (predicate.test(offset)) { + return offset; + } + } + c = c.getSuperclass(); + } + throw new UnsupportedOperationException("Failed to find field offset in class."); + } + + private static long getFieldOffsetInt(Object container, int value) { + return getFieldOffset(container.getClass(), int.class, offset -> UNSAFE.getInt(container, offset) == value); + } + + private static long getAddressOffset() { + final ByteBuffer bb = ByteBuffer.allocateDirect(0); + return getFieldOffset(bb.getClass(), long.class, "address"); + + // TODO: do this portably + // long MAGIC_ADDRESS = 0xDEADBEEF8BADF00DL & (BITS32 ? 0xFFFF_FFFFL : 0xFFFF_FFFF_FFFF_FFFFL); + // ByteBuffer bb = Objects.requireNonNull(NewDirectByteBuffer(MAGIC_ADDRESS, 0)); + //return getFieldOffset(bb.getClass(), long.class, offset -> UNSAFE.getLong(bb, offset) == MAGIC_ADDRESS); + } + + private static final int MAGIC_CAPACITY = 0x0D15EA5E; + private static final int MAGIC_POSITION = 0x00FACADE; + + private static long getMarkOffset() { + // TODO: is this actually reliable without NewDirectByteBuffer? + ByteBuffer bb = ByteBuffer.allocateDirect(0); + return getFieldOffsetInt(bb, -1); + // ByteBuffer bb = Objects.requireNonNull(NewDirectByteBuffer(1L, 0)); + // return getFieldOffsetInt(bb, -1); + } + + private static long getPositionOffset() { + ByteBuffer bb = ByteBuffer.allocateDirect(MAGIC_CAPACITY); + bb.position(MAGIC_POSITION); + return getFieldOffsetInt(bb, MAGIC_POSITION); + } + + private static long getLimitOffset() { + ByteBuffer bb = ByteBuffer.allocateDirect(MAGIC_CAPACITY); + bb.limit(MAGIC_POSITION); + return getFieldOffsetInt(bb, MAGIC_POSITION); + } + + private static long getCapacityOffset() { + ByteBuffer bb = ByteBuffer.allocateDirect(MAGIC_CAPACITY); + bb.limit(0); + return getFieldOffsetInt(bb, MAGIC_CAPACITY); + } + + static IntBuffer wrapBufferInt(long address, int capacity) { + IntBuffer buffer; + try { + buffer = (IntBuffer)UNSAFE.allocateInstance(BUFFER_INT); + } catch (InstantiationException e) { + throw new UnsupportedOperationException(e); + } + + UNSAFE.putLong(buffer, ADDRESS, address); + UNSAFE.putInt(buffer, MARK, -1); + UNSAFE.putInt(buffer, LIMIT, capacity); + UNSAFE.putInt(buffer, CAPACITY, capacity); + + return buffer; + } + + static FloatBuffer wrapBufferFloat(long address, int capacity) { + FloatBuffer buffer; + try { + buffer = (FloatBuffer)UNSAFE.allocateInstance(BUFFER_FLOAT); + } catch (InstantiationException e) { + throw new UnsupportedOperationException(e); + } + + UNSAFE.putLong(buffer, ADDRESS, address); + UNSAFE.putInt(buffer, MARK, -1); + UNSAFE.putInt(buffer, LIMIT, capacity); + UNSAFE.putInt(buffer, CAPACITY, capacity); + + return buffer; + } } diff --git a/src/main/java/com/gtnewhorizons/angelica/compat/lwjgl/MemoryStack.java b/src/main/java/com/gtnewhorizons/angelica/compat/lwjgl/MemoryStack.java new file mode 100644 index 000000000..28180d803 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/compat/lwjgl/MemoryStack.java @@ -0,0 +1,382 @@ +/* + * This class is backported from LWJGL3 under the BSD 3-clause "New" or "Revised" License + */ + +package com.gtnewhorizons.angelica.compat.lwjgl; + + +import static com.gtnewhorizons.angelica.compat.lwjgl.CompatMemoryUtil.memPutDouble; +import static com.gtnewhorizons.angelica.compat.lwjgl.CompatMemoryUtil.memPutFloat; +import static com.gtnewhorizons.angelica.compat.lwjgl.CompatMemoryUtil.memPutInt; +import static com.gtnewhorizons.angelica.compat.lwjgl.CompatMemoryUtil.memPutLong; +import static com.gtnewhorizons.angelica.compat.lwjgl.CompatMemoryUtil.memPutShort; +import static com.gtnewhorizons.angelica.compat.lwjgl.CompatMemoryUtil.memSet; +import static com.gtnewhorizons.angelica.compat.lwjgl.CompatMemoryUtil.wrapBufferFloat; +import static com.gtnewhorizons.angelica.compat.lwjgl.CompatMemoryUtil.wrapBufferInt; + +import com.gtnewhorizons.angelica.loading.AngelicaTweaker; +import java.nio.ByteBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.util.Arrays; +import org.jetbrains.annotations.Nullable; +import org.lwjgl.BufferUtils; +import org.lwjgl.MemoryUtil; + +/** + * An off-heap memory stack. + * + *

This class should be used in a thread-local manner for stack allocations.

+ * + * @ see Configuration#STACK_SIZE + * @ see Configuration#DEBUG_STACK + */ +@SuppressWarnings("LombokGetterMayBeUsed") +public class MemoryStack extends Pointer.Default implements AutoCloseable { + + private static final int DEFAULT_STACK_SIZE = /*Configuration.STACK_SIZE.get(64)*/ 64 * 1024; + private static final int DEFAULT_STACK_FRAMES = 8; + + private static final ThreadLocal TLS = ThreadLocal.withInitial(MemoryStack::create); + + static { + if (DEFAULT_STACK_SIZE < 0) { + throw new IllegalStateException("Invalid stack size."); + } + } + + @SuppressWarnings({"FieldCanBeLocal", "unused"}) + private final @Nullable ByteBuffer container; + + private final int size; + + private int pointer; + + private int[] frames; + protected int frameIndex; + + /** + * Creates a new {@code MemoryStack} backed by the specified memory region. + * + *

In the initial state, there is no active stack frame. The {@link #push} method must be used before any allocations.

+ * + * @param container the backing memory buffer, may be null + * @param address the backing memory address + * @param size the backing memory size + */ + protected MemoryStack(@Nullable ByteBuffer container, long address, int size) { + super(address); + this.container = container; + + this.size = size; + this.pointer = size; + + this.frames = new int[DEFAULT_STACK_FRAMES]; + } + + /** + * Creates a new {@code MemoryStack} with the default size. + * + *

In the initial state, there is no active stack frame. The {@link #push} method must be used before any allocations.

+ */ + public static MemoryStack create() { + return create(DEFAULT_STACK_SIZE); + } + + /** + * Creates a new {@code MemoryStack} with the specified size. + * + *

In the initial state, there is no active stack frame. The {@link #push} method must be used before any allocations.

+ * + * @param capacity the maximum number of bytes that may be allocated on the stack + */ + public static MemoryStack create(int capacity) { + return create(BufferUtils.createByteBuffer(capacity)); + } + + /** + * Creates a new {@code MemoryStack} backed by the specified memory buffer. + * + *

In the initial state, there is no active stack frame. The {@link #push} method must be used before any allocations.

+ * + * @param buffer the backing memory buffer + */ + public static MemoryStack create(ByteBuffer buffer) { + long address = MemoryUtil.getAddress(buffer); + int size = buffer.remaining(); + return new MemoryStack(buffer, address, size); + } + + /** + * Creates a new {@code MemoryStack} backed by the specified memory region. + * + *

In the initial state, there is no active stack frame. The {@link #push} method must be used before any allocations.

+ * + * @param address the backing memory address + * @param size the backing memory size + */ + public static MemoryStack ncreate(long address, int size) { + return new MemoryStack(null, address, size); + } + + /** + * Stores the current stack pointer and pushes a new frame to the stack. + * + *

This method should be called when entering a method, before doing any stack allocations. When exiting a method, call the {@link #pop} method to + * restore the previous stack frame.

+ * + *

Pairs of push/pop calls may be nested. Care must be taken to:

+ * + * + * @return this stack + */ + public MemoryStack push() { + if (frameIndex == frames.length) { + frameOverflow(); + } + + frames[frameIndex++] = pointer; + return this; + } + + private void frameOverflow() { + if (/*DEBUG*/ false) { + AngelicaTweaker.LOGGER.warn("[WARNING] Out of frame stack space (" + frames.length + ") in thread: " + Thread.currentThread()); + } + frames = Arrays.copyOf(frames, frames.length * 3 / 2); + } + + /** + * Pops the current stack frame and moves the stack pointer to the end of the previous stack frame. + * + * @return this stack + */ + public MemoryStack pop() { + pointer = frames[--frameIndex]; + return this; + } + + /** + * Calls {@link #pop} on this {@code MemoryStack}. + * + *

This method should not be used directly. It is called automatically when the {@code MemoryStack} is used as a resource in a try-with-resources + * statement.

+ */ + @Override + public void close() { + //noinspection resource + pop(); + } + + /** + * Returns the address of the backing off-heap memory. + * + *

The stack grows "downwards", so the bottom of the stack is at {@code address + size}, while the top is at {@code address}.

+ */ + public long getAddress() { + return address; + } + + /** + * Returns the size of the backing off-heap memory. + * + *

This is the maximum number of bytes that may be allocated on the stack.

+ */ + public int getSize() { + return size; + } + + /** + * Returns the current frame index. + * + *

This is the current number of nested {@link #push} calls.

+ */ + public int getFrameIndex() { + return frameIndex; + } + + /** Returns the memory address at the current stack pointer. */ + public long getPointerAddress() { + return address + (pointer & 0xFFFF_FFFFL); + } + + /** + * Returns the current stack pointer. + * + *

The stack grows "downwards", so when the stack is empty {@code pointer} is equal to {@code size}. On every allocation {@code pointer} is reduced by + * the allocated size (after alignment) and {@code address + pointer} points to the first byte of the last allocation.

+ * + *

Effectively, this methods returns how many more bytes may be allocated on the stack.

+ */ + public int getPointer() { + return pointer; + } + + /** + * Sets the current stack pointer. + * + *

This method directly manipulates the stack pointer. Using it irresponsibly may break the internal state of the stack. It should only be used in rare + * cases or in auto-generated code.

+ */ + public void setPointer(int pointer) { + if (/*CHECKS*/ false) { + checkPointer(pointer); + } + + this.pointer = pointer; + } + + private void checkPointer(int pointer) { + if (pointer < 0 || size < pointer) { + throw new IndexOutOfBoundsException("Invalid stack pointer"); + } + } + + private static void checkAlignment(int alignment) { + if (Integer.bitCount(alignment) != 1) { + throw new IllegalArgumentException("Alignment must be a power-of-two value."); + } + } + + /** + * Calls {@link #nmalloc(int, int)} with {@code alignment} equal to {@link Pointer#POINTER_SIZE POINTER_SIZE}. + * + * @param size the allocation size + * + * @return the memory address on the stack for the requested allocation + */ + public long nmalloc(int size) { + return nmalloc(POINTER_SIZE, size); + } + + /** + * Allocates a block of {@code size} bytes of memory on the stack. The content of the newly allocated block of memory is not initialized, remaining with + * indeterminate values. + * + * @param alignment the required alignment + * @param size the allocation size + * + * @return the memory address on the stack for the requested allocation + */ + public long nmalloc(int alignment, int size) { + // Align address to the specified alignment + long address = (this.address + pointer - size) & ~Integer.toUnsignedLong(alignment - 1); + + pointer = (int)(address - this.address); + if (/*CHECKS*/ false && pointer < 0) { + throw new OutOfMemoryError("Out of stack space."); + } + + return address; + } + + /** + * Allocates a block of memory on the stack for an array of {@code num} elements, each of them {@code size} bytes long, and initializes all its bits to + * zero. + * + * @param alignment the required element alignment + * @param num num the number of elements to allocate + * @param size the size of each element + * + * @return the memory address on the stack for the requested allocation + */ + public long ncalloc(int alignment, int num, int size) { + int bytes = num * size; + long address = nmalloc(alignment, bytes); + memSet(address, 0, bytes); + return address; + } + + // ------------------------------------------------- + + /** Unsafe version of {@link #shorts(short)}. */ + public long nshort(short value) { + long a = nmalloc(2, 2); + memPutShort(a, value); + return a; + } + + // ------------------------------------------------- + + /** Int version of {@link #malloc(int)}. */ + public IntBuffer mallocInt(int size) { return wrapBufferInt(nmalloc(4, size << 2), size); } + + /** Unsafe version of {@link #ints(int)}. */ + public long nint(int value) { + long a = nmalloc(4, 4); + memPutInt(a, value); + return a; + } + + // ------------------------------------------------- + + /** Unsafe version of {@link #longs(long)}. */ + public long nlong(long value) { + long a = nmalloc(8, 8); + memPutLong(a, value); + return a; + } + + // ------------------------------------------------- + + /** Float version of {@link #malloc(int)}. */ + public FloatBuffer mallocFloat(int size) { return wrapBufferFloat(nmalloc(4, size << 2), size); } + + /** Unsafe version of {@link #floats(float)}. */ + public long nfloat(float value) { + long a = nmalloc(4, 4); + memPutFloat(a, value); + return a; + } + + // ------------------------------------------------- + + /** Unsafe version of {@link #doubles(double)}. */ + public long ndouble(double value) { + long a = nmalloc(8, 8); + memPutDouble(a, value); + return a; + } + + // ------------------------------------------------- + // ------------------------------------------------- + // ------------------------------------------------- + + + /** Returns the stack of the current thread. */ + public static MemoryStack stackGet() { + return TLS.get(); + } + + /** + * Calls {@link #push} on the stack of the current thread. + * + * @return the stack of the current thread. + */ + public static MemoryStack stackPush() { + return stackGet().push(); + } + + /** + * Calls {@link #pop} on the stack of the current thread. + * + * @return the stack of the current thread. + */ + public static MemoryStack stackPop() { + return stackGet().pop(); + } + + /** Thread-local version of {@link #nmalloc(int)}. */ + public static long nstackMalloc(int size) { return stackGet().nmalloc(size); } + /** Thread-local version of {@link #nmalloc(int, int)}. */ + public static long nstackMalloc(int alignment, int size) { return stackGet().nmalloc(alignment, size); } + /** Thread-local version of {@link #ncalloc}. */ + public static long nstackCalloc(int alignment, int num, int size) { return stackGet().ncalloc(alignment, num, size); } + + // ------------------------------------------------- + +} diff --git a/src/main/java/com/gtnewhorizons/angelica/compat/lwjgl/Pointer.java b/src/main/java/com/gtnewhorizons/angelica/compat/lwjgl/Pointer.java new file mode 100644 index 000000000..254aabfa8 --- /dev/null +++ b/src/main/java/com/gtnewhorizons/angelica/compat/lwjgl/Pointer.java @@ -0,0 +1,93 @@ +/* + * This class is backported from LWJGL3 under the BSD 3-clause "New" or "Revised" License + */ +package com.gtnewhorizons.angelica.compat.lwjgl; + + +import static com.gtnewhorizons.angelica.compat.lwjgl.CompatMemoryUtil.NULL; +import static com.gtnewhorizons.angelica.compat.lwjgl.CompatMemoryUtil.UNSAFE; +import static org.lwjgl.LWJGLUtil.CHECKS; + +import net.minecraft.util.Util; +import org.jetbrains.annotations.Nullable; + +/** + * Pointer interface. + * + *

LWJGL can run on both 32bit and 64bit architectures. Since LWJGL applications deal with native memory directly, this interface provides necessary + * information about the underlying architecture of the running JVM process.

+ * + *

When interacting with native functions, pointer values are mapped to Java {@code long}. LWJGL automatically converts long values to the correct pointer + * addresses when used in native code. Native functions sometimes require arrays of pointer values; the {@link PointerBuffer} class may be used for that + * purpose. It has an API similar to a {@link java.nio.LongBuffer} but handles pointer casts automatically.

+ */ +public interface Pointer { + + /** The pointer size in bytes. Will be 4 on a 32bit JVM and 8 on a 64bit one. */ + int POINTER_SIZE = UNSAFE.addressSize(); + + /** The pointer size power-of-two. Will be 2 on a 32bit JVM and 3 on a 64bit one. */ + int POINTER_SHIFT = POINTER_SIZE == 8 ? 3 : 2; + + /** The value of {@code sizeof(long)} for the current platform. */ + int CLONG_SIZE = POINTER_SIZE == 8 && Util.getOSType() == Util.EnumOS.WINDOWS ? 4 : POINTER_SIZE; + + /** The value of {@code sizeof(long)} as a power-of-two. */ + int CLONG_SHIFT = CLONG_SIZE == 8 ? 3 : 2; + + /** Will be true on a 32bit JVM. */ + boolean BITS32 = POINTER_SIZE * 8 == 32; + + /** Will be true on a 64bit JVM. */ + boolean BITS64 = POINTER_SIZE * 8 == 64; + + /** + * Returns the raw pointer address as a {@code long} value. + * + * @return the pointer address + */ + long address(); + + /** Default {@link Pointer} implementation. */ + abstract class Default implements Pointer { + + // Removed final due to JDK-8139758. TODO: Restore if the fix is backported to JDK 8. + protected long address; + + protected Default(long address) { + if (CHECKS && address == NULL) { + throw new NullPointerException(); + } + this.address = address; + } + + @Override + public long address() { + return address; + } + + public boolean equals(@Nullable Object o) { + if (this == o) { + return true; + } + if (!(o instanceof Pointer)) { + return false; + } + + Pointer that = (Pointer)o; + + return address == that.address(); + } + + public int hashCode() { + return (int)(address ^ (address >>> 32)); + } + + @Override + public String toString() { + return String.format("%s pointer [0x%X]", getClass().getSimpleName(), address); + } + + } + +} 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 03ddd3c51..64d021aa2 100644 --- a/src/main/java/com/gtnewhorizons/angelica/compat/mojang/NativeImage.java +++ b/src/main/java/com/gtnewhorizons/angelica/compat/mojang/NativeImage.java @@ -1,18 +1,17 @@ package com.gtnewhorizons.angelica.compat.mojang; -import lombok.Getter; -import net.coderbot.iris.Iris; -import org.lwjgl.BufferUtils; -import org.lwjgl.opengl.GL11; -import org.lwjgl.opengl.GL12; - -import javax.imageio.ImageIO; +import com.gtnewhorizons.angelica.compat.lwjgl.MemoryStack; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.nio.ByteBuffer; import java.nio.IntBuffer; +import javax.imageio.ImageIO; +import lombok.Getter; +import net.coderbot.iris.Iris; +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL12; // TBD public class NativeImage extends BufferedImage { @@ -59,12 +58,14 @@ 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); - IntBuffer buffer = BufferUtils.createIntBuffer(size); - int[] data = new int[size]; + try (final MemoryStack stack = MemoryStack.stackPush()) { + final IntBuffer buffer = stack.mallocInt(size); + GL11.glGetTexImage(GL11.GL_TEXTURE_2D, level, format.glFormat, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, buffer); - GL11.glGetTexImage(GL11.GL_TEXTURE_2D, level, format.glFormat, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, buffer); - buffer.get(data); - setRGB(0, 0, width, height, data, 0, width); + int[] data = new int[size]; + buffer.get(data); + setRGB(0, 0, width, height, data, 0, width); + } } public void writeToFile(File file) throws IOException{ try { diff --git a/src/main/java/com/gtnewhorizons/angelica/debug/F3Graph.java b/src/main/java/com/gtnewhorizons/angelica/debug/F3Graph.java index 7b024b2a3..bb26867ba 100644 --- a/src/main/java/com/gtnewhorizons/angelica/debug/F3Graph.java +++ b/src/main/java/com/gtnewhorizons/angelica/debug/F3Graph.java @@ -30,6 +30,7 @@ import static org.lwjgl.opengl.GL20.glUniform1i; import static org.lwjgl.opengl.GL20.glVertexAttribPointer; import com.gtnewhorizon.gtnhlib.client.renderer.shader.ShaderProgram; +import com.gtnewhorizons.angelica.compat.lwjgl.MemoryStack; import java.nio.FloatBuffer; import net.minecraft.client.Minecraft; import net.minecraft.client.gui.FontRenderer; @@ -49,7 +50,7 @@ public abstract class F3Graph { private static final int FONT_COLOR = 0xFFE0E0E0; // Due to GLSL 120 limitations, it's just easier to use floats private final FloatBuffer sampleBuf = BufferUtils.createFloatBuffer(NUM_SAMPLES); - private final long[] samples = new long[NUM_SAMPLES]; // CPU-side copy for reads + private final long[] samples = new long[NUM_SAMPLES]; // long version for calculations // Circular buffer holding the last 240 samples, in nanoseconds private int samplesHead = 0; // one ahead of the position of the last sample private boolean initialized = false; @@ -130,18 +131,20 @@ public abstract class F3Graph { // Load vertex buffer vertBuf = glGenBuffers(); glBindBuffer(GL_ARRAY_BUFFER, vertBuf); - final FloatBuffer vertices = BufferUtils.createFloatBuffer(VERT_COUNT * VERT_FLOATS); - // Since we use a triangle strip, we only need 4 vertices. The quad extends to the top of the screen so spikes - // don't get truncated. The max height is replaced in the vert shader, no need to be precise. - vertices.put(new float[]{ - BORDER, BORDER, - WIDTH + BORDER, BORDER, - BORDER, Float.MAX_VALUE, - WIDTH + BORDER, Float.MAX_VALUE - }); - vertices.rewind(); + try (final MemoryStack stack = MemoryStack.stackPush()) { + final FloatBuffer vertices = stack.mallocFloat(VERT_COUNT * VERT_FLOATS); + // Since we use a triangle strip, we only need 4 vertices. The quad extends to the top of the screen so spikes + // don't get truncated. The max height is replaced in the vert shader, no need to be precise. + vertices.put(new float[]{ + BORDER, BORDER, + WIDTH + BORDER, BORDER, + BORDER, Float.MAX_VALUE, + WIDTH + BORDER, Float.MAX_VALUE + }); + vertices.rewind(); - glBufferData(GL_ARRAY_BUFFER, vertices, GL_STATIC_DRAW); + glBufferData(GL_ARRAY_BUFFER, vertices, GL_STATIC_DRAW); + } glBindBuffer(GL_ARRAY_BUFFER, 0); final Minecraft mc = Minecraft.getMinecraft(); diff --git a/src/main/java/com/gtnewhorizons/angelica/glsm/RenderSystem.java b/src/main/java/com/gtnewhorizons/angelica/glsm/RenderSystem.java index c7e534dfa..51b97423b 100644 --- a/src/main/java/com/gtnewhorizons/angelica/glsm/RenderSystem.java +++ b/src/main/java/com/gtnewhorizons/angelica/glsm/RenderSystem.java @@ -239,7 +239,7 @@ public class RenderSystem { dsaState.bindTextureToUnit(unit, texture); } - public static FloatBuffer PROJECTION_MATRIX_BUFFER = BufferUtils.createFloatBuffer(16); + public static final FloatBuffer PROJECTION_MATRIX_BUFFER = BufferUtils.createFloatBuffer(16); public static void setupProjectionMatrix(Matrix4f matrix) { GL11.glMatrixMode(GL11.GL_PROJECTION); GL11.glPushMatrix(); diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/GameRendererContext.java b/src/main/java/me/jellysquid/mods/sodium/client/render/GameRendererContext.java index 65535adf1..3d65f43cd 100644 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/GameRendererContext.java +++ b/src/main/java/me/jellysquid/mods/sodium/client/render/GameRendererContext.java @@ -1,13 +1,12 @@ package me.jellysquid.mods.sodium.client.render; +import com.gtnewhorizons.angelica.compat.lwjgl.MemoryStack; import com.gtnewhorizons.angelica.compat.toremove.MatrixStack; import com.gtnewhorizons.angelica.config.AngelicaConfig; import com.gtnewhorizons.angelica.rendering.RenderingState; +import java.nio.FloatBuffer; import net.coderbot.iris.shadows.ShadowRenderingState; import org.joml.Matrix4f; -import org.lwjgl.BufferUtils; - -import java.nio.FloatBuffer; public class GameRendererContext { /** @@ -17,8 +16,8 @@ public class GameRendererContext { * @return A float-buffer on the stack containing the model-view-projection matrix in a format suitable for * uploading as uniform state */ - public static FloatBuffer getModelViewProjectionMatrix(MatrixStack.Entry matrices) { - final FloatBuffer bufModelViewProjection = BufferUtils.createFloatBuffer(16); + public static FloatBuffer getModelViewProjectionMatrix(MatrixStack.Entry matrices, MemoryStack stack) { + final FloatBuffer bufModelViewProjection = stack.mallocFloat(16); final Matrix4f projectionMatrix = (AngelicaConfig.enableIris && ShadowRenderingState.areShadowsCurrentlyBeingRendered()) ? ShadowRenderingState.getShadowOrthoMatrix() : RenderingState.INSTANCE.getProjectionMatrix(); final Matrix4f matrix = new Matrix4f(projectionMatrix); matrix.mul(matrices.getModel()); diff --git a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkProgram.java b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkProgram.java index f2e05b687..6d26d4fa5 100644 --- a/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkProgram.java +++ b/src/main/java/me/jellysquid/mods/sodium/client/render/chunk/shader/ChunkProgram.java @@ -1,5 +1,6 @@ package me.jellysquid.mods.sodium.client.render.chunk.shader; +import com.gtnewhorizons.angelica.compat.lwjgl.MemoryStack; import com.gtnewhorizons.angelica.compat.toremove.MatrixStack; import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; import me.jellysquid.mods.sodium.client.gl.shader.GlProgram; @@ -47,6 +48,12 @@ public class ChunkProgram extends GlProgram { this.fogShader.setup(); - if(this.uModelViewProjectionMatrix != -1) GL20.glUniformMatrix4(this.uModelViewProjectionMatrix, false, GameRendererContext.getModelViewProjectionMatrix(matrixStack.peek())); + if (this.uModelViewProjectionMatrix == -1) return; + try (MemoryStack stack = MemoryStack.stackPush()) { + GL20.glUniformMatrix4( + this.uModelViewProjectionMatrix, + false, + GameRendererContext.getModelViewProjectionMatrix(matrixStack.peek(), stack)); + } } } diff --git a/src/main/java/net/coderbot/iris/gl/framebuffer/GlFramebuffer.java b/src/main/java/net/coderbot/iris/gl/framebuffer/GlFramebuffer.java index a3661f47a..24f314a2d 100644 --- a/src/main/java/net/coderbot/iris/gl/framebuffer/GlFramebuffer.java +++ b/src/main/java/net/coderbot/iris/gl/framebuffer/GlFramebuffer.java @@ -1,19 +1,18 @@ package net.coderbot.iris.gl.framebuffer; +import com.gtnewhorizons.angelica.compat.lwjgl.MemoryStack; import com.gtnewhorizons.angelica.glsm.RenderSystem; import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache; import it.unimi.dsi.fastutil.ints.Int2IntArrayMap; import it.unimi.dsi.fastutil.ints.Int2IntMap; +import java.nio.IntBuffer; import net.coderbot.iris.gl.GlResource; import net.coderbot.iris.gl.texture.DepthBufferFormat; import net.minecraft.client.renderer.OpenGlHelper; -import org.lwjgl.BufferUtils; import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL20; import org.lwjgl.opengl.GL30; -import java.nio.IntBuffer; - public class GlFramebuffer extends GlResource { private final Int2IntMap attachments; private final int maxDrawBuffers; @@ -52,25 +51,29 @@ public class GlFramebuffer extends GlResource { } public void noDrawBuffers() { - final IntBuffer buffer = BufferUtils.createIntBuffer(1); - buffer.put(GL11.GL_NONE); - RenderSystem.drawBuffers(getGlId(), buffer); + try (MemoryStack stack = MemoryStack.stackPush()) { + final IntBuffer buffer = stack.mallocInt(1); + buffer.put(GL11.GL_NONE); + RenderSystem.drawBuffers(getGlId(), buffer); + } } public void drawBuffers(int[] buffers) { - final IntBuffer glBuffers = BufferUtils.createIntBuffer(buffers.length); - int index = 0; + try (MemoryStack stack = MemoryStack.stackPush()) { + final IntBuffer glBuffers = stack.mallocInt(buffers.length); + int index = 0; - if (buffers.length > maxDrawBuffers) { - throw new IllegalArgumentException("Cannot write to more than " + maxDrawBuffers + " draw buffers on this GPU"); - } - for (int buffer : buffers) { - if (buffer >= maxColorAttachments) { - throw new IllegalArgumentException("Only " + maxColorAttachments + " color attachments are supported on this GPU, but an attempt was made to write to a color attachment with index " + buffer); - } - glBuffers.put(index++, GL30.GL_COLOR_ATTACHMENT0 + buffer); - } - RenderSystem.drawBuffers(getGlId(), glBuffers); + if (buffers.length > maxDrawBuffers) { + throw new IllegalArgumentException("Cannot write to more than " + maxDrawBuffers + " draw buffers on this GPU"); + } + for (int buffer : buffers) { + if (buffer >= maxColorAttachments) { + throw new IllegalArgumentException("Only " + maxColorAttachments + " color attachments are supported on this GPU, but an attempt was made to write to a color attachment with index " + buffer); + } + glBuffers.put(index++, GL30.GL_COLOR_ATTACHMENT0 + buffer); + } + RenderSystem.drawBuffers(getGlId(), glBuffers); + } } public void readBuffer(int buffer) { diff --git a/src/main/java/net/coderbot/iris/gl/program/ComputeProgram.java b/src/main/java/net/coderbot/iris/gl/program/ComputeProgram.java index 570eed35c..a9a3100ec 100644 --- a/src/main/java/net/coderbot/iris/gl/program/ComputeProgram.java +++ b/src/main/java/net/coderbot/iris/gl/program/ComputeProgram.java @@ -19,7 +19,7 @@ public final class ComputeProgram extends GlResource { private Vector3i absoluteWorkGroups; private Vector2f relativeWorkGroups; // private int[] localSize; - private IntBuffer localSizeBuffer; + private final IntBuffer localSizeBuffer; private float cachedWidth; private float cachedHeight; private Vector3i cachedWorkGroups; diff --git a/src/main/java/net/coderbot/iris/pipeline/ShadowRenderer.java b/src/main/java/net/coderbot/iris/pipeline/ShadowRenderer.java index 7218e92ac..798dd603e 100644 --- a/src/main/java/net/coderbot/iris/pipeline/ShadowRenderer.java +++ b/src/main/java/net/coderbot/iris/pipeline/ShadowRenderer.java @@ -5,12 +5,14 @@ import com.gtnewhorizons.angelica.compat.mojang.Camera; import com.gtnewhorizons.angelica.compat.toremove.MatrixStack; import com.gtnewhorizons.angelica.glsm.GLStateManager; import com.gtnewhorizons.angelica.glsm.RenderSystem; -import com.gtnewhorizons.angelica.mixins.interfaces.IRenderGlobalExt; import com.gtnewhorizons.angelica.rendering.RenderingState; -import cpw.mods.fml.relauncher.ReflectionHelper; -import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; +import java.util.Objects; import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer; -import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass; import net.coderbot.iris.Iris; import net.coderbot.iris.shaderpack.OptionalBoolean; import net.coderbot.iris.shaderpack.PackDirectives; @@ -33,7 +35,6 @@ import net.minecraft.client.multiplayer.WorldClient; import net.minecraft.client.renderer.EntityRenderer; import net.minecraft.client.renderer.OpenGlHelper; import net.minecraft.client.renderer.RenderGlobal; -import net.minecraft.client.renderer.RenderHelper; import net.minecraft.client.renderer.culling.Frustrum; import net.minecraft.client.renderer.entity.RenderManager; import net.minecraft.client.renderer.texture.TextureMap; @@ -52,16 +53,9 @@ import org.lwjgl.opengl.GL13; import org.lwjgl.opengl.GL14; import org.lwjgl.opengl.GL30; -import java.nio.FloatBuffer; -import java.nio.IntBuffer; -import java.util.ArrayList; -import java.util.Comparator; -import java.util.List; -import java.util.Objects; - public class ShadowRenderer { public static final Matrix4f MODELVIEW = new Matrix4f(); - public static FloatBuffer MODELVIEW_BUFFER = BufferUtils.createFloatBuffer(16); + public static final FloatBuffer MODELVIEW_BUFFER = BufferUtils.createFloatBuffer(16); public static final Matrix4f PROJECTION = new Matrix4f(); public static List visibleTileEntities; public static boolean ACTIVE = false; diff --git a/src/main/java/net/coderbot/iris/rendertarget/RenderTarget.java b/src/main/java/net/coderbot/iris/rendertarget/RenderTarget.java index 91993627b..9ca5cb17a 100644 --- a/src/main/java/net/coderbot/iris/rendertarget/RenderTarget.java +++ b/src/main/java/net/coderbot/iris/rendertarget/RenderTarget.java @@ -1,5 +1,6 @@ package net.coderbot.iris.rendertarget; +import com.gtnewhorizons.angelica.compat.lwjgl.MemoryStack; import com.gtnewhorizons.angelica.glsm.GLStateManager; import com.gtnewhorizons.angelica.glsm.RenderSystem; import lombok.Getter; @@ -40,11 +41,13 @@ public class RenderTarget { this.width = builder.width; this.height = builder.height; - IntBuffer textures = BufferUtils.createIntBuffer(2); - GL11.glGenTextures(textures); + try (MemoryStack stack = MemoryStack.stackPush()) { + IntBuffer textures = stack.mallocInt(2); + GL11.glGenTextures(textures); - this.mainTexture = textures.get(0); - this.altTexture = textures.get(1); + this.mainTexture = textures.get(0); + this.altTexture = textures.get(1); + } boolean isPixelFormatInteger = builder.internalFormat.getPixelFormat().isInteger(); setupTexture(mainTexture, builder.width, builder.height, !isPixelFormatInteger); diff --git a/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgram.java b/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgram.java index 33598af0f..2917a6367 100644 --- a/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgram.java +++ b/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgram.java @@ -1,7 +1,9 @@ package net.coderbot.iris.sodium.shader_overrides; +import com.gtnewhorizons.angelica.compat.lwjgl.MemoryStack; import com.gtnewhorizons.angelica.compat.toremove.MatrixStack; import com.gtnewhorizons.angelica.glsm.RenderSystem; +import java.nio.FloatBuffer; import me.jellysquid.mods.sodium.client.gl.device.RenderDevice; import me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkProgram; import me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkShaderFogComponent; @@ -11,9 +13,6 @@ import net.coderbot.iris.gl.program.ProgramUniforms; import net.minecraft.util.ResourceLocation; import org.jetbrains.annotations.Nullable; import org.joml.Matrix4f; -import org.lwjgl.BufferUtils; - -import java.nio.FloatBuffer; public class IrisChunkProgram extends ChunkProgram { // Uniform variable binding indexes @@ -87,10 +86,12 @@ public class IrisChunkProgram extends ChunkProgram { return; } - FloatBuffer buffer = BufferUtils.createFloatBuffer(16); + try (MemoryStack stack = MemoryStack.stackPush()) { + FloatBuffer buffer = stack.mallocFloat(16); - matrix.get(buffer); + matrix.get(buffer); - RenderSystem.uniformMatrix4fv(location, false, buffer); + RenderSystem.uniformMatrix4fv(location, false, buffer); + } } }