Command Buffer & RenderThread

src/main/java/rs117/hd/HdPluginConfig.java

@@ -245,7 +245,7 @@ default SyncMode syncMode()
 	)
 	@Range(
 		min = 0,
-		max = 999
+		max = 2000
 	)
 	default int fpsTarget()
 	{
@@ -1098,17 +1098,6 @@ default boolean wireframe() {
 		return false;
 	}
 
-	String KEY_ASYNC_UI_COPY = "experimentalAsyncUICopy";
-	@ConfigItem(
-		keyName = KEY_ASYNC_UI_COPY,
-		name = "Perform UI copy asynchronously",
-		description = "Slightly improves performance by delaying the UI by one frame.",
-		section = experimentalSettings
-	)
-	default boolean asyncUICopy() {
-		return false;
-	}
-
 	String KEY_TILED_LIGHTING_IMAGE_STORE = "experimentalTiledLightingImageStore";
 	@ConfigItem(
 		keyName = KEY_TILED_LIGHTING_IMAGE_STORE,
@@ -1120,6 +1109,17 @@ default boolean tiledLightingImageLoadStore() {
 		return true;
 	}
 
+	String KEY_RENDER_THREAD = "experimentalRenderThread";
+	@ConfigItem(
+		keyName = KEY_RENDER_THREAD,
+		name = "Render Thread",
+		description = "Its a Render Thread...",
+		section = experimentalSettings
+	)
+	default boolean renderThread() {
+		return true;
+	}
+
 
 	/*====== Internal settings ======*/
 

src/main/java/rs117/hd/opengl/commandbuffer/AWTContextWrapper.java

@@ -0,0 +1,149 @@
+package rs117.hd.opengl.commandbuffer;
+
+import java.awt.Canvas;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+import net.runelite.api.*;
+import net.runelite.rlawt.AWTContext;
+import org.lwjgl.opengl.*;
+import rs117.hd.HdPlugin;
+
+@Slf4j
+@Singleton
+public final class AWTContextWrapper {
+	private static final boolean VALIDATE = log.isDebugEnabled();
+
+	public enum Owner { CLIENT, RENDER_THREAD, NONE }
+
+	private final Object ownershipLock = new Object();
+	private volatile Owner currentOwner = Owner.CLIENT;
+
+	private static final int MAX_OWNERSHIP_LOG = 8;
+	private final ConcurrentLinkedQueue<String> ownershipLog = new ConcurrentLinkedQueue<>();
+
+	private final StringBuilder sb = new StringBuilder();
+
+	@Inject
+	private Client client;
+
+	@Getter
+	private AWTContext context;
+
+	@Getter
+	private Canvas canvas;
+
+	public boolean initialize() {
+		AWTContext.loadNatives();
+		canvas = client.getCanvas();
+
+		synchronized (canvas.getTreeLock()) {
+			// Delay plugin startup until the client's canvas is valid
+			if (!canvas.isValid())
+				return false;
+
+			context = new AWTContext(canvas);
+			context.configurePixelFormat(0, 0, 0);
+		}
+
+		context.createGLContext();
+		canvas.setIgnoreRepaint(true);
+		return true;
+	}
+
+	public void shutdown() {
+		if (context != null)
+			context.destroy();
+		context = null;
+
+		// Validate the canvas so it becomes valid without having to manually resize the client
+		if(canvas != null)
+			canvas.validate();
+		canvas = null;
+	}
+
+	public int setSwapInterval(int interval) { return context.setSwapInterval(interval); }
+
+	public int getBufferMode() { return context.getBufferMode(); }
+
+	public int getBackBuffer() { return context.getFramebuffer(false); }
+
+	public Owner getOwner() { return currentOwner; }
+
+	public void makeCurrent(Owner newOwner) {
+		if (currentOwner == newOwner)
+			return;
+
+		synchronized (ownershipLock) {
+			while (currentOwner != Owner.NONE) {
+				try {
+					ownershipLock.wait();
+				} catch (InterruptedException e) {
+					Thread.currentThread().interrupt();
+					return;
+				}
+			}
+
+			try {
+				context.makeCurrent();
+				if(newOwner == Owner.RENDER_THREAD && HdPlugin.GL_RENDER_THREAD_CAPS == null){
+					HdPlugin.GL_RENDER_THREAD_CAPS = GL.createCapabilities();
+				}
+				updateOwner(newOwner, "makeCurrent");
+			} catch (Exception e) {
+				printOwnershipLog();
+				log.error("Failed to make OpenGL context current for {}", newOwner, e);
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+	public void detachCurrent(String reason) {
+		try {
+			context.detachCurrent();
+			updateOwner(Owner.NONE, reason);
+		} catch (Exception e) {
+			printOwnershipLog();
+			log.error("Failed to detach OpenGL context: " + reason, e);
+			throw new RuntimeException(e);
+		}
+	}
+
+	private void updateOwner(Owner newOwner, String action) {
+		if (currentOwner != newOwner && VALIDATE) {
+			if (ownershipLog.size() >= MAX_OWNERSHIP_LOG)
+				ownershipLog.poll();
+
+			sb.append(currentOwner)
+				.append(" -> ")
+				.append(newOwner)
+				.append(" via ")
+				.append(action);
+
+			ownershipLog.add(sb.toString());
+
+			sb.setLength(0);
+		}
+
+		currentOwner = newOwner;
+
+		synchronized (ownershipLock) {
+			ownershipLock.notifyAll();
+		}
+	}
+
+	private void printOwnershipLog() {
+		if (!VALIDATE) return;
+
+		if (ownershipLog.isEmpty()) {
+			log.error("No recent ownership transitions recorded.");
+		} else {
+			log.error("Recent ownership transitions:");
+			for (String entry : ownershipLog) {
+				log.error(" - {}", entry);
+			}
+		}
+	}
+}

src/main/java/rs117/hd/opengl/commandbuffer/BaseCommand.java

@@ -0,0 +1,67 @@
+package rs117.hd.opengl.commandbuffer;
+
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+import org.lwjgl.system.MemoryStack;
+import rs117.hd.opengl.uniforms.UniformBuffer;
+
+@Slf4j
+public abstract class BaseCommand {
+
+	protected int id;
+
+	@Getter
+	private final String name;
+
+	@Getter
+	private final boolean isDrawCall;
+
+	@Getter
+	private final boolean isGLCommand;
+
+	protected CommandBuffer owner;
+
+	protected BaseCommand(boolean isDrawCall, boolean isGLCommand) {
+		this.name = getClass().getSimpleName();
+		this.isDrawCall = isDrawCall;
+		this.isGLCommand = isDrawCall || isGLCommand;
+	}
+
+	protected BaseCommand(boolean isDrawCall) { this(isDrawCall, false); }
+
+	protected BaseCommand() { this(false, false); }
+
+	protected abstract void execute(MemoryStack stack);
+	protected abstract void print(StringBuilder sb);
+
+	protected final void write() {
+		write8(id);
+		doWrite();
+	}
+
+	protected abstract void doWrite();
+	protected abstract void doRead(MemoryStack stack);
+
+	protected final void markUniformBufferDirty(UniformBuffer buffer) { owner.markUniformBufferDirty(buffer); }
+
+	protected final void write1(int value)   { owner.writeBits(value & 0x1L, 1); }
+	protected final void write8(int value)   { owner.writeBits(value & 0xFFL, 8); }
+	protected final void write16(int value)  { owner.writeBits(value & 0xFFFFL, 16); }
+	protected final void write32(int value)  { owner.writeBits(value & 0xFFFFFFFFL, 32); }
+	protected final void write64(long value) { owner.writeBits(value, 64); }
+
+	protected final int read1()    { return (int) owner.readBits(1); }
+	protected final int read8()    { return (int) owner.readBits(8); }
+	protected final int read16()   { return (int) owner.readBits(16); }
+	protected final int read32()   { return (int) owner.readBits(32); }
+	protected final long read64()  { return owner.readBits(64); }
+
+	protected final void writeObject(Object value)  {owner.writeObject(value);}
+	protected final <T> T readObject()  { return owner.readObject(); }
+
+	protected final void write32F(float value)  { write32(Float.floatToIntBits(value)); }
+	protected final float read32F()  { return Float.intBitsToFloat(read32()); }
+
+	protected final void writeFlag(boolean value) { write1(value ? 1 : 0); }
+	protected final boolean readFlag() { return read1() != 0; }
+}