mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-17 19:15:06 +00:00
275 lines
11 KiB
Java
275 lines
11 KiB
Java
package com.gtnewhorizons.angelica.debug;
|
|
|
|
import static org.lwjgl.opengl.GL11.GL_ALPHA_TEST;
|
|
import static org.lwjgl.opengl.GL11.GL_BLEND;
|
|
import static org.lwjgl.opengl.GL11.GL_CULL_FACE;
|
|
import static org.lwjgl.opengl.GL11.GL_DEPTH_TEST;
|
|
import static org.lwjgl.opengl.GL11.GL_FLOAT;
|
|
import static org.lwjgl.opengl.GL11.GL_ONE_MINUS_SRC_ALPHA;
|
|
import static org.lwjgl.opengl.GL11.GL_SRC_ALPHA;
|
|
import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D;
|
|
import static org.lwjgl.opengl.GL11.GL_TRIANGLE_STRIP;
|
|
import static org.lwjgl.opengl.GL11.GL_VERTEX_ARRAY;
|
|
import static org.lwjgl.opengl.GL11.glBlendFunc;
|
|
import static org.lwjgl.opengl.GL11.glColor4f;
|
|
import static org.lwjgl.opengl.GL11.glDisable;
|
|
import static org.lwjgl.opengl.GL11.glDisableClientState;
|
|
import static org.lwjgl.opengl.GL11.glDrawArrays;
|
|
import static org.lwjgl.opengl.GL11.glEnable;
|
|
import static org.lwjgl.opengl.GL11.glEnableClientState;
|
|
import static org.lwjgl.opengl.GL15.GL_ARRAY_BUFFER;
|
|
import static org.lwjgl.opengl.GL15.GL_STATIC_DRAW;
|
|
import static org.lwjgl.opengl.GL15.glBindBuffer;
|
|
import static org.lwjgl.opengl.GL15.glBufferData;
|
|
import static org.lwjgl.opengl.GL15.glGenBuffers;
|
|
import static org.lwjgl.opengl.GL20.glDisableVertexAttribArray;
|
|
import static org.lwjgl.opengl.GL20.glEnableVertexAttribArray;
|
|
import static org.lwjgl.opengl.GL20.glUniform1;
|
|
import static org.lwjgl.opengl.GL20.glUniform1f;
|
|
import static org.lwjgl.opengl.GL20.glUniform1i;
|
|
import static org.lwjgl.opengl.GL20.glVertexAttribPointer;
|
|
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryStack.*;
|
|
|
|
import com.gtnewhorizon.gtnhlib.bytebuf.MemoryStack;
|
|
import com.gtnewhorizon.gtnhlib.client.renderer.shader.ShaderProgram;
|
|
import java.nio.FloatBuffer;
|
|
import net.minecraft.client.Minecraft;
|
|
import net.minecraft.client.gui.FontRenderer;
|
|
import net.minecraft.client.gui.ScaledResolution;
|
|
import net.minecraft.client.renderer.Tessellator;
|
|
import net.minecraft.util.ResourceLocation;
|
|
import org.lwjgl.BufferUtils;
|
|
|
|
public abstract class F3Graph {
|
|
private static final int NUM_SAMPLES = 240;
|
|
// Two floats (x,y)
|
|
private static final int VERT_FLOATS = 2;
|
|
private static final int VERT_COUNT = 4;
|
|
private static final int BORDER = 1;
|
|
private static final int HEIGHT = 60;
|
|
private static final int WIDTH = NUM_SAMPLES;
|
|
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]; // 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;
|
|
private ShaderProgram shader;
|
|
private int aPos;
|
|
private int uFBWidth;
|
|
private int uFBHeight;
|
|
private int uScaleFactor;
|
|
private int uHeadIdx;
|
|
private int uSamples;
|
|
private int vertBuf;
|
|
private final ResourceLocation texture;
|
|
private final float pxPerNs;
|
|
private final boolean left;
|
|
private long sum;
|
|
|
|
protected F3Graph(ResourceLocation texture, float pxPerNs, boolean left) {
|
|
this.texture = texture;
|
|
this.pxPerNs = pxPerNs;
|
|
this.left = left;
|
|
}
|
|
|
|
public void putSample(long time) {
|
|
// Manage running trackers
|
|
sum -= samples[samplesHead];
|
|
sum += time;
|
|
samples[samplesHead] = time;
|
|
|
|
sampleBuf.put(samplesHead, (float) time);
|
|
samplesHead = (samplesHead + 1) % NUM_SAMPLES;
|
|
}
|
|
|
|
private int getVertX(ScaledResolution sres, int idx) {
|
|
if (left) {
|
|
return switch (idx) {
|
|
case 0, 3 -> WIDTH + BORDER * 2;
|
|
case 1, 2 -> 0;
|
|
default -> throw new RuntimeException("Tried to get out-of-bounds vertex for graph!");
|
|
};
|
|
}
|
|
|
|
final int displayWidth = sres.getScaledWidth();
|
|
return switch (idx) {
|
|
case 0, 3 -> displayWidth;
|
|
case 1, 2 -> displayWidth - WIDTH - BORDER * 2;
|
|
default -> throw new RuntimeException("Tried to get out-of-bounds vertex for graph!");
|
|
};
|
|
}
|
|
|
|
private int getVertY(ScaledResolution sres, int idx) {
|
|
final int displayHeight = sres.getScaledHeight();
|
|
return switch (idx) {
|
|
case 0, 1 -> displayHeight - HEIGHT - BORDER * 2;
|
|
case 2, 3 -> displayHeight;
|
|
default -> throw new RuntimeException("Tried to get out-of-bounds vertex for graph!");
|
|
};
|
|
}
|
|
|
|
private void init() {
|
|
shader = new ShaderProgram(
|
|
"angelica",
|
|
"shaders/debug_graph.vert.glsl",
|
|
"shaders/debug_graph.frag.glsl");
|
|
shader.use();
|
|
|
|
// Register attributes
|
|
aPos = shader.getAttribLocation("pos");
|
|
|
|
// Register uniforms
|
|
uFBWidth = shader.getUniformLocation("fbWidth");
|
|
uFBHeight = shader.getUniformLocation("fbHeight");
|
|
uScaleFactor = shader.getUniformLocation("scaleFactor");
|
|
uSamples = shader.getUniformLocation("samples");
|
|
uHeadIdx = shader.getUniformLocation("headIdx");
|
|
final int uPxPerNs = shader.getUniformLocation("pxPerNs");
|
|
final int uLeft = shader.getUniformLocation("left");
|
|
|
|
// Load vertex buffer
|
|
vertBuf = glGenBuffers();
|
|
glBindBuffer(GL_ARRAY_BUFFER, vertBuf);
|
|
try (final MemoryStack stack = 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);
|
|
}
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
|
|
final Minecraft mc = Minecraft.getMinecraft();
|
|
final ScaledResolution sr = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
|
|
|
|
// Load initial value for uniforms
|
|
glUniform1f(uFBWidth, mc.displayWidth);
|
|
glUniform1f(uFBHeight, mc.displayHeight);
|
|
glUniform1f(uScaleFactor, sr.getScaleFactor());
|
|
glUniform1i(uHeadIdx, samplesHead);
|
|
glUniform1(uSamples, sampleBuf);
|
|
glUniform1f(uPxPerNs, pxPerNs);
|
|
glUniform1i(uLeft, left ? 1 : 0); // this is how you load bool uniforms
|
|
|
|
ShaderProgram.clear();
|
|
}
|
|
|
|
public void render() {
|
|
if (!initialized) {
|
|
init();
|
|
initialized = true;
|
|
}
|
|
|
|
/*
|
|
* We try to copy modern vanilla's tracker.
|
|
* It is 240 (FRAME_TIMES) wide by 60 tall, including the 1px borders.
|
|
* We instead make it 242x62 including borders to prevent the borders from overlapping the samples.
|
|
* The background is ARGB 90505050, the borders FFFFFFFF, and the text FFE0E0E0.
|
|
* First the background is rendered, then the samples, then the foreground texture and the text.
|
|
* The background is drawn via a 242x62 translucent rect.
|
|
* Next, the samples are rendered by a shader on a transparent 240x60 rect.
|
|
* Finally, the foreground texture and the text is rendered on top.
|
|
* The shader pipeline is only needed for the sample draw.
|
|
*/
|
|
|
|
final Minecraft mc = Minecraft.getMinecraft();
|
|
final ScaledResolution sr = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
|
|
|
|
// Setup GL state
|
|
final Tessellator tess = Tessellator.instance;
|
|
glDisable(GL_DEPTH_TEST);
|
|
glEnable(GL_ALPHA_TEST);
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
|
|
// Draw background
|
|
glDisable(GL_TEXTURE_2D);
|
|
glColor4f(0x50 / 255.0F, 0x50 / 255.0F, 0x50 / 255.0F, 0x90 / 255.0F);
|
|
tess.startDrawingQuads();
|
|
for (int i = 0; i < 4; ++i) {
|
|
tess.addVertex(getVertX(sr, i), getVertY(sr, i), 0);
|
|
}
|
|
tess.draw();
|
|
glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
|
|
// Draw samples
|
|
shader.use();
|
|
|
|
// Load uniforms
|
|
glUniform1f(uFBWidth, mc.displayWidth);
|
|
glUniform1f(uFBHeight, mc.displayHeight);
|
|
glUniform1f(uScaleFactor, sr.getScaleFactor());
|
|
glUniform1i(uHeadIdx, samplesHead);
|
|
glUniform1(uSamples, sampleBuf);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, vertBuf);
|
|
glEnableVertexAttribArray(aPos);
|
|
glVertexAttribPointer(aPos, VERT_FLOATS, GL_FLOAT, false, VERT_FLOATS * 4, 0);
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
|
|
// Left side graphs are inverted, so temporarily disable culling
|
|
if (!left) glDisable(GL_CULL_FACE);
|
|
|
|
glDrawArrays(GL_TRIANGLE_STRIP, 0, VERT_COUNT);
|
|
|
|
if (!left) glEnable(GL_CULL_FACE);
|
|
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
glDisableVertexAttribArray(aPos);
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
|
|
ShaderProgram.clear();
|
|
|
|
// Draw foreground
|
|
|
|
mc.getTextureManager().bindTexture(texture);
|
|
tess.startDrawingQuads();
|
|
tess.addVertexWithUV(getVertX(sr, 0), getVertY(sr, 0), 0.0D, 1, 0);
|
|
tess.addVertexWithUV(getVertX(sr, 1), getVertY(sr, 1), 0.0D, 0, 0);
|
|
tess.addVertexWithUV(getVertX(sr, 2), getVertY(sr, 2), 0.0D, 0, 1);
|
|
tess.addVertexWithUV(getVertX(sr, 3), getVertY(sr, 3), 0.0D, 1, 1);
|
|
tess.draw();
|
|
|
|
// Reset GL state
|
|
glEnable(GL_DEPTH_TEST);
|
|
glDisable(GL_ALPHA_TEST);
|
|
glDisable(GL_BLEND);
|
|
|
|
// Draw text
|
|
// Ensure running counters are reset on first sample
|
|
long min = Long.MAX_VALUE;
|
|
long max = Long.MIN_VALUE;
|
|
for (int i = 0; i < NUM_SAMPLES; ++i) {
|
|
min = Math.min(min, samples[i]);
|
|
max = Math.max(max, samples[i]);
|
|
}
|
|
String minStr = String.format("%.1f ms min", min / 1_000_000D);
|
|
String avgStr = String.format("%.1f ms avg", sum / 1_000_000 / (double) NUM_SAMPLES);
|
|
String maxStr = String.format("%.1f ms max", max / 1_000_000D);
|
|
final FontRenderer fr = mc.fontRenderer;
|
|
final int top = sr.getScaledHeight() - HEIGHT - BORDER * 2 - fr.FONT_HEIGHT;
|
|
final int scaledWidth = sr.getScaledWidth();
|
|
|
|
if (left) {
|
|
fr.drawString(minStr, BORDER * 2, top, FONT_COLOR, true);
|
|
fr.drawString(avgStr, BORDER + WIDTH / 2 - fr.getStringWidth(avgStr) / 2, top, FONT_COLOR, true);
|
|
fr.drawString(maxStr, BORDER * 2 + WIDTH - fr.getStringWidth(maxStr), top, FONT_COLOR, true);
|
|
} else {
|
|
fr.drawString(minStr, scaledWidth - (BORDER * 2 + WIDTH), top, FONT_COLOR, true);
|
|
fr.drawString(avgStr, scaledWidth - (BORDER + WIDTH / 2 + fr.getStringWidth(avgStr) / 2), top, FONT_COLOR, true);
|
|
fr.drawString(maxStr, scaledWidth - (BORDER * 2 + fr.getStringWidth(maxStr)), top, FONT_COLOR, true);
|
|
}
|
|
}
|
|
}
|