mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-19 11:59:40 +00:00
Add display list compilation/optimization (#1141)
This commit is contained in:
1 parent
55811b9d7b
commit
33de1de9c4
118 files changed
+11342
-670
No files matched your search
@@ -18,7 +18,7 @@ import cpw.mods.fml.common.event.FMLPreInitializationEvent;
|
||||
name = "Angelica",
|
||||
version = Tags.VERSION,
|
||||
dependencies = """
|
||||
required-after:gtnhlib@[0.6.6,);\
|
||||
required-after:gtnhlib@[0.8.18,);\
|
||||
before:lwjgl3ify@[1.5.3,);\
|
||||
after:hodgepodge@[2.4.4,);\
|
||||
after:CodeChickenCore@[1.2.0,);\
|
||||
|
||||
@@ -17,7 +17,7 @@ public class AngelicaConfig {
|
||||
@Config.DefaultBoolean(true)
|
||||
public static boolean enableReesesSodiumOptions;
|
||||
|
||||
@Config.Comment("Enable Sodium fluid rendering")
|
||||
@Config.Comment("Enable Sodium fluid rendering [Experimental]")
|
||||
@Config.DefaultBoolean(false)
|
||||
@Config.RequiresMcRestart
|
||||
public static boolean enableSodiumFluidRendering;
|
||||
@@ -42,10 +42,10 @@ public class AngelicaConfig {
|
||||
@Config.RequiresMcRestart
|
||||
public static boolean enableMCPatcherForgeFeatures;
|
||||
|
||||
@Config.Comment("Replace some vanilla render paths with more optimized versions. Disable if you encounter mixin conflicts.")
|
||||
@Config.Comment("Replace cloud renderer with a VBO version.")
|
||||
@Config.DefaultBoolean(true)
|
||||
@Config.RequiresMcRestart
|
||||
public static boolean enableVBO;
|
||||
public static boolean enableVBOClouds;
|
||||
|
||||
@Config.Comment("Enable NotFine features")
|
||||
@Config.DefaultBoolean(true)
|
||||
|
||||
@@ -37,6 +37,8 @@ public class DynamicLights {
|
||||
public static DynamicLightsMode Mode = DynamicLightsMode.OFF;
|
||||
public static boolean ShaderForce = false;
|
||||
|
||||
public static final boolean configEnabled = AngelicaConfig.enableDynamicLights;
|
||||
|
||||
private static final double MAX_RADIUS = 7.75;
|
||||
private static final double MAX_RADIUS_SQUARED = MAX_RADIUS * MAX_RADIUS;
|
||||
private final Set<IDynamicLightSource> dynamicLightSources = new ObjectOpenHashSet<>();
|
||||
@@ -51,7 +53,7 @@ public class DynamicLights {
|
||||
}
|
||||
|
||||
public static boolean isEnabled() {
|
||||
return AngelicaConfig.enableDynamicLights &&
|
||||
return configEnabled &&
|
||||
Mode.isEnabled() &&
|
||||
// if shader force is enabled then true
|
||||
// if not, then true when shaders are not in use
|
||||
|
||||
@@ -0,0 +1,172 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.AccumulatedDraw;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.CommandBuffer;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.CommandBufferProcessor;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.CommandBufferProcessor.BufferTransformOptimizer;
|
||||
import it.unimi.dsi.fastutil.objects.Object2IntMap;
|
||||
import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Comparator;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Builds final command buffers from raw command buffers and compiled VBO data.
|
||||
* Bridges the gap between VBO compilation (glsm types) and buffer processing (recording types).
|
||||
*/
|
||||
public final class CommandBufferBuilder {
|
||||
|
||||
private CommandBufferBuilder() {}
|
||||
|
||||
/**
|
||||
* Build commands with transform collapsing optimization.
|
||||
* Accumulates MODELVIEW transforms and emits MultMatrix at barriers (draws, CallList).
|
||||
* Uses mergedRanges where consecutive same-transform draws are combined.
|
||||
*/
|
||||
public static void buildOptimizedFromRawBuffer(
|
||||
CommandBuffer rawBuffer,
|
||||
Map<CapturingTessellator.Flags, CompiledFormatBuffer> compiledQuadBuffers,
|
||||
CompiledLineBuffer compiledLineBuffer,
|
||||
VertexBuffer[] ownedVbos,
|
||||
int glListId,
|
||||
CommandBuffer finalBuffer) {
|
||||
|
||||
// Build VBO index map for efficient lookup (no boxing)
|
||||
final Object2IntMap<VertexBuffer> vboIndexMap = new Object2IntOpenHashMap<>();
|
||||
vboIndexMap.defaultReturnValue(-1);
|
||||
for (int i = 0; i < ownedVbos.length; i++) {
|
||||
vboIndexMap.put(ownedVbos[i], i);
|
||||
}
|
||||
|
||||
// Collect all merged draw ranges sorted by command index
|
||||
final List<DrawRangeWithBuffer> allRanges = collectDrawRanges(compiledQuadBuffers, compiledLineBuffer);
|
||||
|
||||
// Buffer optimizer state
|
||||
final BufferTransformOptimizer opt = new BufferTransformOptimizer();
|
||||
|
||||
rawBuffer.resetRead();
|
||||
int cmdIndex = 0;
|
||||
int rangeIndex = 0;
|
||||
|
||||
while (rawBuffer.hasRemaining()) {
|
||||
// Emit draw ranges at this command position
|
||||
while (rangeIndex < allRanges.size() && allRanges.get(rangeIndex).range().commandIndex() == cmdIndex) {
|
||||
emitDrawRangeToBuffer(allRanges.get(rangeIndex++), opt, finalBuffer, vboIndexMap);
|
||||
}
|
||||
|
||||
// Read and process the command
|
||||
final int opcode = rawBuffer.readInt();
|
||||
CommandBufferProcessor.processCommandForOptimization(opcode, rawBuffer, opt, finalBuffer);
|
||||
cmdIndex++;
|
||||
}
|
||||
|
||||
// Emit remaining draw ranges at end of command stream
|
||||
while (rangeIndex < allRanges.size()) {
|
||||
emitDrawRangeToBuffer(allRanges.get(rangeIndex++), opt, finalBuffer, vboIndexMap);
|
||||
}
|
||||
|
||||
// Emit residual transform if not identity
|
||||
if (!opt.isIdentity()) {
|
||||
opt.emitPendingTransform(finalBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Build commands without transform collapsing.
|
||||
* Copies state commands directly (no transform optimization), but still uses
|
||||
* merged draw ranges (draws already collapsed by format + transform in VBO compilation).
|
||||
*/
|
||||
public static void buildUnoptimizedFromRawBuffer(
|
||||
CommandBuffer rawBuffer,
|
||||
List<AccumulatedDraw> accumulatedDraws,
|
||||
Map<CapturingTessellator.Flags, CompiledFormatBuffer> compiledQuadBuffers,
|
||||
CompiledLineBuffer compiledLineBuffer,
|
||||
VertexBuffer[] ownedVbos,
|
||||
CommandBuffer finalBuffer) {
|
||||
|
||||
// Build VBO index map for efficient lookup (no boxing)
|
||||
final Object2IntMap<VertexBuffer> vboIndexMap = new Object2IntOpenHashMap<>();
|
||||
vboIndexMap.defaultReturnValue(-1);
|
||||
for (int i = 0; i < ownedVbos.length; i++) {
|
||||
vboIndexMap.put(ownedVbos[i], i);
|
||||
}
|
||||
|
||||
// Collect all merged draw ranges sorted by command index
|
||||
final List<DrawRangeWithBuffer> allRanges = collectDrawRanges(compiledQuadBuffers, compiledLineBuffer);
|
||||
|
||||
rawBuffer.resetRead();
|
||||
int cmdIndex = 0;
|
||||
int rangeIndex = 0;
|
||||
|
||||
while (rawBuffer.hasRemaining()) {
|
||||
// Emit draw ranges at this command position
|
||||
while (rangeIndex < allRanges.size() && allRanges.get(rangeIndex).range().commandIndex() == cmdIndex) {
|
||||
final DrawRangeWithBuffer drb = allRanges.get(rangeIndex++);
|
||||
final int vboIdx = vboIndexMap.getInt(drb.vbo());
|
||||
if (vboIdx >= 0) {
|
||||
finalBuffer.writeDrawRange(vboIdx, drb.range().startVertex(), drb.range().vertexCount(), drb.hasBrightness());
|
||||
}
|
||||
}
|
||||
|
||||
// Copy the command directly
|
||||
CommandBufferProcessor.copyCommand(rawBuffer, finalBuffer);
|
||||
cmdIndex++;
|
||||
}
|
||||
|
||||
// Emit remaining draw ranges at end of command stream
|
||||
while (rangeIndex < allRanges.size()) {
|
||||
final DrawRangeWithBuffer drb = allRanges.get(rangeIndex++);
|
||||
final int vboIdx = vboIndexMap.getInt(drb.vbo());
|
||||
if (vboIdx >= 0) {
|
||||
finalBuffer.writeDrawRange(vboIdx, drb.range().startVertex(), drb.range().vertexCount(), drb.hasBrightness());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Collect all draw ranges from compiled buffers, sorted by command index.
|
||||
*/
|
||||
private static List<DrawRangeWithBuffer> collectDrawRanges(
|
||||
Map<CapturingTessellator.Flags, CompiledFormatBuffer> compiledQuadBuffers,
|
||||
CompiledLineBuffer compiledLineBuffer) {
|
||||
|
||||
final List<DrawRangeWithBuffer> allRanges = new ArrayList<>();
|
||||
|
||||
for (CompiledFormatBuffer compiledBuffer : compiledQuadBuffers.values()) {
|
||||
for (DrawRange range : compiledBuffer.mergedRanges()) {
|
||||
allRanges.add(new DrawRangeWithBuffer(range, compiledBuffer.vbo(), compiledBuffer.flags().hasBrightness));
|
||||
}
|
||||
}
|
||||
|
||||
if (compiledLineBuffer != null) {
|
||||
for (DrawRange range : compiledLineBuffer.mergedRanges()) {
|
||||
allRanges.add(new DrawRangeWithBuffer(range, compiledLineBuffer.vbo(), false));
|
||||
}
|
||||
}
|
||||
|
||||
allRanges.sort(Comparator.comparingInt(r -> r.range().commandIndex()));
|
||||
return allRanges;
|
||||
}
|
||||
|
||||
/**
|
||||
* Emit a draw range to the output buffer, with transform if needed.
|
||||
*/
|
||||
private static void emitDrawRangeToBuffer(
|
||||
DrawRangeWithBuffer drb,
|
||||
BufferTransformOptimizer opt,
|
||||
CommandBuffer out,
|
||||
Object2IntMap<VertexBuffer> vboIndexMap) {
|
||||
// Emit transform to reach the draw's expected transform
|
||||
opt.emitTransformTo(out, drb.range().transform());
|
||||
|
||||
// Write the draw range command
|
||||
final int vboIdx = vboIndexMap.getInt(drb.vbo());
|
||||
if (vboIdx >= 0) {
|
||||
out.writeDrawRange(vboIdx, drb.range().startVertex(), drb.range().vertexCount(), drb.hasBrightness());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
|
||||
|
||||
/**
|
||||
* A compiled VBO with its associated draw ranges.
|
||||
* All ranges reference vertices within this single VBO.
|
||||
* <p>
|
||||
* Contains two range arrays:
|
||||
* <ul>
|
||||
* <li><b>mergedRanges</b>: For optimized path - consecutive same-transform draws merged</li>
|
||||
* <li><b>perDrawRanges</b>: For unoptimized path - 1:1 with original draws</li>
|
||||
* </ul>
|
||||
*/
|
||||
@Desugar
|
||||
record CompiledFormatBuffer(
|
||||
VertexBuffer vbo,
|
||||
CapturingTessellator.Flags flags,
|
||||
DrawRange[] mergedRanges,
|
||||
DrawRange[] perDrawRanges
|
||||
) {}
|
||||
@@ -0,0 +1,21 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
|
||||
|
||||
/**
|
||||
* A compiled VBO containing all line geometry with associated draw ranges.
|
||||
* All ranges reference vertices within this single VBO.
|
||||
* <p>
|
||||
* Contains two range arrays:
|
||||
* <ul>
|
||||
* <li><b>mergedRanges</b>: For optimized path - consecutive same-transform draws merged</li>
|
||||
* <li><b>perDrawRanges</b>: For unoptimized path - 1:1 with original draws</li>
|
||||
* </ul>
|
||||
*/
|
||||
@Desugar
|
||||
record CompiledLineBuffer(
|
||||
VertexBuffer vbo,
|
||||
DrawRange[] mergedRanges,
|
||||
DrawRange[] perDrawRanges
|
||||
) {}
|
||||
@@ -0,0 +1,871 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadViewMutable;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.VAOManager;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VBOManager;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.AccumulatedDraw;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.AccumulatedLineDraw;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.CommandBuffer;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.CommandRecorder;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.CompiledDisplayList;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.ImmediateModeRecorder;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.commands.DisplayListCommand;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.commands.OptimizationContext;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
|
||||
import lombok.Getter;
|
||||
import lombok.experimental.UtilityClass;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.joml.Matrix4f;
|
||||
import org.joml.Matrix4fStack;
|
||||
import org.joml.Vector3f;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.ArrayDeque;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.Comparator;
|
||||
import java.util.Deque;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Manages display list compilation, caching, and playback.
|
||||
* Handles VBO-based display list emulation with command recording and batching.
|
||||
*
|
||||
* <p>This class is responsible for:
|
||||
* <ul>
|
||||
* <li>Display list lifecycle (glNewList, glEndList, glCallList, glDeleteLists)</li>
|
||||
* <li>Command recording and accumulation during compilation</li>
|
||||
* <li>Building optimized (batched) and unoptimized (nested-safe) command lists</li>
|
||||
* <li>Transform tracking and collapsing for optimal GL call counts</li>
|
||||
* <li>Cache management for compiled display lists</li>
|
||||
* </ul>
|
||||
*
|
||||
* <h3>Architecture: Transform Collapsing</h3>
|
||||
* <p>The optimization strategy collapses consecutive MODELVIEW transforms into single MultMatrix
|
||||
* commands, emitting them at "barriers" (draws, CallList, exit). This approach:</p>
|
||||
* <ul>
|
||||
* <li>Keeps vertices canonical (untransformed) in VBOs</li>
|
||||
* <li>Properly handles nested display lists (CallList) - GL state is correct before sub-list</li>
|
||||
* <li>Reduces GL calls (multiple transforms → one MultMatrix)</li>
|
||||
* <li>Maintains proper Push/Pop stack semantics</li>
|
||||
* </ul>
|
||||
*
|
||||
* <h4>Transform Tracking State</h4>
|
||||
* <ul>
|
||||
* <li><b>accumulated:</b> Total relative transform (what GL matrix should be)</li>
|
||||
* <li><b>lastEmitted:</b> What we've emitted (what GL matrix is)</li>
|
||||
* <li><b>stack:</b> Saved accumulated values at Push points</li>
|
||||
* </ul>
|
||||
*
|
||||
* <h4>Batching Strategy</h4>
|
||||
* <p>Format-based batching: All draws with the same vertex format share a single VBO via
|
||||
* {@link FormatBuffer}. Each draw's position within the VBO is tracked as a {@link DrawRange}.
|
||||
* Consecutive draws with the same transform are merged into single ranges. Transforms are
|
||||
* handled via delta-based emission using {@link TransformOptimizer}.</p>
|
||||
*
|
||||
* @see com.gtnewhorizons.angelica.glsm.recording.CompiledDisplayList
|
||||
* @see com.gtnewhorizons.angelica.glsm.recording.AccumulatedDraw
|
||||
* @see com.gtnewhorizons.angelica.glsm.recording.commands.DrawRangeCmd
|
||||
*/
|
||||
@UtilityClass
|
||||
public class DisplayListManager {
|
||||
private static final Logger LOGGER = LogManager.getLogger("DisplayListManager");
|
||||
|
||||
/**
|
||||
* Debug flag to enable building unoptimized display list commands.
|
||||
* When false (default), unoptimized commands are not built
|
||||
* When true, unoptimized commands are built for debugging GL behavior.
|
||||
* Set via: -Dangelica.debugDisplayLists=true
|
||||
*/
|
||||
private static final boolean DEBUG_DISPLAY_LISTS = Boolean.getBoolean("angelica.debugDisplayLists");
|
||||
|
||||
// Track which display list is currently being rendered
|
||||
@Getter private static int currentRenderingList = -1;
|
||||
|
||||
/**
|
||||
* Check if we're currently rendering a display list.
|
||||
* Used by format overrides to avoid interfering with display list VBOs.
|
||||
*/
|
||||
public static boolean isRenderingDisplayList() {
|
||||
return currentRenderingList != -1;
|
||||
}
|
||||
|
||||
static boolean isIdentity(Matrix4f m) {
|
||||
return (m.properties() & Matrix4f.PROPERTY_IDENTITY) != 0;
|
||||
}
|
||||
|
||||
/** Transform operation types for relative transform tracking. */
|
||||
public enum TransformOp { TRANSLATE, SCALE, ROTATE }
|
||||
|
||||
// Display list compilation state (current/active context)
|
||||
private static int glListMode = 0;
|
||||
private static int glListId = -1;
|
||||
private static boolean tessellatorCompiling = false; // Track if we started compiling
|
||||
private static CommandRecorder currentRecorder = null; // Command recorder (null when not recording)
|
||||
private static volatile Thread recordingThread = null; // Thread that started recording (for thread-safety)
|
||||
private static List<AccumulatedDraw> accumulatedDraws = null; // Accumulates quad draws for batching
|
||||
private static List<AccumulatedLineDraw> accumulatedLineDraws = null; // Accumulates line draws
|
||||
private static Matrix4fStack relativeTransform = null; // Tracks relative transforms during compilation (with push/pop support)
|
||||
@Getter private static ImmediateModeRecorder immediateModeRecorder = null; // Records glBegin/glEnd/glVertex during compilation
|
||||
|
||||
// Nested compilation support - stack of parent contexts
|
||||
private static final Deque<CompilationContext> compilationStack = new ArrayDeque<>();
|
||||
|
||||
// Display list cache
|
||||
private static final Int2ObjectMap<CompiledDisplayList> displayListCache = new Int2ObjectOpenHashMap<>();
|
||||
|
||||
/**
|
||||
* Compilation context for a single display list being compiled.
|
||||
* Used to support nested glNewList() calls (spec-violating but needed for mod compatibility).
|
||||
*/
|
||||
@Desugar
|
||||
private record CompilationContext(
|
||||
int listId,
|
||||
int listMode,
|
||||
CommandRecorder recorder,
|
||||
List<AccumulatedDraw> draws,
|
||||
List<AccumulatedLineDraw> lineDraws,
|
||||
Matrix4fStack transform,
|
||||
boolean wasTessellatorCompiling,
|
||||
ImmediateModeRecorder immediateRecorder
|
||||
) {}
|
||||
|
||||
/**
|
||||
* Check if the current thread is recording a display list.
|
||||
* Only returns true for the thread that started recording.
|
||||
* This prevents other threads from having their GL calls captured.
|
||||
*/
|
||||
public static boolean isRecording() {
|
||||
return currentRecorder != null && Thread.currentThread() == recordingThread;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the ID of the display list currently being recorded.
|
||||
* @return The list ID, or -1 if not recording
|
||||
*/
|
||||
public static int getRecordingListId() {
|
||||
return glListId;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current display list mode (GL_COMPILE or GL_COMPILE_AND_EXECUTE).
|
||||
* @return The current list mode, or 0 if not recording
|
||||
*/
|
||||
public static int getListMode() {
|
||||
return glListMode;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current command count (for draw position tracking).
|
||||
* @return The current command position
|
||||
*/
|
||||
public static int getCommandCount() {
|
||||
return currentRecorder != null ? currentRecorder.getCommandCount() : 0;
|
||||
}
|
||||
|
||||
// ==================== Recording Method Delegates ====================
|
||||
// These delegate to the current CommandRecorder during compilation.
|
||||
|
||||
public static void recordEnable(int cap) { if (currentRecorder != null) currentRecorder.recordEnable(cap); }
|
||||
public static void recordDisable(int cap) { if (currentRecorder != null) currentRecorder.recordDisable(cap); }
|
||||
public static void recordClear(int mask) { if (currentRecorder != null) currentRecorder.recordClear(mask); }
|
||||
public static void recordClearColor(float r, float g, float b, float a) { if (currentRecorder != null) currentRecorder.recordClearColor(r, g, b, a); }
|
||||
public static void recordClearStencil(int s) { if (currentRecorder != null) currentRecorder.recordClearStencil(s); }
|
||||
public static void recordColor(float r, float g, float b, float a) { if (currentRecorder != null) currentRecorder.recordColor(r, g, b, a); }
|
||||
public static void recordColorMask(boolean r, boolean g, boolean b, boolean a) { if (currentRecorder != null) currentRecorder.recordColorMask(r, g, b, a); }
|
||||
public static void recordDepthMask(boolean flag) { if (currentRecorder != null) currentRecorder.recordDepthMask(flag); }
|
||||
public static void recordDepthFunc(int func) { if (currentRecorder != null) currentRecorder.recordDepthFunc(func); }
|
||||
public static void recordBlendFunc(int srcRgb, int dstRgb, int srcAlpha, int dstAlpha) { if (currentRecorder != null) currentRecorder.recordBlendFunc(srcRgb, dstRgb, srcAlpha, dstAlpha); }
|
||||
public static void recordAlphaFunc(int func, float ref) { if (currentRecorder != null) currentRecorder.recordAlphaFunc(func, ref); }
|
||||
public static void recordCullFace(int mode) { if (currentRecorder != null) currentRecorder.recordCullFace(mode); }
|
||||
public static void recordShadeModel(int mode) { if (currentRecorder != null) currentRecorder.recordShadeModel(mode); }
|
||||
public static void recordBindTexture(int target, int texture) { if (currentRecorder != null) currentRecorder.recordBindTexture(target, texture); }
|
||||
public static void recordTexParameteri(int target, int pname, int param) { if (currentRecorder != null) currentRecorder.recordTexParameteri(target, pname, param); }
|
||||
public static void recordTexParameterf(int target, int pname, float param) { if (currentRecorder != null) currentRecorder.recordTexParameterf(target, pname, param); }
|
||||
public static void recordMatrixMode(int mode) { if (currentRecorder != null) currentRecorder.recordMatrixMode(mode); }
|
||||
public static void recordLoadIdentity(int matrixMode) { if (currentRecorder != null) currentRecorder.recordLoadIdentity(matrixMode); }
|
||||
public static void recordPushMatrix(int matrixMode) { if (currentRecorder != null) currentRecorder.recordPushMatrix(matrixMode); }
|
||||
public static void recordPopMatrix(int matrixMode) { if (currentRecorder != null) currentRecorder.recordPopMatrix(matrixMode); }
|
||||
public static void recordTranslate(int matrixMode, double x, double y, double z) { if (currentRecorder != null) currentRecorder.recordTranslate(matrixMode, x, y, z); }
|
||||
public static void recordRotate(int matrixMode, double angle, double x, double y, double z) { if (currentRecorder != null) currentRecorder.recordRotate(matrixMode, angle, x, y, z); }
|
||||
public static void recordScale(int matrixMode, double x, double y, double z) { if (currentRecorder != null) currentRecorder.recordScale(matrixMode, x, y, z); }
|
||||
public static void recordMultMatrix(int matrixMode, Matrix4f matrix) { if (currentRecorder != null) currentRecorder.recordMultMatrix(matrixMode, matrix); }
|
||||
public static void recordLoadMatrix(int matrixMode, Matrix4f matrix) { if (currentRecorder != null) currentRecorder.recordLoadMatrix(matrixMode, matrix); }
|
||||
public static void recordOrtho(double left, double right, double bottom, double top, double zNear, double zFar) { if (currentRecorder != null) currentRecorder.recordOrtho(left, right, bottom, top, zNear, zFar); }
|
||||
public static void recordFrustum(double left, double right, double bottom, double top, double zNear, double zFar) { if (currentRecorder != null) currentRecorder.recordFrustum(left, right, bottom, top, zNear, zFar); }
|
||||
public static void recordViewport(int x, int y, int width, int height) { if (currentRecorder != null) currentRecorder.recordViewport(x, y, width, height); }
|
||||
public static void recordNormal(float nx, float ny, float nz) { if (currentRecorder != null) currentRecorder.recordNormal(nx, ny, nz); }
|
||||
public static void recordPointSize(float size) { if (currentRecorder != null) currentRecorder.recordPointSize(size); }
|
||||
public static void recordLineWidth(float width) { if (currentRecorder != null) currentRecorder.recordLineWidth(width); }
|
||||
public static void recordLineStipple(int factor, int pattern) { if (currentRecorder != null) currentRecorder.recordLineStipple(factor, pattern); }
|
||||
public static void recordPolygonOffset(float factor, float units) { if (currentRecorder != null) currentRecorder.recordPolygonOffset(factor, units); }
|
||||
public static void recordPolygonMode(int face, int mode) { if (currentRecorder != null) currentRecorder.recordPolygonMode(face, mode); }
|
||||
public static void recordColorMaterial(int face, int mode) { if (currentRecorder != null) currentRecorder.recordColorMaterial(face, mode); }
|
||||
public static void recordLogicOp(int opcode) { if (currentRecorder != null) currentRecorder.recordLogicOp(opcode); }
|
||||
public static void recordActiveTexture(int texture) { if (currentRecorder != null) currentRecorder.recordActiveTexture(texture); }
|
||||
public static void recordUseProgram(int program) { if (currentRecorder != null) currentRecorder.recordUseProgram(program); }
|
||||
public static void recordPushAttrib(int mask) { if (currentRecorder != null) currentRecorder.recordPushAttrib(mask); }
|
||||
public static void recordPopAttrib() { if (currentRecorder != null) currentRecorder.recordPopAttrib(); }
|
||||
public static void recordFogf(int pname, float param) { if (currentRecorder != null) currentRecorder.recordFogf(pname, param); }
|
||||
public static void recordFogi(int pname, int param) { if (currentRecorder != null) currentRecorder.recordFogi(pname, param); }
|
||||
public static void recordFog(int pname, java.nio.FloatBuffer params) { if (currentRecorder != null) currentRecorder.recordFog(pname, params); }
|
||||
public static void recordLightf(int light, int pname, float param) { if (currentRecorder != null) currentRecorder.recordLightf(light, pname, param); }
|
||||
public static void recordLighti(int light, int pname, int param) { if (currentRecorder != null) currentRecorder.recordLighti(light, pname, param); }
|
||||
public static void recordLight(int light, int pname, java.nio.FloatBuffer params) { if (currentRecorder != null) currentRecorder.recordLight(light, pname, params); }
|
||||
public static void recordLightModelf(int pname, float param) { if (currentRecorder != null) currentRecorder.recordLightModelf(pname, param); }
|
||||
public static void recordLightModeli(int pname, int param) { if (currentRecorder != null) currentRecorder.recordLightModeli(pname, param); }
|
||||
public static void recordLightModel(int pname, java.nio.FloatBuffer params) { if (currentRecorder != null) currentRecorder.recordLightModel(pname, params); }
|
||||
public static void recordMaterialf(int face, int pname, float val) { if (currentRecorder != null) currentRecorder.recordMaterialf(face, pname, val); }
|
||||
public static void recordMaterial(int face, int pname, java.nio.FloatBuffer params) { if (currentRecorder != null) currentRecorder.recordMaterial(face, pname, params); }
|
||||
public static void recordStencilFunc(int func, int ref, int mask) { if (currentRecorder != null) currentRecorder.recordStencilFunc(func, ref, mask); }
|
||||
public static void recordStencilFuncSeparate(int face, int func, int ref, int mask) { if (currentRecorder != null) currentRecorder.recordStencilFuncSeparate(face, func, ref, mask); }
|
||||
public static void recordStencilOp(int fail, int zfail, int zpass) { if (currentRecorder != null) currentRecorder.recordStencilOp(fail, zfail, zpass); }
|
||||
public static void recordStencilOpSeparate(int face, int sfail, int dpfail, int dppass) { if (currentRecorder != null) currentRecorder.recordStencilOpSeparate(face, sfail, dpfail, dppass); }
|
||||
public static void recordStencilMask(int mask) { if (currentRecorder != null) currentRecorder.recordStencilMask(mask); }
|
||||
public static void recordStencilMaskSeparate(int face, int mask) { if (currentRecorder != null) currentRecorder.recordStencilMaskSeparate(face, mask); }
|
||||
public static void recordCallList(int listId) { if (currentRecorder != null) currentRecorder.recordCallList(listId); }
|
||||
public static void recordComplexCommand(DisplayListCommand cmd) { if (currentRecorder != null) currentRecorder.recordComplexCommand(cmd); }
|
||||
|
||||
/**
|
||||
* Add an immediate mode draw to the current display list compilation.
|
||||
* Called by GLStateManager.glEnd() when immediate mode geometry is ready.
|
||||
*
|
||||
* <p>This method captures the current transform and command position, creating
|
||||
* an AccumulatedDraw that will be interleaved correctly with other commands
|
||||
* during display list playback.
|
||||
*
|
||||
* @param result The immediate mode result containing quads, lines, and flags
|
||||
*/
|
||||
public static void addImmediateModeDraw(ImmediateModeRecorder.Result result) {
|
||||
if (accumulatedDraws == null || result == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Get relative transform (changes since glNewList, not absolute matrix state)
|
||||
final Matrix4f currentTransform = new Matrix4f(relativeTransform);
|
||||
|
||||
// Add quad draw if we have quads
|
||||
if (!result.quads().isEmpty()) {
|
||||
final AccumulatedDraw quadDraw = new AccumulatedDraw(result.quads(), currentTransform, result.flags(), getCommandCount());
|
||||
accumulatedDraws.add(quadDraw);
|
||||
}
|
||||
|
||||
// Add line draw if we have lines
|
||||
if (!result.lines().isEmpty()) {
|
||||
final AccumulatedLineDraw lineDraw = new AccumulatedLineDraw(result.lines(), currentTransform, result.flags(), getCommandCount());
|
||||
accumulatedLineDraws.add(lineDraw);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Update the relative transform during display list compilation.
|
||||
* Called by GLStateManager matrix methods (glTranslate, glRotate, glScale).
|
||||
*
|
||||
* @param x Translation x, scale x, or rotation angle (degrees)
|
||||
* @param y Translation y or scale y (ignored for rotate)
|
||||
* @param z Translation z or scale z (ignored for rotate)
|
||||
* @param op The operation type
|
||||
* @param rotationAxis For rotation only, the axis vector (null otherwise)
|
||||
*/
|
||||
public static void updateRelativeTransform(float x, float y, float z, TransformOp op, Vector3f rotationAxis) {
|
||||
if (relativeTransform == null || !GLStateManager.isModelViewMatrix()) {
|
||||
return;
|
||||
}
|
||||
|
||||
switch (op) {
|
||||
case TRANSLATE -> relativeTransform.translate(x, y, z);
|
||||
case SCALE -> relativeTransform.scale(x, y, z);
|
||||
case ROTATE -> {
|
||||
if (rotationAxis != null) {
|
||||
relativeTransform.rotate((float) Math.toRadians(x), rotationAxis);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Update the relative transform with a matrix multiplication during display list compilation.
|
||||
* Called by GLStateManager.glMultMatrix().
|
||||
*
|
||||
* @param matrix The matrix to multiply
|
||||
*/
|
||||
public static void updateRelativeTransform(Matrix4f matrix) {
|
||||
if (relativeTransform == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Only track MODELVIEW - projection/texture don't affect baked geometry
|
||||
if (!GLStateManager.isModelViewMatrix()) {
|
||||
return;
|
||||
}
|
||||
|
||||
relativeTransform.mul(matrix);
|
||||
}
|
||||
|
||||
/**
|
||||
* Push the current MODELVIEW transform onto the stack.
|
||||
* Only operates when current matrix mode is MODELVIEW.
|
||||
* Called by GLStateManager.glPushMatrix() during recording.
|
||||
*/
|
||||
public static void pushRelativeTransform() {
|
||||
if (relativeTransform == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Only track MODELVIEW - projection/texture don't affect baked geometry
|
||||
if (!GLStateManager.isModelViewMatrix()) {
|
||||
return;
|
||||
}
|
||||
|
||||
relativeTransform.pushMatrix();
|
||||
}
|
||||
|
||||
/**
|
||||
* Pop the MODELVIEW transform from stack.
|
||||
* Only operates when current matrix mode is MODELVIEW.
|
||||
* Called by GLStateManager.glPopMatrix() during recording.
|
||||
*/
|
||||
public static void popRelativeTransform() {
|
||||
if (relativeTransform == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Only track MODELVIEW - projection/texture don't affect baked geometry
|
||||
if (!GLStateManager.isModelViewMatrix()) {
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
relativeTransform.popMatrix();
|
||||
} catch (RuntimeException e) {
|
||||
LOGGER.warn("[DisplayList] Transform stack underflow in list={}", glListId);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset the relative transform to identity during display list compilation.
|
||||
* Called by GLStateManager.glLoadMatrix() - after loading an absolute matrix,
|
||||
* subsequent transforms are relative to that loaded matrix (i.e., start from identity).
|
||||
*/
|
||||
public static void resetRelativeTransform() {
|
||||
if (relativeTransform == null) {
|
||||
return;
|
||||
}
|
||||
relativeTransform.identity();
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a display list exists (has been compiled and stored).
|
||||
* Checks both DisplayListManager's cache and VBOManager for GTNHLib compatibility.
|
||||
*
|
||||
* @param list The display list ID to check
|
||||
* @return true if the display list exists, false otherwise
|
||||
*/
|
||||
public static boolean displayListExists(int list) {
|
||||
if (displayListCache.containsKey(list)) {
|
||||
return true;
|
||||
}
|
||||
// Check VBOManager for GTNHLib compatibility (negative IDs)
|
||||
if (list < -1) {
|
||||
return VBOManager.get(list) != null;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a compiled display list from the cache.
|
||||
* Used by CallListCmd to execute nested display lists with the unoptimized version.
|
||||
*
|
||||
* @param list The display list ID
|
||||
* @return The CompiledDisplayList, or null if not found
|
||||
*/
|
||||
public static CompiledDisplayList getDisplayList(int list) {
|
||||
return displayListCache.get(list);
|
||||
}
|
||||
|
||||
/**
|
||||
* Start display list compilation.
|
||||
* Supports nested glNewList() calls (spec-violating but needed for mod compatibility).
|
||||
*/
|
||||
public static void glNewList(int list, int mode) {
|
||||
// Assert main thread for display list compilation
|
||||
if (!Thread.currentThread().equals(GLStateManager.getMainThread())) {
|
||||
throw new IllegalStateException("Display list compilation must happen on main thread");
|
||||
}
|
||||
|
||||
// Handle nested compilation - push current context onto stack
|
||||
final boolean isNested = glListMode > 0;
|
||||
|
||||
if (isNested) {
|
||||
// Nested display list compilation violates OpenGL spec, but some of our optimizations require it
|
||||
// Save current compilation context and start fresh for nested list
|
||||
final CompilationContext parentContext = new CompilationContext(
|
||||
glListId, glListMode, currentRecorder, accumulatedDraws, accumulatedLineDraws,
|
||||
relativeTransform, tessellatorCompiling, immediateModeRecorder
|
||||
);
|
||||
compilationStack.push(parentContext);
|
||||
}
|
||||
|
||||
// Initialize fresh context for this (possibly nested) list
|
||||
glListId = list;
|
||||
glListMode = mode;
|
||||
recordingThread = Thread.currentThread(); // Track which thread is recording
|
||||
currentRecorder = new CommandRecorder(); // Create command recorder
|
||||
accumulatedDraws = new ArrayList<>(64); // Fewer draws than commands typically
|
||||
accumulatedLineDraws = new ArrayList<>(16); // Line draws are less common
|
||||
relativeTransform = new Matrix4fStack(GLStateManager.MAX_MODELVIEW_STACK_DEPTH);
|
||||
relativeTransform.identity(); // Track relative transforms from identity
|
||||
immediateModeRecorder = new ImmediateModeRecorder(); // For glBegin/glEnd/glVertex
|
||||
|
||||
// Start compiling mode with per-draw callback (works for both root and nested lists now)
|
||||
TessellatorManager.setCompiling((quads, flags) -> {
|
||||
if (quads.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Get relative transform (changes since glNewList, not absolute matrix state)
|
||||
final Matrix4f currentTransform = new Matrix4f(relativeTransform);
|
||||
|
||||
// Accumulate this draw for batching at glEndList()
|
||||
final AccumulatedDraw draw = new AccumulatedDraw(quads, currentTransform, flags, getCommandCount());
|
||||
accumulatedDraws.add(draw);
|
||||
});
|
||||
tessellatorCompiling = true;
|
||||
|
||||
// We hijack display list compilation completely - no GL11.glNewList() calls
|
||||
// During compile don't actually apply any changes to GL, but do track them
|
||||
GLStateManager.getModelViewMatrix().pushMatrix(); // Save current model view matrix state
|
||||
GLStateManager.pushState(GL11.GL_ALL_ATTRIB_BITS);
|
||||
}
|
||||
|
||||
/**
|
||||
* End display list compilation and build optimized/unoptimized versions.
|
||||
*/
|
||||
public static void glEndList() {
|
||||
if (glListMode == 0) {
|
||||
throw new RuntimeException("glEndList called outside of a display list!");
|
||||
}
|
||||
final boolean needsRender = glListMode == GL11.GL_COMPILE_AND_EXECUTE;
|
||||
final boolean isNested = !compilationStack.isEmpty();
|
||||
|
||||
// Stop compiling mode (works for both root and nested lists now)
|
||||
if (tessellatorCompiling) {
|
||||
TessellatorManager.stopCompiling();
|
||||
tessellatorCompiling = false;
|
||||
}
|
||||
|
||||
final CompiledDisplayList compiled;
|
||||
// Create CompiledDisplayList with both unoptimized and optimized versions
|
||||
final CommandBuffer rawCommandBuffer = currentRecorder != null ? currentRecorder.getBuffer() : null;
|
||||
final boolean hasCommands = rawCommandBuffer != null && rawCommandBuffer.size() > 0;
|
||||
final boolean hasDraws = accumulatedDraws != null && !accumulatedDraws.isEmpty();
|
||||
final boolean hasLineDraws = accumulatedLineDraws != null && !accumulatedLineDraws.isEmpty();
|
||||
|
||||
if (hasCommands || hasDraws || hasLineDraws) {
|
||||
// Phase 1: Compile format-based VBOs (shared by both optimized and unoptimized paths)
|
||||
final Map<CapturingTessellator.Flags, CompiledFormatBuffer> compiledQuadBuffers = compileFormatBasedVBOs(accumulatedDraws);
|
||||
|
||||
// Phase 2: Compile line VBO (shared by both paths)
|
||||
final CompiledLineBuffer compiledLineBuffer = compileLineBuffer(accumulatedLineDraws);
|
||||
|
||||
// Collect all owned VBOs (quads + lines)
|
||||
final VertexBuffer[] ownedVbos = extractOwnedVbos(compiledQuadBuffers, compiledLineBuffer);
|
||||
|
||||
// Build to CommandBuffer - optimize raw buffer to final buffer
|
||||
final CommandBuffer finalBuffer = new CommandBuffer();
|
||||
if (DEBUG_DISPLAY_LISTS) {
|
||||
CommandBufferBuilder.buildUnoptimizedFromRawBuffer(rawCommandBuffer, accumulatedDraws, compiledQuadBuffers, compiledLineBuffer, ownedVbos, finalBuffer);
|
||||
} else {
|
||||
CommandBufferBuilder.buildOptimizedFromRawBuffer(rawCommandBuffer, compiledQuadBuffers, compiledLineBuffer, ownedVbos, glListId, finalBuffer);
|
||||
}
|
||||
|
||||
// Free the recorder (and its buffer) after optimization
|
||||
currentRecorder.free();
|
||||
|
||||
compiled = new CompiledDisplayList(finalBuffer.toBuffer(), finalBuffer.getComplexObjects(), ownedVbos);
|
||||
displayListCache.put(glListId, compiled);
|
||||
} else {
|
||||
// Free the recorder even if empty
|
||||
if (currentRecorder != null) {
|
||||
currentRecorder.free();
|
||||
}
|
||||
compiled = null;
|
||||
}
|
||||
|
||||
// Handle nested compilation - restore parent context
|
||||
if (isNested) {
|
||||
final CompilationContext parentContext = compilationStack.pop();
|
||||
|
||||
// Restore parent context
|
||||
glListId = parentContext.listId;
|
||||
glListMode = parentContext.listMode;
|
||||
currentRecorder = parentContext.recorder;
|
||||
accumulatedDraws = parentContext.draws;
|
||||
accumulatedLineDraws = parentContext.lineDraws;
|
||||
relativeTransform = parentContext.transform;
|
||||
tessellatorCompiling = parentContext.wasTessellatorCompiling;
|
||||
immediateModeRecorder = parentContext.immediateRecorder;
|
||||
|
||||
// Note: TessellatorManager callback stack was popped by stopCompiling()
|
||||
// Parent's COMPILING callback is now active again
|
||||
} else {
|
||||
// Not nested - clear all compilation state
|
||||
currentRecorder = null;
|
||||
recordingThread = null;
|
||||
accumulatedDraws = null;
|
||||
accumulatedLineDraws = null;
|
||||
relativeTransform = null;
|
||||
immediateModeRecorder = null;
|
||||
glListId = -1;
|
||||
glListMode = 0;
|
||||
}
|
||||
|
||||
GLStateManager.getModelViewMatrix().popMatrix();
|
||||
GLStateManager.popState();
|
||||
|
||||
// Only execute if COMPILE_AND_EXECUTE AND this is the root (non-nested) list
|
||||
// Nested lists will execute naturally when the parent executes via CallListCmd
|
||||
if (needsRender && !isNested && compiled != null) {
|
||||
compiled.render();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute a compiled display list.
|
||||
*/
|
||||
public static void glCallList(int list) {
|
||||
// If we're currently recording, record a reference to this list Per OpenGL spec: the inner list is NOT executed during compilation.
|
||||
// It only executes when the parent list is played back.
|
||||
// For GL_COMPILE_AND_EXECUTE: the entire parent list (including this CallListCmd) executes at the end of glEndList, not during compilation.
|
||||
if (currentRecorder != null) {
|
||||
// Record a CallList command that will execute the referenced list during playback
|
||||
recordCallList(list);
|
||||
return;
|
||||
}
|
||||
|
||||
// Normal playback mode
|
||||
final CompiledDisplayList compiled = displayListCache.get(list);
|
||||
if (compiled != null) {
|
||||
GLStateManager.trySyncProgram();
|
||||
final int prevList = currentRenderingList;
|
||||
currentRenderingList = list;
|
||||
compiled.render();
|
||||
currentRenderingList = prevList;
|
||||
return;
|
||||
}
|
||||
|
||||
// Fall back to VBOManager or legacy display list
|
||||
if (list < 0) {
|
||||
// Negative IDs are VBOManager space (entity models, etc.)
|
||||
final VertexBuffer vbo = VBOManager.get(list);
|
||||
if (vbo != null) {
|
||||
vbo.render();
|
||||
}
|
||||
// Per OpenGL spec: if list is undefined, glCallList has no effect
|
||||
} else {
|
||||
// Positive IDs - fall back to native GL display lists
|
||||
// This happens for lists allocated but never compiled via glNewList
|
||||
GLStateManager.trySyncProgram();
|
||||
GL11.glCallList(list);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete display lists and free their VBO resources.
|
||||
*/
|
||||
public static void glDeleteLists(int list, int range) {
|
||||
for (int i = list; i < list + range; i++) {
|
||||
CompiledDisplayList compiled = displayListCache.remove(i);
|
||||
if (compiled != null) {
|
||||
compiled.delete();
|
||||
}
|
||||
}
|
||||
// Also call legacy glDeleteLists for any lists we didn't handle
|
||||
GL11.glDeleteLists(list, range);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile format-based VBOs from accumulated draws.
|
||||
* Groups draws by vertex format and compiles each format's geometry into a single VBO.
|
||||
* Both optimized and unoptimized paths share these VBOs.
|
||||
*
|
||||
* @param accumulatedDraws The accumulated draws to compile
|
||||
* @return Map from format flags to compiled buffers (VBO + ranges)
|
||||
*/
|
||||
private static Map<CapturingTessellator.Flags, CompiledFormatBuffer> compileFormatBasedVBOs(
|
||||
List<AccumulatedDraw> accumulatedDraws) {
|
||||
if (accumulatedDraws == null || accumulatedDraws.isEmpty()) {
|
||||
return Collections.emptyMap();
|
||||
}
|
||||
|
||||
// Group draws by vertex format
|
||||
final Map<CapturingTessellator.Flags, FormatBuffer> formatBuffers = new HashMap<>();
|
||||
for (AccumulatedDraw draw : accumulatedDraws) {
|
||||
formatBuffers.computeIfAbsent(draw.flags, FormatBuffer::new).addDraw(draw);
|
||||
}
|
||||
|
||||
// Compile each format's geometry into a single VBO
|
||||
final Map<CapturingTessellator.Flags, CompiledFormatBuffer> compiled = new HashMap<>();
|
||||
for (var entry : formatBuffers.entrySet()) {
|
||||
compiled.put(entry.getKey(), entry.getValue().finish());
|
||||
}
|
||||
return compiled;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile line draws into a shared VBO.
|
||||
*
|
||||
* @param lineDraws The accumulated line draws
|
||||
* @return Compiled line buffer, or null if no lines
|
||||
*/
|
||||
private static CompiledLineBuffer compileLineBuffer(List<AccumulatedLineDraw> lineDraws) {
|
||||
if (lineDraws == null || lineDraws.isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
|
||||
final LineBuffer buffer = new LineBuffer();
|
||||
for (AccumulatedLineDraw draw : lineDraws) {
|
||||
buffer.addDraw(draw);
|
||||
}
|
||||
return buffer.finish();
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract owned VBOs from compiled buffers (quads + lines).
|
||||
* These VBOs are shared by both optimized and unoptimized paths.
|
||||
*
|
||||
* @param compiledQuadBuffers The compiled quad format buffers
|
||||
* @param compiledLineBuffer The compiled line buffer (may be null)
|
||||
* @return Array of VBOs that need to be deleted when the display list is deleted
|
||||
*/
|
||||
private static VertexBuffer[] extractOwnedVbos(
|
||||
Map<CapturingTessellator.Flags, CompiledFormatBuffer> compiledQuadBuffers,
|
||||
CompiledLineBuffer compiledLineBuffer) {
|
||||
final List<VertexBuffer> vbos = new ArrayList<>();
|
||||
|
||||
// Add quad VBOs
|
||||
for (CompiledFormatBuffer buffer : compiledQuadBuffers.values()) {
|
||||
vbos.add(buffer.vbo());
|
||||
}
|
||||
|
||||
// Add line VBO if present
|
||||
if (compiledLineBuffer != null) {
|
||||
vbos.add(compiledLineBuffer.vbo());
|
||||
}
|
||||
|
||||
return vbos.toArray(new VertexBuffer[0]);
|
||||
}
|
||||
|
||||
// ==================== Buffer-to-Buffer Optimization ====================
|
||||
/**
|
||||
* Build optimized command list using pre-compiled VBOs.
|
||||
* Uses mergedRanges (consecutive same-transform draws combined) and collapses MODELVIEW transforms.
|
||||
* (Package-private for testing)
|
||||
*
|
||||
* @param currentCommands Original matrix/state commands
|
||||
* @param compiledQuadBuffers Pre-compiled format-based quad VBOs
|
||||
* @param compiledLineBuffer Pre-compiled line VBO (may be null)
|
||||
* @param glListId Display list ID for logging
|
||||
* @return Optimized command array
|
||||
*/
|
||||
static DisplayListCommand[] buildOptimizedCommands(
|
||||
List<DisplayListCommand> currentCommands,
|
||||
Map<CapturingTessellator.Flags, CompiledFormatBuffer> compiledQuadBuffers,
|
||||
CompiledLineBuffer compiledLineBuffer,
|
||||
int glListId) {
|
||||
|
||||
final List<DisplayListCommand> optimized = new ArrayList<>();
|
||||
final TransformOptimizer transformOpt = new TransformOptimizer(glListId);
|
||||
|
||||
// Collect all merged draw ranges (quads + lines) sorted by command index
|
||||
final List<DrawRangeWithBuffer> allRanges = new ArrayList<>();
|
||||
|
||||
// Add quad ranges
|
||||
for (CompiledFormatBuffer compiledBuffer : compiledQuadBuffers.values()) {
|
||||
for (DrawRange range : compiledBuffer.mergedRanges()) {
|
||||
allRanges.add(new DrawRangeWithBuffer(range, compiledBuffer.vbo(), compiledBuffer.flags().hasBrightness));
|
||||
}
|
||||
}
|
||||
|
||||
// Add line ranges
|
||||
if (compiledLineBuffer != null) {
|
||||
for (DrawRange range : compiledLineBuffer.mergedRanges()) {
|
||||
allRanges.add(new DrawRangeWithBuffer(range, compiledLineBuffer.vbo(), false));
|
||||
}
|
||||
}
|
||||
|
||||
allRanges.sort(Comparator.comparingInt(r -> r.range().commandIndex()));
|
||||
|
||||
// Process command stream with interleaved draws
|
||||
final OptimizationContextImpl ctx = new OptimizationContextImpl(transformOpt, optimized);
|
||||
|
||||
int rangeIndex = 0;
|
||||
for (int i = 0; i < currentCommands.size(); i++) {
|
||||
// Emit draw ranges (quads and lines) at this command position
|
||||
while (rangeIndex < allRanges.size() && allRanges.get(rangeIndex).range().commandIndex() == i) {
|
||||
emitDrawRangeLegacy(allRanges.get(rangeIndex++), transformOpt, optimized);
|
||||
}
|
||||
|
||||
// Process the original command
|
||||
final DisplayListCommand cmd = currentCommands.get(i);
|
||||
if (cmd.handleOptimization(ctx)) {
|
||||
optimized.add(cmd);
|
||||
}
|
||||
}
|
||||
|
||||
// Emit remaining draw ranges at end of command stream
|
||||
while (rangeIndex < allRanges.size()) {
|
||||
emitDrawRangeLegacy(allRanges.get(rangeIndex++), transformOpt, optimized);
|
||||
}
|
||||
|
||||
// Emit residual transform to match expected GL state
|
||||
if (!transformOpt.isIdentity()) {
|
||||
transformOpt.emitPendingTransform(optimized);
|
||||
}
|
||||
|
||||
return optimized.toArray(new DisplayListCommand[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build optimized display list: batches draws with same flags, collapses MODELVIEW transforms.
|
||||
* Instead of baking transforms into vertices, we emit collapsed MultMatrix commands at barriers.
|
||||
* This properly handles nested display lists (CallList) which need GL state to be correct.
|
||||
*
|
||||
* <p>Transform collapsing strategy:
|
||||
* <ul>
|
||||
* <li>Track accumulated MODELVIEW transform during command stream analysis</li>
|
||||
* <li>At barriers (Draw, CallList), emit a single MultMatrix if transform changed</li>
|
||||
* <li>Push/Pop maintain proper stack semantics</li>
|
||||
* <li>Vertices stay canonical (untransformed) in VBOs</li>
|
||||
* </ul>
|
||||
*/
|
||||
// Package-private for testing
|
||||
static OptimizedListResult buildOptimizedDisplayList(
|
||||
List<DisplayListCommand> currentCommands,
|
||||
List<AccumulatedDraw> accumulatedDraws,
|
||||
List<AccumulatedLineDraw> accumulatedLineDraws,
|
||||
int glListId) {
|
||||
// Compile quad VBOs
|
||||
final Map<CapturingTessellator.Flags, CompiledFormatBuffer> compiledQuadBuffers = compileFormatBasedVBOs(accumulatedDraws);
|
||||
|
||||
// Compile line VBO
|
||||
final CompiledLineBuffer compiledLineBuffer = compileLineBuffer(accumulatedLineDraws);
|
||||
|
||||
// Extract owned VBOs
|
||||
final VertexBuffer[] ownedVbos = extractOwnedVbos(compiledQuadBuffers, compiledLineBuffer);
|
||||
|
||||
// Build optimized commands using the new unified path
|
||||
final DisplayListCommand[] optimized = buildOptimizedCommands(currentCommands, compiledQuadBuffers, compiledLineBuffer, glListId);
|
||||
|
||||
return new OptimizedListResult(optimized, ownedVbos);
|
||||
}
|
||||
|
||||
/**
|
||||
* Emit a draw range command for the legacy path (testing).
|
||||
* Uses delta-based transform emission via TransformOptimizer.
|
||||
*/
|
||||
private static void emitDrawRangeLegacy(DrawRangeWithBuffer drwb, TransformOptimizer transformOpt,
|
||||
List<DisplayListCommand> output) {
|
||||
final DrawRange range = drwb.range();
|
||||
|
||||
// Delta-based: only emit MultMatrix if transform differs from last emitted
|
||||
if (transformOpt.needsTransformForDraw(range.transform())) {
|
||||
transformOpt.emitTransformTo(output, range.transform());
|
||||
}
|
||||
|
||||
output.add(new com.gtnewhorizons.angelica.glsm.recording.commands.DrawRangeCmd(
|
||||
drwb.vbo(),
|
||||
range.startVertex(),
|
||||
range.vertexCount(),
|
||||
drwb.hasBrightness()
|
||||
));
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of OptimizationContext that wraps transform optimizer.
|
||||
*/
|
||||
@Desugar
|
||||
private record OptimizationContextImpl(
|
||||
TransformOptimizer transformOpt,
|
||||
List<DisplayListCommand> output
|
||||
) implements OptimizationContext {
|
||||
@Override public Matrix4f getAccumulatedTransform() { return transformOpt.getAccumulated(); }
|
||||
@Override public void loadIdentity() { transformOpt.loadIdentity(); }
|
||||
@Override public void pushTransform() { transformOpt.pushTransform(); }
|
||||
@Override public void popTransform() { transformOpt.popTransform(); }
|
||||
@Override public void emitPendingTransform() { transformOpt.emitPendingTransform(output); }
|
||||
@Override public void emitTransformTo(Matrix4f target) { transformOpt.emitTransformTo(output, target); }
|
||||
@Override public void emit(DisplayListCommand cmd) { output.add(cmd); }
|
||||
@Override public void markAbsoluteMatrix() { transformOpt.markAbsoluteMatrix(); }
|
||||
@Override public boolean checkAndClearAbsoluteMatrix() { return transformOpt.checkAndClearAbsoluteMatrix(); }
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Selects the optimal VertexFormat from GTNHLib defaults based on actual attribute usage.
|
||||
* This reduces memory usage by excluding unused attributes.
|
||||
*/
|
||||
private static VertexFormat selectOptimalFormat(CapturingTessellator.Flags flags) {
|
||||
final boolean hasColor = flags.hasColor;
|
||||
final boolean hasTexture = flags.hasTexture;
|
||||
final boolean hasBrightness = flags.hasBrightness;
|
||||
final boolean hasNormals = flags.hasNormals;
|
||||
|
||||
final VertexFormat format;
|
||||
|
||||
// Map flags to GTNHLib formats, ordered by guess at frequency/likelihood
|
||||
if (!hasColor && hasTexture && !hasBrightness && !hasNormals) {
|
||||
format = DefaultVertexFormat.POSITION_TEXTURE; // Entity models, common
|
||||
} else if (!hasColor && !hasTexture && !hasBrightness && !hasNormals) {
|
||||
format = DefaultVertexFormat.POSITION; // Sky rendering, simple geometry
|
||||
} else if (hasColor && hasTexture && !hasBrightness && !hasNormals) {
|
||||
format = DefaultVertexFormat.POSITION_COLOR_TEXTURE; // Colored blocks/UI
|
||||
} else if (!hasColor && hasTexture && hasBrightness && hasNormals) {
|
||||
format = DefaultVertexFormat.POSITION_TEXTURE_LIGHT_NORMAL; // BuildCraft fluids
|
||||
} else if (!hasColor && hasTexture && !hasBrightness && hasNormals) {
|
||||
format = DefaultVertexFormat.POSITION_TEXTURE_NORMAL; // Lit geometry with normals
|
||||
} else if (hasColor && hasTexture && hasBrightness && !hasNormals) {
|
||||
format = DefaultVertexFormat.POSITION_COLOR_TEX_LIGHTMAP; // Colored lit blocks
|
||||
} else if (hasColor && !hasTexture && !hasBrightness && !hasNormals) {
|
||||
format = DefaultVertexFormat.POSITION_COLOR; // Colored lines/particles
|
||||
} else {
|
||||
format = DefaultVertexFormat.POSITION_COLOR_TEXTURE_LIGHT_NORMAL; // Full format fallback
|
||||
}
|
||||
|
||||
return format;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile captured Tessellator quads into a VertexBuffer (VAO or VBO).
|
||||
* Uses VertexBuffer for proper compatibility with fixed-function pipeline.
|
||||
*
|
||||
* @param quads The quads to compile
|
||||
* @param flags The vertex attribute flags
|
||||
* @return The uploaded VertexBuffer
|
||||
*/
|
||||
static VertexBuffer compileQuads(List<ModelQuadViewMutable> quads, CapturingTessellator.Flags flags) {
|
||||
// Select optimal predefined format from GTNHLib
|
||||
final VertexFormat format = selectOptimalFormat(flags);
|
||||
|
||||
// Use VAOManager to create VAO with optimal format (falls back to VBO if unsupported)
|
||||
final VertexBuffer vao = VAOManager.createVAO(format, GL11.GL_QUADS);
|
||||
|
||||
final ByteBuffer buffer = CapturingTessellator.quadsToBuffer(quads, format);
|
||||
|
||||
vao.upload(buffer);
|
||||
|
||||
return vao;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import org.joml.Matrix4f;
|
||||
|
||||
/**
|
||||
* Represents a vertex range within a shared VBO, along with its transform.
|
||||
* Used during format-based batching to track where each draw's vertices are stored.
|
||||
*/
|
||||
@Desugar
|
||||
record DrawRange(int startVertex, int vertexCount, Matrix4f transform, int commandIndex) {}
|
||||
@@ -0,0 +1,12 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
|
||||
|
||||
/**
|
||||
* Helper record pairing a DrawRange with its VBO and brightness flag.
|
||||
* Used for sorting ranges by command index while retaining VBO reference.
|
||||
* Works for both quad ranges (from CompiledFormatBuffer) and line ranges (from CompiledLineBuffer).
|
||||
*/
|
||||
@Desugar
|
||||
record DrawRangeWithBuffer(DrawRange range, VertexBuffer vbo, boolean hasBrightness) {}
|
||||
@@ -2,6 +2,7 @@ package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.BooleanStateStack;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
@@ -22,6 +23,7 @@ public class Feature {
|
||||
GL11.GL_STENCIL_BUFFER_BIT, GL11.GL_TEXTURE_BIT, GL11.GL_TRANSFORM_BIT, GL11.GL_VIEWPORT_BIT };
|
||||
|
||||
static final Int2ObjectMap<List<IStateStack<?>>> maskToFeaturesMap = new Int2ObjectOpenHashMap<>();
|
||||
static final Int2ObjectMap<IStateStack<?>[]> maskToNonBooleanStacksMap = new Int2ObjectOpenHashMap<>();
|
||||
|
||||
static List<IStateStack<?>> maskToFeatures(int mask) {
|
||||
if(maskToFeaturesMap.containsKey(mask)) {
|
||||
@@ -42,6 +44,29 @@ public class Feature {
|
||||
return asList;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns only non-BooleanStateStack instances for the given mask.
|
||||
* These use traditional push/pop without global depth tracking.
|
||||
*/
|
||||
static IStateStack<?>[] maskToNonBooleanStacks(int mask) {
|
||||
IStateStack<?>[] cached = maskToNonBooleanStacksMap.get(mask);
|
||||
if (cached != null) {
|
||||
return cached;
|
||||
}
|
||||
|
||||
final List<IStateStack<?>> all = maskToFeatures(mask);
|
||||
final List<IStateStack<?>> nonBooleans = new ArrayList<>();
|
||||
for (int i = 0; i < all.size(); i++) {
|
||||
final IStateStack<?> stack = all.get(i);
|
||||
if (!(stack instanceof BooleanStateStack)) {
|
||||
nonBooleans.add(stack);
|
||||
}
|
||||
}
|
||||
cached = nonBooleans.toArray(new IStateStack<?>[0]);
|
||||
maskToNonBooleanStacksMap.put(mask, cached);
|
||||
return cached;
|
||||
}
|
||||
|
||||
private static final Map<Integer, Set<IStateStack<?>>> attribToFeatures = new HashMap<>();
|
||||
|
||||
/**
|
||||
@@ -223,10 +248,9 @@ public class Feature {
|
||||
, GLStateManager.shadeModelState // GL_SHADE_MODEL setting
|
||||
));
|
||||
attribToFeatures.put(GL11.GL_LINE_BIT, ImmutableSet.of(
|
||||
// GL_LINE_SMOOTH flag
|
||||
// GL_LINE_STIPPLE enable bit
|
||||
// Line stipple pattern and repeat counter
|
||||
// Line width
|
||||
GLStateManager.lineSmoothState // GL_LINE_SMOOTH flag
|
||||
, GLStateManager.lineStippleState // GL_LINE_STIPPLE enable bit
|
||||
, GLStateManager.lineState // Line stipple pattern, repeat counter, and width
|
||||
));
|
||||
attribToFeatures.put(GL11.GL_LIST_BIT, ImmutableSet.of(
|
||||
// GL_LIST_BASE setting
|
||||
@@ -251,21 +275,17 @@ public class Feature {
|
||||
// GL_READ_BUFFER setting
|
||||
));
|
||||
attribToFeatures.put(GL11.GL_POINT_BIT, ImmutableSet.of(
|
||||
// GL_POINT_SMOOTH flag
|
||||
// Point size
|
||||
GLStateManager.pointSmoothState // GL_POINT_SMOOTH flag
|
||||
, GLStateManager.pointState // Point size
|
||||
));
|
||||
attribToFeatures.put(GL11.GL_POLYGON_BIT, ImmutableSet.of(
|
||||
GLStateManager.cullState // GL_CULL_FACE enable bit
|
||||
// GL_CULL_FACE_MODE value
|
||||
// GL_FRONT_FACE indicator
|
||||
// GL_POLYGON_MODE setting
|
||||
// GL_POLYGON_SMOOTH flag
|
||||
// GL_POLYGON_STIPPLE enable bit
|
||||
// GL_POLYGON_OFFSET_FILL flag
|
||||
// GL_POLYGON_OFFSET_LINE flag
|
||||
// GL_POLYGON_OFFSET_POINT flag
|
||||
// GL_POLYGON_OFFSET_FACTOR
|
||||
// GL_POLYGON_OFFSET_UNITS
|
||||
, GLStateManager.polygonSmoothState // GL_POLYGON_SMOOTH flag
|
||||
, GLStateManager.polygonStippleState // GL_POLYGON_STIPPLE enable bit
|
||||
, GLStateManager.polygonOffsetFillState // GL_POLYGON_OFFSET_FILL flag
|
||||
, GLStateManager.polygonOffsetLineState // GL_POLYGON_OFFSET_LINE flag
|
||||
, GLStateManager.polygonOffsetPointState // GL_POLYGON_OFFSET_POINT flag
|
||||
, GLStateManager.polygonState // GL_CULL_FACE_MODE, GL_FRONT_FACE, GL_POLYGON_MODE, GL_POLYGON_OFFSET_FACTOR/UNITS
|
||||
));
|
||||
attribToFeatures.put(GL11.GL_POLYGON_STIPPLE_BIT, ImmutableSet.of(
|
||||
// Polygon stipple pattern
|
||||
@@ -275,12 +295,8 @@ public class Feature {
|
||||
// Scissor box
|
||||
));
|
||||
attribToFeatures.put(GL11.GL_STENCIL_BUFFER_BIT, ImmutableSet.of(
|
||||
// GL_STENCIL_TEST enable bit
|
||||
// Stencil function and reference value
|
||||
// Stencil value mask
|
||||
// Stencil fail, pass, and depth buffer pass actions
|
||||
// Stencil buffer clear value
|
||||
// Stencil buffer writemask
|
||||
GLStateManager.stencilTest // GL_STENCIL_TEST enable bit
|
||||
, GLStateManager.stencilState // Stencil function, ref, mask, ops, writemask, clear value
|
||||
));
|
||||
final Set<IStateStack<?>> textureAttribs = new HashSet<>(ImmutableSet.of(
|
||||
GLStateManager.activeTextureUnit // Active texture unit
|
||||
|
||||
@@ -0,0 +1,96 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadViewMutable;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.AccumulatedDraw;
|
||||
import org.joml.Matrix4f;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Accumulates geometry for a single vertex format during display list compilation.
|
||||
* All draws with the same format are collected here, then compiled into a single VBO.
|
||||
* <p>
|
||||
* Tracks two types of ranges:
|
||||
* <ul>
|
||||
* <li><b>mergedRanges</b>: Consecutive same-transform draws merged for optimized path</li>
|
||||
* <li><b>perDrawRanges</b>: One range per input draw for unoptimized path (1:1 with addDraw calls)</li>
|
||||
* </ul>
|
||||
*/
|
||||
class FormatBuffer {
|
||||
final CapturingTessellator.Flags flags;
|
||||
final List<ModelQuadViewMutable> allQuads = new ArrayList<>();
|
||||
|
||||
// Merged ranges for optimized path (consecutive same-transform draws combined)
|
||||
final List<DrawRange> mergedRanges = new ArrayList<>();
|
||||
|
||||
// Per-draw ranges for unoptimized path (1:1 with input draws)
|
||||
final List<DrawRange> perDrawRanges = new ArrayList<>();
|
||||
|
||||
int currentVertexOffset = 0;
|
||||
|
||||
// Track the current range being built for merging consecutive same-transform draws
|
||||
private int pendingStartVertex = -1;
|
||||
private int pendingVertexCount = 0;
|
||||
private Matrix4f pendingTransform = null;
|
||||
private int pendingCommandIndex = -1;
|
||||
|
||||
FormatBuffer(CapturingTessellator.Flags flags) {
|
||||
this.flags = flags;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a draw to this format buffer.
|
||||
* Tracks both merged (for optimized) and per-draw (for unoptimized) ranges.
|
||||
*/
|
||||
void addDraw(AccumulatedDraw draw) {
|
||||
int vertexCount = draw.quads.size() * 4; // 4 vertices per quad
|
||||
|
||||
// Always track per-draw range for unoptimized path
|
||||
perDrawRanges.add(new DrawRange(currentVertexOffset, vertexCount, draw.transform, draw.commandIndex));
|
||||
|
||||
// Merge logic for optimized path
|
||||
if (pendingTransform != null && pendingTransform.equals(draw.transform)) {
|
||||
// Extend the pending range
|
||||
pendingVertexCount += vertexCount;
|
||||
} else {
|
||||
// Flush pending range if any
|
||||
flushPendingRange();
|
||||
|
||||
// Start new pending range
|
||||
pendingStartVertex = currentVertexOffset;
|
||||
pendingVertexCount = vertexCount;
|
||||
pendingTransform = new Matrix4f(draw.transform);
|
||||
pendingCommandIndex = draw.commandIndex;
|
||||
}
|
||||
|
||||
allQuads.addAll(draw.quads);
|
||||
currentVertexOffset += vertexCount;
|
||||
}
|
||||
|
||||
private void flushPendingRange() {
|
||||
if (pendingTransform != null) {
|
||||
mergedRanges.add(new DrawRange(pendingStartVertex, pendingVertexCount, pendingTransform, pendingCommandIndex));
|
||||
pendingTransform = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile all accumulated quads into a single VBO.
|
||||
* @return The compiled buffer with VBO and both range types
|
||||
*/
|
||||
CompiledFormatBuffer finish() {
|
||||
// Flush any remaining pending range
|
||||
flushPendingRange();
|
||||
|
||||
VertexBuffer vbo = DisplayListManager.compileQuads(allQuads, flags);
|
||||
return new CompiledFormatBuffer(
|
||||
vbo,
|
||||
flags,
|
||||
mergedRanges.toArray(new DrawRange[0]),
|
||||
perDrawRanges.toArray(new DrawRange[0])
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -9,7 +9,11 @@ import org.lwjgl.opengl.AMDDebugOutput;
|
||||
import org.lwjgl.opengl.AMDDebugOutputCallback;
|
||||
import org.lwjgl.opengl.ARBDebugOutput;
|
||||
import org.lwjgl.opengl.ARBDebugOutputCallback;
|
||||
import org.lwjgl.opengl.EXTBlendColor;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL12;
|
||||
import org.lwjgl.opengl.GL13;
|
||||
import org.lwjgl.opengl.GL14;
|
||||
import org.lwjgl.opengl.GL30;
|
||||
import org.lwjgl.opengl.GL43;
|
||||
import org.lwjgl.opengl.KHRDebug;
|
||||
@@ -269,6 +273,304 @@ public final class GLDebug {
|
||||
};
|
||||
}
|
||||
|
||||
public static String getMatrixModeName(int mode) {
|
||||
return switch (mode) {
|
||||
case GL11.GL_MODELVIEW -> "MODELVIEW";
|
||||
case GL11.GL_PROJECTION -> "PROJECTION";
|
||||
case GL11.GL_TEXTURE -> "TEXTURE";
|
||||
case GL11.GL_COLOR -> "COLOR";
|
||||
default -> String.format("0x%X", mode);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getCapabilityName(int cap) {
|
||||
return switch (cap) {
|
||||
case GL11.GL_ALPHA_TEST -> "ALPHA_TEST";
|
||||
case GL11.GL_BLEND -> "BLEND";
|
||||
case GL11.GL_COLOR_MATERIAL -> "COLOR_MATERIAL";
|
||||
case GL11.GL_CULL_FACE -> "CULL_FACE";
|
||||
case GL11.GL_DEPTH_TEST -> "DEPTH_TEST";
|
||||
case GL11.GL_FOG -> "FOG";
|
||||
case GL11.GL_LIGHTING -> "LIGHTING";
|
||||
case GL11.GL_LINE_SMOOTH -> "LINE_SMOOTH";
|
||||
case GL11.GL_NORMALIZE -> "NORMALIZE";
|
||||
case GL11.GL_POINT_SMOOTH -> "POINT_SMOOTH";
|
||||
case GL11.GL_POLYGON_OFFSET_FILL -> "POLYGON_OFFSET_FILL";
|
||||
case GL11.GL_POLYGON_OFFSET_LINE -> "POLYGON_OFFSET_LINE";
|
||||
case GL11.GL_POLYGON_SMOOTH -> "POLYGON_SMOOTH";
|
||||
case GL12.GL_RESCALE_NORMAL -> "RESCALE_NORMAL";
|
||||
case GL11.GL_SCISSOR_TEST -> "SCISSOR_TEST";
|
||||
case GL11.GL_STENCIL_TEST -> "STENCIL_TEST";
|
||||
case GL11.GL_TEXTURE_1D -> "TEXTURE_1D";
|
||||
case GL11.GL_TEXTURE_2D -> "TEXTURE_2D";
|
||||
case GL11.GL_LIGHT0 -> "LIGHT0";
|
||||
case GL11.GL_LIGHT1 -> "LIGHT1";
|
||||
case GL11.GL_LIGHT2 -> "LIGHT2";
|
||||
case GL11.GL_LIGHT3 -> "LIGHT3";
|
||||
case GL11.GL_LIGHT4 -> "LIGHT4";
|
||||
case GL11.GL_LIGHT5 -> "LIGHT5";
|
||||
case GL11.GL_LIGHT6 -> "LIGHT6";
|
||||
case GL11.GL_LIGHT7 -> "LIGHT7";
|
||||
default -> String.format("0x%X", cap);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getComparisonFuncName(int func) {
|
||||
return switch (func) {
|
||||
case GL11.GL_NEVER -> "NEVER";
|
||||
case GL11.GL_LESS -> "LESS";
|
||||
case GL11.GL_EQUAL -> "EQUAL";
|
||||
case GL11.GL_LEQUAL -> "LEQUAL";
|
||||
case GL11.GL_GREATER -> "GREATER";
|
||||
case GL11.GL_NOTEQUAL -> "NOTEQUAL";
|
||||
case GL11.GL_GEQUAL -> "GEQUAL";
|
||||
case GL11.GL_ALWAYS -> "ALWAYS";
|
||||
default -> String.format("0x%X", func);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getBlendFactorName(int factor) {
|
||||
return switch (factor) {
|
||||
case GL11.GL_ZERO -> "ZERO";
|
||||
case GL11.GL_ONE -> "ONE";
|
||||
case GL11.GL_SRC_COLOR -> "SRC_COLOR";
|
||||
case GL11.GL_ONE_MINUS_SRC_COLOR -> "ONE_MINUS_SRC_COLOR";
|
||||
case GL11.GL_DST_COLOR -> "DST_COLOR";
|
||||
case GL11.GL_ONE_MINUS_DST_COLOR -> "ONE_MINUS_DST_COLOR";
|
||||
case GL11.GL_SRC_ALPHA -> "SRC_ALPHA";
|
||||
case GL11.GL_ONE_MINUS_SRC_ALPHA -> "ONE_MINUS_SRC_ALPHA";
|
||||
case GL11.GL_DST_ALPHA -> "DST_ALPHA";
|
||||
case GL11.GL_ONE_MINUS_DST_ALPHA -> "ONE_MINUS_DST_ALPHA";
|
||||
case EXTBlendColor.GL_CONSTANT_COLOR_EXT -> "CONSTANT_COLOR";
|
||||
case EXTBlendColor.GL_ONE_MINUS_CONSTANT_COLOR_EXT -> "ONE_MINUS_CONSTANT_COLOR";
|
||||
case EXTBlendColor.GL_CONSTANT_ALPHA_EXT -> "CONSTANT_ALPHA";
|
||||
case EXTBlendColor.GL_ONE_MINUS_CONSTANT_ALPHA_EXT -> "ONE_MINUS_CONSTANT_ALPHA";
|
||||
case GL11.GL_SRC_ALPHA_SATURATE -> "SRC_ALPHA_SATURATE";
|
||||
default -> String.format("0x%X", factor);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getShadeModelName(int mode) {
|
||||
return switch (mode) {
|
||||
case GL11.GL_FLAT -> "FLAT";
|
||||
case GL11.GL_SMOOTH -> "SMOOTH";
|
||||
default -> String.format("0x%X", mode);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getTextureTargetName(int target) {
|
||||
return switch (target) {
|
||||
case GL11.GL_TEXTURE_1D -> "TEXTURE_1D";
|
||||
case GL11.GL_TEXTURE_2D -> "TEXTURE_2D";
|
||||
case GL12.GL_TEXTURE_3D -> "TEXTURE_3D";
|
||||
case GL13.GL_TEXTURE_CUBE_MAP -> "TEXTURE_CUBE_MAP";
|
||||
default -> String.format("0x%X", target);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getTexturePnameName(int pname) {
|
||||
return switch (pname) {
|
||||
case GL11.GL_TEXTURE_MIN_FILTER -> "TEXTURE_MIN_FILTER";
|
||||
case GL11.GL_TEXTURE_MAG_FILTER -> "TEXTURE_MAG_FILTER";
|
||||
case GL11.GL_TEXTURE_WRAP_S -> "TEXTURE_WRAP_S";
|
||||
case GL11.GL_TEXTURE_WRAP_T -> "TEXTURE_WRAP_T";
|
||||
case GL12.GL_TEXTURE_WRAP_R -> "TEXTURE_WRAP_R";
|
||||
case GL12.GL_TEXTURE_MIN_LOD -> "TEXTURE_MIN_LOD";
|
||||
case GL12.GL_TEXTURE_MAX_LOD -> "TEXTURE_MAX_LOD";
|
||||
case GL12.GL_TEXTURE_BASE_LEVEL -> "TEXTURE_BASE_LEVEL";
|
||||
case GL12.GL_TEXTURE_MAX_LEVEL -> "TEXTURE_MAX_LEVEL";
|
||||
case GL11.GL_TEXTURE_BORDER_COLOR -> "TEXTURE_BORDER_COLOR";
|
||||
case GL11.GL_TEXTURE_PRIORITY -> "TEXTURE_PRIORITY";
|
||||
case GL14.GL_TEXTURE_LOD_BIAS -> "TEXTURE_LOD_BIAS";
|
||||
case GL14.GL_GENERATE_MIPMAP -> "GENERATE_MIPMAP";
|
||||
default -> String.format("0x%X", pname);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getTextureFormatName(int format) {
|
||||
return switch (format) {
|
||||
case GL11.GL_RED -> "RED";
|
||||
case GL11.GL_GREEN -> "GREEN";
|
||||
case GL11.GL_BLUE -> "BLUE";
|
||||
case GL11.GL_ALPHA -> "ALPHA";
|
||||
case GL11.GL_RGB -> "RGB";
|
||||
case GL11.GL_RGBA -> "RGBA";
|
||||
case GL11.GL_LUMINANCE -> "LUMINANCE";
|
||||
case GL11.GL_LUMINANCE_ALPHA -> "LUMINANCE_ALPHA";
|
||||
case GL12.GL_BGR -> "BGR";
|
||||
case GL12.GL_BGRA -> "BGRA";
|
||||
case GL11.GL_DEPTH_COMPONENT -> "DEPTH_COMPONENT";
|
||||
case GL11.GL_STENCIL_INDEX -> "STENCIL_INDEX";
|
||||
case GL30.GL_DEPTH_STENCIL -> "DEPTH_STENCIL";
|
||||
// Internal formats
|
||||
case GL11.GL_RGB8 -> "RGB8";
|
||||
case GL11.GL_RGBA8 -> "RGBA8";
|
||||
case GL11.GL_ALPHA8 -> "ALPHA8";
|
||||
case GL11.GL_LUMINANCE8 -> "LUMINANCE8";
|
||||
case GL11.GL_LUMINANCE8_ALPHA8 -> "LUMINANCE8_ALPHA8";
|
||||
default -> String.format("0x%X", format);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getDataTypeName(int type) {
|
||||
return switch (type) {
|
||||
case GL11.GL_UNSIGNED_BYTE -> "UNSIGNED_BYTE";
|
||||
case GL11.GL_BYTE -> "BYTE";
|
||||
case GL11.GL_UNSIGNED_SHORT -> "UNSIGNED_SHORT";
|
||||
case GL11.GL_SHORT -> "SHORT";
|
||||
case GL11.GL_UNSIGNED_INT -> "UNSIGNED_INT";
|
||||
case GL11.GL_INT -> "INT";
|
||||
case GL11.GL_FLOAT -> "FLOAT";
|
||||
case GL11.GL_DOUBLE -> "DOUBLE";
|
||||
case GL12.GL_UNSIGNED_BYTE_3_3_2 -> "UNSIGNED_BYTE_3_3_2";
|
||||
case GL12.GL_UNSIGNED_SHORT_4_4_4_4 -> "UNSIGNED_SHORT_4_4_4_4";
|
||||
case GL12.GL_UNSIGNED_SHORT_5_5_5_1 -> "UNSIGNED_SHORT_5_5_5_1";
|
||||
case GL12.GL_UNSIGNED_INT_8_8_8_8 -> "UNSIGNED_INT_8_8_8_8";
|
||||
case GL12.GL_UNSIGNED_INT_10_10_10_2 -> "UNSIGNED_INT_10_10_10_2";
|
||||
default -> String.format("0x%X", type);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getLightName(int light) {
|
||||
return switch (light) {
|
||||
case GL11.GL_LIGHT0 -> "LIGHT0";
|
||||
case GL11.GL_LIGHT1 -> "LIGHT1";
|
||||
case GL11.GL_LIGHT2 -> "LIGHT2";
|
||||
case GL11.GL_LIGHT3 -> "LIGHT3";
|
||||
case GL11.GL_LIGHT4 -> "LIGHT4";
|
||||
case GL11.GL_LIGHT5 -> "LIGHT5";
|
||||
case GL11.GL_LIGHT6 -> "LIGHT6";
|
||||
case GL11.GL_LIGHT7 -> "LIGHT7";
|
||||
default -> String.format("0x%X", light);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getLightPnameName(int pname) {
|
||||
return switch (pname) {
|
||||
case GL11.GL_AMBIENT -> "AMBIENT";
|
||||
case GL11.GL_DIFFUSE -> "DIFFUSE";
|
||||
case GL11.GL_SPECULAR -> "SPECULAR";
|
||||
case GL11.GL_POSITION -> "POSITION";
|
||||
case GL11.GL_SPOT_DIRECTION -> "SPOT_DIRECTION";
|
||||
case GL11.GL_SPOT_EXPONENT -> "SPOT_EXPONENT";
|
||||
case GL11.GL_SPOT_CUTOFF -> "SPOT_CUTOFF";
|
||||
case GL11.GL_CONSTANT_ATTENUATION -> "CONSTANT_ATTENUATION";
|
||||
case GL11.GL_LINEAR_ATTENUATION -> "LINEAR_ATTENUATION";
|
||||
case GL11.GL_QUADRATIC_ATTENUATION -> "QUADRATIC_ATTENUATION";
|
||||
default -> String.format("0x%X", pname);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getMaterialPnameName(int pname) {
|
||||
return switch (pname) {
|
||||
case GL11.GL_AMBIENT -> "AMBIENT";
|
||||
case GL11.GL_DIFFUSE -> "DIFFUSE";
|
||||
case GL11.GL_SPECULAR -> "SPECULAR";
|
||||
case GL11.GL_EMISSION -> "EMISSION";
|
||||
case GL11.GL_SHININESS -> "SHININESS";
|
||||
case GL11.GL_AMBIENT_AND_DIFFUSE -> "AMBIENT_AND_DIFFUSE";
|
||||
case GL11.GL_COLOR_INDEXES -> "COLOR_INDEXES";
|
||||
default -> String.format("0x%X", pname);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getFaceName(int face) {
|
||||
return switch (face) {
|
||||
case GL11.GL_FRONT -> "FRONT";
|
||||
case GL11.GL_BACK -> "BACK";
|
||||
case GL11.GL_FRONT_AND_BACK -> "FRONT_AND_BACK";
|
||||
default -> String.format("0x%X", face);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getColorMaterialModeName(int mode) {
|
||||
return switch (mode) {
|
||||
case GL11.GL_AMBIENT -> "AMBIENT";
|
||||
case GL11.GL_DIFFUSE -> "DIFFUSE";
|
||||
case GL11.GL_SPECULAR -> "SPECULAR";
|
||||
case GL11.GL_EMISSION -> "EMISSION";
|
||||
case GL11.GL_AMBIENT_AND_DIFFUSE -> "AMBIENT_AND_DIFFUSE";
|
||||
default -> String.format("0x%X", mode);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getFogPnameName(int pname) {
|
||||
return switch (pname) {
|
||||
case GL11.GL_FOG_MODE -> "FOG_MODE";
|
||||
case GL11.GL_FOG_DENSITY -> "FOG_DENSITY";
|
||||
case GL11.GL_FOG_START -> "FOG_START";
|
||||
case GL11.GL_FOG_END -> "FOG_END";
|
||||
case GL11.GL_FOG_INDEX -> "FOG_INDEX";
|
||||
case GL11.GL_FOG_COLOR -> "FOG_COLOR";
|
||||
default -> String.format("0x%X", pname);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getLightModelPnameName(int pname) {
|
||||
return switch (pname) {
|
||||
case GL11.GL_LIGHT_MODEL_AMBIENT -> "LIGHT_MODEL_AMBIENT";
|
||||
case GL11.GL_LIGHT_MODEL_LOCAL_VIEWER -> "LIGHT_MODEL_LOCAL_VIEWER";
|
||||
case GL11.GL_LIGHT_MODEL_TWO_SIDE -> "LIGHT_MODEL_TWO_SIDE";
|
||||
case GL12.GL_LIGHT_MODEL_COLOR_CONTROL -> "LIGHT_MODEL_COLOR_CONTROL";
|
||||
default -> String.format("0x%X", pname);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getClearMaskString(int mask) {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
boolean first = true;
|
||||
if ((mask & GL11.GL_COLOR_BUFFER_BIT) != 0) {
|
||||
sb.append("COLOR");
|
||||
first = false;
|
||||
}
|
||||
if ((mask & GL11.GL_DEPTH_BUFFER_BIT) != 0) {
|
||||
if (!first) sb.append("|");
|
||||
sb.append("DEPTH");
|
||||
first = false;
|
||||
}
|
||||
if ((mask & GL11.GL_STENCIL_BUFFER_BIT) != 0) {
|
||||
if (!first) sb.append("|");
|
||||
sb.append("STENCIL");
|
||||
first = false;
|
||||
}
|
||||
if ((mask & GL11.GL_ACCUM_BUFFER_BIT) != 0) {
|
||||
if (!first) sb.append("|");
|
||||
sb.append("ACCUM");
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
public static String getCullFaceName(int mode) {
|
||||
return switch (mode) {
|
||||
case GL11.GL_FRONT -> "FRONT";
|
||||
case GL11.GL_BACK -> "BACK";
|
||||
case GL11.GL_FRONT_AND_BACK -> "FRONT_AND_BACK";
|
||||
default -> String.format("0x%X", mode);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getLogicOpName(int opcode) {
|
||||
return switch (opcode) {
|
||||
case GL11.GL_CLEAR -> "CLEAR";
|
||||
case GL11.GL_AND -> "AND";
|
||||
case GL11.GL_AND_REVERSE -> "AND_REVERSE";
|
||||
case GL11.GL_COPY -> "COPY";
|
||||
case GL11.GL_AND_INVERTED -> "AND_INVERTED";
|
||||
case GL11.GL_NOOP -> "NOOP";
|
||||
case GL11.GL_XOR -> "XOR";
|
||||
case GL11.GL_OR -> "OR";
|
||||
case GL11.GL_NOR -> "NOR";
|
||||
case GL11.GL_EQUIV -> "EQUIV";
|
||||
case GL11.GL_INVERT -> "INVERT";
|
||||
case GL11.GL_OR_REVERSE -> "OR_REVERSE";
|
||||
case GL11.GL_COPY_INVERTED -> "COPY_INVERTED";
|
||||
case GL11.GL_OR_INVERTED -> "OR_INVERTED";
|
||||
case GL11.GL_NAND -> "NAND";
|
||||
case GL11.GL_SET -> "SET";
|
||||
default -> String.format("0x%X", opcode);
|
||||
};
|
||||
}
|
||||
|
||||
private static DebugState debugState;
|
||||
|
||||
private interface DebugState {
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,125 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.VAOManager;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.AccumulatedLineDraw;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.ImmediateModeRecorder;
|
||||
import org.joml.Matrix4f;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Accumulates line geometry during display list compilation.
|
||||
* All line draws are collected here, then compiled into a single VBO.
|
||||
* <p>
|
||||
* Lines all use the same format (POSITION_COLOR), so no format-based grouping needed.
|
||||
* <p>
|
||||
* Tracks two types of ranges:
|
||||
* <ul>
|
||||
* <li><b>mergedRanges</b>: Consecutive same-transform draws merged for optimized path</li>
|
||||
* <li><b>perDrawRanges</b>: One range per input draw for unoptimized path (1:1 with addDraw calls)</li>
|
||||
* </ul>
|
||||
*/
|
||||
class LineBuffer {
|
||||
final List<ImmediateModeRecorder.LineVertex> allVertices = new ArrayList<>();
|
||||
|
||||
// Merged ranges for optimized path (consecutive same-transform draws combined)
|
||||
final List<DrawRange> mergedRanges = new ArrayList<>();
|
||||
|
||||
// Per-draw ranges for unoptimized path (1:1 with input draws)
|
||||
final List<DrawRange> perDrawRanges = new ArrayList<>();
|
||||
|
||||
int currentVertexOffset = 0;
|
||||
|
||||
// Track the current range being built for merging consecutive same-transform draws
|
||||
private int pendingStartVertex = -1;
|
||||
private int pendingVertexCount = 0;
|
||||
private Matrix4f pendingTransform = null;
|
||||
private int pendingCommandIndex = -1;
|
||||
|
||||
/**
|
||||
* Add a line draw to this buffer.
|
||||
* Tracks both merged (for optimized) and per-draw (for unoptimized) ranges.
|
||||
*/
|
||||
void addDraw(AccumulatedLineDraw draw) {
|
||||
int vertexCount = draw.lines.size(); // Each LineVertex is one vertex, lines come in pairs
|
||||
|
||||
// Always track per-draw range for unoptimized path
|
||||
perDrawRanges.add(new DrawRange(currentVertexOffset, vertexCount, draw.transform, draw.commandIndex));
|
||||
|
||||
// Merge logic for optimized path
|
||||
if (pendingTransform != null && pendingTransform.equals(draw.transform)) {
|
||||
// Extend the pending range
|
||||
pendingVertexCount += vertexCount;
|
||||
} else {
|
||||
// Flush pending range if any
|
||||
flushPendingRange();
|
||||
|
||||
// Start new pending range
|
||||
pendingStartVertex = currentVertexOffset;
|
||||
pendingVertexCount = vertexCount;
|
||||
pendingTransform = new Matrix4f(draw.transform);
|
||||
pendingCommandIndex = draw.commandIndex;
|
||||
}
|
||||
|
||||
allVertices.addAll(draw.lines);
|
||||
currentVertexOffset += vertexCount;
|
||||
}
|
||||
|
||||
private void flushPendingRange() {
|
||||
if (pendingTransform != null) {
|
||||
mergedRanges.add(new DrawRange(pendingStartVertex, pendingVertexCount, pendingTransform, pendingCommandIndex));
|
||||
pendingTransform = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile all accumulated line vertices into a single VBO.
|
||||
* @return The compiled buffer with VBO and both range types, or null if empty
|
||||
*/
|
||||
CompiledLineBuffer finish() {
|
||||
if (allVertices.isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// Flush any remaining pending range
|
||||
flushPendingRange();
|
||||
|
||||
VertexBuffer vbo = compileLinesToVBO(allVertices);
|
||||
return new CompiledLineBuffer(
|
||||
vbo,
|
||||
mergedRanges.toArray(new DrawRange[0]),
|
||||
perDrawRanges.toArray(new DrawRange[0])
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile line vertices into a VertexBuffer (VAO or VBO).
|
||||
* Lines use POSITION_COLOR format (x, y, z, color).
|
||||
*/
|
||||
private static VertexBuffer compileLinesToVBO(List<ImmediateModeRecorder.LineVertex> lines) {
|
||||
final VertexFormat format = DefaultVertexFormat.POSITION_COLOR;
|
||||
final VertexBuffer vao = VAOManager.createVAO(format, GL11.GL_LINES);
|
||||
|
||||
// POSITION_COLOR format: 3 floats (12 bytes) + 4 bytes color = 16 bytes per vertex
|
||||
final int vertexSize = format.getVertexSize();
|
||||
final ByteBuffer buffer = org.lwjgl.BufferUtils.createByteBuffer(vertexSize * lines.size());
|
||||
|
||||
for (ImmediateModeRecorder.LineVertex v : lines) {
|
||||
buffer.putFloat(v.x);
|
||||
buffer.putFloat(v.y);
|
||||
buffer.putFloat(v.z);
|
||||
buffer.putInt(v.color);
|
||||
}
|
||||
buffer.flip();
|
||||
|
||||
vao.upload(buffer);
|
||||
|
||||
return vao;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.commands.DisplayListCommand;
|
||||
|
||||
/**
|
||||
* Result of building an optimized display list.
|
||||
* Contains both the commands and the shared VBOs that need lifecycle management.
|
||||
*/
|
||||
@Desugar
|
||||
record OptimizedListResult(DisplayListCommand[] commands, VertexBuffer[] ownedVbos) {}
|
||||
@@ -131,6 +131,22 @@ public class RenderSystem {
|
||||
dsaState.texParameterf(texture, target, pname, param);
|
||||
}
|
||||
|
||||
public static void textureImage2D(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, ByteBuffer pixels) {
|
||||
dsaState.textureImage2D(texture, target, level, internalformat, width, height, border, format, type, pixels);
|
||||
}
|
||||
|
||||
public static void textureImage2D(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, IntBuffer pixels) {
|
||||
dsaState.textureImage2D(texture, target, level, internalformat, width, height, border, format, type, pixels);
|
||||
}
|
||||
|
||||
public static void textureSubImage2D(int texture, int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, ByteBuffer pixels) {
|
||||
dsaState.textureSubImage2D(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);
|
||||
}
|
||||
|
||||
public static void textureSubImage2D(int texture, int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, IntBuffer pixels) {
|
||||
dsaState.textureSubImage2D(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);
|
||||
}
|
||||
|
||||
public static String getProgramInfoLog(int program) {
|
||||
return GL20.glGetProgramInfoLog(program, GL20.glGetProgrami(program, GL20.GL_INFO_LOG_LENGTH));
|
||||
}
|
||||
|
||||
@@ -0,0 +1,137 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.recording.commands.DisplayListCommand;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.commands.MultMatrixCmd;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.joml.Matrix4f;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.util.ArrayDeque;
|
||||
import java.util.Deque;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Helper class for tracking and collapsing MODELVIEW transforms during optimization.
|
||||
* Implements the transform accumulation and emission strategy:
|
||||
* <ul>
|
||||
* <li>accumulated: total relative transform (what GL matrix should be)</li>
|
||||
* <li>lastEmitted: what we've emitted (what GL matrix is)</li>
|
||||
* <li>stack: saved accumulated values at Push points</li>
|
||||
* </ul>
|
||||
*/
|
||||
class TransformOptimizer {
|
||||
private static final Logger LOGGER = LogManager.getLogger("TransformOptimizer");
|
||||
|
||||
private final Matrix4f accumulated = new Matrix4f(); // Current accumulated transform
|
||||
private final Matrix4f lastEmitted = new Matrix4f(); // Last emitted transform
|
||||
private final Deque<Matrix4f> stack = new ArrayDeque<>(); // For Push/Pop
|
||||
private final int listId; // For logging
|
||||
private boolean absoluteMatrixFlag = false; // True after LoadMatrix, cleared by LoadIdentity emit
|
||||
|
||||
TransformOptimizer(int listId) {
|
||||
this.listId = listId;
|
||||
accumulated.identity();
|
||||
lastEmitted.identity();
|
||||
}
|
||||
|
||||
Matrix4f getAccumulated() {
|
||||
return accumulated;
|
||||
}
|
||||
|
||||
void loadIdentity() {
|
||||
accumulated.identity();
|
||||
}
|
||||
|
||||
void pushTransform() {
|
||||
stack.push(new Matrix4f(accumulated));
|
||||
}
|
||||
|
||||
void popTransform() {
|
||||
if (!stack.isEmpty()) {
|
||||
final Matrix4f popped = stack.pop();
|
||||
accumulated.set(popped);
|
||||
// After Pop, GL state is restored to the pushed value so lastEmitted should also reflect this
|
||||
lastEmitted.set(accumulated);
|
||||
} else {
|
||||
LOGGER.warn("[TransformOptimizer] list={} Pop with empty stack - resetting to identity", listId);
|
||||
accumulated.identity();
|
||||
lastEmitted.identity();
|
||||
}
|
||||
}
|
||||
|
||||
boolean isIdentity() {
|
||||
return DisplayListManager.isIdentity(accumulated);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if there's a pending transform that hasn't been emitted yet.
|
||||
*/
|
||||
boolean hasPendingTransform() {
|
||||
return !accumulated.equals(lastEmitted);
|
||||
}
|
||||
|
||||
/**
|
||||
* Emit a MultMatrix command if accumulated differs from lastEmitted.
|
||||
* Updates lastEmitted to match accumulated after emission.
|
||||
*/
|
||||
void emitPendingTransform(List<DisplayListCommand> output) {
|
||||
if (!accumulated.equals(lastEmitted)) {
|
||||
emitTransformTo(output, accumulated);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Emit a MultMatrix command to make GL state match a target transform.
|
||||
* Used when a draw expects a specific transform that may differ from accumulated.
|
||||
* Updates lastEmitted to match target after emission.
|
||||
*
|
||||
* @param output The command list to emit to
|
||||
* @param target The target transform to reach
|
||||
*/
|
||||
void emitTransformTo(List<DisplayListCommand> output, Matrix4f target) {
|
||||
if (target.equals(lastEmitted)) {
|
||||
// Already at target - nothing to emit
|
||||
return;
|
||||
}
|
||||
|
||||
// Calculate delta: what we need to multiply to go from lastEmitted to target
|
||||
// delta = inverse(lastEmitted) * target
|
||||
// But for simplicity, if lastEmitted is identity, just emit target
|
||||
if (DisplayListManager.isIdentity(lastEmitted)) {
|
||||
// Simple case: just emit target
|
||||
output.add(MultMatrixCmd.create(target, GL11.GL_MODELVIEW));
|
||||
} else {
|
||||
// Need to emit delta: inv(lastEmitted) * target
|
||||
final Matrix4f delta = new Matrix4f(lastEmitted).invert().mul(target);
|
||||
output.add(MultMatrixCmd.create(delta, GL11.GL_MODELVIEW));
|
||||
}
|
||||
lastEmitted.set(target);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a draw's expected transform differs from what we've emitted.
|
||||
*/
|
||||
boolean needsTransformForDraw(Matrix4f drawTransform) {
|
||||
return !drawTransform.equals(lastEmitted);
|
||||
}
|
||||
|
||||
/**
|
||||
* Mark that the GL matrix is at an absolute value (after LoadMatrix).
|
||||
* Subsequent LoadIdentity commands must be emitted to actually reset GL to identity.
|
||||
*/
|
||||
void markAbsoluteMatrix() {
|
||||
absoluteMatrixFlag = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the GL matrix is at an absolute value and clear the flag.
|
||||
* Used by LoadIdentityCmd to determine if it needs to emit.
|
||||
* @return true if LoadMatrix was called and not yet reset by LoadIdentity
|
||||
*/
|
||||
boolean checkAndClearAbsoluteMatrix() {
|
||||
boolean was = absoluteMatrixFlag;
|
||||
absoluteMatrixFlag = false;
|
||||
return was;
|
||||
}
|
||||
}
|
||||
@@ -4,6 +4,7 @@ import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.lwjgl.opengl.ARBDirectStateAccess;
|
||||
import org.lwjgl.opengl.GL45;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
@@ -14,6 +15,29 @@ public class DSAARB extends DSAUnsupported {
|
||||
ARBDirectStateAccess.glGenerateTextureMipmap(texture);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void textureImage2D(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, ByteBuffer pixels) {
|
||||
// Note: DSA glTextureImage2D doesn't exist in ARB_direct_state_access
|
||||
// We need to use glTextureStorage2D + glTextureSubImage2D, or fall back to bind-based approach
|
||||
// For simplicity, use the fallback which binds, uploads, and restores
|
||||
super.textureImage2D(texture, target, level, internalformat, width, height, border, format, type, pixels);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void textureImage2D(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, IntBuffer pixels) {
|
||||
super.textureImage2D(texture, target, level, internalformat, width, height, border, format, type, pixels);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void textureSubImage2D(int texture, int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, ByteBuffer pixels) {
|
||||
ARBDirectStateAccess.glTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void textureSubImage2D(int texture, int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, IntBuffer pixels) {
|
||||
ARBDirectStateAccess.glTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void texParameteri(int texture, int target, int pname, int param) {
|
||||
if(!GLStateManager.updateTexParameteriCache(target, texture, pname, param)) return;
|
||||
|
||||
@@ -1,11 +1,18 @@
|
||||
package com.gtnewhorizons.angelica.glsm.dsa;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
public interface DSAAccess {
|
||||
void generateMipmaps(int texture, int target);
|
||||
|
||||
// Texture image upload - DSA allows specifying texture directly without binding
|
||||
void textureImage2D(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, ByteBuffer pixels);
|
||||
void textureImage2D(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, IntBuffer pixels);
|
||||
void textureSubImage2D(int texture, int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, ByteBuffer pixels);
|
||||
void textureSubImage2D(int texture, int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, IntBuffer pixels);
|
||||
|
||||
void texParameteri(int texture, int target, int pname, int param);
|
||||
void texParameterf(int texture, int target, int pname, float param);
|
||||
void texParameteriv(int texture, int target, int pname, IntBuffer params);
|
||||
|
||||
@@ -9,6 +9,7 @@ import org.lwjgl.opengl.GL15;
|
||||
import org.lwjgl.opengl.GL20;
|
||||
import org.lwjgl.opengl.GL30;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
@@ -20,6 +21,39 @@ public class DSAUnsupported implements DSAAccess {
|
||||
GL30.glGenerateMipmap(target);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void textureImage2D(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, ByteBuffer pixels) {
|
||||
// Get what cache thinks is bound - we'll restore to this to keep cache/GL in sync
|
||||
final int cachedBinding = GLStateManager.getBoundTexture();
|
||||
GL11.glBindTexture(target, texture);
|
||||
GL11.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
|
||||
GL11.glBindTexture(target, cachedBinding); // Restore to cache value
|
||||
}
|
||||
|
||||
@Override
|
||||
public void textureImage2D(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, IntBuffer pixels) {
|
||||
final int cachedBinding = GLStateManager.getBoundTexture();
|
||||
GL11.glBindTexture(target, texture);
|
||||
GL11.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
|
||||
GL11.glBindTexture(target, cachedBinding);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void textureSubImage2D(int texture, int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, ByteBuffer pixels) {
|
||||
final int cachedBinding = GLStateManager.getBoundTexture();
|
||||
GL11.glBindTexture(target, texture);
|
||||
GL11.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
|
||||
GL11.glBindTexture(target, cachedBinding);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void textureSubImage2D(int texture, int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, IntBuffer pixels) {
|
||||
final int cachedBinding = GLStateManager.getBoundTexture();
|
||||
GL11.glBindTexture(target, texture);
|
||||
GL11.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
|
||||
GL11.glBindTexture(target, cachedBinding);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void texParameteri(int texture, int target, int pname, int param) {
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadViewMutable;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.util.ModelQuadUtil;
|
||||
import org.joml.Matrix4f;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Represents an accumulated draw call during display list compilation.
|
||||
* Matrix-as-Data Architecture: Stores untransformed vertices + captured matrix.
|
||||
* The matrix will be applied at runtime, not baked into vertices.
|
||||
*/
|
||||
public class AccumulatedDraw {
|
||||
public final List<ModelQuadViewMutable> quads;
|
||||
public final Matrix4f transform;
|
||||
public final CapturingTessellator.Flags flags;
|
||||
public final int commandIndex; // Position in command list for state tracking
|
||||
|
||||
public AccumulatedDraw(List<ModelQuadViewMutable> quads, Matrix4f transform, CapturingTessellator.Flags flags, int commandIndex) {
|
||||
// Deep copy quads - pooled quads are reused after callback
|
||||
this.quads = ModelQuadUtil.deepCopyQuads(quads);
|
||||
|
||||
this.transform = new Matrix4f(transform); // Snapshot for runtime application
|
||||
this.flags = flags;
|
||||
this.commandIndex = commandIndex;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return String.format("AccumulatedDraw[quads=%d, cmdIdx=%d, flags=C%dT%dL%dN%d]",
|
||||
quads.size(), commandIndex, flags.hasColor ? 1 : 0, flags.hasTexture ? 1 : 0, flags.hasBrightness ? 1 : 0, flags.hasNormals ? 1 : 0);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
|
||||
import org.joml.Matrix4f;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Represents an accumulated line draw call during display list compilation.
|
||||
* Similar to AccumulatedDraw but for line primitives.
|
||||
* Stores untransformed line vertices + captured matrix.
|
||||
*/
|
||||
public class AccumulatedLineDraw {
|
||||
public final List<ImmediateModeRecorder.LineVertex> lines;
|
||||
public final Matrix4f transform;
|
||||
public final CapturingTessellator.Flags flags;
|
||||
public final int commandIndex; // Position in command list for state tracking
|
||||
|
||||
public AccumulatedLineDraw(List<ImmediateModeRecorder.LineVertex> lines, Matrix4f transform, CapturingTessellator.Flags flags, int commandIndex) {
|
||||
// Copy lines - the source list may be cleared
|
||||
this.lines = new ArrayList<>(lines);
|
||||
this.transform = new Matrix4f(transform); // Snapshot for runtime application
|
||||
this.flags = flags;
|
||||
this.commandIndex = commandIndex;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return String.format("AccumulatedLineDraw[lines=%d, cmdIdx=%d, flags=C%dT%dL%dN%d]",
|
||||
lines.size() / 2, commandIndex, flags.hasColor ? 1 : 0, flags.hasTexture ? 1 : 0, flags.hasBrightness ? 1 : 0, flags.hasNormals ? 1 : 0);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,660 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.recording.commands.DisplayListCommand;
|
||||
import org.joml.Matrix4f;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*;
|
||||
|
||||
public final class CommandBuffer {
|
||||
private static final int DEFAULT_CAPACITY = 4096; // Guess at typical display list size
|
||||
|
||||
private ByteBuffer buffer;
|
||||
private long basePointer;
|
||||
private long writePointer;
|
||||
private final List<Object> complexObjects = new ArrayList<>();
|
||||
|
||||
public CommandBuffer() {
|
||||
this(DEFAULT_CAPACITY);
|
||||
}
|
||||
|
||||
public CommandBuffer(int initialCapacity) {
|
||||
this.buffer = memAlloc(initialCapacity);
|
||||
this.basePointer = memAddress(buffer);
|
||||
this.writePointer = basePointer;
|
||||
}
|
||||
|
||||
// === Low-level write operations ===
|
||||
|
||||
private void writeInt(int value) {
|
||||
memPutInt(writePointer, value);
|
||||
writePointer += 4;
|
||||
}
|
||||
|
||||
private void writeFloat(float value) {
|
||||
memPutFloat(writePointer, value);
|
||||
writePointer += 4;
|
||||
}
|
||||
|
||||
private void writeDouble(double value) {
|
||||
memPutDouble(writePointer, value);
|
||||
writePointer += 8;
|
||||
}
|
||||
|
||||
private void ensureCapacity(int needed) {
|
||||
final int size = size();
|
||||
final int remaining = buffer.capacity() - size;
|
||||
if (remaining < needed) {
|
||||
final int newCapacity = Math.max(buffer.capacity() * 2, buffer.capacity() + needed);
|
||||
buffer = memRealloc(buffer, newCapacity);
|
||||
basePointer = memAddress(buffer);
|
||||
writePointer = basePointer + size;
|
||||
}
|
||||
}
|
||||
|
||||
// === Single int commands ===
|
||||
|
||||
public void writeEnable(int cap) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.ENABLE);
|
||||
writeInt(cap);
|
||||
}
|
||||
|
||||
public void writeDisable(int cap) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.DISABLE);
|
||||
writeInt(cap);
|
||||
}
|
||||
|
||||
public void writeClear(int mask) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.CLEAR);
|
||||
writeInt(mask);
|
||||
}
|
||||
|
||||
public void writeClearStencil(int s) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.CLEAR_STENCIL);
|
||||
writeInt(s);
|
||||
}
|
||||
|
||||
public void writeCullFace(int mode) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.CULL_FACE);
|
||||
writeInt(mode);
|
||||
}
|
||||
|
||||
public void writeDepthFunc(int func) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.DEPTH_FUNC);
|
||||
writeInt(func);
|
||||
}
|
||||
|
||||
public void writeShadeModel(int mode) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.SHADE_MODEL);
|
||||
writeInt(mode);
|
||||
}
|
||||
|
||||
public void writeLogicOp(int opcode) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.LOGIC_OP);
|
||||
writeInt(opcode);
|
||||
}
|
||||
|
||||
public void writeMatrixMode(int mode) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.MATRIX_MODE);
|
||||
writeInt(mode);
|
||||
}
|
||||
|
||||
public void writeActiveTexture(int texture) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.ACTIVE_TEXTURE);
|
||||
writeInt(texture);
|
||||
}
|
||||
|
||||
public void writeUseProgram(int program) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.USE_PROGRAM);
|
||||
writeInt(program);
|
||||
}
|
||||
|
||||
public void writePushAttrib(int mask) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.PUSH_ATTRIB);
|
||||
writeInt(mask);
|
||||
}
|
||||
|
||||
public void writePopAttrib() {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.POP_ATTRIB);
|
||||
writeInt(0); // unused padding
|
||||
}
|
||||
|
||||
public void writeLoadIdentity(int matrixMode) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.LOAD_IDENTITY);
|
||||
writeInt(matrixMode);
|
||||
}
|
||||
|
||||
public void writePushMatrix(int matrixMode) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.PUSH_MATRIX);
|
||||
writeInt(matrixMode);
|
||||
}
|
||||
|
||||
public void writePopMatrix(int matrixMode) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.POP_MATRIX);
|
||||
writeInt(matrixMode);
|
||||
}
|
||||
|
||||
public void writeStencilMask(int mask) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.STENCIL_MASK);
|
||||
writeInt(mask);
|
||||
}
|
||||
|
||||
public void writeDepthMask(boolean flag) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.DEPTH_MASK);
|
||||
writeInt(flag ? 1 : 0);
|
||||
}
|
||||
|
||||
// === Two int commands ===
|
||||
|
||||
public void writeBindTexture(int target, int texture) {
|
||||
ensureCapacity(12);
|
||||
writeInt(GLCommand.BIND_TEXTURE);
|
||||
writeInt(target);
|
||||
writeInt(texture);
|
||||
}
|
||||
|
||||
public void writePolygonMode(int face, int mode) {
|
||||
ensureCapacity(12);
|
||||
writeInt(GLCommand.POLYGON_MODE);
|
||||
writeInt(face);
|
||||
writeInt(mode);
|
||||
}
|
||||
|
||||
public void writeColorMaterial(int face, int mode) {
|
||||
ensureCapacity(12);
|
||||
writeInt(GLCommand.COLOR_MATERIAL);
|
||||
writeInt(face);
|
||||
writeInt(mode);
|
||||
}
|
||||
|
||||
public void writeLineStipple(int factor, int pattern) {
|
||||
ensureCapacity(12);
|
||||
writeInt(GLCommand.LINE_STIPPLE);
|
||||
writeInt(factor);
|
||||
writeInt(pattern);
|
||||
}
|
||||
|
||||
public void writeStencilMaskSeparate(int face, int mask) {
|
||||
ensureCapacity(12);
|
||||
writeInt(GLCommand.STENCIL_MASK_SEPARATE);
|
||||
writeInt(face);
|
||||
writeInt(mask);
|
||||
}
|
||||
|
||||
public void writeFogi(int pname, int param) {
|
||||
ensureCapacity(12);
|
||||
writeInt(GLCommand.FOGI);
|
||||
writeInt(pname);
|
||||
writeInt(param);
|
||||
}
|
||||
|
||||
// === Three int commands ===
|
||||
|
||||
public void writeStencilFunc(int func, int ref, int mask) {
|
||||
ensureCapacity(16);
|
||||
writeInt(GLCommand.STENCIL_FUNC);
|
||||
writeInt(func);
|
||||
writeInt(ref);
|
||||
writeInt(mask);
|
||||
}
|
||||
|
||||
public void writeStencilOp(int fail, int zfail, int zpass) {
|
||||
ensureCapacity(16);
|
||||
writeInt(GLCommand.STENCIL_OP);
|
||||
writeInt(fail);
|
||||
writeInt(zfail);
|
||||
writeInt(zpass);
|
||||
}
|
||||
|
||||
public void writeTexParameteri(int target, int pname, int param) {
|
||||
ensureCapacity(16);
|
||||
writeInt(GLCommand.TEX_PARAMETERI);
|
||||
writeInt(target);
|
||||
writeInt(pname);
|
||||
writeInt(param);
|
||||
}
|
||||
|
||||
// === Four int commands ===
|
||||
|
||||
public void writeViewport(int x, int y, int width, int height) {
|
||||
ensureCapacity(20);
|
||||
writeInt(GLCommand.VIEWPORT);
|
||||
writeInt(x);
|
||||
writeInt(y);
|
||||
writeInt(width);
|
||||
writeInt(height);
|
||||
}
|
||||
|
||||
public void writeBlendFunc(int srcRgb, int dstRgb, int srcAlpha, int dstAlpha) {
|
||||
ensureCapacity(20);
|
||||
writeInt(GLCommand.BLEND_FUNC);
|
||||
writeInt(srcRgb);
|
||||
writeInt(dstRgb);
|
||||
writeInt(srcAlpha);
|
||||
writeInt(dstAlpha);
|
||||
}
|
||||
|
||||
public void writeColorMask(boolean red, boolean green, boolean blue, boolean alpha) {
|
||||
ensureCapacity(20);
|
||||
writeInt(GLCommand.COLOR_MASK);
|
||||
writeInt(red ? 1 : 0);
|
||||
writeInt(green ? 1 : 0);
|
||||
writeInt(blue ? 1 : 0);
|
||||
writeInt(alpha ? 1 : 0);
|
||||
}
|
||||
|
||||
public void writeStencilFuncSeparate(int face, int func, int ref, int mask) {
|
||||
ensureCapacity(20);
|
||||
writeInt(GLCommand.STENCIL_FUNC_SEPARATE);
|
||||
writeInt(face);
|
||||
writeInt(func);
|
||||
writeInt(ref);
|
||||
writeInt(mask);
|
||||
}
|
||||
|
||||
public void writeStencilOpSeparate(int face, int sfail, int dpfail, int dppass) {
|
||||
ensureCapacity(20);
|
||||
writeInt(GLCommand.STENCIL_OP_SEPARATE);
|
||||
writeInt(face);
|
||||
writeInt(sfail);
|
||||
writeInt(dpfail);
|
||||
writeInt(dppass);
|
||||
}
|
||||
|
||||
// === Float commands ===
|
||||
|
||||
public void writePointSize(float size) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.POINT_SIZE);
|
||||
writeFloat(size);
|
||||
}
|
||||
|
||||
public void writeLineWidth(float width) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.LINE_WIDTH);
|
||||
writeFloat(width);
|
||||
}
|
||||
|
||||
public void writePolygonOffset(float factor, float units) {
|
||||
ensureCapacity(12);
|
||||
writeInt(GLCommand.POLYGON_OFFSET);
|
||||
writeFloat(factor);
|
||||
writeFloat(units);
|
||||
}
|
||||
|
||||
public void writeNormal(float x, float y, float z) {
|
||||
ensureCapacity(16);
|
||||
writeInt(GLCommand.NORMAL);
|
||||
writeFloat(x);
|
||||
writeFloat(y);
|
||||
writeFloat(z);
|
||||
}
|
||||
|
||||
public void writeColor(float r, float g, float b, float a) {
|
||||
ensureCapacity(20);
|
||||
writeInt(GLCommand.COLOR);
|
||||
writeFloat(r);
|
||||
writeFloat(g);
|
||||
writeFloat(b);
|
||||
writeFloat(a);
|
||||
}
|
||||
|
||||
public void writeClearColor(float r, float g, float b, float a) {
|
||||
ensureCapacity(20);
|
||||
writeInt(GLCommand.CLEAR_COLOR);
|
||||
writeFloat(r);
|
||||
writeFloat(g);
|
||||
writeFloat(b);
|
||||
writeFloat(a);
|
||||
}
|
||||
|
||||
// === Mixed int+float commands ===
|
||||
|
||||
public void writeAlphaFunc(int func, float ref) {
|
||||
ensureCapacity(12);
|
||||
writeInt(GLCommand.ALPHA_FUNC);
|
||||
writeInt(func);
|
||||
writeFloat(ref);
|
||||
}
|
||||
|
||||
public void writeFogf(int pname, float param) {
|
||||
ensureCapacity(12);
|
||||
writeInt(GLCommand.FOGF);
|
||||
writeInt(pname);
|
||||
writeFloat(param);
|
||||
}
|
||||
|
||||
public void writeLightf(int light, int pname, float param) {
|
||||
ensureCapacity(16);
|
||||
writeInt(GLCommand.LIGHTF);
|
||||
writeInt(light);
|
||||
writeInt(pname);
|
||||
writeFloat(param);
|
||||
}
|
||||
|
||||
public void writeLightModelf(int pname, float param) {
|
||||
ensureCapacity(12);
|
||||
writeInt(GLCommand.LIGHT_MODELF);
|
||||
writeInt(pname);
|
||||
writeFloat(param);
|
||||
}
|
||||
|
||||
public void writeLighti(int light, int pname, int param) {
|
||||
ensureCapacity(16);
|
||||
writeInt(GLCommand.LIGHTI);
|
||||
writeInt(light);
|
||||
writeInt(pname);
|
||||
writeInt(param);
|
||||
}
|
||||
|
||||
public void writeLightModeli(int pname, int param) {
|
||||
ensureCapacity(12);
|
||||
writeInt(GLCommand.LIGHT_MODELI);
|
||||
writeInt(pname);
|
||||
writeInt(param);
|
||||
}
|
||||
|
||||
public void writeMaterialf(int face, int pname, float param) {
|
||||
ensureCapacity(16);
|
||||
writeInt(GLCommand.MATERIALF);
|
||||
writeInt(face);
|
||||
writeInt(pname);
|
||||
writeFloat(param);
|
||||
}
|
||||
|
||||
public void writeTexParameterf(int target, int pname, float param) {
|
||||
ensureCapacity(16);
|
||||
writeInt(GLCommand.TEX_PARAMETERF);
|
||||
writeInt(target);
|
||||
writeInt(pname);
|
||||
writeFloat(param);
|
||||
}
|
||||
|
||||
// === Double commands ===
|
||||
|
||||
public void writeTranslate(int matrixMode, double x, double y, double z) {
|
||||
ensureCapacity(32);
|
||||
writeInt(GLCommand.TRANSLATE);
|
||||
writeInt(matrixMode);
|
||||
writeDouble(x);
|
||||
writeDouble(y);
|
||||
writeDouble(z);
|
||||
}
|
||||
|
||||
public void writeRotate(int matrixMode, double angle, double x, double y, double z) {
|
||||
ensureCapacity(40);
|
||||
writeInt(GLCommand.ROTATE);
|
||||
writeInt(matrixMode);
|
||||
writeDouble(angle);
|
||||
writeDouble(x);
|
||||
writeDouble(y);
|
||||
writeDouble(z);
|
||||
}
|
||||
|
||||
public void writeScale(int matrixMode, double x, double y, double z) {
|
||||
ensureCapacity(32);
|
||||
writeInt(GLCommand.SCALE);
|
||||
writeInt(matrixMode);
|
||||
writeDouble(x);
|
||||
writeDouble(y);
|
||||
writeDouble(z);
|
||||
}
|
||||
|
||||
public void writeOrtho(double left, double right, double bottom, double top, double zNear, double zFar) {
|
||||
ensureCapacity(52);
|
||||
writeInt(GLCommand.ORTHO);
|
||||
writeDouble(left);
|
||||
writeDouble(right);
|
||||
writeDouble(bottom);
|
||||
writeDouble(top);
|
||||
writeDouble(zNear);
|
||||
writeDouble(zFar);
|
||||
}
|
||||
|
||||
public void writeFrustum(double left, double right, double bottom, double top, double zNear, double zFar) {
|
||||
ensureCapacity(52);
|
||||
writeInt(GLCommand.FRUSTUM);
|
||||
writeDouble(left);
|
||||
writeDouble(right);
|
||||
writeDouble(bottom);
|
||||
writeDouble(top);
|
||||
writeDouble(zNear);
|
||||
writeDouble(zFar);
|
||||
}
|
||||
|
||||
// === Matrix commands ===
|
||||
|
||||
public void writeMultMatrix(int matrixMode, Matrix4f matrix) {
|
||||
ensureCapacity(72);
|
||||
writeInt(GLCommand.MULT_MATRIX);
|
||||
writeInt(matrixMode);
|
||||
writeMatrix4f(matrix);
|
||||
}
|
||||
|
||||
public void writeLoadMatrix(int matrixMode, Matrix4f matrix) {
|
||||
ensureCapacity(72);
|
||||
writeInt(GLCommand.LOAD_MATRIX);
|
||||
writeInt(matrixMode);
|
||||
writeMatrix4f(matrix);
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a Matrix4f to the buffer in column-major order (OpenGL convention).
|
||||
* Uses accessor methods instead of getToAddress() to avoid JOML MemUtil issues.
|
||||
*/
|
||||
private void writeMatrix4f(Matrix4f m) {
|
||||
// Column 0
|
||||
writeFloat(m.m00()); writeFloat(m.m01()); writeFloat(m.m02()); writeFloat(m.m03());
|
||||
// Column 1
|
||||
writeFloat(m.m10()); writeFloat(m.m11()); writeFloat(m.m12()); writeFloat(m.m13());
|
||||
// Column 2
|
||||
writeFloat(m.m20()); writeFloat(m.m21()); writeFloat(m.m22()); writeFloat(m.m23());
|
||||
// Column 3
|
||||
writeFloat(m.m30()); writeFloat(m.m31()); writeFloat(m.m32()); writeFloat(m.m33());
|
||||
}
|
||||
|
||||
// === Buffer commands (inline 4 floats) ===
|
||||
|
||||
public void writeFog(int pname, FloatBuffer params) {
|
||||
final int count = Math.min(params.remaining(), 4);
|
||||
ensureCapacity(12 + count * 4);
|
||||
writeInt(GLCommand.FOG);
|
||||
writeInt(pname);
|
||||
writeInt(count);
|
||||
final int pos = params.position();
|
||||
for (int i = 0; i < count; i++) {
|
||||
writeFloat(params.get(pos + i));
|
||||
}
|
||||
}
|
||||
|
||||
public void writeLight(int light, int pname, FloatBuffer params) {
|
||||
final int count = Math.min(params.remaining(), 4);
|
||||
ensureCapacity(16 + count * 4);
|
||||
writeInt(GLCommand.LIGHT);
|
||||
writeInt(light);
|
||||
writeInt(pname);
|
||||
writeInt(count);
|
||||
final int pos = params.position();
|
||||
for (int i = 0; i < count; i++) {
|
||||
writeFloat(params.get(pos + i));
|
||||
}
|
||||
}
|
||||
|
||||
public void writeLightModel(int pname, FloatBuffer params) {
|
||||
final int count = Math.min(params.remaining(), 4);
|
||||
ensureCapacity(12 + count * 4);
|
||||
writeInt(GLCommand.LIGHT_MODEL);
|
||||
writeInt(pname);
|
||||
writeInt(count);
|
||||
final int pos = params.position();
|
||||
for (int i = 0; i < count; i++) {
|
||||
writeFloat(params.get(pos + i));
|
||||
}
|
||||
}
|
||||
|
||||
public void writeMaterial(int face, int pname, FloatBuffer params) {
|
||||
final int count = Math.min(params.remaining(), 4);
|
||||
ensureCapacity(16 + count * 4);
|
||||
writeInt(GLCommand.MATERIAL);
|
||||
writeInt(face);
|
||||
writeInt(pname);
|
||||
writeInt(count);
|
||||
final int pos = params.position();
|
||||
for (int i = 0; i < count; i++) {
|
||||
writeFloat(params.get(pos + i));
|
||||
}
|
||||
}
|
||||
|
||||
// === Draw commands ===
|
||||
|
||||
public void writeDrawRange(int vboIndex, int startVertex, int vertexCount, boolean hasBrightness) {
|
||||
ensureCapacity(20);
|
||||
writeInt(GLCommand.DRAW_RANGE);
|
||||
writeInt(vboIndex);
|
||||
writeInt(startVertex);
|
||||
writeInt(vertexCount);
|
||||
writeInt(hasBrightness ? 1 : 0);
|
||||
}
|
||||
|
||||
public void writeCallList(int listId) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.CALL_LIST);
|
||||
writeInt(listId);
|
||||
}
|
||||
|
||||
// === Complex object reference ===
|
||||
|
||||
public void writeComplexRef(DisplayListCommand cmd) {
|
||||
ensureCapacity(8);
|
||||
final int index = complexObjects.size();
|
||||
complexObjects.add(cmd);
|
||||
writeInt(GLCommand.COMPLEX_REF);
|
||||
writeInt(index);
|
||||
}
|
||||
|
||||
// === Reading methods for optimization pass ===
|
||||
|
||||
private long readPointer = 0;
|
||||
|
||||
/**
|
||||
* Reset read position to the beginning of the buffer.
|
||||
*/
|
||||
public void resetRead() {
|
||||
readPointer = basePointer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if there's more data to read.
|
||||
*/
|
||||
public boolean hasRemaining() {
|
||||
return readPointer < writePointer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read an int from the current position.
|
||||
*/
|
||||
public int readInt() {
|
||||
final int value = memGetInt(readPointer);
|
||||
readPointer += 4;
|
||||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read a float from the current position.
|
||||
*/
|
||||
public float readFloat() {
|
||||
final float value = memGetFloat(readPointer);
|
||||
readPointer += 4;
|
||||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read a double from the current position.
|
||||
*/
|
||||
public double readDouble() {
|
||||
final double value = memGetDouble(readPointer);
|
||||
readPointer += 8;
|
||||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read a Matrix4f from the current position (16 floats in column-major order).
|
||||
*/
|
||||
public Matrix4f readMatrix4f(Matrix4f dest) {
|
||||
dest.m00(readFloat()); dest.m01(readFloat()); dest.m02(readFloat()); dest.m03(readFloat());
|
||||
dest.m10(readFloat()); dest.m11(readFloat()); dest.m12(readFloat()); dest.m13(readFloat());
|
||||
dest.m20(readFloat()); dest.m21(readFloat()); dest.m22(readFloat()); dest.m23(readFloat());
|
||||
dest.m30(readFloat()); dest.m31(readFloat()); dest.m32(readFloat()); dest.m33(readFloat());
|
||||
return dest;
|
||||
}
|
||||
|
||||
// === Lifecycle ===
|
||||
|
||||
public int size() {
|
||||
return (int) (writePointer - basePointer);
|
||||
}
|
||||
|
||||
public long address() {
|
||||
return basePointer;
|
||||
}
|
||||
|
||||
public ByteBuffer toBuffer() {
|
||||
buffer.limit(size());
|
||||
buffer.position(0);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
public Object[] getComplexObjects() {
|
||||
return complexObjects.toArray();
|
||||
}
|
||||
|
||||
public Object getComplexObject(int index) {
|
||||
return complexObjects.get(index);
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return size() == 0 && complexObjects.isEmpty();
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear the buffer for reuse. Does NOT free memory.
|
||||
*/
|
||||
public void clear() {
|
||||
writePointer = basePointer;
|
||||
complexObjects.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Free the underlying buffer. Must be called when done.
|
||||
*/
|
||||
public void free() {
|
||||
if (buffer != null) {
|
||||
memFree(buffer);
|
||||
buffer = null;
|
||||
basePointer = 0;
|
||||
writePointer = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,494 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
|
||||
import com.gtnewhorizons.angelica.glsm.DisplayListManager;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.commands.DisplayListCommand;
|
||||
import org.lwjgl.BufferUtils;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*;
|
||||
|
||||
/**
|
||||
* Executes commands from a CommandBuffer
|
||||
*/
|
||||
public final class CommandBufferExecutor {
|
||||
private CommandBufferExecutor() {}
|
||||
|
||||
// Static reusable buffer for matrix ops (render thread only, LWJGL2/3 compatible)
|
||||
private static final FloatBuffer MATRIX_BUFFER = BufferUtils.createFloatBuffer(16);
|
||||
// Static reusable buffer for fog/light/material params
|
||||
private static final FloatBuffer PARAMS_BUFFER = BufferUtils.createFloatBuffer(4);
|
||||
|
||||
/**
|
||||
* Execute all commands in the buffer.
|
||||
*
|
||||
* @param buffer The command buffer (position should be at 0, limit at size)
|
||||
* @param complexObjects Array of complex objects (TexImage2DCmd, etc.)
|
||||
* @param ownedVbos Array of VBOs owned by the display list (indexed by DrawRange commands)
|
||||
*/
|
||||
public static void execute(ByteBuffer buffer, Object[] complexObjects, VertexBuffer[] ownedVbos) {
|
||||
long ptr = memAddress(buffer);
|
||||
final long end = ptr + buffer.limit();
|
||||
|
||||
while (ptr < end) {
|
||||
final int cmd = memGetInt(ptr);
|
||||
ptr += 4;
|
||||
|
||||
switch (cmd) {
|
||||
// === Single int commands ===
|
||||
case GLCommand.ENABLE -> {
|
||||
GLStateManager.glEnable(memGetInt(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.DISABLE -> {
|
||||
GLStateManager.glDisable(memGetInt(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.CLEAR -> {
|
||||
GLStateManager.glClear(memGetInt(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.CLEAR_STENCIL -> {
|
||||
GLStateManager.glClearStencil(memGetInt(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.CULL_FACE -> {
|
||||
GLStateManager.glCullFace(memGetInt(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.DEPTH_FUNC -> {
|
||||
GLStateManager.glDepthFunc(memGetInt(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.SHADE_MODEL -> {
|
||||
GLStateManager.glShadeModel(memGetInt(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.LOGIC_OP -> {
|
||||
GLStateManager.glLogicOp(memGetInt(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.MATRIX_MODE -> {
|
||||
GLStateManager.glMatrixMode(memGetInt(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.ACTIVE_TEXTURE -> {
|
||||
GLStateManager.glActiveTexture(memGetInt(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.USE_PROGRAM -> {
|
||||
GLStateManager.glUseProgram(memGetInt(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.PUSH_ATTRIB -> {
|
||||
GLStateManager.glPushAttrib(memGetInt(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.POP_ATTRIB -> {
|
||||
GLStateManager.glPopAttrib();
|
||||
ptr += 4; // Skip unused padding
|
||||
}
|
||||
case GLCommand.LOAD_IDENTITY -> {
|
||||
final int mode = memGetInt(ptr);
|
||||
ptr += 4;
|
||||
final int savedMode = GLStateManager.getMatrixMode().getMode();
|
||||
GLStateManager.glMatrixMode(mode);
|
||||
GLStateManager.glLoadIdentity();
|
||||
GLStateManager.glMatrixMode(savedMode);
|
||||
}
|
||||
case GLCommand.PUSH_MATRIX -> {
|
||||
final int mode = memGetInt(ptr);
|
||||
ptr += 4;
|
||||
final int savedMode = GLStateManager.getMatrixMode().getMode();
|
||||
GLStateManager.glMatrixMode(mode);
|
||||
GLStateManager.glPushMatrix();
|
||||
GLStateManager.glMatrixMode(savedMode);
|
||||
}
|
||||
case GLCommand.POP_MATRIX -> {
|
||||
final int mode = memGetInt(ptr);
|
||||
ptr += 4;
|
||||
final int savedMode = GLStateManager.getMatrixMode().getMode();
|
||||
GLStateManager.glMatrixMode(mode);
|
||||
GLStateManager.glPopMatrix();
|
||||
GLStateManager.glMatrixMode(savedMode);
|
||||
}
|
||||
case GLCommand.STENCIL_MASK -> {
|
||||
GLStateManager.glStencilMask(memGetInt(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.DEPTH_MASK -> {
|
||||
GLStateManager.glDepthMask(memGetInt(ptr) != 0);
|
||||
ptr += 4;
|
||||
}
|
||||
|
||||
// === Two int commands ===
|
||||
case GLCommand.BIND_TEXTURE -> {
|
||||
final int target = memGetInt(ptr);
|
||||
final int texture = memGetInt(ptr + 4);
|
||||
ptr += 8;
|
||||
GLStateManager.glBindTexture(target, texture);
|
||||
}
|
||||
case GLCommand.POLYGON_MODE -> {
|
||||
final int face = memGetInt(ptr);
|
||||
final int mode = memGetInt(ptr + 4);
|
||||
ptr += 8;
|
||||
GLStateManager.glPolygonMode(face, mode);
|
||||
}
|
||||
case GLCommand.COLOR_MATERIAL -> {
|
||||
final int face = memGetInt(ptr);
|
||||
final int mode = memGetInt(ptr + 4);
|
||||
ptr += 8;
|
||||
GLStateManager.glColorMaterial(face, mode);
|
||||
}
|
||||
case GLCommand.LINE_STIPPLE -> {
|
||||
final int factor = memGetInt(ptr);
|
||||
final int pattern = memGetInt(ptr + 4);
|
||||
ptr += 8;
|
||||
GLStateManager.glLineStipple(factor, (short) pattern);
|
||||
}
|
||||
case GLCommand.STENCIL_MASK_SEPARATE -> {
|
||||
final int face = memGetInt(ptr);
|
||||
final int mask = memGetInt(ptr + 4);
|
||||
ptr += 8;
|
||||
GLStateManager.glStencilMaskSeparate(face, mask);
|
||||
}
|
||||
case GLCommand.FOGI -> {
|
||||
final int pname = memGetInt(ptr);
|
||||
final int param = memGetInt(ptr + 4);
|
||||
ptr += 8;
|
||||
GLStateManager.glFogi(pname, param);
|
||||
}
|
||||
|
||||
// === Three int commands ===
|
||||
case GLCommand.STENCIL_FUNC -> {
|
||||
final int func = memGetInt(ptr);
|
||||
final int ref = memGetInt(ptr + 4);
|
||||
final int mask = memGetInt(ptr + 8);
|
||||
ptr += 12;
|
||||
GLStateManager.glStencilFunc(func, ref, mask);
|
||||
}
|
||||
case GLCommand.STENCIL_OP -> {
|
||||
final int fail = memGetInt(ptr);
|
||||
final int zfail = memGetInt(ptr + 4);
|
||||
final int zpass = memGetInt(ptr + 8);
|
||||
ptr += 12;
|
||||
GLStateManager.glStencilOp(fail, zfail, zpass);
|
||||
}
|
||||
case GLCommand.TEX_PARAMETERI -> {
|
||||
final int target = memGetInt(ptr);
|
||||
final int pname = memGetInt(ptr + 4);
|
||||
final int param = memGetInt(ptr + 8);
|
||||
ptr += 12;
|
||||
GLStateManager.glTexParameteri(target, pname, param);
|
||||
}
|
||||
|
||||
// === Four int commands ===
|
||||
case GLCommand.VIEWPORT -> {
|
||||
final int x = memGetInt(ptr);
|
||||
final int y = memGetInt(ptr + 4);
|
||||
final int width = memGetInt(ptr + 8);
|
||||
final int height = memGetInt(ptr + 12);
|
||||
ptr += 16;
|
||||
GLStateManager.glViewport(x, y, width, height);
|
||||
}
|
||||
case GLCommand.BLEND_FUNC -> {
|
||||
final int srcRgb = memGetInt(ptr);
|
||||
final int dstRgb = memGetInt(ptr + 4);
|
||||
final int srcAlpha = memGetInt(ptr + 8);
|
||||
final int dstAlpha = memGetInt(ptr + 12);
|
||||
ptr += 16;
|
||||
if (srcRgb == srcAlpha && dstRgb == dstAlpha) {
|
||||
GLStateManager.glBlendFunc(srcRgb, dstRgb);
|
||||
} else {
|
||||
GLStateManager.tryBlendFuncSeparate(srcRgb, dstRgb, srcAlpha, dstAlpha);
|
||||
}
|
||||
}
|
||||
case GLCommand.COLOR_MASK -> {
|
||||
final boolean r = memGetInt(ptr) != 0;
|
||||
final boolean g = memGetInt(ptr + 4) != 0;
|
||||
final boolean b = memGetInt(ptr + 8) != 0;
|
||||
final boolean a = memGetInt(ptr + 12) != 0;
|
||||
ptr += 16;
|
||||
GLStateManager.glColorMask(r, g, b, a);
|
||||
}
|
||||
case GLCommand.STENCIL_FUNC_SEPARATE -> {
|
||||
final int face = memGetInt(ptr);
|
||||
final int func = memGetInt(ptr + 4);
|
||||
final int ref = memGetInt(ptr + 8);
|
||||
final int mask = memGetInt(ptr + 12);
|
||||
ptr += 16;
|
||||
GLStateManager.glStencilFuncSeparate(face, func, ref, mask);
|
||||
}
|
||||
case GLCommand.STENCIL_OP_SEPARATE -> {
|
||||
final int face = memGetInt(ptr);
|
||||
final int sfail = memGetInt(ptr + 4);
|
||||
final int dpfail = memGetInt(ptr + 8);
|
||||
final int dppass = memGetInt(ptr + 12);
|
||||
ptr += 16;
|
||||
GLStateManager.glStencilOpSeparate(face, sfail, dpfail, dppass);
|
||||
}
|
||||
|
||||
// === Float commands ===
|
||||
case GLCommand.POINT_SIZE -> {
|
||||
GLStateManager.glPointSize(memGetFloat(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.LINE_WIDTH -> {
|
||||
GLStateManager.glLineWidth(memGetFloat(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.POLYGON_OFFSET -> {
|
||||
final float factor = memGetFloat(ptr);
|
||||
final float units = memGetFloat(ptr + 4);
|
||||
ptr += 8;
|
||||
GLStateManager.glPolygonOffset(factor, units);
|
||||
}
|
||||
case GLCommand.NORMAL -> {
|
||||
final float x = memGetFloat(ptr);
|
||||
final float y = memGetFloat(ptr + 4);
|
||||
final float z = memGetFloat(ptr + 8);
|
||||
ptr += 12;
|
||||
GLStateManager.glNormal3f(x, y, z);
|
||||
}
|
||||
case GLCommand.COLOR -> {
|
||||
final float r = memGetFloat(ptr);
|
||||
final float g = memGetFloat(ptr + 4);
|
||||
final float b = memGetFloat(ptr + 8);
|
||||
final float a = memGetFloat(ptr + 12);
|
||||
ptr += 16;
|
||||
GLStateManager.glColor4f(r, g, b, a);
|
||||
}
|
||||
case GLCommand.CLEAR_COLOR -> {
|
||||
final float r = memGetFloat(ptr);
|
||||
final float g = memGetFloat(ptr + 4);
|
||||
final float b = memGetFloat(ptr + 8);
|
||||
final float a = memGetFloat(ptr + 12);
|
||||
ptr += 16;
|
||||
GLStateManager.glClearColor(r, g, b, a);
|
||||
}
|
||||
|
||||
// === Mixed int+float commands ===
|
||||
case GLCommand.ALPHA_FUNC -> {
|
||||
final int func = memGetInt(ptr);
|
||||
final float ref = memGetFloat(ptr + 4);
|
||||
ptr += 8;
|
||||
GLStateManager.glAlphaFunc(func, ref);
|
||||
}
|
||||
case GLCommand.FOGF -> {
|
||||
final int pname = memGetInt(ptr);
|
||||
final float param = memGetFloat(ptr + 4);
|
||||
ptr += 8;
|
||||
GLStateManager.glFogf(pname, param);
|
||||
}
|
||||
case GLCommand.LIGHTF -> {
|
||||
final int light = memGetInt(ptr);
|
||||
final int pname = memGetInt(ptr + 4);
|
||||
final float param = memGetFloat(ptr + 8);
|
||||
ptr += 12;
|
||||
GLStateManager.glLightf(light, pname, param);
|
||||
}
|
||||
case GLCommand.LIGHT_MODELF -> {
|
||||
final int pname = memGetInt(ptr);
|
||||
final float param = memGetFloat(ptr + 4);
|
||||
ptr += 8;
|
||||
GLStateManager.glLightModelf(pname, param);
|
||||
}
|
||||
case GLCommand.LIGHTI -> {
|
||||
final int light = memGetInt(ptr);
|
||||
final int pname = memGetInt(ptr + 4);
|
||||
final int param = memGetInt(ptr + 8);
|
||||
ptr += 12;
|
||||
GLStateManager.glLighti(light, pname, param);
|
||||
}
|
||||
case GLCommand.LIGHT_MODELI -> {
|
||||
final int pname = memGetInt(ptr);
|
||||
final int param = memGetInt(ptr + 4);
|
||||
ptr += 8;
|
||||
GLStateManager.glLightModeli(pname, param);
|
||||
}
|
||||
case GLCommand.MATERIALF -> {
|
||||
final int face = memGetInt(ptr);
|
||||
final int pname = memGetInt(ptr + 4);
|
||||
final float param = memGetFloat(ptr + 8);
|
||||
ptr += 12;
|
||||
GLStateManager.glMaterialf(face, pname, param);
|
||||
}
|
||||
case GLCommand.TEX_PARAMETERF -> {
|
||||
final int target = memGetInt(ptr);
|
||||
final int pname = memGetInt(ptr + 4);
|
||||
final float param = memGetFloat(ptr + 8);
|
||||
ptr += 12;
|
||||
GLStateManager.glTexParameterf(target, pname, param);
|
||||
}
|
||||
|
||||
// === Double commands ===
|
||||
case GLCommand.TRANSLATE -> {
|
||||
final int mode = memGetInt(ptr);
|
||||
final double x = memGetDouble(ptr + 4);
|
||||
final double y = memGetDouble(ptr + 12);
|
||||
final double z = memGetDouble(ptr + 20);
|
||||
ptr += 28;
|
||||
final int savedMode = GLStateManager.getMatrixMode().getMode();
|
||||
GLStateManager.glMatrixMode(mode);
|
||||
GLStateManager.glTranslated(x, y, z);
|
||||
GLStateManager.glMatrixMode(savedMode);
|
||||
}
|
||||
case GLCommand.ROTATE -> {
|
||||
final int mode = memGetInt(ptr);
|
||||
final double angle = memGetDouble(ptr + 4);
|
||||
final double x = memGetDouble(ptr + 12);
|
||||
final double y = memGetDouble(ptr + 20);
|
||||
final double z = memGetDouble(ptr + 28);
|
||||
ptr += 36;
|
||||
final int savedMode = GLStateManager.getMatrixMode().getMode();
|
||||
GLStateManager.glMatrixMode(mode);
|
||||
GLStateManager.glRotated(angle, x, y, z);
|
||||
GLStateManager.glMatrixMode(savedMode);
|
||||
}
|
||||
case GLCommand.SCALE -> {
|
||||
final int mode = memGetInt(ptr);
|
||||
final double x = memGetDouble(ptr + 4);
|
||||
final double y = memGetDouble(ptr + 12);
|
||||
final double z = memGetDouble(ptr + 20);
|
||||
ptr += 28;
|
||||
final int savedMode = GLStateManager.getMatrixMode().getMode();
|
||||
GLStateManager.glMatrixMode(mode);
|
||||
GLStateManager.glScaled(x, y, z);
|
||||
GLStateManager.glMatrixMode(savedMode);
|
||||
}
|
||||
case GLCommand.ORTHO -> {
|
||||
final double left = memGetDouble(ptr);
|
||||
final double right = memGetDouble(ptr + 8);
|
||||
final double bottom = memGetDouble(ptr + 16);
|
||||
final double top = memGetDouble(ptr + 24);
|
||||
final double zNear = memGetDouble(ptr + 32);
|
||||
final double zFar = memGetDouble(ptr + 40);
|
||||
ptr += 48;
|
||||
GLStateManager.glOrtho(left, right, bottom, top, zNear, zFar);
|
||||
}
|
||||
case GLCommand.FRUSTUM -> {
|
||||
final double left = memGetDouble(ptr);
|
||||
final double right = memGetDouble(ptr + 8);
|
||||
final double bottom = memGetDouble(ptr + 16);
|
||||
final double top = memGetDouble(ptr + 24);
|
||||
final double zNear = memGetDouble(ptr + 32);
|
||||
final double zFar = memGetDouble(ptr + 40);
|
||||
ptr += 48;
|
||||
GLStateManager.glFrustum(left, right, bottom, top, zNear, zFar);
|
||||
}
|
||||
|
||||
// === Matrix commands ===
|
||||
case GLCommand.MULT_MATRIX -> {
|
||||
final int mode = memGetInt(ptr);
|
||||
ptr += 4;
|
||||
MATRIX_BUFFER.clear();
|
||||
for (int i = 0; i < 16; i++) {
|
||||
MATRIX_BUFFER.put(memGetFloat(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
MATRIX_BUFFER.flip();
|
||||
final int savedMode = GLStateManager.getMatrixMode().getMode();
|
||||
GLStateManager.glMatrixMode(mode);
|
||||
GLStateManager.glMultMatrix(MATRIX_BUFFER);
|
||||
GLStateManager.glMatrixMode(savedMode);
|
||||
}
|
||||
case GLCommand.LOAD_MATRIX -> {
|
||||
final int mode = memGetInt(ptr);
|
||||
ptr += 4;
|
||||
MATRIX_BUFFER.clear();
|
||||
for (int i = 0; i < 16; i++) {
|
||||
MATRIX_BUFFER.put(memGetFloat(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
MATRIX_BUFFER.flip();
|
||||
final int savedMode = GLStateManager.getMatrixMode().getMode();
|
||||
GLStateManager.glMatrixMode(mode);
|
||||
GLStateManager.glLoadMatrix(MATRIX_BUFFER);
|
||||
GLStateManager.glMatrixMode(savedMode);
|
||||
}
|
||||
|
||||
// === Buffer commands ===
|
||||
case GLCommand.FOG -> {
|
||||
final int pname = memGetInt(ptr);
|
||||
final int count = memGetInt(ptr + 4);
|
||||
ptr += 8;
|
||||
PARAMS_BUFFER.clear();
|
||||
for (int i = 0; i < count; i++) {
|
||||
PARAMS_BUFFER.put(memGetFloat(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
PARAMS_BUFFER.flip();
|
||||
GLStateManager.glFog(pname, PARAMS_BUFFER);
|
||||
}
|
||||
case GLCommand.LIGHT -> {
|
||||
final int light = memGetInt(ptr);
|
||||
final int pname = memGetInt(ptr + 4);
|
||||
final int count = memGetInt(ptr + 8);
|
||||
ptr += 12;
|
||||
PARAMS_BUFFER.clear();
|
||||
for (int i = 0; i < count; i++) {
|
||||
PARAMS_BUFFER.put(memGetFloat(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
PARAMS_BUFFER.flip();
|
||||
GLStateManager.glLight(light, pname, PARAMS_BUFFER);
|
||||
}
|
||||
case GLCommand.LIGHT_MODEL -> {
|
||||
final int pname = memGetInt(ptr);
|
||||
final int count = memGetInt(ptr + 4);
|
||||
ptr += 8;
|
||||
PARAMS_BUFFER.clear();
|
||||
for (int i = 0; i < count; i++) {
|
||||
PARAMS_BUFFER.put(memGetFloat(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
PARAMS_BUFFER.flip();
|
||||
GLStateManager.glLightModel(pname, PARAMS_BUFFER);
|
||||
}
|
||||
case GLCommand.MATERIAL -> {
|
||||
final int face = memGetInt(ptr);
|
||||
final int pname = memGetInt(ptr + 4);
|
||||
final int count = memGetInt(ptr + 8);
|
||||
ptr += 12;
|
||||
PARAMS_BUFFER.clear();
|
||||
for (int i = 0; i < count; i++) {
|
||||
PARAMS_BUFFER.put(memGetFloat(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
PARAMS_BUFFER.flip();
|
||||
GLStateManager.glMaterial(face, pname, PARAMS_BUFFER);
|
||||
}
|
||||
|
||||
// === Draw commands ===
|
||||
case GLCommand.DRAW_RANGE -> {
|
||||
final int vboIndex = memGetInt(ptr);
|
||||
final int start = memGetInt(ptr + 4);
|
||||
final int count = memGetInt(ptr + 8);
|
||||
final boolean hasBrightness = memGetInt(ptr + 12) != 0;
|
||||
ptr += 16;
|
||||
final VertexBuffer vbo = ownedVbos[vboIndex];
|
||||
vbo.setupState();
|
||||
vbo.draw(start, count);
|
||||
vbo.cleanupState();
|
||||
}
|
||||
case GLCommand.CALL_LIST -> {
|
||||
final int listId = memGetInt(ptr);
|
||||
ptr += 4;
|
||||
DisplayListManager.glCallList(listId);
|
||||
}
|
||||
|
||||
// === Complex object reference ===
|
||||
case GLCommand.COMPLEX_REF -> {
|
||||
final int index = memGetInt(ptr);
|
||||
ptr += 4;
|
||||
((DisplayListCommand) complexObjects[index]).execute();
|
||||
}
|
||||
|
||||
default -> throw new IllegalStateException("Unknown command opcode: " + cmd);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,352 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.recording.commands.DisplayListCommand;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.joml.Matrix4f;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.FloatBuffer;
|
||||
import java.util.ArrayDeque;
|
||||
import java.util.Deque;
|
||||
|
||||
public final class CommandBufferProcessor {
|
||||
private static final Logger LOGGER = LogManager.getLogger("CommandBufferProcessor");
|
||||
private static final Matrix4f tempMatrix = new Matrix4f();
|
||||
|
||||
private CommandBufferProcessor() {}
|
||||
|
||||
public static void processCommandForOptimization(int opcode, CommandBuffer raw, BufferTransformOptimizer opt, CommandBuffer out) {
|
||||
switch (opcode) {
|
||||
// === MODELVIEW matrix commands - accumulate instead of copying ===
|
||||
case GLCommand.TRANSLATE -> {
|
||||
final int mode = raw.readInt();
|
||||
final double x = raw.readDouble();
|
||||
final double y = raw.readDouble();
|
||||
final double z = raw.readDouble();
|
||||
if (mode == GL11.GL_MODELVIEW) {
|
||||
opt.translate(x, y, z);
|
||||
} else {
|
||||
out.writeTranslate(mode, x, y, z);
|
||||
}
|
||||
}
|
||||
case GLCommand.ROTATE -> {
|
||||
final int mode = raw.readInt();
|
||||
final double angle = raw.readDouble();
|
||||
final double x = raw.readDouble();
|
||||
final double y = raw.readDouble();
|
||||
final double z = raw.readDouble();
|
||||
if (mode == GL11.GL_MODELVIEW) {
|
||||
opt.rotate(angle, x, y, z);
|
||||
} else {
|
||||
out.writeRotate(mode, angle, x, y, z);
|
||||
}
|
||||
}
|
||||
case GLCommand.SCALE -> {
|
||||
final int mode = raw.readInt();
|
||||
final double x = raw.readDouble();
|
||||
final double y = raw.readDouble();
|
||||
final double z = raw.readDouble();
|
||||
if (mode == GL11.GL_MODELVIEW) {
|
||||
opt.scale(x, y, z);
|
||||
} else {
|
||||
out.writeScale(mode, x, y, z);
|
||||
}
|
||||
}
|
||||
case GLCommand.MULT_MATRIX -> {
|
||||
final int mode = raw.readInt();
|
||||
raw.readMatrix4f(tempMatrix);
|
||||
if (mode == GL11.GL_MODELVIEW) {
|
||||
opt.multMatrix(tempMatrix);
|
||||
} else {
|
||||
out.writeMultMatrix(mode, tempMatrix);
|
||||
}
|
||||
}
|
||||
case GLCommand.LOAD_IDENTITY -> {
|
||||
final int mode = raw.readInt();
|
||||
if (mode == GL11.GL_MODELVIEW) {
|
||||
if (opt.checkAndClearAbsoluteMatrix()) {
|
||||
out.writeLoadIdentity(mode);
|
||||
}
|
||||
opt.loadIdentity();
|
||||
} else {
|
||||
out.writeLoadIdentity(mode);
|
||||
}
|
||||
}
|
||||
case GLCommand.LOAD_MATRIX -> {
|
||||
final int mode = raw.readInt();
|
||||
raw.readMatrix4f(tempMatrix);
|
||||
if (mode == GL11.GL_MODELVIEW) {
|
||||
opt.emitPendingTransform(out);
|
||||
out.writeLoadMatrix(mode, tempMatrix);
|
||||
opt.loadIdentity();
|
||||
opt.markAbsoluteMatrix();
|
||||
} else {
|
||||
out.writeLoadMatrix(mode, tempMatrix);
|
||||
}
|
||||
}
|
||||
|
||||
// === Stack operations - update optimizer state and copy ===
|
||||
case GLCommand.PUSH_MATRIX -> {
|
||||
final int mode = raw.readInt();
|
||||
if (mode == GL11.GL_MODELVIEW) {
|
||||
opt.emitPendingTransform(out);
|
||||
opt.push();
|
||||
}
|
||||
out.writePushMatrix(mode);
|
||||
}
|
||||
case GLCommand.POP_MATRIX -> {
|
||||
final int mode = raw.readInt();
|
||||
if (mode == GL11.GL_MODELVIEW) {
|
||||
opt.pop();
|
||||
}
|
||||
out.writePopMatrix(mode);
|
||||
}
|
||||
|
||||
// === Barriers - emit pending transform before copying ===
|
||||
case GLCommand.CALL_LIST -> {
|
||||
final int listId = raw.readInt();
|
||||
opt.emitPendingTransform(out);
|
||||
out.writeCallList(listId);
|
||||
}
|
||||
case GLCommand.PUSH_ATTRIB -> {
|
||||
final int mask = raw.readInt();
|
||||
if ((mask & GL11.GL_TRANSFORM_BIT) != 0) {
|
||||
opt.emitPendingTransform(out);
|
||||
}
|
||||
out.writePushAttrib(mask);
|
||||
}
|
||||
|
||||
// === All other commands - just copy ===
|
||||
default -> copyCommandData(opcode, raw, out);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy a complete command (opcode already read) from raw to final buffer.
|
||||
*/
|
||||
public static void copyCommand(CommandBuffer raw, CommandBuffer out) {
|
||||
final int opcode = raw.readInt();
|
||||
copyCommandData(opcode, raw, out);
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy command data based on opcode (opcode already consumed from raw).
|
||||
*/
|
||||
public static void copyCommandData(int opcode, CommandBuffer raw, CommandBuffer out) {
|
||||
switch (opcode) {
|
||||
// Single int commands
|
||||
case GLCommand.ENABLE -> out.writeEnable(raw.readInt());
|
||||
case GLCommand.DISABLE -> out.writeDisable(raw.readInt());
|
||||
case GLCommand.CLEAR -> out.writeClear(raw.readInt());
|
||||
case GLCommand.CLEAR_STENCIL -> out.writeClearStencil(raw.readInt());
|
||||
case GLCommand.CULL_FACE -> out.writeCullFace(raw.readInt());
|
||||
case GLCommand.DEPTH_FUNC -> out.writeDepthFunc(raw.readInt());
|
||||
case GLCommand.SHADE_MODEL -> out.writeShadeModel(raw.readInt());
|
||||
case GLCommand.LOGIC_OP -> out.writeLogicOp(raw.readInt());
|
||||
case GLCommand.MATRIX_MODE -> out.writeMatrixMode(raw.readInt());
|
||||
case GLCommand.ACTIVE_TEXTURE -> out.writeActiveTexture(raw.readInt());
|
||||
case GLCommand.USE_PROGRAM -> out.writeUseProgram(raw.readInt());
|
||||
case GLCommand.PUSH_ATTRIB -> out.writePushAttrib(raw.readInt());
|
||||
case GLCommand.POP_ATTRIB -> { raw.readInt(); out.writePopAttrib(); }
|
||||
case GLCommand.LOAD_IDENTITY -> out.writeLoadIdentity(raw.readInt());
|
||||
case GLCommand.PUSH_MATRIX -> out.writePushMatrix(raw.readInt());
|
||||
case GLCommand.POP_MATRIX -> out.writePopMatrix(raw.readInt());
|
||||
case GLCommand.STENCIL_MASK -> out.writeStencilMask(raw.readInt());
|
||||
case GLCommand.DEPTH_MASK -> out.writeDepthMask(raw.readInt() != 0);
|
||||
|
||||
// Two int commands
|
||||
case GLCommand.BIND_TEXTURE -> out.writeBindTexture(raw.readInt(), raw.readInt());
|
||||
case GLCommand.POLYGON_MODE -> out.writePolygonMode(raw.readInt(), raw.readInt());
|
||||
case GLCommand.COLOR_MATERIAL -> out.writeColorMaterial(raw.readInt(), raw.readInt());
|
||||
case GLCommand.LINE_STIPPLE -> out.writeLineStipple(raw.readInt(), raw.readInt());
|
||||
case GLCommand.STENCIL_MASK_SEPARATE -> out.writeStencilMaskSeparate(raw.readInt(), raw.readInt());
|
||||
case GLCommand.FOGI -> out.writeFogi(raw.readInt(), raw.readInt());
|
||||
|
||||
// Three int commands
|
||||
case GLCommand.STENCIL_FUNC -> out.writeStencilFunc(raw.readInt(), raw.readInt(), raw.readInt());
|
||||
case GLCommand.STENCIL_OP -> out.writeStencilOp(raw.readInt(), raw.readInt(), raw.readInt());
|
||||
case GLCommand.TEX_PARAMETERI -> out.writeTexParameteri(raw.readInt(), raw.readInt(), raw.readInt());
|
||||
|
||||
// Four int commands
|
||||
case GLCommand.VIEWPORT -> out.writeViewport(raw.readInt(), raw.readInt(), raw.readInt(), raw.readInt());
|
||||
case GLCommand.BLEND_FUNC -> out.writeBlendFunc(raw.readInt(), raw.readInt(), raw.readInt(), raw.readInt());
|
||||
case GLCommand.COLOR_MASK -> out.writeColorMask(raw.readInt() != 0, raw.readInt() != 0, raw.readInt() != 0, raw.readInt() != 0);
|
||||
case GLCommand.STENCIL_FUNC_SEPARATE -> out.writeStencilFuncSeparate(raw.readInt(), raw.readInt(), raw.readInt(), raw.readInt());
|
||||
case GLCommand.STENCIL_OP_SEPARATE -> out.writeStencilOpSeparate(raw.readInt(), raw.readInt(), raw.readInt(), raw.readInt());
|
||||
|
||||
// Float commands
|
||||
case GLCommand.POINT_SIZE -> out.writePointSize(raw.readFloat());
|
||||
case GLCommand.LINE_WIDTH -> out.writeLineWidth(raw.readFloat());
|
||||
case GLCommand.POLYGON_OFFSET -> out.writePolygonOffset(raw.readFloat(), raw.readFloat());
|
||||
case GLCommand.NORMAL -> out.writeNormal(raw.readFloat(), raw.readFloat(), raw.readFloat());
|
||||
case GLCommand.COLOR -> out.writeColor(raw.readFloat(), raw.readFloat(), raw.readFloat(), raw.readFloat());
|
||||
case GLCommand.CLEAR_COLOR -> out.writeClearColor(raw.readFloat(), raw.readFloat(), raw.readFloat(), raw.readFloat());
|
||||
|
||||
// Mixed int+float commands
|
||||
case GLCommand.ALPHA_FUNC -> out.writeAlphaFunc(raw.readInt(), raw.readFloat());
|
||||
case GLCommand.FOGF -> out.writeFogf(raw.readInt(), raw.readFloat());
|
||||
case GLCommand.LIGHTF -> out.writeLightf(raw.readInt(), raw.readInt(), raw.readFloat());
|
||||
case GLCommand.LIGHT_MODELF -> out.writeLightModelf(raw.readInt(), raw.readFloat());
|
||||
case GLCommand.LIGHTI -> out.writeLighti(raw.readInt(), raw.readInt(), raw.readInt());
|
||||
case GLCommand.LIGHT_MODELI -> out.writeLightModeli(raw.readInt(), raw.readInt());
|
||||
case GLCommand.MATERIALF -> out.writeMaterialf(raw.readInt(), raw.readInt(), raw.readFloat());
|
||||
case GLCommand.TEX_PARAMETERF -> out.writeTexParameterf(raw.readInt(), raw.readInt(), raw.readFloat());
|
||||
|
||||
// Double commands
|
||||
case GLCommand.TRANSLATE -> out.writeTranslate(raw.readInt(), raw.readDouble(), raw.readDouble(), raw.readDouble());
|
||||
case GLCommand.ROTATE -> out.writeRotate(raw.readInt(), raw.readDouble(), raw.readDouble(), raw.readDouble(), raw.readDouble());
|
||||
case GLCommand.SCALE -> out.writeScale(raw.readInt(), raw.readDouble(), raw.readDouble(), raw.readDouble());
|
||||
case GLCommand.ORTHO -> out.writeOrtho(raw.readDouble(), raw.readDouble(), raw.readDouble(), raw.readDouble(), raw.readDouble(), raw.readDouble());
|
||||
case GLCommand.FRUSTUM -> out.writeFrustum(raw.readDouble(), raw.readDouble(), raw.readDouble(), raw.readDouble(), raw.readDouble(), raw.readDouble());
|
||||
|
||||
// Matrix commands
|
||||
case GLCommand.MULT_MATRIX -> { int mode = raw.readInt(); out.writeMultMatrix(mode, raw.readMatrix4f(tempMatrix)); }
|
||||
case GLCommand.LOAD_MATRIX -> { int mode = raw.readInt(); out.writeLoadMatrix(mode, raw.readMatrix4f(tempMatrix)); }
|
||||
|
||||
// FloatBuffer commands (inline 4 floats max)
|
||||
case GLCommand.FOG -> {
|
||||
final int pname = raw.readInt();
|
||||
final int count = raw.readInt();
|
||||
final FloatBuffer fb = FloatBuffer.allocate(count);
|
||||
for (int i = 0; i < count; i++) fb.put(raw.readFloat());
|
||||
fb.flip();
|
||||
out.writeFog(pname, fb);
|
||||
}
|
||||
case GLCommand.LIGHT -> {
|
||||
final int light = raw.readInt();
|
||||
final int pname = raw.readInt();
|
||||
final int count = raw.readInt();
|
||||
final FloatBuffer fb = FloatBuffer.allocate(count);
|
||||
for (int i = 0; i < count; i++) fb.put(raw.readFloat());
|
||||
fb.flip();
|
||||
out.writeLight(light, pname, fb);
|
||||
}
|
||||
case GLCommand.LIGHT_MODEL -> {
|
||||
final int pname = raw.readInt();
|
||||
final int count = raw.readInt();
|
||||
final FloatBuffer fb = FloatBuffer.allocate(count);
|
||||
for (int i = 0; i < count; i++) fb.put(raw.readFloat());
|
||||
fb.flip();
|
||||
out.writeLightModel(pname, fb);
|
||||
}
|
||||
case GLCommand.MATERIAL -> {
|
||||
final int face = raw.readInt();
|
||||
final int pname = raw.readInt();
|
||||
final int count = raw.readInt();
|
||||
final FloatBuffer fb = FloatBuffer.allocate(count);
|
||||
for (int i = 0; i < count; i++) fb.put(raw.readFloat());
|
||||
fb.flip();
|
||||
out.writeMaterial(face, pname, fb);
|
||||
}
|
||||
|
||||
// Draw/call commands
|
||||
case GLCommand.DRAW_RANGE -> out.writeDrawRange(raw.readInt(), raw.readInt(), raw.readInt(), raw.readInt() != 0);
|
||||
case GLCommand.CALL_LIST -> out.writeCallList(raw.readInt());
|
||||
|
||||
// Complex object reference - transfer the object to output buffer
|
||||
case GLCommand.COMPLEX_REF -> {
|
||||
final int index = raw.readInt();
|
||||
final Object obj = raw.getComplexObject(index);
|
||||
out.writeComplexRef((DisplayListCommand) obj);
|
||||
}
|
||||
|
||||
default -> LOGGER.warn("[CommandBufferProcessor] Unknown opcode in buffer copy: {}", opcode);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a matrix is identity (within epsilon).
|
||||
*/
|
||||
public static boolean isIdentity(Matrix4f m) {
|
||||
final float eps = 1e-6f;
|
||||
return Math.abs(m.m00() - 1) < eps && Math.abs(m.m01()) < eps && Math.abs(m.m02()) < eps && Math.abs(m.m03()) < eps
|
||||
&& Math.abs(m.m10()) < eps && Math.abs(m.m11() - 1) < eps && Math.abs(m.m12()) < eps && Math.abs(m.m13()) < eps
|
||||
&& Math.abs(m.m20()) < eps && Math.abs(m.m21()) < eps && Math.abs(m.m22() - 1) < eps && Math.abs(m.m23()) < eps
|
||||
&& Math.abs(m.m30()) < eps && Math.abs(m.m31()) < eps && Math.abs(m.m32()) < eps && Math.abs(m.m33() - 1) < eps;
|
||||
}
|
||||
|
||||
/**
|
||||
* Lightweight transform optimizer for buffer-to-buffer processing.
|
||||
* Tracks accumulated MODELVIEW transform and emits MultMatrix commands when needed.
|
||||
*/
|
||||
public static class BufferTransformOptimizer {
|
||||
private final Matrix4f accumulated = new Matrix4f();
|
||||
private final Matrix4f lastEmitted = new Matrix4f();
|
||||
private final Deque<Matrix4f> stack = new ArrayDeque<>();
|
||||
private boolean absoluteMatrixFlag = false;
|
||||
|
||||
public BufferTransformOptimizer() {
|
||||
accumulated.identity();
|
||||
lastEmitted.identity();
|
||||
}
|
||||
|
||||
public void translate(double x, double y, double z) {
|
||||
accumulated.translate((float) x, (float) y, (float) z);
|
||||
}
|
||||
|
||||
public void rotate(double angle, double x, double y, double z) {
|
||||
accumulated.rotate((float) Math.toRadians(angle), (float) x, (float) y, (float) z);
|
||||
}
|
||||
|
||||
public void scale(double x, double y, double z) {
|
||||
accumulated.scale((float) x, (float) y, (float) z);
|
||||
}
|
||||
|
||||
public void multMatrix(Matrix4f m) {
|
||||
accumulated.mul(m);
|
||||
}
|
||||
|
||||
public void loadIdentity() {
|
||||
accumulated.identity();
|
||||
}
|
||||
|
||||
public void push() {
|
||||
stack.push(new Matrix4f(accumulated));
|
||||
}
|
||||
|
||||
public void pop() {
|
||||
if (!stack.isEmpty()) {
|
||||
accumulated.set(stack.pop());
|
||||
lastEmitted.set(accumulated);
|
||||
} else {
|
||||
accumulated.identity();
|
||||
lastEmitted.identity();
|
||||
}
|
||||
}
|
||||
|
||||
public boolean isIdentity() {
|
||||
return CommandBufferProcessor.isIdentity(accumulated);
|
||||
}
|
||||
|
||||
public void markAbsoluteMatrix() {
|
||||
absoluteMatrixFlag = true;
|
||||
}
|
||||
|
||||
public boolean checkAndClearAbsoluteMatrix() {
|
||||
final boolean was = absoluteMatrixFlag;
|
||||
absoluteMatrixFlag = false;
|
||||
return was;
|
||||
}
|
||||
|
||||
public void emitPendingTransform(CommandBuffer out) {
|
||||
if (!accumulated.equals(lastEmitted)) {
|
||||
emitTransformTo(out, accumulated);
|
||||
}
|
||||
}
|
||||
|
||||
public void emitTransformTo(CommandBuffer out, Matrix4f target) {
|
||||
if (target.equals(lastEmitted)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (CommandBufferProcessor.isIdentity(lastEmitted)) {
|
||||
out.writeMultMatrix(GL11.GL_MODELVIEW, target);
|
||||
} else {
|
||||
final Matrix4f delta = new Matrix4f(lastEmitted).invert().mul(target);
|
||||
out.writeMultMatrix(GL11.GL_MODELVIEW, delta);
|
||||
}
|
||||
lastEmitted.set(target);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,328 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.recording.commands.DisplayListCommand;
|
||||
import org.joml.Matrix4f;
|
||||
|
||||
import java.nio.FloatBuffer;
|
||||
|
||||
/**
|
||||
* Records GL commands to a CommandBuffer during display list compilation.
|
||||
*/
|
||||
public class CommandRecorder {
|
||||
private final CommandBuffer buffer;
|
||||
private int commandCount;
|
||||
|
||||
public CommandRecorder() {
|
||||
this.buffer = new CommandBuffer();
|
||||
this.commandCount = 0;
|
||||
}
|
||||
|
||||
public CommandBuffer getBuffer() {
|
||||
return buffer;
|
||||
}
|
||||
|
||||
public int getCommandCount() {
|
||||
return commandCount;
|
||||
}
|
||||
|
||||
public void free() {
|
||||
buffer.free();
|
||||
}
|
||||
|
||||
// ==================== Recording Methods ====================
|
||||
|
||||
public void recordEnable(int cap) {
|
||||
buffer.writeEnable(cap);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordDisable(int cap) {
|
||||
buffer.writeDisable(cap);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordClear(int mask) {
|
||||
buffer.writeClear(mask);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordClearColor(float r, float g, float b, float a) {
|
||||
buffer.writeClearColor(r, g, b, a);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordClearStencil(int s) {
|
||||
buffer.writeClearStencil(s);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordColor(float r, float g, float b, float a) {
|
||||
buffer.writeColor(r, g, b, a);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordColorMask(boolean r, boolean g, boolean b, boolean a) {
|
||||
buffer.writeColorMask(r, g, b, a);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordDepthMask(boolean flag) {
|
||||
buffer.writeDepthMask(flag);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordDepthFunc(int func) {
|
||||
buffer.writeDepthFunc(func);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordBlendFunc(int srcRgb, int dstRgb, int srcAlpha, int dstAlpha) {
|
||||
buffer.writeBlendFunc(srcRgb, dstRgb, srcAlpha, dstAlpha);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordAlphaFunc(int func, float ref) {
|
||||
buffer.writeAlphaFunc(func, ref);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordCullFace(int mode) {
|
||||
buffer.writeCullFace(mode);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordShadeModel(int mode) {
|
||||
buffer.writeShadeModel(mode);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordBindTexture(int target, int texture) {
|
||||
buffer.writeBindTexture(target, texture);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordTexParameteri(int target, int pname, int param) {
|
||||
buffer.writeTexParameteri(target, pname, param);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordTexParameterf(int target, int pname, float param) {
|
||||
buffer.writeTexParameterf(target, pname, param);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordMatrixMode(int mode) {
|
||||
buffer.writeMatrixMode(mode);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordLoadIdentity(int matrixMode) {
|
||||
buffer.writeLoadIdentity(matrixMode);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordPushMatrix(int matrixMode) {
|
||||
buffer.writePushMatrix(matrixMode);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordPopMatrix(int matrixMode) {
|
||||
buffer.writePopMatrix(matrixMode);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordTranslate(int matrixMode, double x, double y, double z) {
|
||||
buffer.writeTranslate(matrixMode, x, y, z);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordRotate(int matrixMode, double angle, double x, double y, double z) {
|
||||
buffer.writeRotate(matrixMode, angle, x, y, z);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordScale(int matrixMode, double x, double y, double z) {
|
||||
buffer.writeScale(matrixMode, x, y, z);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordMultMatrix(int matrixMode, Matrix4f matrix) {
|
||||
buffer.writeMultMatrix(matrixMode, matrix);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordLoadMatrix(int matrixMode, Matrix4f matrix) {
|
||||
buffer.writeLoadMatrix(matrixMode, matrix);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordOrtho(double left, double right, double bottom, double top, double zNear, double zFar) {
|
||||
buffer.writeOrtho(left, right, bottom, top, zNear, zFar);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordFrustum(double left, double right, double bottom, double top, double zNear, double zFar) {
|
||||
buffer.writeFrustum(left, right, bottom, top, zNear, zFar);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordViewport(int x, int y, int width, int height) {
|
||||
buffer.writeViewport(x, y, width, height);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordNormal(float nx, float ny, float nz) {
|
||||
buffer.writeNormal(nx, ny, nz);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordPointSize(float size) {
|
||||
buffer.writePointSize(size);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordLineWidth(float width) {
|
||||
buffer.writeLineWidth(width);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordLineStipple(int factor, int pattern) {
|
||||
buffer.writeLineStipple(factor, pattern);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordPolygonOffset(float factor, float units) {
|
||||
buffer.writePolygonOffset(factor, units);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordPolygonMode(int face, int mode) {
|
||||
buffer.writePolygonMode(face, mode);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordColorMaterial(int face, int mode) {
|
||||
buffer.writeColorMaterial(face, mode);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordLogicOp(int opcode) {
|
||||
buffer.writeLogicOp(opcode);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordActiveTexture(int texture) {
|
||||
buffer.writeActiveTexture(texture);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordUseProgram(int program) {
|
||||
buffer.writeUseProgram(program);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordPushAttrib(int mask) {
|
||||
buffer.writePushAttrib(mask);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordPopAttrib() {
|
||||
buffer.writePopAttrib();
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordFogf(int pname, float param) {
|
||||
buffer.writeFogf(pname, param);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordFogi(int pname, int param) {
|
||||
buffer.writeFogi(pname, param);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordFog(int pname, FloatBuffer params) {
|
||||
buffer.writeFog(pname, params);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordLightf(int light, int pname, float param) {
|
||||
buffer.writeLightf(light, pname, param);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordLighti(int light, int pname, int param) {
|
||||
buffer.writeLighti(light, pname, param);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordLight(int light, int pname, FloatBuffer params) {
|
||||
buffer.writeLight(light, pname, params);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordLightModelf(int pname, float param) {
|
||||
buffer.writeLightModelf(pname, param);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordLightModeli(int pname, int param) {
|
||||
buffer.writeLightModeli(pname, param);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordLightModel(int pname, FloatBuffer params) {
|
||||
buffer.writeLightModel(pname, params);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordMaterialf(int face, int pname, float val) {
|
||||
buffer.writeMaterialf(face, pname, val);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordMaterial(int face, int pname, FloatBuffer params) {
|
||||
buffer.writeMaterial(face, pname, params);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordStencilFunc(int func, int ref, int mask) {
|
||||
buffer.writeStencilFunc(func, ref, mask);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordStencilFuncSeparate(int face, int func, int ref, int mask) {
|
||||
buffer.writeStencilFuncSeparate(face, func, ref, mask);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordStencilOp(int fail, int zfail, int zpass) {
|
||||
buffer.writeStencilOp(fail, zfail, zpass);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordStencilOpSeparate(int face, int sfail, int dpfail, int dppass) {
|
||||
buffer.writeStencilOpSeparate(face, sfail, dpfail, dppass);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordStencilMask(int mask) {
|
||||
buffer.writeStencilMask(mask);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordStencilMaskSeparate(int face, int mask) {
|
||||
buffer.writeStencilMaskSeparate(face, mask);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordCallList(int listId) {
|
||||
buffer.writeCallList(listId);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordComplexCommand(DisplayListCommand cmd) {
|
||||
buffer.writeComplexRef(cmd);
|
||||
commandCount++;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,184 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.commands.DisplayListCommand;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAddress;
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memFree;
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt;
|
||||
|
||||
/**
|
||||
* Represents a compiled display list.
|
||||
*
|
||||
* <p>Contains commands serialized to a direct ByteBuffer for off-heap storage,
|
||||
* with complex objects (TexImage2DCmd, TexSubImage2DCmd) stored separately.
|
||||
*
|
||||
* <p>The ownedVbos array contains VBOs that are referenced by DrawRange commands.
|
||||
*/
|
||||
public final class CompiledDisplayList {
|
||||
private final ByteBuffer commandBuffer; // Off-heap command storage, must be freed
|
||||
private final Object[] complexObjects; // Complex commands (TexImage2D, etc.)
|
||||
private final VertexBuffer[] ownedVbos; // GPU resources referenced by index
|
||||
|
||||
public CompiledDisplayList(ByteBuffer commandBuffer, Object[] complexObjects, VertexBuffer[] ownedVbos) {
|
||||
this.commandBuffer = commandBuffer;
|
||||
this.complexObjects = complexObjects;
|
||||
this.ownedVbos = ownedVbos;
|
||||
}
|
||||
|
||||
/**
|
||||
* Render this display list by executing all commands.
|
||||
*/
|
||||
public void render() {
|
||||
if (commandBuffer != null && commandBuffer.limit() > 0) {
|
||||
CommandBufferExecutor.execute(commandBuffer, complexObjects, ownedVbos);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete all resources held by this display list.
|
||||
*/
|
||||
public void delete() {
|
||||
// Delete complex objects that hold resources
|
||||
if (complexObjects != null) {
|
||||
for (Object obj : complexObjects) {
|
||||
if (obj instanceof DisplayListCommand cmd) {
|
||||
cmd.delete();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Close VBOs
|
||||
if (ownedVbos != null) {
|
||||
for (VertexBuffer vbo : ownedVbos) {
|
||||
if (vbo != null) {
|
||||
vbo.close();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Free the command buffer (off-heap memory)
|
||||
if (commandBuffer != null) {
|
||||
memFree(commandBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the command buffer for debugging/inspection.
|
||||
*/
|
||||
public ByteBuffer getCommandBuffer() {
|
||||
return commandBuffer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get complex objects for inlining into another display list (nested lists).
|
||||
*/
|
||||
public Object[] getComplexObjects() {
|
||||
return complexObjects;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get owned VBOs for inlining into another display list.
|
||||
*/
|
||||
public VertexBuffer[] getOwnedVbos() {
|
||||
return ownedVbos;
|
||||
}
|
||||
|
||||
// === Test inspection methods ===
|
||||
|
||||
/**
|
||||
* Get counts of each command type in the buffer.
|
||||
* Used for testing to verify optimization results.
|
||||
*/
|
||||
public Map<Integer, Integer> getCommandCounts() {
|
||||
Map<Integer, Integer> counts = new HashMap<>();
|
||||
if (commandBuffer == null || commandBuffer.limit() == 0) {
|
||||
return counts;
|
||||
}
|
||||
long ptr = memAddress(commandBuffer);
|
||||
long end = ptr + commandBuffer.limit();
|
||||
while (ptr < end) {
|
||||
int cmd = memGetInt(ptr);
|
||||
counts.merge(cmd, 1, Integer::sum);
|
||||
ptr += getCommandSize(cmd, ptr);
|
||||
}
|
||||
return counts;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the sequence of command opcodes in order.
|
||||
* Used for testing to verify command ordering.
|
||||
*/
|
||||
public List<Integer> getCommandOpcodes() {
|
||||
List<Integer> opcodes = new ArrayList<>();
|
||||
if (commandBuffer == null || commandBuffer.limit() == 0) {
|
||||
return opcodes;
|
||||
}
|
||||
long ptr = memAddress(commandBuffer);
|
||||
long end = ptr + commandBuffer.limit();
|
||||
while (ptr < end) {
|
||||
int cmd = memGetInt(ptr);
|
||||
opcodes.add(cmd);
|
||||
ptr += getCommandSize(cmd, ptr);
|
||||
}
|
||||
return opcodes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get size of a command in bytes (including the opcode).
|
||||
*/
|
||||
private static int getCommandSize(int cmd, long ptr) {
|
||||
return switch (cmd) {
|
||||
// Single int commands (8 bytes)
|
||||
case GLCommand.ENABLE, GLCommand.DISABLE, GLCommand.CLEAR, GLCommand.CLEAR_STENCIL,
|
||||
GLCommand.CULL_FACE, GLCommand.DEPTH_FUNC, GLCommand.SHADE_MODEL, GLCommand.LOGIC_OP,
|
||||
GLCommand.MATRIX_MODE, GLCommand.ACTIVE_TEXTURE, GLCommand.USE_PROGRAM,
|
||||
GLCommand.PUSH_ATTRIB, GLCommand.POP_ATTRIB, GLCommand.LOAD_IDENTITY,
|
||||
GLCommand.PUSH_MATRIX, GLCommand.POP_MATRIX, GLCommand.STENCIL_MASK,
|
||||
GLCommand.DEPTH_MASK, GLCommand.POINT_SIZE, GLCommand.LINE_WIDTH,
|
||||
GLCommand.CALL_LIST, GLCommand.COMPLEX_REF -> 8;
|
||||
|
||||
// Two int commands (12 bytes)
|
||||
case GLCommand.BIND_TEXTURE, GLCommand.POLYGON_MODE, GLCommand.COLOR_MATERIAL,
|
||||
GLCommand.LINE_STIPPLE, GLCommand.STENCIL_MASK_SEPARATE, GLCommand.FOGI,
|
||||
GLCommand.POLYGON_OFFSET, GLCommand.ALPHA_FUNC, GLCommand.FOGF,
|
||||
GLCommand.LIGHT_MODELF, GLCommand.LIGHT_MODELI -> 12;
|
||||
|
||||
// Three int commands (16 bytes)
|
||||
case GLCommand.STENCIL_FUNC, GLCommand.STENCIL_OP, GLCommand.TEX_PARAMETERI,
|
||||
GLCommand.NORMAL, GLCommand.LIGHTF, GLCommand.LIGHTI,
|
||||
GLCommand.MATERIALF, GLCommand.TEX_PARAMETERF -> 16;
|
||||
|
||||
// Four int commands (20 bytes)
|
||||
case GLCommand.VIEWPORT, GLCommand.BLEND_FUNC, GLCommand.COLOR_MASK,
|
||||
GLCommand.STENCIL_FUNC_SEPARATE, GLCommand.STENCIL_OP_SEPARATE,
|
||||
GLCommand.COLOR, GLCommand.CLEAR_COLOR, GLCommand.DRAW_RANGE -> 20;
|
||||
|
||||
// Double commands
|
||||
case GLCommand.TRANSLATE, GLCommand.SCALE -> 32; // cmd + mode + 3 doubles
|
||||
case GLCommand.ROTATE -> 40; // cmd + mode + 4 doubles
|
||||
case GLCommand.ORTHO, GLCommand.FRUSTUM -> 52; // cmd + 6 doubles
|
||||
|
||||
// Matrix commands (72 bytes)
|
||||
case GLCommand.MULT_MATRIX, GLCommand.LOAD_MATRIX -> 72;
|
||||
|
||||
// Buffer commands (variable, read count)
|
||||
case GLCommand.FOG, GLCommand.LIGHT_MODEL -> {
|
||||
int count = memGetInt(ptr + 8); // pname at +4, count at +8
|
||||
yield 12 + count * 4;
|
||||
}
|
||||
case GLCommand.LIGHT, GLCommand.MATERIAL -> {
|
||||
int count = memGetInt(ptr + 12); // light/face at +4, pname at +8, count at +12
|
||||
yield 16 + count * 4;
|
||||
}
|
||||
|
||||
default -> throw new IllegalStateException("Unknown command: " + cmd);
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,161 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
/**
|
||||
* Command opcodes for ByteBuffer-based display list serialization.
|
||||
* Each command has a fixed layout described in comments.
|
||||
* All values are 4-byte aligned.
|
||||
*/
|
||||
public final class GLCommand {
|
||||
private GLCommand() {}
|
||||
|
||||
// === Single int commands (8 bytes: opcode + param) ===
|
||||
public static final int ENABLE = 1; // [cmd:4][cap:4]
|
||||
public static final int DISABLE = 2; // [cmd:4][cap:4]
|
||||
public static final int CLEAR = 3; // [cmd:4][mask:4]
|
||||
public static final int CLEAR_STENCIL = 4; // [cmd:4][s:4]
|
||||
public static final int CULL_FACE = 5; // [cmd:4][mode:4]
|
||||
public static final int DEPTH_FUNC = 6; // [cmd:4][func:4]
|
||||
public static final int SHADE_MODEL = 7; // [cmd:4][mode:4]
|
||||
public static final int LOGIC_OP = 8; // [cmd:4][opcode:4]
|
||||
public static final int MATRIX_MODE = 9; // [cmd:4][mode:4]
|
||||
public static final int ACTIVE_TEXTURE = 10; // [cmd:4][texture:4]
|
||||
public static final int USE_PROGRAM = 11; // [cmd:4][program:4]
|
||||
public static final int PUSH_ATTRIB = 12; // [cmd:4][mask:4]
|
||||
public static final int POP_ATTRIB = 13; // [cmd:4][unused:4]
|
||||
public static final int LOAD_IDENTITY = 14; // [cmd:4][matrixMode:4]
|
||||
public static final int PUSH_MATRIX = 15; // [cmd:4][matrixMode:4]
|
||||
public static final int POP_MATRIX = 16; // [cmd:4][matrixMode:4]
|
||||
public static final int STENCIL_MASK = 17; // [cmd:4][mask:4]
|
||||
public static final int DEPTH_MASK = 18; // [cmd:4][flag:4] (0 or 1)
|
||||
|
||||
// === Two int commands (12 bytes) ===
|
||||
public static final int BIND_TEXTURE = 20; // [cmd:4][target:4][texture:4]
|
||||
public static final int POLYGON_MODE = 21; // [cmd:4][face:4][mode:4]
|
||||
public static final int COLOR_MATERIAL = 22; // [cmd:4][face:4][mode:4]
|
||||
public static final int LINE_STIPPLE = 23; // [cmd:4][factor:4][pattern:4]
|
||||
public static final int STENCIL_MASK_SEPARATE = 24; // [cmd:4][face:4][mask:4]
|
||||
public static final int FOGI = 25; // [cmd:4][pname:4][param:4]
|
||||
|
||||
// === Three int commands (16 bytes) ===
|
||||
public static final int STENCIL_FUNC = 30; // [cmd:4][func:4][ref:4][mask:4]
|
||||
public static final int STENCIL_OP = 31; // [cmd:4][fail:4][zfail:4][zpass:4]
|
||||
public static final int TEX_PARAMETERI = 32; // [cmd:4][target:4][pname:4][param:4]
|
||||
|
||||
// === Four int commands (20 bytes) ===
|
||||
public static final int VIEWPORT = 40; // [cmd:4][x:4][y:4][width:4][height:4]
|
||||
public static final int BLEND_FUNC = 41; // [cmd:4][srcRgb:4][dstRgb:4][srcAlpha:4][dstAlpha:4]
|
||||
public static final int COLOR_MASK = 42; // [cmd:4][r:4][g:4][b:4][a:4] (0 or 1 each)
|
||||
public static final int STENCIL_FUNC_SEPARATE = 43; // [cmd:4][face:4][func:4][ref:4][mask:4]
|
||||
public static final int STENCIL_OP_SEPARATE = 44; // [cmd:4][face:4][sfail:4][dpfail:4][dppass:4]
|
||||
|
||||
// === Float commands ===
|
||||
public static final int POINT_SIZE = 50; // [cmd:4][size:4f]
|
||||
public static final int LINE_WIDTH = 51; // [cmd:4][width:4f]
|
||||
public static final int POLYGON_OFFSET = 52; // [cmd:4][factor:4f][units:4f]
|
||||
public static final int NORMAL = 53; // [cmd:4][x:4f][y:4f][z:4f]
|
||||
public static final int COLOR = 54; // [cmd:4][r:4f][g:4f][b:4f][a:4f]
|
||||
public static final int CLEAR_COLOR = 55; // [cmd:4][r:4f][g:4f][b:4f][a:4f]
|
||||
|
||||
// === Mixed int+float commands ===
|
||||
public static final int ALPHA_FUNC = 60; // [cmd:4][func:4][ref:4f]
|
||||
public static final int FOGF = 61; // [cmd:4][pname:4][param:4f]
|
||||
public static final int LIGHTF = 62; // [cmd:4][light:4][pname:4][param:4f]
|
||||
public static final int LIGHT_MODELF = 63; // [cmd:4][pname:4][param:4f]
|
||||
public static final int LIGHTI = 64; // [cmd:4][light:4][pname:4][param:4]
|
||||
public static final int LIGHT_MODELI = 65; // [cmd:4][pname:4][param:4]
|
||||
public static final int MATERIALF = 66; // [cmd:4][face:4][pname:4][param:4f]
|
||||
public static final int TEX_PARAMETERF = 67; // [cmd:4][target:4][pname:4][param:4f]
|
||||
|
||||
// === Double commands ===
|
||||
public static final int TRANSLATE = 70; // [cmd:4][mode:4][x:8d][y:8d][z:8d] = 32 bytes
|
||||
public static final int ROTATE = 71; // [cmd:4][mode:4][angle:8d][x:8d][y:8d][z:8d] = 40 bytes
|
||||
public static final int SCALE = 72; // [cmd:4][mode:4][x:8d][y:8d][z:8d] = 32 bytes
|
||||
public static final int ORTHO = 73; // [cmd:4][left:8d][right:8d][bottom:8d][top:8d][zNear:8d][zFar:8d] = 52 bytes
|
||||
public static final int FRUSTUM = 74; // [cmd:4][left:8d][right:8d][bottom:8d][top:8d][zNear:8d][zFar:8d] = 52 bytes
|
||||
|
||||
// === Matrix commands (72 bytes) ===
|
||||
public static final int MULT_MATRIX = 80; // [cmd:4][mode:4][m00-m33:64f] = 72 bytes
|
||||
public static final int LOAD_MATRIX = 81; // [cmd:4][mode:4][m00-m33:64f] = 72 bytes
|
||||
|
||||
// === Buffer commands (inline 4 floats max) ===
|
||||
public static final int FOG = 90; // [cmd:4][pname:4][count:4][params:16f] = 28 bytes
|
||||
public static final int LIGHT = 91; // [cmd:4][light:4][pname:4][count:4][params:16f] = 32 bytes
|
||||
public static final int LIGHT_MODEL = 92; // [cmd:4][pname:4][count:4][params:16f] = 28 bytes
|
||||
public static final int MATERIAL = 93; // [cmd:4][face:4][pname:4][count:4][params:16f] = 32 bytes
|
||||
|
||||
// === Draw commands ===
|
||||
public static final int DRAW_RANGE = 100; // [cmd:4][vboIndex:4][start:4][count:4][hasBrightness:4] = 20 bytes
|
||||
public static final int CALL_LIST = 101; // [cmd:4][listId:4] = 8 bytes
|
||||
|
||||
// === Complex object reference ===
|
||||
public static final int COMPLEX_REF = 255; // [cmd:4][index:4] = 8 bytes
|
||||
|
||||
/**
|
||||
* Get a human-readable name for an opcode (for debugging).
|
||||
*/
|
||||
public static String getName(int opcode) {
|
||||
return switch (opcode) {
|
||||
case ENABLE -> "ENABLE";
|
||||
case DISABLE -> "DISABLE";
|
||||
case CLEAR -> "CLEAR";
|
||||
case CLEAR_STENCIL -> "CLEAR_STENCIL";
|
||||
case CULL_FACE -> "CULL_FACE";
|
||||
case DEPTH_FUNC -> "DEPTH_FUNC";
|
||||
case SHADE_MODEL -> "SHADE_MODEL";
|
||||
case LOGIC_OP -> "LOGIC_OP";
|
||||
case MATRIX_MODE -> "MATRIX_MODE";
|
||||
case ACTIVE_TEXTURE -> "ACTIVE_TEXTURE";
|
||||
case USE_PROGRAM -> "USE_PROGRAM";
|
||||
case PUSH_ATTRIB -> "PUSH_ATTRIB";
|
||||
case POP_ATTRIB -> "POP_ATTRIB";
|
||||
case LOAD_IDENTITY -> "LOAD_IDENTITY";
|
||||
case PUSH_MATRIX -> "PUSH_MATRIX";
|
||||
case POP_MATRIX -> "POP_MATRIX";
|
||||
case STENCIL_MASK -> "STENCIL_MASK";
|
||||
case DEPTH_MASK -> "DEPTH_MASK";
|
||||
case BIND_TEXTURE -> "BIND_TEXTURE";
|
||||
case POLYGON_MODE -> "POLYGON_MODE";
|
||||
case COLOR_MATERIAL -> "COLOR_MATERIAL";
|
||||
case LINE_STIPPLE -> "LINE_STIPPLE";
|
||||
case STENCIL_MASK_SEPARATE -> "STENCIL_MASK_SEPARATE";
|
||||
case FOGI -> "FOGI";
|
||||
case STENCIL_FUNC -> "STENCIL_FUNC";
|
||||
case STENCIL_OP -> "STENCIL_OP";
|
||||
case TEX_PARAMETERI -> "TEX_PARAMETERI";
|
||||
case VIEWPORT -> "VIEWPORT";
|
||||
case BLEND_FUNC -> "BLEND_FUNC";
|
||||
case COLOR_MASK -> "COLOR_MASK";
|
||||
case STENCIL_FUNC_SEPARATE -> "STENCIL_FUNC_SEPARATE";
|
||||
case STENCIL_OP_SEPARATE -> "STENCIL_OP_SEPARATE";
|
||||
case POINT_SIZE -> "POINT_SIZE";
|
||||
case LINE_WIDTH -> "LINE_WIDTH";
|
||||
case POLYGON_OFFSET -> "POLYGON_OFFSET";
|
||||
case NORMAL -> "NORMAL";
|
||||
case COLOR -> "COLOR";
|
||||
case CLEAR_COLOR -> "CLEAR_COLOR";
|
||||
case ALPHA_FUNC -> "ALPHA_FUNC";
|
||||
case FOGF -> "FOGF";
|
||||
case LIGHTF -> "LIGHTF";
|
||||
case LIGHT_MODELF -> "LIGHT_MODELF";
|
||||
case LIGHTI -> "LIGHTI";
|
||||
case LIGHT_MODELI -> "LIGHT_MODELI";
|
||||
case MATERIALF -> "MATERIALF";
|
||||
case TEX_PARAMETERF -> "TEX_PARAMETERF";
|
||||
case TRANSLATE -> "TRANSLATE";
|
||||
case ROTATE -> "ROTATE";
|
||||
case SCALE -> "SCALE";
|
||||
case ORTHO -> "ORTHO";
|
||||
case FRUSTUM -> "FRUSTUM";
|
||||
case MULT_MATRIX -> "MULT_MATRIX";
|
||||
case LOAD_MATRIX -> "LOAD_MATRIX";
|
||||
case FOG -> "FOG";
|
||||
case LIGHT -> "LIGHT";
|
||||
case LIGHT_MODEL -> "LIGHT_MODEL";
|
||||
case MATERIAL -> "MATERIAL";
|
||||
case DRAW_RANGE -> "DRAW_RANGE";
|
||||
case CALL_LIST -> "CALL_LIST";
|
||||
case COMPLEX_REF -> "COMPLEX_REF";
|
||||
default -> "UNKNOWN(" + opcode + ")";
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,708 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.NormI8;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuad;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadViewMutable;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.util.ModelQuadUtil;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.DoubleBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
import java.nio.IntBuffer;
|
||||
import java.nio.ShortBuffer;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Records immediate mode GL calls (glBegin/glEnd/glVertex) during display list compilation.
|
||||
* Converts immediate mode geometry to ModelQuad format for VBO compilation.
|
||||
*
|
||||
* <p>Tracks current immediate mode state:
|
||||
* <ul>
|
||||
* <li>TexCoord: Set by glTexCoord* calls</li>
|
||||
* <li>Normal: Set by glNormal* calls</li>
|
||||
* <li>Color: Read from GLStateManager.getColor() at vertex emission time</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>Supported primitive types:
|
||||
* <ul>
|
||||
* <li>GL_QUADS: 4 vertices per quad (native support)</li>
|
||||
* <li>GL_TRIANGLES: 3 vertices per triangle (converted to degenerate quad)</li>
|
||||
* <li>GL_TRIANGLE_FAN: Fan of triangles (converted to individual quads)</li>
|
||||
* <li>GL_TRIANGLE_STRIP: Strip of triangles (converted to individual quads)</li>
|
||||
* <li>GL_QUAD_STRIP: Strip of quads (converted to individual quads)</li>
|
||||
* <li>GL_POLYGON: Polygon (treated as triangle fan)</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>Unsupported primitive types (logged warning, geometry discarded):
|
||||
* <ul>
|
||||
* <li>GL_LINES, GL_LINE_STRIP, GL_LINE_LOOP: Line primitives</li>
|
||||
* <li>GL_POINTS: Point primitives</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class ImmediateModeRecorder {
|
||||
private static final Logger LOGGER = LogManager.getLogger("ImmediateModeRecorder");
|
||||
|
||||
// Accumulated quads from completed primitives
|
||||
private final List<ModelQuadViewMutable> quads = new ArrayList<>();
|
||||
|
||||
// Accumulated line vertices (pairs of vertices for GL_LINES)
|
||||
private final List<LineVertex> lineVertices = new ArrayList<>();
|
||||
|
||||
// Current primitive state
|
||||
private int currentPrimitiveType = -1;
|
||||
private boolean inPrimitive = false;
|
||||
|
||||
// Vertices for current primitive (cleared on glEnd)
|
||||
private final List<ImmediateVertex> currentVertices = new ArrayList<>();
|
||||
|
||||
// Current immediate mode state (set by glTexCoord*, glNormal*)
|
||||
private float texCoordS = 0.0f;
|
||||
private float texCoordT = 0.0f;
|
||||
private float normalX = 0.0f;
|
||||
private float normalY = 0.0f;
|
||||
private float normalZ = 1.0f; // Default normal points +Z
|
||||
|
||||
// Track which attributes have been set (for flags)
|
||||
private boolean hasTexCoord = false;
|
||||
private boolean hasNormal = false;
|
||||
private boolean hasColor = false;
|
||||
|
||||
/**
|
||||
* Represents a single vertex captured during immediate mode.
|
||||
*/
|
||||
private static class ImmediateVertex {
|
||||
float x, y, z; // Position
|
||||
int color; // Packed ABGR color
|
||||
float texU, texV; // Texture coordinates
|
||||
int normal; // Packed normal
|
||||
|
||||
ImmediateVertex(float x, float y, float z, int color, float texU, float texV, int normal) {
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
this.z = z;
|
||||
this.color = color;
|
||||
this.texU = texU;
|
||||
this.texV = texV;
|
||||
this.normal = normal;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents a vertex for line primitives.
|
||||
* Simpler than ImmediateVertex - just position and color.
|
||||
*/
|
||||
public static class LineVertex {
|
||||
public final float x, y, z;
|
||||
public final int color; // Packed ABGR color
|
||||
|
||||
public LineVertex(float x, float y, float z, int color) {
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
this.z = z;
|
||||
this.color = color;
|
||||
}
|
||||
}
|
||||
|
||||
public ImmediateModeRecorder() {
|
||||
// Recorder is ready to capture geometry
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the current texture coordinate.
|
||||
* Called by GLStateManager.glTexCoord*.
|
||||
*/
|
||||
public void setTexCoord(float s, float t) {
|
||||
this.texCoordS = s;
|
||||
this.texCoordT = t;
|
||||
this.hasTexCoord = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the current normal vector.
|
||||
* Called by GLStateManager.glNormal*.
|
||||
*/
|
||||
public void setNormal(float x, float y, float z) {
|
||||
this.normalX = x;
|
||||
this.normalY = y;
|
||||
this.normalZ = z;
|
||||
this.hasNormal = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if currently in a primitive (between glBegin and glEnd).
|
||||
*/
|
||||
public boolean isInPrimitive() {
|
||||
return inPrimitive;
|
||||
}
|
||||
|
||||
/**
|
||||
* Start recording a new primitive.
|
||||
*/
|
||||
public void begin(int primitiveType) {
|
||||
if (inPrimitive) {
|
||||
throw new IllegalStateException("glBegin called while already in primitive");
|
||||
}
|
||||
this.currentPrimitiveType = primitiveType;
|
||||
this.currentVertices.clear();
|
||||
this.inPrimitive = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* End the current primitive, convert to quads/lines, and return them immediately.
|
||||
* This allows the caller to create AccumulatedDraw at the correct command position.
|
||||
*
|
||||
* @return Result containing quads, lines, and flags, or null if no geometry was produced
|
||||
*/
|
||||
public Result end() {
|
||||
if (!inPrimitive) {
|
||||
throw new IllegalStateException("glEnd called without glBegin");
|
||||
}
|
||||
|
||||
// Convert this primitive's vertices to quads or lines
|
||||
convertPrimitiveToQuads();
|
||||
this.currentVertices.clear();
|
||||
this.inPrimitive = false;
|
||||
|
||||
// Return geometry from this primitive immediately (don't accumulate)
|
||||
if (quads.isEmpty() && lineVertices.isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// Copy geometry and create flags
|
||||
List<ModelQuadViewMutable> resultQuads = new ArrayList<>(quads);
|
||||
List<LineVertex> resultLines = new ArrayList<>(lineVertices);
|
||||
CapturingTessellator.Flags flags = new CapturingTessellator.Flags(
|
||||
hasTexCoord, // hasTexture
|
||||
false, // hasBrightness - immediate mode doesn't typically use lightmap
|
||||
hasColor, // hasColor
|
||||
hasNormal // hasNormals
|
||||
);
|
||||
|
||||
// Clear for next primitive (but keep attribute tracking state)
|
||||
quads.clear();
|
||||
lineVertices.clear();
|
||||
|
||||
return new Result(resultQuads, resultLines, flags);
|
||||
}
|
||||
|
||||
/**
|
||||
* Record a vertex with current attributes.
|
||||
* Color is read from GLStateManager at call time.
|
||||
*/
|
||||
public void vertex(float x, float y, float z) {
|
||||
if (!inPrimitive) {
|
||||
throw new IllegalStateException("glVertex called outside glBegin/glEnd");
|
||||
}
|
||||
|
||||
// Get current color from GLStateManager
|
||||
int packedColor = packColor(
|
||||
GLStateManager.getColor().getRed(),
|
||||
GLStateManager.getColor().getGreen(),
|
||||
GLStateManager.getColor().getBlue(),
|
||||
GLStateManager.getColor().getAlpha()
|
||||
);
|
||||
if (packedColor != 0xFFFFFFFF) {
|
||||
hasColor = true;
|
||||
}
|
||||
|
||||
// Pack normal
|
||||
int packedNormal = NormI8.pack(normalX, normalY, normalZ);
|
||||
|
||||
currentVertices.add(new ImmediateVertex(
|
||||
x, y, z,
|
||||
packedColor,
|
||||
texCoordS, texCoordT,
|
||||
packedNormal
|
||||
));
|
||||
}
|
||||
|
||||
/**
|
||||
* Pack RGBA floats (0-1) into ABGR int format used by ModelQuad.
|
||||
*/
|
||||
private static int packColor(float r, float g, float b, float a) {
|
||||
int ri = (int) (r * 255.0f) & 0xFF;
|
||||
int gi = (int) (g * 255.0f) & 0xFF;
|
||||
int bi = (int) (b * 255.0f) & 0xFF;
|
||||
int ai = (int) (a * 255.0f) & 0xFF;
|
||||
// ABGR format (little-endian: stored as RGBA bytes)
|
||||
return (ai << 24) | (bi << 16) | (gi << 8) | ri;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert the current primitive vertices to quads.
|
||||
* Handles different primitive types.
|
||||
*/
|
||||
private void convertPrimitiveToQuads() {
|
||||
int vertexCount = currentVertices.size();
|
||||
if (vertexCount == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
switch (currentPrimitiveType) {
|
||||
case GL11.GL_QUADS -> convertQuads();
|
||||
case GL11.GL_TRIANGLES -> convertTriangles();
|
||||
case GL11.GL_TRIANGLE_FAN, GL11.GL_POLYGON -> convertTriangleFan();
|
||||
case GL11.GL_TRIANGLE_STRIP -> convertTriangleStrip();
|
||||
case GL11.GL_QUAD_STRIP -> convertQuadStrip();
|
||||
case GL11.GL_LINES -> convertLines();
|
||||
case GL11.GL_LINE_STRIP -> convertLineStripToLines();
|
||||
case GL11.GL_LINE_LOOP -> convertLineLoopToLines();
|
||||
case GL11.GL_POINTS -> {
|
||||
LOGGER.warn("[ImmediateModeRecorder] Point primitives not supported, discarding {} vertices", vertexCount);
|
||||
}
|
||||
default -> {
|
||||
LOGGER.warn("[ImmediateModeRecorder] Unknown primitive type {}, discarding {} vertices",
|
||||
currentPrimitiveType, vertexCount);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert GL_QUADS vertices to ModelQuads (4 vertices per quad).
|
||||
*/
|
||||
private void convertQuads() {
|
||||
int vertexCount = currentVertices.size();
|
||||
int fullQuads = vertexCount / 4;
|
||||
|
||||
for (int i = 0; i < fullQuads; i++) {
|
||||
int base = i * 4;
|
||||
addQuad(
|
||||
currentVertices.get(base),
|
||||
currentVertices.get(base + 1),
|
||||
currentVertices.get(base + 2),
|
||||
currentVertices.get(base + 3)
|
||||
);
|
||||
}
|
||||
|
||||
int remaining = vertexCount % 4;
|
||||
if (remaining > 0) {
|
||||
LOGGER.warn("[ImmediateModeRecorder] GL_QUADS: Incomplete quad, discarding {} vertices", remaining);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert GL_TRIANGLES vertices to degenerate quads (3 vertices per triangle, duplicate last).
|
||||
*/
|
||||
private void convertTriangles() {
|
||||
int vertexCount = currentVertices.size();
|
||||
int fullTriangles = vertexCount / 3;
|
||||
|
||||
for (int i = 0; i < fullTriangles; i++) {
|
||||
int base = i * 3;
|
||||
ImmediateVertex v0 = currentVertices.get(base);
|
||||
ImmediateVertex v1 = currentVertices.get(base + 1);
|
||||
ImmediateVertex v2 = currentVertices.get(base + 2);
|
||||
// Degenerate quad: duplicate third vertex
|
||||
addQuad(v0, v1, v2, v2);
|
||||
}
|
||||
|
||||
int remaining = vertexCount % 3;
|
||||
if (remaining > 0) {
|
||||
LOGGER.warn("[ImmediateModeRecorder] GL_TRIANGLES: Incomplete triangle, discarding {} vertices", remaining);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert GL_TRIANGLE_FAN vertices to triangles then to degenerate quads.
|
||||
* First vertex is center, subsequent vertices form fan.
|
||||
*/
|
||||
private void convertTriangleFan() {
|
||||
int vertexCount = currentVertices.size();
|
||||
if (vertexCount < 3) {
|
||||
LOGGER.warn("[ImmediateModeRecorder] GL_TRIANGLE_FAN: Need at least 3 vertices, got {}", vertexCount);
|
||||
return;
|
||||
}
|
||||
|
||||
ImmediateVertex center = currentVertices.get(0);
|
||||
for (int i = 1; i < vertexCount - 1; i++) {
|
||||
ImmediateVertex v1 = currentVertices.get(i);
|
||||
ImmediateVertex v2 = currentVertices.get(i + 1);
|
||||
// Triangle: center, v1, v2 -> degenerate quad
|
||||
addQuad(center, v1, v2, v2);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert GL_TRIANGLE_STRIP vertices to triangles then to degenerate quads.
|
||||
*/
|
||||
private void convertTriangleStrip() {
|
||||
int vertexCount = currentVertices.size();
|
||||
if (vertexCount < 3) {
|
||||
LOGGER.warn("[ImmediateModeRecorder] GL_TRIANGLE_STRIP: Need at least 3 vertices, got {}", vertexCount);
|
||||
return;
|
||||
}
|
||||
|
||||
for (int i = 0; i < vertexCount - 2; i++) {
|
||||
ImmediateVertex v0, v1, v2;
|
||||
if ((i & 1) == 0) {
|
||||
// Even triangle: v[i], v[i+1], v[i+2]
|
||||
v0 = currentVertices.get(i);
|
||||
v1 = currentVertices.get(i + 1);
|
||||
v2 = currentVertices.get(i + 2);
|
||||
} else {
|
||||
// Odd triangle: v[i+1], v[i], v[i+2] (reverse winding)
|
||||
v0 = currentVertices.get(i + 1);
|
||||
v1 = currentVertices.get(i);
|
||||
v2 = currentVertices.get(i + 2);
|
||||
}
|
||||
addQuad(v0, v1, v2, v2);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert GL_QUAD_STRIP vertices to quads.
|
||||
* Vertices come in pairs: (v0,v1), (v2,v3), (v4,v5)...
|
||||
* Each quad uses 4 consecutive vertices in pattern: v[2i], v[2i+1], v[2i+3], v[2i+2]
|
||||
*/
|
||||
private void convertQuadStrip() {
|
||||
int vertexCount = currentVertices.size();
|
||||
if (vertexCount < 4) {
|
||||
LOGGER.warn("[ImmediateModeRecorder] GL_QUAD_STRIP: Need at least 4 vertices, got {}", vertexCount);
|
||||
return;
|
||||
}
|
||||
|
||||
int numQuads = (vertexCount - 2) / 2;
|
||||
for (int i = 0; i < numQuads; i++) {
|
||||
int base = i * 2;
|
||||
// Quad strip winding: v[0], v[1], v[3], v[2]
|
||||
addQuad(
|
||||
currentVertices.get(base),
|
||||
currentVertices.get(base + 1),
|
||||
currentVertices.get(base + 3),
|
||||
currentVertices.get(base + 2)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert GL_LINES vertices to line segments (pairs of vertices).
|
||||
*/
|
||||
private void convertLines() {
|
||||
int vertexCount = currentVertices.size();
|
||||
int fullLines = vertexCount / 2;
|
||||
|
||||
for (int i = 0; i < fullLines; i++) {
|
||||
int base = i * 2;
|
||||
ImmediateVertex v0 = currentVertices.get(base);
|
||||
ImmediateVertex v1 = currentVertices.get(base + 1);
|
||||
lineVertices.add(new LineVertex(v0.x, v0.y, v0.z, v0.color));
|
||||
lineVertices.add(new LineVertex(v1.x, v1.y, v1.z, v1.color));
|
||||
}
|
||||
|
||||
int remaining = vertexCount % 2;
|
||||
if (remaining > 0) {
|
||||
LOGGER.warn("[ImmediateModeRecorder] GL_LINES: Incomplete line, discarding {} vertices", remaining);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert GL_LINE_STRIP to individual line segments.
|
||||
* Vertices 0-1-2-3 become lines: 0-1, 1-2, 2-3
|
||||
*/
|
||||
private void convertLineStripToLines() {
|
||||
int vertexCount = currentVertices.size();
|
||||
if (vertexCount < 2) {
|
||||
LOGGER.warn("[ImmediateModeRecorder] GL_LINE_STRIP: Need at least 2 vertices, got {}", vertexCount);
|
||||
return;
|
||||
}
|
||||
|
||||
for (int i = 0; i < vertexCount - 1; i++) {
|
||||
ImmediateVertex v0 = currentVertices.get(i);
|
||||
ImmediateVertex v1 = currentVertices.get(i + 1);
|
||||
lineVertices.add(new LineVertex(v0.x, v0.y, v0.z, v0.color));
|
||||
lineVertices.add(new LineVertex(v1.x, v1.y, v1.z, v1.color));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert GL_LINE_LOOP to individual line segments.
|
||||
* Like LINE_STRIP but also closes the loop from last to first vertex.
|
||||
*/
|
||||
private void convertLineLoopToLines() {
|
||||
int vertexCount = currentVertices.size();
|
||||
if (vertexCount < 2) {
|
||||
LOGGER.warn("[ImmediateModeRecorder] GL_LINE_LOOP: Need at least 2 vertices, got {}", vertexCount);
|
||||
return;
|
||||
}
|
||||
|
||||
// Convert as strip first
|
||||
convertLineStripToLines();
|
||||
|
||||
// Close the loop: add last-to-first segment
|
||||
ImmediateVertex vLast = currentVertices.get(vertexCount - 1);
|
||||
ImmediateVertex vFirst = currentVertices.get(0);
|
||||
lineVertices.add(new LineVertex(vLast.x, vLast.y, vLast.z, vLast.color));
|
||||
lineVertices.add(new LineVertex(vFirst.x, vFirst.y, vFirst.z, vFirst.color));
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a ModelQuad from 4 ImmediateVertex objects.
|
||||
*/
|
||||
private void addQuad(ImmediateVertex v0, ImmediateVertex v1, ImmediateVertex v2, ImmediateVertex v3) {
|
||||
ModelQuad quad = new ModelQuad();
|
||||
|
||||
setVertex(quad, 0, v0);
|
||||
setVertex(quad, 1, v1);
|
||||
setVertex(quad, 2, v2);
|
||||
setVertex(quad, 3, v3);
|
||||
|
||||
// Set light face based on computed normal
|
||||
quad.setLightFace(ModelQuadUtil.findLightFace(quad.getComputedFaceNormal()));
|
||||
|
||||
quads.add(quad);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set a single vertex in a ModelQuad.
|
||||
*/
|
||||
private void setVertex(ModelQuad quad, int idx, ImmediateVertex v) {
|
||||
quad.setX(idx, v.x);
|
||||
quad.setY(idx, v.y);
|
||||
quad.setZ(idx, v.z);
|
||||
quad.setColor(idx, v.color);
|
||||
quad.setTexU(idx, v.texU);
|
||||
quad.setTexV(idx, v.texV);
|
||||
quad.setForgeNormal(idx, v.normal);
|
||||
// Light defaults to full brightness (no lightmap for immediate mode typically)
|
||||
quad.setLight(idx, ModelQuadUtil.DEFAULT_LIGHTMAP);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if any immediate mode geometry has been captured.
|
||||
*
|
||||
* <p>Note: With immediate flush mode, this will typically return false as geometry
|
||||
* is returned from end() immediately. This method is kept for edge cases
|
||||
* where primitives might fail to convert (e.g., incomplete quads).
|
||||
*/
|
||||
public boolean hasGeometry() {
|
||||
return !quads.isEmpty() || !lineVertices.isEmpty();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get any remaining accumulated geometry and clear the recorder.
|
||||
*
|
||||
* <p>Note: With immediate flush mode, this will typically return null as geometry
|
||||
* is returned from end() immediately. This method is kept for cleanup and
|
||||
* edge cases where geometry might remain (e.g., if end() was never called).
|
||||
*
|
||||
* @return Result containing remaining quads, lines, and flags, or null if no geometry
|
||||
*/
|
||||
public Result getQuadsAndClear() {
|
||||
if (inPrimitive) {
|
||||
throw new IllegalStateException("Cannot get geometry while in primitive (missing glEnd)");
|
||||
}
|
||||
|
||||
if (quads.isEmpty() && lineVertices.isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// Copy geometry and create flags
|
||||
List<ModelQuadViewMutable> resultQuads = new ArrayList<>(quads);
|
||||
List<LineVertex> resultLines = new ArrayList<>(lineVertices);
|
||||
CapturingTessellator.Flags flags = new CapturingTessellator.Flags(
|
||||
hasTexCoord, // hasTexture
|
||||
false, // hasBrightness - immediate mode doesn't typically use lightmap
|
||||
hasColor, // hasColor
|
||||
hasNormal // hasNormals
|
||||
);
|
||||
|
||||
// Clear state for reuse
|
||||
quads.clear();
|
||||
lineVertices.clear();
|
||||
hasColor = false;
|
||||
hasTexCoord = false;
|
||||
hasNormal = false;
|
||||
// Note: current texcoord/normal values are NOT reset - they persist per OpenGL spec
|
||||
|
||||
return new Result(resultQuads, resultLines, flags);
|
||||
}
|
||||
|
||||
/**
|
||||
* Result of immediate mode recording: quads, lines, and their attribute flags.
|
||||
*/
|
||||
@com.github.bsideup.jabel.Desugar
|
||||
public record Result(List<ModelQuadViewMutable> quads, List<LineVertex> lines, CapturingTessellator.Flags flags) {}
|
||||
|
||||
/**
|
||||
* Reset all state including current texcoord/normal.
|
||||
* Called when starting a new display list.
|
||||
*/
|
||||
public void reset() {
|
||||
quads.clear();
|
||||
lineVertices.clear();
|
||||
currentVertices.clear();
|
||||
inPrimitive = false;
|
||||
currentPrimitiveType = -1;
|
||||
texCoordS = 0.0f;
|
||||
texCoordT = 0.0f;
|
||||
normalX = 0.0f;
|
||||
normalY = 0.0f;
|
||||
normalZ = 1.0f;
|
||||
hasColor = false;
|
||||
hasTexCoord = false;
|
||||
hasNormal = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Process a glDrawArrays call during display list recording.
|
||||
* Reads vertex data from client arrays (tracked globally in GLStateManager) and converts to immediate mode geometry.
|
||||
*
|
||||
* @param mode Primitive type (GL_QUADS, GL_LINES, etc.)
|
||||
* @param first Starting index in arrays
|
||||
* @param count Number of vertices
|
||||
* @return Result containing converted geometry, or null if no geometry produced
|
||||
*/
|
||||
public Result processDrawArrays(int mode, int first, int count) {
|
||||
final var cas = GLStateManager.getClientArrayState();
|
||||
final var vertexPointer = cas.isVertexArrayEnabled() ? cas.getVertexPointer() : null;
|
||||
final var colorPointer = cas.isColorArrayEnabled() ? cas.getColorPointer() : null;
|
||||
|
||||
return convertClientArrays(
|
||||
mode, first, count,
|
||||
vertexPointer,
|
||||
cas.getVertexPointerType(), cas.getVertexPointerSize(), cas.getVertexPointerStride(),
|
||||
colorPointer,
|
||||
cas.getColorPointerType(), cas.getColorPointerSize(), cas.getColorPointerStride()
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert client array data to immediate mode.
|
||||
* Called by glDrawArrays during display list recording.
|
||||
* Like Mesa's save_DrawArrays, reads vertex data from arrays and emits as immediate mode.
|
||||
*
|
||||
* @param mode Primitive type (GL_QUADS, GL_LINES, etc.)
|
||||
* @param first Starting index in arrays
|
||||
* @param count Number of vertices
|
||||
* @param vertexPointer Vertex position buffer (or null if not enabled)
|
||||
* @param vertexType GL type (GL_FLOAT, GL_DOUBLE, etc.)
|
||||
* @param vertexSize Size of vertex (2, 3, or 4)
|
||||
* @param vertexStride Stride in bytes (0 for tightly packed)
|
||||
* @param colorPointer Color buffer (or null if not enabled)
|
||||
* @param colorType GL type (GL_FLOAT, GL_UNSIGNED_BYTE, etc.)
|
||||
* @param colorSize Size of color (3 or 4)
|
||||
* @param colorStride Stride in bytes (0 for tightly packed)
|
||||
* @return Result containing converted geometry, or null if no geometry produced
|
||||
*/
|
||||
public Result convertClientArrays(
|
||||
int mode, int first, int count,
|
||||
java.nio.Buffer vertexPointer, int vertexType, int vertexSize, int vertexStride,
|
||||
java.nio.Buffer colorPointer, int colorType, int colorSize, int colorStride
|
||||
) {
|
||||
begin(mode);
|
||||
|
||||
// Hoist type checks and stride calculations outside the loop for performance.
|
||||
// Mesa's algorithm: offset_bytes = index * effective_stride
|
||||
// effective_stride = (stride == 0) ? (numComponents * sizeof(element)) : stride
|
||||
|
||||
// Determine color reader (hoisted out of loop)
|
||||
final ColorReader colorReader;
|
||||
final int colorEffectiveStride;
|
||||
if (colorPointer == null) {
|
||||
colorReader = null;
|
||||
colorEffectiveStride = 0;
|
||||
} else if (colorType == GL11.GL_FLOAT && colorPointer instanceof FloatBuffer fb) {
|
||||
colorEffectiveStride = (colorStride == 0) ? colorSize * 4 : colorStride;
|
||||
final int strideInFloats = colorEffectiveStride / 4;
|
||||
colorReader = (idx) -> {
|
||||
final int offset = idx * strideInFloats;
|
||||
final float r = fb.get(offset);
|
||||
final float g = fb.get(offset + 1);
|
||||
final float b = fb.get(offset + 2);
|
||||
final float a = (colorSize == 4) ? fb.get(offset + 3) : 1.0f;
|
||||
GLStateManager.glColor4f(r, g, b, a);
|
||||
};
|
||||
} else if ((colorType == GL11.GL_UNSIGNED_BYTE || colorType == GL11.GL_BYTE) && colorPointer instanceof ByteBuffer bb) {
|
||||
colorEffectiveStride = (colorStride == 0) ? colorSize : colorStride;
|
||||
colorReader = (idx) -> {
|
||||
final int offset = idx * colorEffectiveStride;
|
||||
final float r = (bb.get(offset) & 0xFF) / 255.0f;
|
||||
final float g = (bb.get(offset + 1) & 0xFF) / 255.0f;
|
||||
final float b = (bb.get(offset + 2) & 0xFF) / 255.0f;
|
||||
final float a = (colorSize == 4) ? (bb.get(offset + 3) & 0xFF) / 255.0f : 1.0f;
|
||||
GLStateManager.glColor4f(r, g, b, a);
|
||||
};
|
||||
} else {
|
||||
// Unsupported color type - use white
|
||||
colorEffectiveStride = 0;
|
||||
colorReader = (idx) -> GLStateManager.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
|
||||
}
|
||||
|
||||
// Determine vertex reader (hoisted out of loop)
|
||||
final VertexReader vertexReader;
|
||||
if (vertexPointer == null) {
|
||||
vertexReader = null;
|
||||
} else if (vertexType == GL11.GL_FLOAT && vertexPointer instanceof FloatBuffer fb) {
|
||||
final int effectiveStride = (vertexStride == 0) ? vertexSize * 4 : vertexStride;
|
||||
final int strideInFloats = effectiveStride / 4;
|
||||
vertexReader = (idx) -> {
|
||||
final int offset = idx * strideInFloats;
|
||||
final float x = fb.get(offset);
|
||||
final float y = fb.get(offset + 1);
|
||||
final float z = (vertexSize >= 3) ? fb.get(offset + 2) : 0.0f;
|
||||
vertex(x, y, z);
|
||||
};
|
||||
} else if (vertexType == GL11.GL_DOUBLE && vertexPointer instanceof DoubleBuffer db) {
|
||||
final int effectiveStride = (vertexStride == 0) ? vertexSize * 8 : vertexStride;
|
||||
final int strideInDoubles = effectiveStride / 8;
|
||||
vertexReader = (idx) -> {
|
||||
final int offset = idx * strideInDoubles;
|
||||
final float x = (float) db.get(offset);
|
||||
final float y = (float) db.get(offset + 1);
|
||||
final float z = (vertexSize >= 3) ? (float) db.get(offset + 2) : 0.0f;
|
||||
vertex(x, y, z);
|
||||
};
|
||||
} else if (vertexType == GL11.GL_INT && vertexPointer instanceof IntBuffer ib) {
|
||||
final int effectiveStride = (vertexStride == 0) ? vertexSize * 4 : vertexStride;
|
||||
final int strideInInts = effectiveStride / 4;
|
||||
vertexReader = (idx) -> {
|
||||
final int offset = idx * strideInInts;
|
||||
final float x = ib.get(offset);
|
||||
final float y = ib.get(offset + 1);
|
||||
final float z = (vertexSize >= 3) ? ib.get(offset + 2) : 0.0f;
|
||||
vertex(x, y, z);
|
||||
};
|
||||
} else if (vertexType == GL11.GL_SHORT && vertexPointer instanceof ShortBuffer sb) {
|
||||
final int effectiveStride = (vertexStride == 0) ? vertexSize * 2 : vertexStride;
|
||||
final int strideInShorts = effectiveStride / 2;
|
||||
vertexReader = (idx) -> {
|
||||
final int offset = idx * strideInShorts;
|
||||
final float x = sb.get(offset);
|
||||
final float y = sb.get(offset + 1);
|
||||
final float z = (vertexSize >= 3) ? sb.get(offset + 2) : 0.0f;
|
||||
vertex(x, y, z);
|
||||
};
|
||||
} else {
|
||||
// Unsupported vertex type
|
||||
vertexReader = null;
|
||||
}
|
||||
|
||||
// Main loop - no type checks, just function calls
|
||||
for (int i = first; i < first + count; i++) {
|
||||
if (colorReader != null) {
|
||||
colorReader.read(i);
|
||||
}
|
||||
if (vertexReader != null) {
|
||||
vertexReader.read(i);
|
||||
}
|
||||
}
|
||||
|
||||
return end();
|
||||
}
|
||||
|
||||
@FunctionalInterface
|
||||
private interface ColorReader {
|
||||
void read(int index);
|
||||
}
|
||||
|
||||
@FunctionalInterface
|
||||
private interface VertexReader {
|
||||
void read(int index);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.commands.DrawCommand;
|
||||
import me.jellysquid.mods.sodium.client.gl.attribute.BufferVertexFormat;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Represents recorded geometry from a display list compilation.
|
||||
* Contains the vertex data buffer and metadata about draw commands.
|
||||
*/
|
||||
@Desugar
|
||||
public record RecordedGeometry(ByteBuffer buffer, BufferVertexFormat format, List<DrawCommand> drawCommands, int totalVertexCount) {
|
||||
public int getByteSize() {
|
||||
return buffer.remaining();
|
||||
}
|
||||
}
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import org.joml.Matrix4f;
|
||||
|
||||
/**
|
||||
* Interface for matrix commands that can be accumulated during transform optimization.
|
||||
* Implemented by TranslateCmd, RotateCmd, ScaleCmd, and MultMatrixCmd.
|
||||
*/
|
||||
public interface AccumulableMatrixCommand extends DisplayListCommand {
|
||||
boolean isModelView();
|
||||
void applyTo(Matrix4f matrix);
|
||||
|
||||
@Override
|
||||
default boolean handleOptimization(OptimizationContext ctx) {
|
||||
if (isModelView()) {
|
||||
applyTo(ctx.getAccumulatedTransform());
|
||||
return false; // Accumulated, don't emit
|
||||
}
|
||||
return true; // Non-MODELVIEW, emit as-is
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.CompiledDisplayList;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
/**
|
||||
* Command: Call another display list (glCallList)
|
||||
* Records a reference to another display list to be executed during playback.
|
||||
* Per OpenGL spec: the referenced list is NOT executed during compilation,
|
||||
* only the reference is recorded.
|
||||
*
|
||||
*/
|
||||
@Desugar
|
||||
public record CallListCmd(int listId) implements DisplayListCommand {
|
||||
private static final Logger LOGGER = LogManager.getLogger("CallListCmd");
|
||||
|
||||
@Override
|
||||
public void execute() {
|
||||
final CompiledDisplayList compiled = GLStateManager.getDisplayList(listId);
|
||||
|
||||
if (compiled != null) {
|
||||
GLDebug.pushGroup("CallList(" + listId + ")");
|
||||
try {
|
||||
compiled.render();
|
||||
} finally {
|
||||
GLDebug.popGroup();
|
||||
}
|
||||
} else {
|
||||
// Fallback if list not found (shouldn't happen in normal operation)
|
||||
LOGGER.warn("[CallListCmd] List {} not found in cache, using fallback glCallList", listId);
|
||||
GLStateManager.glCallList(listId);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void delete() {
|
||||
// No resources to free - we just hold a reference
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean needsTransformSync() {
|
||||
return true; // Nested list uses current GL matrix state
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean handleOptimization(OptimizationContext ctx) {
|
||||
// Nested list needs current GL matrix state
|
||||
ctx.emitPendingTransform();
|
||||
return true; // Emit this command
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NotNull String toString() {
|
||||
return "CallList(" + listId + ")";
|
||||
}
|
||||
}
|
||||
+55
@@ -0,0 +1,55 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
/**
|
||||
* A single command recorded during display list compilation.
|
||||
* Commands are executed in sequence during glCallList() to replay the display list.
|
||||
*/
|
||||
public interface DisplayListCommand {
|
||||
/**
|
||||
* Execute this command by calling the appropriate GL function.
|
||||
*/
|
||||
void execute();
|
||||
|
||||
/**
|
||||
* Release any resources held by this command (e.g., VBOs).
|
||||
* Called when the display list is deleted.
|
||||
*/
|
||||
default void delete() {
|
||||
// Most commands don't hold resources
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if this barrier command requires the MODELVIEW transform to be
|
||||
* synchronized with the accumulated state before execution.
|
||||
*
|
||||
* <p>This should return true for commands where the GL matrix state matters,
|
||||
* such as CallListCmd (nested lists use current GL state) or PushAttribCmd
|
||||
* with GL_TRANSFORM_BIT (saves the current matrix).</p>
|
||||
*
|
||||
* <p>Commands like PushAttribCmd with only GL_COLOR_BUFFER_BIT don't need
|
||||
* transform sync because they don't interact with the matrix stack.</p>
|
||||
*
|
||||
* @return true if transform must be synced to accumulated before this barrier
|
||||
*/
|
||||
default boolean needsTransformSync() {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle this command during display list optimization.
|
||||
*
|
||||
* <p>Commands override this to implement their optimization behavior:
|
||||
* <ul>
|
||||
* <li>Matrix transforms: accumulate into the optimizer, return false</li>
|
||||
* <li>Push/Pop: update stack, return true to emit</li>
|
||||
* <li>Barriers: emit pending transforms, return true to emit</li>
|
||||
* <li>State changes: return true to emit</li>
|
||||
* </ul>
|
||||
*
|
||||
* @param ctx The optimization context providing access to transform state
|
||||
* @return true if this command should be added to output, false if handled internally
|
||||
*/
|
||||
default boolean handleOptimization(OptimizationContext ctx) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
|
||||
/**
|
||||
* Represents a single draw call within a compiled display list.
|
||||
* Each DrawCommand corresponds to one glBegin/glEnd block.
|
||||
*/
|
||||
@Desugar
|
||||
public record DrawCommand(
|
||||
int firstVertex,
|
||||
int vertexCount,
|
||||
int primitiveType
|
||||
) {}
|
||||
@@ -0,0 +1,42 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
/**
|
||||
* Command: Draw a range of vertices from a shared VBO.
|
||||
* <p>
|
||||
* DrawRangeCmd references a shared VBO owned by CompiledDisplayList.ownedVbos.
|
||||
* Multiple DrawRangeCmds can reference different ranges within the same VBO,
|
||||
* enabling format-based batching where all draws with the same vertex format
|
||||
* share a single VBO.
|
||||
* <p>
|
||||
* Transform is NOT stored here - handled by TransformOptimizer emitting
|
||||
* MultMatrixCmd before this command during optimization.
|
||||
*/
|
||||
@Desugar
|
||||
public record DrawRangeCmd(
|
||||
VertexBuffer sharedVbo,
|
||||
int startVertex,
|
||||
int vertexCount,
|
||||
boolean hasBrightness
|
||||
) implements DisplayListCommand {
|
||||
|
||||
@Override
|
||||
public void execute() {
|
||||
sharedVbo.setupState();
|
||||
sharedVbo.draw(startVertex, vertexCount);
|
||||
sharedVbo.cleanupState();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void delete() {
|
||||
// No-op: VBO lifetime is managed by CompiledDisplayList.ownedVbos
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NotNull String toString() {
|
||||
return "DrawRange(start=" + startVertex + ", count=" + vertexCount + ", hasBrightness=" + hasBrightness + ")";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
/**
|
||||
* Command: glLoadIdentity()
|
||||
* Replaces the current matrix with the identity matrix for the specified matrix mode.
|
||||
*/
|
||||
@Desugar
|
||||
public record LoadIdentityCmd(int matrixMode) implements DisplayListCommand {
|
||||
@Override
|
||||
public void execute() {
|
||||
GLStateManager.glLoadIdentity();
|
||||
}
|
||||
|
||||
public boolean isModelView() {
|
||||
return matrixMode == GL11.GL_MODELVIEW;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean handleOptimization(OptimizationContext ctx) {
|
||||
if (isModelView()) {
|
||||
// Check if we're at an absolute matrix (after LoadMatrix)
|
||||
// If so, we must emit LoadIdentity to actually reset GL state
|
||||
if (ctx.checkAndClearAbsoluteMatrix()) {
|
||||
ctx.emit(this);
|
||||
ctx.loadIdentity();
|
||||
return false; // Already emitted
|
||||
}
|
||||
ctx.loadIdentity();
|
||||
return false; // Accumulated, don't emit
|
||||
}
|
||||
return true; // Non-MODELVIEW, emit as-is
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NotNull String toString() {
|
||||
return String.format("LoadIdentity(%s)", GLDebug.getMatrixModeName(matrixMode));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.joml.Matrix4f;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.FloatBuffer;
|
||||
|
||||
/**
|
||||
* Command: glLoadMatrix(matrix)
|
||||
* Replaces the current matrix with the specified matrix for the given matrix mode.
|
||||
*
|
||||
* <p>Unlike MultMatrixCmd which can be absorbed into the accumulated transform,
|
||||
* LoadMatrixCmd must always be emitted because it sets an absolute value, not a relative one.
|
||||
* After a LoadMatrix command, the accumulated transform is reset to identity since
|
||||
* subsequent transforms are relative to the newly loaded matrix.</p>
|
||||
*/
|
||||
@Desugar
|
||||
public record LoadMatrixCmd(Matrix4f matrix, int matrixMode, FloatBuffer buffer) implements DisplayListCommand {
|
||||
|
||||
/**
|
||||
* Create a LoadMatrixCmd with pre-allocated buffer.
|
||||
*/
|
||||
public static LoadMatrixCmd create(Matrix4f matrix, int matrixMode) {
|
||||
final FloatBuffer buffer = BufferUtils.createFloatBuffer(16);
|
||||
matrix.get(buffer);
|
||||
buffer.rewind();
|
||||
return new LoadMatrixCmd(new Matrix4f(matrix), matrixMode, buffer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a LoadMatrixCmd from a FloatBuffer (copies the data).
|
||||
*/
|
||||
public static LoadMatrixCmd create(FloatBuffer src, int matrixMode) {
|
||||
final Matrix4f matrix = new Matrix4f().set(src);
|
||||
src.rewind();
|
||||
return create(matrix, matrixMode);
|
||||
}
|
||||
|
||||
public boolean isModelView() {
|
||||
return matrixMode == GL11.GL_MODELVIEW;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void execute() {
|
||||
// Buffer already populated at construction, just rewind and use
|
||||
buffer.rewind();
|
||||
GLStateManager.glLoadMatrix(buffer);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean handleOptimization(OptimizationContext ctx) {
|
||||
if (isModelView()) {
|
||||
// LoadMatrix sets an absolute value - emit any pending relative transform first
|
||||
ctx.emitPendingTransform();
|
||||
// Emit this command
|
||||
ctx.emit(this);
|
||||
// Reset accumulated to identity - subsequent transforms are relative to the loaded matrix
|
||||
ctx.loadIdentity();
|
||||
// Mark that GL is at an absolute value - LoadIdentity must emit to reset
|
||||
ctx.markAbsoluteMatrix();
|
||||
return false; // Already emitted
|
||||
}
|
||||
return true; // Non-MODELVIEW, emit as-is
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NotNull String toString() {
|
||||
return String.format("LoadMatrix(%s, %s)", GLDebug.getMatrixModeName(matrixMode), matrix);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.joml.Matrix4f;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.FloatBuffer;
|
||||
|
||||
/**
|
||||
* Command: glMultMatrix(matrix)
|
||||
* Multiplies the specified matrix mode by the specified matrix.
|
||||
*/
|
||||
@Desugar
|
||||
public record MultMatrixCmd(Matrix4f matrix, int matrixMode, FloatBuffer buffer) implements AccumulableMatrixCommand {
|
||||
|
||||
/**
|
||||
* Create a MultMatrixCmd with pre-allocated buffer.
|
||||
*/
|
||||
public static MultMatrixCmd create(Matrix4f matrix, int matrixMode) {
|
||||
final FloatBuffer buffer = BufferUtils.createFloatBuffer(16);
|
||||
matrix.get(buffer);
|
||||
buffer.rewind();
|
||||
return new MultMatrixCmd(new Matrix4f(matrix), matrixMode, buffer);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isModelView() {
|
||||
return matrixMode == GL11.GL_MODELVIEW;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void applyTo(Matrix4f target) {
|
||||
target.mul(matrix);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void execute() {
|
||||
// Buffer already populated at construction, just rewind and use
|
||||
buffer.rewind();
|
||||
GLStateManager.glMultMatrix(buffer);
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NotNull String toString() {
|
||||
return String.format("MultMatrix(%s)", matrix);
|
||||
}
|
||||
}
|
||||
+42
@@ -0,0 +1,42 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import org.joml.Matrix4f;
|
||||
|
||||
/**
|
||||
* Context provided to commands during display list optimization.
|
||||
* Allows commands to interact with the transform optimizer and draw batcher.
|
||||
*/
|
||||
public interface OptimizationContext {
|
||||
/** Get the accumulated MODELVIEW transform matrix. */
|
||||
Matrix4f getAccumulatedTransform();
|
||||
|
||||
/** Reset accumulated transform to identity. */
|
||||
void loadIdentity();
|
||||
|
||||
/** Push current accumulated transform onto stack. */
|
||||
void pushTransform();
|
||||
|
||||
/** Pop transform from stack, restoring previous accumulated value. */
|
||||
void popTransform();
|
||||
|
||||
/** Emit a MultMatrix command if accumulated differs from last emitted. */
|
||||
void emitPendingTransform();
|
||||
|
||||
/** Emit a MultMatrix command to reach the target transform. */
|
||||
void emitTransformTo(Matrix4f target);
|
||||
|
||||
/** Add a command to the output list. */
|
||||
void emit(DisplayListCommand cmd);
|
||||
|
||||
/**
|
||||
* Mark that the GL matrix is at an absolute value (after LoadMatrix).
|
||||
* Subsequent LoadIdentity commands must be emitted to reset to identity.
|
||||
*/
|
||||
void markAbsoluteMatrix();
|
||||
|
||||
/**
|
||||
* Check if the GL matrix is at an absolute value and clear the flag.
|
||||
* @return true if LoadMatrix was called and not yet reset by LoadIdentity
|
||||
*/
|
||||
boolean checkAndClearAbsoluteMatrix();
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
/**
|
||||
* Command: glPopAttrib()
|
||||
* Pops the server attribute stack.
|
||||
*/
|
||||
@Desugar
|
||||
public record PopAttribCmd() implements DisplayListCommand {
|
||||
@Override
|
||||
public void execute() {
|
||||
GLStateManager.glPopAttrib();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean needsTransformSync() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean handleOptimization(OptimizationContext ctx) {
|
||||
ctx.emitPendingTransform();
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NotNull String toString() {
|
||||
return "PopAttrib()";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
/**
|
||||
* Command: glPopMatrix()
|
||||
* Pops the current matrix from the matrix stack for the specified matrix mode.
|
||||
*/
|
||||
@Desugar
|
||||
public record PopMatrixCmd(int matrixMode) implements DisplayListCommand {
|
||||
@Override
|
||||
public void execute() {
|
||||
GLStateManager.glPopMatrix();
|
||||
}
|
||||
|
||||
public boolean isModelView() {
|
||||
return matrixMode == GL11.GL_MODELVIEW;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean handleOptimization(OptimizationContext ctx) {
|
||||
if (isModelView()) {
|
||||
ctx.popTransform();
|
||||
}
|
||||
return true; // Always emit Pop
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NotNull String toString() {
|
||||
return String.format("PopMatrix(%s)", GLDebug.getMatrixModeName(matrixMode));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
/**
|
||||
* Command: glPushAttrib(mask)
|
||||
* Pushes the server attribute stack.
|
||||
*/
|
||||
@Desugar
|
||||
public record PushAttribCmd(int mask) implements DisplayListCommand {
|
||||
@Override
|
||||
public void execute() {
|
||||
GLStateManager.glPushAttrib(mask);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean needsTransformSync() {
|
||||
// Only need transform sync if we're pushing transform state.
|
||||
// GL_TRANSFORM_BIT includes the matrix mode and matrix stacks.
|
||||
return (mask & GL11.GL_TRANSFORM_BIT) != 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean handleOptimization(OptimizationContext ctx) {
|
||||
if (needsTransformSync()) {
|
||||
ctx.emitPendingTransform();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NotNull String toString() {
|
||||
return String.format("PushAttrib(0x%08X)", mask);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
/**
|
||||
* Command: glPushMatrix()
|
||||
* Pushes the current matrix onto the matrix stack for the specified matrix mode.
|
||||
*/
|
||||
@Desugar
|
||||
public record PushMatrixCmd(int matrixMode) implements DisplayListCommand {
|
||||
@Override
|
||||
public void execute() {
|
||||
GLStateManager.glPushMatrix();
|
||||
}
|
||||
|
||||
public boolean isModelView() {
|
||||
return matrixMode == GL11.GL_MODELVIEW;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean handleOptimization(OptimizationContext ctx) {
|
||||
if (isModelView()) {
|
||||
ctx.emitPendingTransform();
|
||||
ctx.pushTransform();
|
||||
}
|
||||
return true; // Always emit Push
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NotNull String toString() {
|
||||
return String.format("PushMatrix(%s)", GLDebug.getMatrixModeName(matrixMode));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.joml.Matrix4f;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
/**
|
||||
* Command: glRotatef() or glRotated()
|
||||
* Stores as doubles for precision.
|
||||
*/
|
||||
@Desugar
|
||||
public record RotateCmd(double angle, double x, double y, double z, int matrixMode) implements AccumulableMatrixCommand {
|
||||
@Override
|
||||
public void execute() {
|
||||
GLStateManager.glRotated(angle, x, y, z);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isModelView() {
|
||||
return matrixMode == GL11.GL_MODELVIEW;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void applyTo(Matrix4f matrix) {
|
||||
matrix.rotate((float) Math.toRadians(angle), (float) x, (float) y, (float) z);
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NotNull String toString() {
|
||||
return String.format("Rotate(%.2f deg, %.2f, %.2f, %.2f, %s)", angle, x, y, z, GLDebug.getMatrixModeName(matrixMode));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.joml.Matrix4f;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
/**
|
||||
* Command: glScalef() or glScaled()
|
||||
* Stores as doubles for precision.
|
||||
*/
|
||||
@Desugar
|
||||
public record ScaleCmd(double x, double y, double z, int matrixMode) implements AccumulableMatrixCommand {
|
||||
@Override
|
||||
public void execute() {
|
||||
GLStateManager.glScaled(x, y, z);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isModelView() {
|
||||
return matrixMode == GL11.GL_MODELVIEW;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void applyTo(Matrix4f matrix) {
|
||||
matrix.scale((float) x, (float) y, (float) z);
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NotNull String toString() {
|
||||
return String.format("Scale(%.2f, %.2f, %.2f, %s)", x, y, z, GLDebug.getMatrixModeName(matrixMode));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,117 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
import java.nio.DoubleBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
/**
|
||||
* Command: glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels)
|
||||
* Specifies a two-dimensional texture image during display list playback.
|
||||
*/
|
||||
@Desugar
|
||||
public record TexImage2DCmd(
|
||||
int target,
|
||||
int level,
|
||||
int internalformat,
|
||||
int width,
|
||||
int height,
|
||||
int border,
|
||||
int format,
|
||||
int type,
|
||||
@Nullable byte[] pixelData
|
||||
) implements DisplayListCommand {
|
||||
|
||||
/**
|
||||
* Create command from IntBuffer
|
||||
*/
|
||||
public static TexImage2DCmd fromIntBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable IntBuffer pixels) {
|
||||
byte[] data = null;
|
||||
if (pixels != null) {
|
||||
int pos = pixels.position();
|
||||
int limit = pixels.limit();
|
||||
int size = (limit - pos) * 4; // 4 bytes per int
|
||||
data = new byte[size];
|
||||
ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.nativeOrder());
|
||||
bb.asIntBuffer().put(pixels);
|
||||
pixels.position(pos); // Restore position
|
||||
}
|
||||
return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create command from FloatBuffer
|
||||
*/
|
||||
public static TexImage2DCmd fromFloatBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable FloatBuffer pixels) {
|
||||
byte[] data = null;
|
||||
if (pixels != null) {
|
||||
int pos = pixels.position();
|
||||
int limit = pixels.limit();
|
||||
int size = (limit - pos) * 4; // 4 bytes per float
|
||||
data = new byte[size];
|
||||
ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.nativeOrder());
|
||||
bb.asFloatBuffer().put(pixels);
|
||||
pixels.position(pos); // Restore position
|
||||
}
|
||||
return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create command from DoubleBuffer
|
||||
*/
|
||||
public static TexImage2DCmd fromDoubleBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable DoubleBuffer pixels) {
|
||||
byte[] data = null;
|
||||
if (pixels != null) {
|
||||
int pos = pixels.position();
|
||||
int limit = pixels.limit();
|
||||
int size = (limit - pos) * 8; // 8 bytes per double
|
||||
data = new byte[size];
|
||||
ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.nativeOrder());
|
||||
bb.asDoubleBuffer().put(pixels);
|
||||
pixels.position(pos); // Restore position
|
||||
}
|
||||
return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create command from ByteBuffer
|
||||
*/
|
||||
public static TexImage2DCmd fromByteBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable ByteBuffer pixels) {
|
||||
byte[] data = null;
|
||||
if (pixels != null) {
|
||||
int pos = pixels.position();
|
||||
int limit = pixels.limit();
|
||||
int size = limit - pos;
|
||||
data = new byte[size];
|
||||
pixels.get(data);
|
||||
pixels.position(pos); // Restore position
|
||||
}
|
||||
return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, data);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void execute() {
|
||||
ByteBuffer buffer = null;
|
||||
if (pixelData != null) {
|
||||
buffer = ByteBuffer.allocateDirect(pixelData.length).order(ByteOrder.nativeOrder());
|
||||
buffer.put(pixelData);
|
||||
buffer.flip();
|
||||
}
|
||||
GLStateManager.glTexImage2D(target, level, internalformat, width, height, border, format, type, buffer);
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NotNull String toString() {
|
||||
String dataStr = pixelData != null ? (pixelData.length + " bytes") : "null";
|
||||
return String.format("TexImage2D(target=%s, level=%d, internalformat=%s, %dx%d, border=%d, format=%s, type=%s, data=%s)",
|
||||
GLDebug.getTextureTargetName(target), level, GLDebug.getTextureFormatName(internalformat),
|
||||
width, height, border, GLDebug.getTextureFormatName(format), GLDebug.getDataTypeName(type), dataStr);
|
||||
}
|
||||
}
|
||||
+117
@@ -0,0 +1,117 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
import java.nio.DoubleBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
/**
|
||||
* Command: glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels)
|
||||
* Updates a portion of an existing two-dimensional texture image during display list playback.
|
||||
*/
|
||||
@Desugar
|
||||
public record TexSubImage2DCmd(
|
||||
int target,
|
||||
int level,
|
||||
int xoffset,
|
||||
int yoffset,
|
||||
int width,
|
||||
int height,
|
||||
int format,
|
||||
int type,
|
||||
@Nullable byte[] pixelData
|
||||
) implements DisplayListCommand {
|
||||
|
||||
/**
|
||||
* Create command from IntBuffer
|
||||
*/
|
||||
public static TexSubImage2DCmd fromIntBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable IntBuffer pixels) {
|
||||
byte[] data = null;
|
||||
if (pixels != null) {
|
||||
int pos = pixels.position();
|
||||
int limit = pixels.limit();
|
||||
int size = (limit - pos) * 4; // 4 bytes per int
|
||||
data = new byte[size];
|
||||
ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.nativeOrder());
|
||||
bb.asIntBuffer().put(pixels);
|
||||
pixels.position(pos); // Restore position
|
||||
}
|
||||
return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create command from FloatBuffer
|
||||
*/
|
||||
public static TexSubImage2DCmd fromFloatBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable FloatBuffer pixels) {
|
||||
byte[] data = null;
|
||||
if (pixels != null) {
|
||||
int pos = pixels.position();
|
||||
int limit = pixels.limit();
|
||||
int size = (limit - pos) * 4; // 4 bytes per float
|
||||
data = new byte[size];
|
||||
ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.nativeOrder());
|
||||
bb.asFloatBuffer().put(pixels);
|
||||
pixels.position(pos); // Restore position
|
||||
}
|
||||
return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create command from DoubleBuffer
|
||||
*/
|
||||
public static TexSubImage2DCmd fromDoubleBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable DoubleBuffer pixels) {
|
||||
byte[] data = null;
|
||||
if (pixels != null) {
|
||||
int pos = pixels.position();
|
||||
int limit = pixels.limit();
|
||||
int size = (limit - pos) * 8; // 8 bytes per double
|
||||
data = new byte[size];
|
||||
ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.nativeOrder());
|
||||
bb.asDoubleBuffer().put(pixels);
|
||||
pixels.position(pos); // Restore position
|
||||
}
|
||||
return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create command from ByteBuffer
|
||||
*/
|
||||
public static TexSubImage2DCmd fromByteBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable ByteBuffer pixels) {
|
||||
byte[] data = null;
|
||||
if (pixels != null) {
|
||||
int pos = pixels.position();
|
||||
int limit = pixels.limit();
|
||||
int size = limit - pos;
|
||||
data = new byte[size];
|
||||
pixels.get(data);
|
||||
pixels.position(pos); // Restore position
|
||||
}
|
||||
return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, data);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void execute() {
|
||||
ByteBuffer buffer = null;
|
||||
if (pixelData != null) {
|
||||
buffer = ByteBuffer.allocateDirect(pixelData.length).order(ByteOrder.nativeOrder());
|
||||
buffer.put(pixelData);
|
||||
buffer.flip();
|
||||
}
|
||||
GLStateManager.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, buffer);
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NotNull String toString() {
|
||||
String dataStr = pixelData != null ? (pixelData.length + " bytes") : "null";
|
||||
return String.format("TexSubImage2D(target=%s, level=%d, offset=(%d,%d), %dx%d, format=%s, type=%s, data=%s)",
|
||||
GLDebug.getTextureTargetName(target), level, xoffset, yoffset, width, height,
|
||||
GLDebug.getTextureFormatName(format), GLDebug.getDataTypeName(type), dataStr);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording.commands;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.joml.Matrix4f;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
/**
|
||||
* Command: glTranslatef() or glTranslated()
|
||||
* Stores as doubles for precision.
|
||||
*/
|
||||
@Desugar
|
||||
public record TranslateCmd(double x, double y, double z, int matrixMode) implements AccumulableMatrixCommand {
|
||||
@Override
|
||||
public void execute() {
|
||||
// Save current mode
|
||||
final int savedMode = GLStateManager.getMatrixMode().getMode();
|
||||
|
||||
// Switch to the mode this was recorded with
|
||||
GLStateManager.glMatrixMode(matrixMode);
|
||||
GLStateManager.glTranslated(x, y, z);
|
||||
|
||||
// Restore mode
|
||||
GLStateManager.glMatrixMode(savedMode);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isModelView() {
|
||||
return matrixMode == GL11.GL_MODELVIEW;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void applyTo(Matrix4f matrix) {
|
||||
matrix.translate((float) x, (float) y, (float) z);
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NotNull String toString() {
|
||||
return String.format("Translate(%.2f, %.2f, %.2f, %s)", x, y, z, GLDebug.getMatrixModeName(matrixMode));
|
||||
}
|
||||
}
|
||||
@@ -3,13 +3,23 @@ package com.gtnewhorizons.angelica.glsm.stacks;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.states.BooleanState;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
/**
|
||||
* A stack for boolean GL state with lazy copy-on-write optimization.
|
||||
* <p>
|
||||
* When using the global attrib depth tracking (from glPushAttrib/glPopAttrib), state is only
|
||||
* saved when actually modified, dramatically reducing overhead when most states
|
||||
* don't change (e.g., GL_ENABLE_BIT saves ~270 states but typically only 3-4 change).
|
||||
*/
|
||||
public class BooleanStateStack extends BooleanState implements IStateStack<BooleanStateStack> {
|
||||
|
||||
protected final BooleanState[] stack;
|
||||
protected final boolean[] stack;
|
||||
|
||||
protected int pointer;
|
||||
/**
|
||||
* The depth at which state has been saved. Compared against GLStateManager.getAttribDepth()
|
||||
* to determine if we need to save before modification or restore on pop.
|
||||
*/
|
||||
protected int savedDepth;
|
||||
|
||||
public BooleanStateStack(int glCap) {
|
||||
// Most booleans default to false
|
||||
@@ -26,34 +36,83 @@ public class BooleanStateStack extends BooleanState implements IStateStack<Boole
|
||||
public BooleanStateStack(int glCap, boolean initialState) {
|
||||
super(glCap);
|
||||
this.enabled = initialState;
|
||||
stack = new BooleanState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
|
||||
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
|
||||
stack[i] = new BooleanState(glCap);
|
||||
}
|
||||
stack = new boolean[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
|
||||
}
|
||||
|
||||
public BooleanStateStack push() {
|
||||
if(pointer == stack.length) {
|
||||
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
|
||||
}
|
||||
// ==================== Traditional Stack Operations ====================
|
||||
|
||||
stack[pointer++].set(this);
|
||||
@Override
|
||||
public BooleanStateStack push() {
|
||||
if (savedDepth >= stack.length) {
|
||||
throw new IllegalStateException("Stack overflow size " + (savedDepth + 1) + " reached");
|
||||
}
|
||||
stack[savedDepth++] = enabled;
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public BooleanStateStack pop() {
|
||||
if(pointer == 0) {
|
||||
if (savedDepth == 0) {
|
||||
throw new IllegalStateException("Stack underflow");
|
||||
}
|
||||
final boolean oldValue = stack[--savedDepth];
|
||||
// Call setEnabledDirect to avoid triggering beforeModify during restore
|
||||
setEnabledDirect(oldValue);
|
||||
return this;
|
||||
}
|
||||
|
||||
set(stack[--pointer]);
|
||||
if (GLStateManager.vendorIsAMD() && glCap == GL11.GL_BLEND) {
|
||||
setEnabled(enabled);
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
return savedDepth == 0;
|
||||
}
|
||||
|
||||
// ==================== Lazy Copy-on-Write Operations ====================
|
||||
|
||||
@Override
|
||||
public int pushDepth() {
|
||||
// No-op: global depth is managed by GLStateManager
|
||||
return GLStateManager.getAttribDepth();
|
||||
}
|
||||
|
||||
/**
|
||||
* Restore state if it was modified at the current depth.
|
||||
* Only called by GLStateManager.popState() for states that registered as modified.
|
||||
*/
|
||||
@Override
|
||||
public BooleanStateStack popDepth() {
|
||||
// We're only called if we were modified, so savedDepth should match
|
||||
if (savedDepth > 0) {
|
||||
final boolean oldValue = stack[--savedDepth];
|
||||
setEnabledDirect(oldValue);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return pointer == 0;
|
||||
/**
|
||||
* Called before modifying state. If we haven't saved at the current depth yet,
|
||||
* save the current value and register with GLStateManager for restoration.
|
||||
*/
|
||||
@Override
|
||||
public void beforeModify() {
|
||||
final int globalDepth = GLStateManager.getAttribDepth();
|
||||
if (savedDepth < globalDepth) {
|
||||
stack[savedDepth++] = enabled;
|
||||
GLStateManager.registerModifiedState(this);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getDepth() {
|
||||
return GLStateManager.getAttribDepth();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setEnabled(boolean enabled) {
|
||||
beforeModify();
|
||||
super.setEnabled(enabled);
|
||||
}
|
||||
|
||||
private void setEnabledDirect(boolean enabled) {
|
||||
super.setEnabled(enabled);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
package com.gtnewhorizons.angelica.glsm.stacks;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.states.LineState;
|
||||
|
||||
/**
|
||||
* Stack for GL line state (width, stipple factor, stipple pattern).
|
||||
* Used by GL_LINE_BIT push/pop attrib.
|
||||
*/
|
||||
public class LineStateStack extends LineState implements IStateStack<LineStateStack> {
|
||||
|
||||
protected final LineState[] stack;
|
||||
protected int pointer;
|
||||
|
||||
public LineStateStack() {
|
||||
stack = new LineState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
|
||||
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
|
||||
stack[i] = new LineState();
|
||||
}
|
||||
}
|
||||
|
||||
public LineStateStack push() {
|
||||
if (pointer == stack.length) {
|
||||
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
|
||||
}
|
||||
stack[pointer++].set(this);
|
||||
return this;
|
||||
}
|
||||
|
||||
public LineStateStack pop() {
|
||||
if (pointer == 0) {
|
||||
throw new IllegalStateException("Stack underflow");
|
||||
}
|
||||
set(stack[--pointer]);
|
||||
return this;
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return pointer == 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
package com.gtnewhorizons.angelica.glsm.stacks;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.states.PointState;
|
||||
|
||||
/**
|
||||
* Stack for GL point state (size).
|
||||
* Used by GL_POINT_BIT push/pop attrib.
|
||||
*/
|
||||
public class PointStateStack extends PointState implements IStateStack<PointStateStack> {
|
||||
|
||||
protected final PointState[] stack;
|
||||
protected int pointer;
|
||||
|
||||
public PointStateStack() {
|
||||
stack = new PointState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
|
||||
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
|
||||
stack[i] = new PointState();
|
||||
}
|
||||
}
|
||||
|
||||
public PointStateStack push() {
|
||||
if (pointer == stack.length) {
|
||||
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
|
||||
}
|
||||
stack[pointer++].set(this);
|
||||
return this;
|
||||
}
|
||||
|
||||
public PointStateStack pop() {
|
||||
if (pointer == 0) {
|
||||
throw new IllegalStateException("Stack underflow");
|
||||
}
|
||||
set(stack[--pointer]);
|
||||
return this;
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return pointer == 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
package com.gtnewhorizons.angelica.glsm.stacks;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.states.PolygonState;
|
||||
|
||||
/**
|
||||
* Stack for GL polygon state (mode, offset, cull face mode, front face).
|
||||
* Used by GL_POLYGON_BIT push/pop attrib.
|
||||
*/
|
||||
public class PolygonStateStack extends PolygonState implements IStateStack<PolygonStateStack> {
|
||||
|
||||
protected final PolygonState[] stack;
|
||||
protected int pointer;
|
||||
|
||||
public PolygonStateStack() {
|
||||
stack = new PolygonState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
|
||||
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
|
||||
stack[i] = new PolygonState();
|
||||
}
|
||||
}
|
||||
|
||||
public PolygonStateStack push() {
|
||||
if (pointer == stack.length) {
|
||||
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
|
||||
}
|
||||
stack[pointer++].set(this);
|
||||
return this;
|
||||
}
|
||||
|
||||
public PolygonStateStack pop() {
|
||||
if (pointer == 0) {
|
||||
throw new IllegalStateException("Stack underflow");
|
||||
}
|
||||
set(stack[--pointer]);
|
||||
return this;
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return pointer == 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
package com.gtnewhorizons.angelica.glsm.stacks;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.states.StencilState;
|
||||
|
||||
/**
|
||||
* Stack for GL stencil buffer state.
|
||||
* Used by GL_STENCIL_BUFFER_BIT push/pop attrib.
|
||||
*/
|
||||
public class StencilStateStack extends StencilState implements IStateStack<StencilStateStack> {
|
||||
|
||||
protected final StencilState[] stack;
|
||||
protected int pointer;
|
||||
|
||||
public StencilStateStack() {
|
||||
stack = new StencilState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
|
||||
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
|
||||
stack[i] = new StencilState();
|
||||
}
|
||||
}
|
||||
|
||||
public StencilStateStack push() {
|
||||
if (pointer == stack.length) {
|
||||
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
|
||||
}
|
||||
stack[pointer++].set(this);
|
||||
return this;
|
||||
}
|
||||
|
||||
public StencilStateStack pop() {
|
||||
if (pointer == 0) {
|
||||
throw new IllegalStateException("Stack underflow");
|
||||
}
|
||||
set(stack[--pointer]);
|
||||
return this;
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return pointer == 0;
|
||||
}
|
||||
}
|
||||
@@ -21,6 +21,18 @@ public class BlendState implements ISettableState<BlendState> {
|
||||
this.dstAlpha = dstAlpha;
|
||||
}
|
||||
|
||||
public void setAll(int srcRgb, int dstRgb, int srcAlpha, int dstAlpha) {
|
||||
this.srcRgb = srcRgb;
|
||||
this.dstRgb = dstRgb;
|
||||
this.srcAlpha = srcAlpha;
|
||||
this.dstAlpha = dstAlpha;
|
||||
}
|
||||
|
||||
public void setSrcDstRgb(int srcRgb, int dstRgb) {
|
||||
this.srcRgb = srcRgb;
|
||||
this.dstRgb = dstRgb;
|
||||
}
|
||||
|
||||
@Override
|
||||
public BlendState set(BlendState state) {
|
||||
this.srcRgb = state.srcRgb;
|
||||
|
||||
@@ -22,12 +22,18 @@ public class BooleanState implements ISettableState<BooleanState> {
|
||||
}
|
||||
|
||||
public void setEnabled(boolean enabled) {
|
||||
if (GLStateManager.shouldBypassCache() || enabled != this.enabled || (this.glCap == GL11.GL_BLEND && GLStateManager.vendorIsAMD() && GLStateManager.isPoppingAttributes())) {
|
||||
this.enabled = enabled;
|
||||
if (enabled) {
|
||||
GL11.glEnable(this.glCap);
|
||||
} else {
|
||||
GL11.glDisable(this.glCap);
|
||||
final boolean bypass = GLStateManager.shouldBypassCache();
|
||||
if (bypass || enabled != this.enabled || (this.glCap == GL11.GL_BLEND && GLStateManager.vendorIsAMD() && GLStateManager.isPoppingAttributes())) {
|
||||
if (!bypass) {
|
||||
this.enabled = enabled;
|
||||
}
|
||||
// Skip actual GL calls during display list recording (state tracking only)
|
||||
if (!GLStateManager.isRecordingDisplayList()) {
|
||||
if (enabled) {
|
||||
GL11.glEnable(this.glCap);
|
||||
} else {
|
||||
GL11.glDisable(this.glCap);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
package com.gtnewhorizons.angelica.glsm.states;
|
||||
|
||||
import java.nio.Buffer;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
/**
|
||||
* Tracks OpenGL client array state (glVertexPointer, glColorPointer, etc.)
|
||||
* This state is NOT part of the server attribute stack (push/pop attrib),
|
||||
* but is needed for display list compilation to capture glDrawArrays calls.
|
||||
*
|
||||
* When a display list is compiled, glDrawArrays reads from the current
|
||||
* vertex/color arrays at compile time (not playback time). We need to track
|
||||
* this state globally so ImmediateModeRecorder can access it.
|
||||
*/
|
||||
public class ClientArrayState {
|
||||
// Vertex array state
|
||||
private boolean vertexArrayEnabled = false;
|
||||
private Buffer vertexPointer = null;
|
||||
private int vertexPointerSize = 4;
|
||||
private int vertexPointerType = GL11.GL_FLOAT;
|
||||
private int vertexPointerStride = 0;
|
||||
|
||||
// Color array state
|
||||
private boolean colorArrayEnabled = false;
|
||||
private Buffer colorPointer = null;
|
||||
private int colorPointerSize = 4;
|
||||
private int colorPointerType = GL11.GL_FLOAT;
|
||||
private int colorPointerStride = 0;
|
||||
|
||||
// Vertex array methods
|
||||
public void setVertexPointer(int size, int type, int stride, Buffer pointer) {
|
||||
this.vertexPointerSize = size;
|
||||
this.vertexPointerType = type;
|
||||
this.vertexPointerStride = stride;
|
||||
this.vertexPointer = pointer;
|
||||
}
|
||||
|
||||
public boolean isVertexArrayEnabled() {
|
||||
return vertexArrayEnabled;
|
||||
}
|
||||
|
||||
public void setVertexArrayEnabled(boolean enabled) {
|
||||
this.vertexArrayEnabled = enabled;
|
||||
}
|
||||
|
||||
public Buffer getVertexPointer() {
|
||||
return vertexPointer;
|
||||
}
|
||||
|
||||
public int getVertexPointerSize() {
|
||||
return vertexPointerSize;
|
||||
}
|
||||
|
||||
public int getVertexPointerType() {
|
||||
return vertexPointerType;
|
||||
}
|
||||
|
||||
public int getVertexPointerStride() {
|
||||
return vertexPointerStride;
|
||||
}
|
||||
|
||||
// Color array methods
|
||||
public void setColorPointer(int size, int type, int stride, Buffer pointer) {
|
||||
this.colorPointerSize = size;
|
||||
this.colorPointerType = type;
|
||||
this.colorPointerStride = stride;
|
||||
this.colorPointer = pointer;
|
||||
}
|
||||
|
||||
public boolean isColorArrayEnabled() {
|
||||
return colorArrayEnabled;
|
||||
}
|
||||
|
||||
public void setColorArrayEnabled(boolean enabled) {
|
||||
this.colorArrayEnabled = enabled;
|
||||
}
|
||||
|
||||
public Buffer getColorPointer() {
|
||||
return colorPointer;
|
||||
}
|
||||
|
||||
public int getColorPointerSize() {
|
||||
return colorPointerSize;
|
||||
}
|
||||
|
||||
public int getColorPointerType() {
|
||||
return colorPointerType;
|
||||
}
|
||||
|
||||
public int getColorPointerStride() {
|
||||
return colorPointerStride;
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,13 @@ public class ColorMask implements ISettableState<ColorMask> {
|
||||
public boolean blue = true;
|
||||
public boolean alpha = true;
|
||||
|
||||
public void setAll(boolean red, boolean green, boolean blue, boolean alpha) {
|
||||
this.red = red;
|
||||
this.green = green;
|
||||
this.blue = blue;
|
||||
this.alpha = alpha;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ColorMask set(ColorMask state) {
|
||||
this.red = state.red;
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
package com.gtnewhorizons.angelica.glsm.states;
|
||||
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
|
||||
/**
|
||||
* Tracks GL line state: width, stipple factor, and stipple pattern.
|
||||
* Corresponds to GL_LINE_BIT attributes.
|
||||
*/
|
||||
@Getter @Setter
|
||||
public class LineState implements ISettableState<LineState> {
|
||||
private float width = 1.0f;
|
||||
private int stippleFactor = 1;
|
||||
private short stipplePattern = (short) 0xFFFF;
|
||||
|
||||
@Override
|
||||
public LineState set(LineState state) {
|
||||
this.width = state.width;
|
||||
this.stippleFactor = state.stippleFactor;
|
||||
this.stipplePattern = state.stipplePattern;
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean sameAs(Object state) {
|
||||
if (this == state) return true;
|
||||
if (!(state instanceof LineState lineState)) return false;
|
||||
return Float.compare(width, lineState.width) == 0
|
||||
&& stippleFactor == lineState.stippleFactor
|
||||
&& stipplePattern == lineState.stipplePattern;
|
||||
}
|
||||
|
||||
@Override
|
||||
public LineState copy() {
|
||||
return new LineState().set(this);
|
||||
}
|
||||
}
|
||||
@@ -15,8 +15,11 @@ public class MatrixMode implements ISettableState<MatrixMode> {
|
||||
return;
|
||||
}
|
||||
|
||||
if(this.mode != mode || GLStateManager.shouldBypassCache()) {
|
||||
this.mode = mode;
|
||||
final boolean bypass = GLStateManager.shouldBypassCache();
|
||||
if (bypass || this.mode != mode) {
|
||||
if (!bypass) {
|
||||
this.mode = mode;
|
||||
}
|
||||
GL11.glMatrixMode(mode);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
package com.gtnewhorizons.angelica.glsm.states;
|
||||
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
|
||||
/**
|
||||
* Tracks GL point state: size.
|
||||
* Corresponds to GL_POINT_BIT attributes.
|
||||
*/
|
||||
@Getter @Setter
|
||||
public class PointState implements ISettableState<PointState> {
|
||||
private float size = 1.0f;
|
||||
|
||||
@Override
|
||||
public PointState set(PointState state) {
|
||||
this.size = state.size;
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean sameAs(Object state) {
|
||||
if (this == state) return true;
|
||||
if (!(state instanceof PointState pointState)) return false;
|
||||
return Float.compare(size, pointState.size) == 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PointState copy() {
|
||||
return new PointState().set(this);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
package com.gtnewhorizons.angelica.glsm.states;
|
||||
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
/**
|
||||
* Tracks GL polygon state: polygon mode (front/back) and polygon offset.
|
||||
* Corresponds to GL_POLYGON_BIT attributes (excluding enable bits which are BooleanStateStack).
|
||||
*/
|
||||
@Getter @Setter
|
||||
public class PolygonState implements ISettableState<PolygonState> {
|
||||
private int frontMode = GL11.GL_FILL;
|
||||
private int backMode = GL11.GL_FILL;
|
||||
private float offsetFactor = 0.0f;
|
||||
private float offsetUnits = 0.0f;
|
||||
private int cullFaceMode = GL11.GL_BACK;
|
||||
private int frontFace = GL11.GL_CCW;
|
||||
|
||||
@Override
|
||||
public PolygonState set(PolygonState state) {
|
||||
this.frontMode = state.frontMode;
|
||||
this.backMode = state.backMode;
|
||||
this.offsetFactor = state.offsetFactor;
|
||||
this.offsetUnits = state.offsetUnits;
|
||||
this.cullFaceMode = state.cullFaceMode;
|
||||
this.frontFace = state.frontFace;
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean sameAs(Object state) {
|
||||
if (this == state) return true;
|
||||
if (!(state instanceof PolygonState polygonState)) return false;
|
||||
return frontMode == polygonState.frontMode
|
||||
&& backMode == polygonState.backMode
|
||||
&& Float.compare(offsetFactor, polygonState.offsetFactor) == 0
|
||||
&& Float.compare(offsetUnits, polygonState.offsetUnits) == 0
|
||||
&& cullFaceMode == polygonState.cullFaceMode
|
||||
&& frontFace == polygonState.frontFace;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PolygonState copy() {
|
||||
return new PolygonState().set(this);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,114 @@
|
||||
package com.gtnewhorizons.angelica.glsm.states;
|
||||
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
/**
|
||||
* Tracks GL stencil buffer state.
|
||||
* Corresponds to GL_STENCIL_BUFFER_BIT attributes.
|
||||
* Supports separate front/back state (GL 2.0 glStencilFuncSeparate, glStencilOpSeparate, glStencilMaskSeparate).
|
||||
*/
|
||||
@Getter @Setter
|
||||
public class StencilState implements ISettableState<StencilState> {
|
||||
// Front face state
|
||||
private int funcFront = GL11.GL_ALWAYS;
|
||||
private int refFront = 0;
|
||||
private int valueMaskFront = 0xFFFFFFFF;
|
||||
private int failOpFront = GL11.GL_KEEP;
|
||||
private int zFailOpFront = GL11.GL_KEEP;
|
||||
private int zPassOpFront = GL11.GL_KEEP;
|
||||
private int writeMaskFront = 0xFFFFFFFF;
|
||||
|
||||
// Back face state (GL 2.0)
|
||||
private int funcBack = GL11.GL_ALWAYS;
|
||||
private int refBack = 0;
|
||||
private int valueMaskBack = 0xFFFFFFFF;
|
||||
private int failOpBack = GL11.GL_KEEP;
|
||||
private int zFailOpBack = GL11.GL_KEEP;
|
||||
private int zPassOpBack = GL11.GL_KEEP;
|
||||
private int writeMaskBack = 0xFFFFFFFF;
|
||||
|
||||
// Clear value (shared)
|
||||
private int clearValue = 0;
|
||||
|
||||
@Override
|
||||
public StencilState set(StencilState state) {
|
||||
this.funcFront = state.funcFront;
|
||||
this.refFront = state.refFront;
|
||||
this.valueMaskFront = state.valueMaskFront;
|
||||
this.failOpFront = state.failOpFront;
|
||||
this.zFailOpFront = state.zFailOpFront;
|
||||
this.zPassOpFront = state.zPassOpFront;
|
||||
this.writeMaskFront = state.writeMaskFront;
|
||||
|
||||
this.funcBack = state.funcBack;
|
||||
this.refBack = state.refBack;
|
||||
this.valueMaskBack = state.valueMaskBack;
|
||||
this.failOpBack = state.failOpBack;
|
||||
this.zFailOpBack = state.zFailOpBack;
|
||||
this.zPassOpBack = state.zPassOpBack;
|
||||
this.writeMaskBack = state.writeMaskBack;
|
||||
|
||||
this.clearValue = state.clearValue;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set both front and back state at once (non-separate calls).
|
||||
*/
|
||||
public void setFunc(int func, int ref, int mask) {
|
||||
this.funcFront = func;
|
||||
this.refFront = ref;
|
||||
this.valueMaskFront = mask;
|
||||
this.funcBack = func;
|
||||
this.refBack = ref;
|
||||
this.valueMaskBack = mask;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set both front and back operations at once (non-separate calls).
|
||||
*/
|
||||
public void setOp(int fail, int zFail, int zPass) {
|
||||
this.failOpFront = fail;
|
||||
this.zFailOpFront = zFail;
|
||||
this.zPassOpFront = zPass;
|
||||
this.failOpBack = fail;
|
||||
this.zFailOpBack = zFail;
|
||||
this.zPassOpBack = zPass;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set both front and back write mask at once (non-separate calls).
|
||||
*/
|
||||
public void setWriteMask(int mask) {
|
||||
this.writeMaskFront = mask;
|
||||
this.writeMaskBack = mask;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean sameAs(Object state) {
|
||||
if (this == state) return true;
|
||||
if (!(state instanceof StencilState stencilState)) return false;
|
||||
return funcFront == stencilState.funcFront
|
||||
&& refFront == stencilState.refFront
|
||||
&& valueMaskFront == stencilState.valueMaskFront
|
||||
&& failOpFront == stencilState.failOpFront
|
||||
&& zFailOpFront == stencilState.zFailOpFront
|
||||
&& zPassOpFront == stencilState.zPassOpFront
|
||||
&& writeMaskFront == stencilState.writeMaskFront
|
||||
&& funcBack == stencilState.funcBack
|
||||
&& refBack == stencilState.refBack
|
||||
&& valueMaskBack == stencilState.valueMaskBack
|
||||
&& failOpBack == stencilState.failOpBack
|
||||
&& zFailOpBack == stencilState.zFailOpBack
|
||||
&& zPassOpBack == stencilState.zPassOpBack
|
||||
&& writeMaskBack == stencilState.writeMaskBack
|
||||
&& clearValue == stencilState.clearValue;
|
||||
}
|
||||
|
||||
@Override
|
||||
public StencilState copy() {
|
||||
return new StencilState().set(this);
|
||||
}
|
||||
}
|
||||
@@ -21,7 +21,7 @@ public class TextureInfoCache {
|
||||
}
|
||||
|
||||
public TextureInfo getInfo(int id) {
|
||||
if(id < 0 || !GLStateManager.isMainThread()) return null;
|
||||
if(id < 0 || !GLStateManager.isCachingEnabled()) return null;
|
||||
return cache.computeIfAbsent(id, TextureInfo::new);
|
||||
}
|
||||
|
||||
@@ -45,7 +45,7 @@ public class TextureInfoCache {
|
||||
}
|
||||
|
||||
public void onDeleteTexture(int id) {
|
||||
if(id >= 0 && GLStateManager.isMainThread()) cache.remove(id);
|
||||
if(id >= 0 && GLStateManager.isCachingEnabled()) cache.remove(id);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,6 +1,5 @@
|
||||
package com.gtnewhorizons.angelica.glsm.texture;
|
||||
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
|
||||
@@ -49,7 +48,7 @@ public class TextureTracker {
|
||||
if (bindTextureListener != null) {
|
||||
bindTextureListener.run();
|
||||
}
|
||||
if(AngelicaConfig.enableIris) {
|
||||
if(Iris.enabled) {
|
||||
final WorldRenderingPipeline pipeline = Iris.getPipelineManager().getPipelineNullable();
|
||||
if (pipeline != null) {
|
||||
pipeline.onBindTexture(id);
|
||||
|
||||
+58
-2
@@ -41,6 +41,7 @@ public final class AngelicaRedirector {
|
||||
private static final String Drawable = "org/lwjgl/opengl/Drawable";
|
||||
private static final String GLStateManager = "com/gtnewhorizons/angelica/glsm/GLStateManager";
|
||||
private static final String GL11 = "org/lwjgl/opengl/GL11";
|
||||
private static final String GL12 = "org/lwjgl/opengl/GL12";
|
||||
private static final String GL13 = "org/lwjgl/opengl/GL13";
|
||||
private static final String GL14 = "org/lwjgl/opengl/GL14";
|
||||
private static final String GL20 = "org/lwjgl/opengl/GL20";
|
||||
@@ -55,7 +56,7 @@ public final class AngelicaRedirector {
|
||||
"initializeTextures", "func_77474_a"
|
||||
);
|
||||
|
||||
private static final ClassConstantPoolParser cstPoolParser = new ClassConstantPoolParser(GL11, GL13, GL14, GL20, OpenGlHelper, EXTBlendFunc, ARBMultiTexture, Project);
|
||||
private static final ClassConstantPoolParser cstPoolParser = new ClassConstantPoolParser(GL11, GL12, GL13, GL14, GL20, OpenGlHelper, EXTBlendFunc, ARBMultiTexture, Project);
|
||||
private static final Map<String, Map<String, String>> methodRedirects = new HashMap<>();
|
||||
private static final Map<Integer, String> glCapRedirects = new HashMap<>();
|
||||
|
||||
@@ -75,9 +76,12 @@ public final class AngelicaRedirector {
|
||||
.add("glBindTexture")
|
||||
.add("glBlendFunc")
|
||||
.add("glCallList")
|
||||
.add("glCallLists")
|
||||
.add("glClear")
|
||||
.add("glClearColor")
|
||||
.add("glClearDepth")
|
||||
.add("glClearStencil")
|
||||
.add("glClipPlane")
|
||||
.add("glColor3b")
|
||||
.add("glColor3d")
|
||||
.add("glColor3f")
|
||||
@@ -88,6 +92,7 @@ public final class AngelicaRedirector {
|
||||
.add("glColor4ub")
|
||||
.add("glColorMask")
|
||||
.add("glColorMaterial")
|
||||
.add("glDeleteLists")
|
||||
.add("glDeleteTextures")
|
||||
.add("glDepthFunc")
|
||||
.add("glDepthMask")
|
||||
@@ -96,6 +101,7 @@ public final class AngelicaRedirector {
|
||||
.add("glDrawBuffer")
|
||||
.add("glDrawElements")
|
||||
.add("glEdgeFlag")
|
||||
.add("glEnd")
|
||||
.add("glEndList")
|
||||
.add("glFog")
|
||||
.add("glFogf")
|
||||
@@ -119,6 +125,9 @@ public final class AngelicaRedirector {
|
||||
.add("glLightModel")
|
||||
.add("glLightModelf")
|
||||
.add("glLightModeli")
|
||||
.add("glLineStipple")
|
||||
.add("glLineWidth")
|
||||
.add("glListBase")
|
||||
.add("glLoadIdentity")
|
||||
.add("glLoadMatrix")
|
||||
.add("glLogicOp")
|
||||
@@ -156,16 +165,59 @@ public final class AngelicaRedirector {
|
||||
.add("glTexCoord3f")
|
||||
.add("glTexCoord4d")
|
||||
.add("glTexCoord4f")
|
||||
.add("glTexImage1D")
|
||||
.add("glTexImage2D")
|
||||
.add("glTexImage3D")
|
||||
.add("glTexSubImage1D")
|
||||
.add("glTexSubImage2D")
|
||||
.add("glCopyTexImage1D")
|
||||
.add("glCopyTexImage2D")
|
||||
.add("glCopyTexSubImage1D")
|
||||
.add("glCopyTexSubImage2D")
|
||||
.add("glPixelStoref")
|
||||
.add("glPixelStorei")
|
||||
.add("glTexParameter")
|
||||
.add("glTexParameterf")
|
||||
.add("glTexParameteri")
|
||||
.add("glTexParameteri")
|
||||
.add("glCullFace")
|
||||
.add("glFrontFace")
|
||||
.add("glHint")
|
||||
.add("glLineStipple")
|
||||
.add("glLineWidth")
|
||||
.add("glPointSize")
|
||||
.add("glPolygonMode")
|
||||
.add("glPolygonOffset")
|
||||
.add("glReadBuffer")
|
||||
.add("glSampleCoverage")
|
||||
.add("glScissor")
|
||||
.add("glStencilFunc")
|
||||
.add("glStencilFuncSeparate")
|
||||
.add("glStencilMask")
|
||||
.add("glStencilMaskSeparate")
|
||||
.add("glStencilOp")
|
||||
.add("glStencilOpSeparate")
|
||||
.add("glTranslated")
|
||||
.add("glTranslatef")
|
||||
.add("glVertex2d")
|
||||
.add("glVertex2f")
|
||||
.add("glVertex3d")
|
||||
.add("glVertex3f")
|
||||
.add("glVertexPointer")
|
||||
.add("glColorPointer")
|
||||
.add("glEnableClientState")
|
||||
.add("glDisableClientState")
|
||||
.add("glViewport")
|
||||
);
|
||||
methodRedirects.put(GL13, RedirectMap.newMap().add("glActiveTexture"));
|
||||
methodRedirects.put(GL12, RedirectMap.newMap()
|
||||
.add("glTexImage3D")
|
||||
.add("glTexSubImage3D")
|
||||
.add("glCopyTexSubImage3D")
|
||||
);
|
||||
methodRedirects.put(GL13, RedirectMap.newMap()
|
||||
.add("glActiveTexture")
|
||||
.add("glSampleCoverage")
|
||||
);
|
||||
methodRedirects.put(GL14, RedirectMap.newMap()
|
||||
.add("glBlendFuncSeparate", "tryBlendFuncSeparate")
|
||||
.add("glBlendColor")
|
||||
@@ -173,6 +225,10 @@ public final class AngelicaRedirector {
|
||||
);
|
||||
methodRedirects.put(GL20, RedirectMap.newMap()
|
||||
.add("glBlendEquationSeparate")
|
||||
.add("glDrawBuffers")
|
||||
.add("glStencilFuncSeparate")
|
||||
.add("glStencilMaskSeparate")
|
||||
.add("glStencilOpSeparate")
|
||||
.add("glUseProgram")
|
||||
);
|
||||
methodRedirects.put(OpenGlHelper, RedirectMap.newMap()
|
||||
|
||||
@@ -35,19 +35,17 @@ public enum Mixins implements IMixins {
|
||||
, "angelica.optimizations.MixinRendererLivingEntity"
|
||||
, "angelica.MixinFMLClientHandler"
|
||||
, "angelica.bugfixes.MixinRenderGlobal_DestroyBlock"
|
||||
, "angelica.glsm.MixinSplashProgressCaching"
|
||||
)
|
||||
),
|
||||
ANGELICA_VBO(
|
||||
|
||||
ANGELICA_VBO_CLOUDS(
|
||||
new MixinBuilder()
|
||||
.setApplyIf(() -> AngelicaConfig.enableVBO)
|
||||
.setApplyIf(() -> AngelicaConfig.enableVBOClouds)
|
||||
.setPhase(Phase.EARLY)
|
||||
.addClientMixins(
|
||||
"angelica.vbo.MixinGLAllocation"
|
||||
, "angelica.vbo.MixinModelRenderer"
|
||||
, "angelica.vbo.MixinRenderGlobal"
|
||||
, "angelica.vbo.MixinWavefrontObject"
|
||||
)
|
||||
.addClientMixins("angelica.vbo.MixinRenderGlobal")
|
||||
),
|
||||
|
||||
ANGELICA_FONT_RENDERER(new MixinBuilder()
|
||||
.setPhase(Phase.EARLY)
|
||||
.setApplyIf(() -> AngelicaConfig.enableFontRenderer)
|
||||
@@ -101,6 +99,10 @@ public enum Mixins implements IMixins {
|
||||
.addClientMixins("angelica.itemrenderer.MixinItemRenderer")
|
||||
.setApplyIf(() -> AngelicaConfig.optimizeInWorldItemRendering)),
|
||||
|
||||
ANGELICA_OPTIMIZE_GLALLOCATION(new MixinBuilder("Replace HashMap with fastutil Int2IntMap in GLAllocation")
|
||||
.setPhase(Phase.EARLY)
|
||||
.addClientMixins("angelica.optimizations.MixinGLAllocation")),
|
||||
|
||||
// Not compatible with the lwjgl debug callbacks, so disable if that's enabled
|
||||
ARCHAIC_SPLASH(new MixinBuilder()
|
||||
.setPhase(Phase.EARLY)
|
||||
@@ -438,16 +440,25 @@ public enum Mixins implements IMixins {
|
||||
"base.MixinMinecraft"
|
||||
))
|
||||
),
|
||||
MCPATCHER_FORGE_RENDERPASS(new MixinBuilder()
|
||||
MCPATCHER_FORGE_RENDERPASS_BASE(new MixinBuilder()
|
||||
.setPhase(Phase.EARLY)
|
||||
.setApplyIf(() -> NotFineConfig.renderPass)
|
||||
.addClientMixins(addPrefix("mcpatcherforge.",
|
||||
"renderpass.MixinEntityRenderer",
|
||||
"renderpass.MixinRenderBlocks",
|
||||
"renderpass.MixinRenderGlobal",
|
||||
"renderpass.MixinWorldRenderer"
|
||||
.addClientMixins(addPrefix("mcpatcherforge.renderpass.",
|
||||
"MixinEntityRenderer",
|
||||
"MixinRenderBlocks",
|
||||
"MixinWorldRenderer"
|
||||
))
|
||||
),
|
||||
MCPATCHER_FORGE_RENDERPASS_DISPLAYLIST(new MixinBuilder("RenderPass display list allocation increase")
|
||||
.setPhase(Phase.EARLY)
|
||||
.setApplyIf(() -> NotFineConfig.renderPass && !AngelicaConfig.enableSodium)
|
||||
.addClientMixins("mcpatcherforge.renderpass.MixinRenderGlobal_DisplayLists")
|
||||
),
|
||||
MCPATCHER_FORGE_RENDERPASS_FEATURES(new MixinBuilder("RenderPass rendering features")
|
||||
.setPhase(Phase.EARLY)
|
||||
.setApplyIf(() -> NotFineConfig.renderPass && !AngelicaConfig.enableSodium)
|
||||
.addClientMixins("mcpatcherforge.renderpass.MixinRenderGlobal_Features")
|
||||
),
|
||||
MCPATCHER_FORGE_CUSTOM_COLORS(new MixinBuilder()
|
||||
.setPhase(Phase.EARLY)
|
||||
.setApplyIf(() -> AngelicaConfig.enableMCPatcherForgeFeatures && MCPatcherForgeConfig.CustomColors.enabled)
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
package com.gtnewhorizons.angelica.utils;
|
||||
|
||||
import org.lwjgl.BufferUtils;
|
||||
|
||||
import java.nio.FloatBuffer;
|
||||
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAddress;
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAllocFloat;
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memCopy;
|
||||
|
||||
/**
|
||||
* Utility class for buffer operations in display list commands.
|
||||
*/
|
||||
public final class BufferUtil {
|
||||
private BufferUtil() {} // Prevent instantiation
|
||||
|
||||
/**
|
||||
* Creates a copy of a FloatBuffer.
|
||||
* The source buffer's position is preserved.
|
||||
*
|
||||
* @param src The source buffer to copy
|
||||
* @return A new FloatBuffer containing a copy of the data
|
||||
*/
|
||||
public static FloatBuffer copyBuffer(FloatBuffer src) {
|
||||
final FloatBuffer dst = BufferUtils.createFloatBuffer(src.remaining());
|
||||
final int pos = src.position();
|
||||
dst.put(src);
|
||||
dst.flip();
|
||||
src.position(pos);
|
||||
return dst;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a copy of a direct FloatBuffer using native memory.
|
||||
* Caller is responsible for freeing the returned buffer with memFree().
|
||||
*
|
||||
* @param src Direct FloatBuffer to copy (must be direct)
|
||||
* @return New direct FloatBuffer with copied data
|
||||
*/
|
||||
public static FloatBuffer copyDirectBuffer(FloatBuffer src) {
|
||||
final int count = src.remaining();
|
||||
final FloatBuffer dst = memAllocFloat(count);
|
||||
memCopy(memAddress(src), memAddress(dst), (long) count * Float.BYTES);
|
||||
return dst;
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,7 @@
|
||||
package jss.notfine.gui;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import jss.notfine.config.NotFineConfig;
|
||||
import jss.notfine.core.Settings;
|
||||
@@ -148,7 +148,7 @@ public class NotFineGameOptionPages {
|
||||
.build())
|
||||
.build());
|
||||
|
||||
if(AngelicaConfig.enableIris) {
|
||||
if(Iris.enabled) {
|
||||
final OptionImpl<GameSettings, Integer> maxShadowDistanceSlider = OptionImpl.createBuilder(int.class, vanillaOpts)
|
||||
.setName(I18n.format("options.iris.shadowDistance"))
|
||||
.setTooltip(I18n.format("options.iris.shadowDistance.sodium_tooltip"))
|
||||
@@ -190,8 +190,8 @@ public class NotFineGameOptionPages {
|
||||
.add(Settings.MODE_WATER.option)
|
||||
.add(Settings.DOWNFALL_DISTANCE.option)
|
||||
.add(Settings.MODE_VIGNETTE.option)
|
||||
.add(Settings.DYNAMIC_LIGHTS.option, AngelicaConfig.enableDynamicLights)
|
||||
.add(Settings.DYNAMIC_LIGHTS_SHADER_FORCE.option, AngelicaConfig.enableDynamicLights)
|
||||
.add(Settings.DYNAMIC_LIGHTS.option, DynamicLights.configEnabled)
|
||||
.add(Settings.DYNAMIC_LIGHTS_SHADER_FORCE.option, DynamicLights.configEnabled)
|
||||
.add(Settings.MODE_SHADOWS.option)
|
||||
.add(Settings.VOID_FOG.option)
|
||||
.add(Settings.MODE_DROPPED_ITEMS.option)
|
||||
|
||||
@@ -1,10 +1,6 @@
|
||||
package jss.notfine.render;
|
||||
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VBOManager;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import jss.notfine.core.Settings;
|
||||
import jss.util.RandomXoshiro256StarStar;
|
||||
import net.minecraft.client.renderer.RenderGlobal;
|
||||
@@ -16,18 +12,9 @@ public class RenderStars {
|
||||
//private static final ResourceLocation locationStarsPng = new ResourceLocation("textures/colormap/stars.png");
|
||||
|
||||
public static void reloadStarRenderList(RenderGlobal render) {
|
||||
|
||||
if(AngelicaConfig.enableVBO) {
|
||||
TessellatorManager.startCapturing();
|
||||
renderStars();
|
||||
VBOManager.registerVBO(render.starGLCallList, TessellatorManager.stopCapturingToVBO(DefaultVertexFormat.POSITION));
|
||||
} else {
|
||||
GL11.glPushMatrix();
|
||||
GL11.glNewList(render.starGLCallList, GL11.GL_COMPILE);
|
||||
renderStars();
|
||||
GL11.glEndList();
|
||||
GL11.glPopMatrix();
|
||||
}
|
||||
GL11.glNewList(render.starGLCallList, GL11.GL_COMPILE);
|
||||
renderStars();
|
||||
GL11.glEndList();
|
||||
}
|
||||
|
||||
public static void renderStars() {
|
||||
|
||||
+2
-1
@@ -4,6 +4,7 @@ import com.gtnewhorizons.angelica.client.gui.FontConfigScreen;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.Element;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import jss.notfine.gui.GuiCustomMenu;
|
||||
import net.coderbot.iris.Iris;
|
||||
import me.flashyreese.mods.reeses_sodium_options.client.gui.frame.AbstractFrame;
|
||||
import me.flashyreese.mods.reeses_sodium_options.client.gui.frame.BasicFrame;
|
||||
import me.flashyreese.mods.reeses_sodium_options.client.gui.frame.components.SearchTextFieldComponent;
|
||||
@@ -104,7 +105,7 @@ public class ReeseSodiumVideoOptionsScreen extends SodiumOptionsGUI {
|
||||
|
||||
int cumulativeXShift = 0;
|
||||
|
||||
if (AngelicaConfig.enableIris) {
|
||||
if (Iris.enabled) {
|
||||
//int size = this.client.textRenderer.getWidth(new TranslatableText(IrisApi.getInstance().getMainScreenLanguageKey()));
|
||||
final String irisText = I18n.format(IrisApi.getInstance().getMainScreenLanguageKey());
|
||||
final int size = this.mc.fontRenderer.getStringWidth(irisText);
|
||||
|
||||
@@ -2,6 +2,7 @@ package me.jellysquid.mods.sodium.client.gui;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import jss.notfine.core.Settings;
|
||||
import jss.notfine.core.SettingsManager;
|
||||
@@ -52,7 +53,7 @@ public class SodiumGameOptionPages {
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build());
|
||||
|
||||
if(AngelicaConfig.enableIris) {
|
||||
if(Iris.enabled) {
|
||||
final OptionImpl<GameSettings, Integer> maxShadowDistanceSlider = OptionImpl.createBuilder(int.class, vanillaOpts)
|
||||
.setName(I18n.format("options.iris.shadowDistance"))
|
||||
.setTooltip(I18n.format("options.iris.shadowDistance.sodium_tooltip"))
|
||||
@@ -264,8 +265,8 @@ public class SodiumGameOptionPages {
|
||||
)*/
|
||||
.add(Settings.MODE_SHADOWS.option)
|
||||
.add(Settings.MODE_VIGNETTE.option)
|
||||
.add(Settings.DYNAMIC_LIGHTS.option, AngelicaConfig.enableDynamicLights)
|
||||
.add(Settings.DYNAMIC_LIGHTS_SHADER_FORCE.option, AngelicaConfig.enableDynamicLights)
|
||||
.add(Settings.DYNAMIC_LIGHTS.option, DynamicLights.configEnabled)
|
||||
.add(Settings.DYNAMIC_LIGHTS_SHADER_FORCE.option, DynamicLights.configEnabled)
|
||||
.build());
|
||||
|
||||
|
||||
|
||||
@@ -4,7 +4,6 @@ import com.google.gson.FieldNamingPolicy;
|
||||
import com.google.gson.Gson;
|
||||
import com.google.gson.GsonBuilder;
|
||||
import com.google.gson.JsonSyntaxException;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import me.jellysquid.mods.sodium.client.SodiumClientMod;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.named.GraphicsQuality;
|
||||
import net.coderbot.iris.Iris;
|
||||
@@ -105,7 +104,7 @@ public class SodiumGameOptions {
|
||||
}
|
||||
|
||||
Files.write(this.configPath, GSON.toJson(this).getBytes(StandardCharsets.UTF_8));
|
||||
if(AngelicaConfig.enableIris) {
|
||||
if(Iris.enabled) {
|
||||
try {
|
||||
if (Iris.getIrisConfig() != null) {
|
||||
Iris.getIrisConfig().save();
|
||||
|
||||
@@ -4,8 +4,8 @@ import com.google.common.collect.ImmutableList;
|
||||
import com.gtnewhorizons.angelica.client.gui.ScrollableGuiScreen;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.Drawable;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.Element;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import jss.notfine.gui.GuiCustomMenu;
|
||||
import net.coderbot.iris.Iris;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.Option;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.OptionFlag;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.OptionGroup;
|
||||
@@ -61,14 +61,14 @@ public class SodiumOptionsGUI extends ScrollableGuiScreen {
|
||||
this.pages.add(SodiumGameOptionPages.advanced());
|
||||
this.pages.add(SodiumGameOptionPages.performance());
|
||||
|
||||
if (AngelicaConfig.enableIris) {
|
||||
if (Iris.enabled) {
|
||||
shaderPacks = new OptionPage(I18n.format("options.iris.shaderPackSelection"), ImmutableList.of());
|
||||
this.pages.add(shaderPacks);
|
||||
}
|
||||
}
|
||||
|
||||
public void setPage(OptionPage page) {
|
||||
if (AngelicaConfig.enableIris && page == shaderPacks) {
|
||||
if (Iris.enabled && page == shaderPacks) {
|
||||
mc.displayGuiScreen(new ShaderPackScreen(this));
|
||||
return;
|
||||
}
|
||||
|
||||
+2
-2
@@ -4,8 +4,8 @@ import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadView;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFlags;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import java.util.Arrays;
|
||||
import net.coderbot.iris.Iris;
|
||||
import me.jellysquid.mods.sodium.client.model.light.LightPipeline;
|
||||
import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess;
|
||||
import me.jellysquid.mods.sodium.client.model.light.data.QuadLightData;
|
||||
@@ -45,7 +45,7 @@ public class FlatLightPipeline implements LightPipeline {
|
||||
}
|
||||
|
||||
Arrays.fill(out.lm, lightmap);
|
||||
final float brightness = (AngelicaConfig.enableIris && BlockRenderingSettings.INSTANCE.shouldDisableDirectionalShading())
|
||||
final float brightness = (Iris.enabled && BlockRenderingSettings.INSTANCE.shouldDisableDirectionalShading())
|
||||
? 1.0F : this.lightCache.getWorld().getBrightness(face, shade);
|
||||
Arrays.fill(out.br, brightness);
|
||||
}
|
||||
|
||||
+2
-2
@@ -5,8 +5,8 @@ import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadView;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFlags;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import me.jellysquid.mods.sodium.client.model.light.LightPipeline;
|
||||
import net.coderbot.iris.Iris;
|
||||
import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess;
|
||||
import me.jellysquid.mods.sodium.client.model.light.data.QuadLightData;
|
||||
import net.coderbot.iris.block_rendering.BlockRenderingSettings;
|
||||
@@ -226,7 +226,7 @@ public class SmoothLightPipeline implements LightPipeline {
|
||||
}
|
||||
|
||||
private void applySidedBrightness(QuadLightData out, ModelQuadFacing face, boolean shade) {
|
||||
if(AngelicaConfig.enableIris && BlockRenderingSettings.INSTANCE.shouldDisableDirectionalShading()) {
|
||||
if(Iris.enabled && BlockRenderingSettings.INSTANCE.shouldDisableDirectionalShading()) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@@ -2,8 +2,8 @@ package me.jellysquid.mods.sodium.client.render;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.bytebuf.MemoryStack;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.MatrixStack;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.rendering.RenderingState;
|
||||
import net.coderbot.iris.Iris;
|
||||
import java.nio.FloatBuffer;
|
||||
import net.coderbot.iris.shadows.ShadowRenderingState;
|
||||
import org.joml.Matrix4f;
|
||||
@@ -18,7 +18,7 @@ public class GameRendererContext {
|
||||
*/
|
||||
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 projectionMatrix = (Iris.enabled && ShadowRenderingState.areShadowsCurrentlyBeingRendered()) ? ShadowRenderingState.getShadowOrthoMatrix() : RenderingState.INSTANCE.getProjectionMatrix();
|
||||
final Matrix4f matrix = new Matrix4f(projectionMatrix);
|
||||
matrix.mul(matrices.getModel());
|
||||
|
||||
|
||||
@@ -3,8 +3,8 @@ package me.jellysquid.mods.sodium.client.render;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.Camera;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.MatrixStack;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.RenderLayer;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
|
||||
import net.coderbot.iris.Iris;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.rendering.RenderingState;
|
||||
import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
|
||||
@@ -171,7 +171,7 @@ public class SodiumWorldRenderer {
|
||||
*/
|
||||
public void scheduleTerrainUpdate() {
|
||||
if (this.chunkRenderManager != null) {
|
||||
if(AngelicaConfig.enableIris) iris$ensureStateSwapped();
|
||||
if(Iris.enabled) iris$ensureStateSwapped();
|
||||
this.chunkRenderManager.markDirty();
|
||||
}
|
||||
}
|
||||
@@ -223,7 +223,7 @@ public class SodiumWorldRenderer {
|
||||
boolean dirty = pos.x != this.lastCameraX || pos.y != this.lastCameraY || pos.z != this.lastCameraZ ||
|
||||
pitch != this.lastCameraPitch || yaw != this.lastCameraYaw || fogDistance != this.lastFogDistance || fov != this.lastFov;
|
||||
|
||||
if(AngelicaConfig.enableIris) {
|
||||
if(Iris.enabled) {
|
||||
iris$ensureStateSwapped();
|
||||
if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) {
|
||||
dirty = true;
|
||||
@@ -258,7 +258,7 @@ public class SodiumWorldRenderer {
|
||||
profiler.endSection();
|
||||
|
||||
SodiumGameOptions.EntityRenderDistance.setRenderDistanceMult(MathHelper.clamp_double((double) this.client.gameSettings.renderDistanceChunks / 8.0D, 1.0D, 2.5D) * (double) 1.0F * (SettingsManager.entityRenderScaleFactor));
|
||||
if(AngelicaConfig.enableIris) {
|
||||
if(Iris.enabled) {
|
||||
if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) {
|
||||
ShadowRenderer.visibleTileEntities.addAll(this.chunkRenderManager.getVisibleTileEntities());
|
||||
ShadowRenderer.globalTileEntities.addAll(this.globalTileEntities);
|
||||
@@ -279,7 +279,7 @@ public class SodiumWorldRenderer {
|
||||
// or other factors as having clouds disabled.
|
||||
GLStateManager.enableCull();
|
||||
|
||||
if(AngelicaConfig.enableIris) iris$ensureStateSwapped();
|
||||
if(Iris.enabled) iris$ensureStateSwapped();
|
||||
// startDrawing/endDrawing are handled by 1.7 already
|
||||
// pass.startDrawing();
|
||||
|
||||
@@ -318,7 +318,7 @@ public class SodiumWorldRenderer {
|
||||
|
||||
final ChunkVertexType vertexFormat;
|
||||
|
||||
if(AngelicaConfig.enableIris && BlockRenderingSettings.INSTANCE.shouldUseExtendedVertexFormat()) {
|
||||
if(Iris.enabled && BlockRenderingSettings.INSTANCE.shouldUseExtendedVertexFormat()) {
|
||||
vertexFormat = IrisModelVertexFormats.MODEL_VERTEX_XHFP;
|
||||
} else if (opts.advanced.useCompactVertexFormat) {
|
||||
vertexFormat = DefaultModelVertexFormats.MODEL_VERTEX_HFP;
|
||||
@@ -358,7 +358,7 @@ public class SodiumWorldRenderer {
|
||||
return;
|
||||
|
||||
try {
|
||||
if(AngelicaConfig.enableIris) {
|
||||
if(Iris.enabled) {
|
||||
final Block block = tileEntity.getWorldObj().getBlock(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord);
|
||||
CapturedRenderingState.INSTANCE.setCurrentBlockEntity(Block.getIdFromBlock(block));
|
||||
GL20.glVertexAttrib2s(ProgramCreator.MC_ENTITY, (short)-1, (short)-1);
|
||||
@@ -376,7 +376,7 @@ public class SodiumWorldRenderer {
|
||||
}
|
||||
}
|
||||
finally {
|
||||
if(AngelicaConfig.enableIris) {
|
||||
if(Iris.enabled) {
|
||||
CapturedRenderingState.INSTANCE.setCurrentBlockEntity(-1);
|
||||
GbufferPrograms.endBlockEntities();
|
||||
}
|
||||
|
||||
@@ -3,8 +3,8 @@ package me.jellysquid.mods.sodium.client.render.chunk;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.Camera;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.ChunkPos;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.MatrixStack;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue;
|
||||
import net.coderbot.iris.Iris;
|
||||
import it.unimi.dsi.fastutil.ints.IntIterator;
|
||||
import it.unimi.dsi.fastutil.ints.IntList;
|
||||
import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
|
||||
@@ -152,7 +152,7 @@ public class ChunkRenderManager<T extends ChunkGraphicsState> implements ChunkSt
|
||||
|
||||
this.useBlockFaceCulling = SodiumClientMod.options().advanced.useBlockFaceCulling;
|
||||
|
||||
if(AngelicaConfig.enableIris) {
|
||||
if(Iris.enabled) {
|
||||
this.chunkRenderListsSwap = new ChunkRenderList[BlockRenderPass.COUNT];
|
||||
this.tickableChunksSwap = new ObjectArrayList<>();
|
||||
this.visibleTileEntitiesSwap = new ObjectArrayList<>();
|
||||
@@ -252,7 +252,7 @@ public class ChunkRenderManager<T extends ChunkGraphicsState> implements ChunkSt
|
||||
private void addChunk(ChunkRenderContainer<T> render) {
|
||||
boolean canRebuild = render.canRebuild();
|
||||
|
||||
if (AngelicaConfig.enableIris && ShadowRenderingState.areShadowsCurrentlyBeingRendered()) {
|
||||
if (Iris.enabled && ShadowRenderingState.areShadowsCurrentlyBeingRendered()) {
|
||||
canRebuild = false;
|
||||
}
|
||||
|
||||
@@ -307,7 +307,7 @@ public class ChunkRenderManager<T extends ChunkGraphicsState> implements ChunkSt
|
||||
}
|
||||
|
||||
private int computeVisibleFaces(ChunkRenderContainer<T> render) {
|
||||
if(AngelicaConfig.enableIris) {
|
||||
if(Iris.enabled) {
|
||||
// TODO: Enable chunk face culling during the shadow pass
|
||||
if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) {
|
||||
return(ChunkFaceFlags.ALL);
|
||||
@@ -366,9 +366,9 @@ public class ChunkRenderManager<T extends ChunkGraphicsState> implements ChunkSt
|
||||
}
|
||||
|
||||
private void reset() {
|
||||
if(!AngelicaConfig.enableIris || !ShadowRenderingState.areShadowsCurrentlyBeingRendered()) this.rebuildQueue.clear();
|
||||
if(!AngelicaConfig.enableIris || !ShadowRenderingState.areShadowsCurrentlyBeingRendered()) this.importantRebuildQueue.clear();
|
||||
if(!AngelicaConfig.enableIris || !ShadowRenderingState.areShadowsCurrentlyBeingRendered()) this.sortQueue.clear();
|
||||
if(!Iris.enabled || !ShadowRenderingState.areShadowsCurrentlyBeingRendered()) this.rebuildQueue.clear();
|
||||
if(!Iris.enabled || !ShadowRenderingState.areShadowsCurrentlyBeingRendered()) this.importantRebuildQueue.clear();
|
||||
if(!Iris.enabled || !ShadowRenderingState.areShadowsCurrentlyBeingRendered()) this.sortQueue.clear();
|
||||
|
||||
this.visibleTileEntities.clear();
|
||||
|
||||
@@ -510,7 +510,7 @@ public class ChunkRenderManager<T extends ChunkGraphicsState> implements ChunkSt
|
||||
|
||||
final RenderDevice device = RenderDevice.INSTANCE;
|
||||
final CommandList commandList = device.createCommandList();
|
||||
if(AngelicaConfig.enableIris) this.backend.iris$begin(matrixStack, pass);
|
||||
if(Iris.enabled) this.backend.iris$begin(matrixStack, pass);
|
||||
else this.backend.begin(matrixStack);
|
||||
|
||||
// Ensure multidraw regions are ordered appropriately
|
||||
@@ -534,7 +534,7 @@ public class ChunkRenderManager<T extends ChunkGraphicsState> implements ChunkSt
|
||||
}
|
||||
|
||||
public void updateChunks() {
|
||||
if (AngelicaConfig.enableIris && ShadowRenderingState.areShadowsCurrentlyBeingRendered()) return;
|
||||
if (Iris.enabled && ShadowRenderingState.areShadowsCurrentlyBeingRendered()) return;
|
||||
this.builder.cleanupSectionCache();
|
||||
|
||||
Deque<CompletableFuture<ChunkBuildResult<T>>> futures = new ArrayDeque<>();
|
||||
|
||||
+2
-2
@@ -1,8 +1,8 @@
|
||||
package me.jellysquid.mods.sodium.client.render.chunk.backends.multidraw;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import it.unimi.dsi.fastutil.objects.ObjectArrayFIFOQueue;
|
||||
import net.coderbot.iris.Iris;
|
||||
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.ArrayList;
|
||||
@@ -196,7 +196,7 @@ public class MultidrawChunkRenderBackend extends ChunkRenderShaderBackend<Multid
|
||||
}
|
||||
|
||||
private GlVertexAttributeBinding[] getBindings() {
|
||||
if(AngelicaConfig.enableIris && BlockRenderingSettings.INSTANCE.shouldUseExtendedVertexFormat()) {
|
||||
if(Iris.enabled && BlockRenderingSettings.INSTANCE.shouldUseExtendedVertexFormat()) {
|
||||
return new GlVertexAttributeBinding[] {
|
||||
new GlVertexAttributeBinding(ChunkShaderBindingPoints.POSITION, this.vertexFormat.getAttribute(ChunkMeshAttribute.POSITION)),
|
||||
new GlVertexAttributeBinding(ChunkShaderBindingPoints.COLOR, this.vertexFormat.getAttribute(ChunkMeshAttribute.COLOR)),
|
||||
|
||||
+2
-2
@@ -1,8 +1,8 @@
|
||||
package me.jellysquid.mods.sodium.client.render.chunk.backends.oneshot;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexAttributeBinding;
|
||||
import net.coderbot.iris.Iris;
|
||||
import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexFormat;
|
||||
import me.jellysquid.mods.sodium.client.gl.buffer.GlBufferUsage;
|
||||
import me.jellysquid.mods.sodium.client.gl.buffer.GlMutableBuffer;
|
||||
@@ -87,7 +87,7 @@ public class ChunkOneshotGraphicsState extends ChunkGraphicsState {
|
||||
}
|
||||
|
||||
private GlVertexAttributeBinding[] getBindings(GlVertexFormat<ChunkMeshAttribute> vertexFormat) {
|
||||
if(AngelicaConfig.enableIris && BlockRenderingSettings.INSTANCE.shouldUseExtendedVertexFormat()) {
|
||||
if(Iris.enabled && BlockRenderingSettings.INSTANCE.shouldUseExtendedVertexFormat()) {
|
||||
return new GlVertexAttributeBinding[] {
|
||||
new GlVertexAttributeBinding(ChunkShaderBindingPoints.POSITION, vertexFormat.getAttribute(ChunkMeshAttribute.POSITION)),
|
||||
new GlVertexAttributeBinding(ChunkShaderBindingPoints.COLOR, vertexFormat.getAttribute(ChunkMeshAttribute.COLOR)),
|
||||
|
||||
+6
-6
@@ -1,8 +1,8 @@
|
||||
package me.jellysquid.mods.sodium.client.render.chunk.compile;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import it.unimi.dsi.fastutil.objects.Object2IntMap;
|
||||
import net.coderbot.iris.Iris;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.Map;
|
||||
import lombok.Getter;
|
||||
@@ -59,7 +59,7 @@ public class ChunkBuildBuffers implements ChunkBuildBuffersExt {
|
||||
}
|
||||
}
|
||||
|
||||
if(AngelicaConfig.enableIris) {
|
||||
if(Iris.enabled) {
|
||||
final Object2IntMap<Block> blockMatches = BlockRenderingSettings.INSTANCE.getBlockMatches();
|
||||
|
||||
if (blockMatches != null) {
|
||||
@@ -76,7 +76,7 @@ public class ChunkBuildBuffers implements ChunkBuildBuffersExt {
|
||||
|
||||
for (ModelQuadFacing facing : ModelQuadFacing.VALUES) {
|
||||
final ModelVertexSink sink = this.vertexType.createBufferWriter(this.buffersByLayer[i][facing.ordinal()], SodiumClientMod.isDirectMemoryAccessEnabled());
|
||||
if (AngelicaConfig.enableIris && sink instanceof ContextAwareVertexWriter) {
|
||||
if (Iris.enabled && sink instanceof ContextAwareVertexWriter) {
|
||||
((ContextAwareVertexWriter) sink).iris$setContextHolder(iris$contextHolder);
|
||||
}
|
||||
writers[facing.ordinal()] = new ChunkModelVertexTransformer(sink, this.offset);
|
||||
@@ -156,17 +156,17 @@ public class ChunkBuildBuffers implements ChunkBuildBuffersExt {
|
||||
|
||||
// Iris Compat
|
||||
public void iris$setLocalPos(int localPosX, int localPosY, int localPosZ) {
|
||||
if(!AngelicaConfig.enableIris) return;
|
||||
if(!Iris.enabled) return;
|
||||
this.iris$contextHolder.setLocalPos(localPosX, localPosY, localPosZ);
|
||||
}
|
||||
|
||||
public void iris$setMaterialId(Block block, short renderType) {
|
||||
if(!AngelicaConfig.enableIris) return;
|
||||
if(!Iris.enabled) return;
|
||||
this.iris$contextHolder.set(block, renderType);
|
||||
}
|
||||
|
||||
public void iris$resetBlockContext() {
|
||||
if(!AngelicaConfig.enableIris) return;
|
||||
if(!Iris.enabled) return;
|
||||
this.iris$contextHolder.reset();
|
||||
}
|
||||
}
|
||||
+6
-7
@@ -1,7 +1,6 @@
|
||||
package me.jellysquid.mods.sodium.client.render.chunk.shader;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.MatrixStack;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexFormat;
|
||||
import me.jellysquid.mods.sodium.client.gl.compat.FogHelper;
|
||||
@@ -52,7 +51,7 @@ public abstract class ChunkRenderShaderBackend<T extends ChunkGraphicsState> imp
|
||||
private ChunkProgram override;
|
||||
|
||||
public ChunkRenderShaderBackend(ChunkVertexType vertexType) {
|
||||
if (AngelicaConfig.enableIris) {
|
||||
if (Iris.enabled) {
|
||||
irisChunkProgramOverrides = new IrisChunkProgramOverrides();
|
||||
}
|
||||
|
||||
@@ -61,7 +60,7 @@ public abstract class ChunkRenderShaderBackend<T extends ChunkGraphicsState> imp
|
||||
}
|
||||
|
||||
public GlShader loadShaderRedirect(RenderDevice device, ShaderType type, ResourceLocation name, List<String> constants) {
|
||||
if (AngelicaConfig.enableIris && this.vertexType == IrisModelVertexFormats.MODEL_VERTEX_XHFP) {
|
||||
if (Iris.enabled && this.vertexType == IrisModelVertexFormats.MODEL_VERTEX_XHFP) {
|
||||
String shader = getShaderSource(ShaderLoader.getShaderPath(name, type));
|
||||
shader = shader.replace("v_LightCoord = a_LightCoord", "v_LightCoord = (iris_LightmapTextureMatrix * vec4(a_LightCoord, 0, 1)).xy");
|
||||
|
||||
@@ -78,7 +77,7 @@ public abstract class ChunkRenderShaderBackend<T extends ChunkGraphicsState> imp
|
||||
}
|
||||
|
||||
private ChunkProgram createShader(RenderDevice device, ChunkFogMode fogMode, GlVertexFormat<ChunkMeshAttribute> vertexFormat) {
|
||||
if(AngelicaConfig.enableIris) {
|
||||
if(Iris.enabled) {
|
||||
this.device = device;
|
||||
WorldRenderingPipeline worldRenderingPipeline = Iris.getPipelineManager().getPipelineNullable();
|
||||
SodiumTerrainPipeline sodiumTerrainPipeline = null;
|
||||
@@ -159,7 +158,7 @@ public abstract class ChunkRenderShaderBackend<T extends ChunkGraphicsState> imp
|
||||
@Override
|
||||
public void begin(MatrixStack matrixStack) {
|
||||
this.activeProgram = this.programs.get(FogHelper.getFogMode());
|
||||
if (AngelicaConfig.enableIris && override != null) {
|
||||
if (Iris.enabled && override != null) {
|
||||
this.activeProgram = override;
|
||||
}
|
||||
this.activeProgram.bind();
|
||||
@@ -170,7 +169,7 @@ public abstract class ChunkRenderShaderBackend<T extends ChunkGraphicsState> imp
|
||||
public void end(MatrixStack matrixStack) {
|
||||
this.activeProgram.unbind();
|
||||
this.activeProgram = null;
|
||||
if(AngelicaConfig.enableIris) {
|
||||
if(Iris.enabled) {
|
||||
ProgramUniforms.clearActiveUniforms();
|
||||
ProgramSamplers.clearActiveSamplers();
|
||||
Iris.getPipelineManager().getPipeline().ifPresent(WorldRenderingPipeline::endSodiumTerrainRendering);
|
||||
@@ -179,7 +178,7 @@ public abstract class ChunkRenderShaderBackend<T extends ChunkGraphicsState> imp
|
||||
|
||||
@Override
|
||||
public void delete() {
|
||||
if(AngelicaConfig.enableIris) {
|
||||
if(Iris.enabled) {
|
||||
irisChunkProgramOverrides.deleteShaders();
|
||||
}
|
||||
for (ChunkProgram shader : this.programs.values()) {
|
||||
|
||||
+9
-8
@@ -6,6 +6,7 @@ import com.gtnewhorizons.angelica.compat.mojang.ChunkOcclusionDataBuilder;
|
||||
import com.gtnewhorizons.angelica.compat.toremove.RenderLayer;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.ITexturesCache;
|
||||
import net.coderbot.iris.Iris;
|
||||
import com.gtnewhorizons.angelica.rendering.AngelicaBlockSafetyRegistry;
|
||||
import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue;
|
||||
import com.gtnewhorizons.angelica.utils.AnimationsRenderUtils;
|
||||
@@ -217,7 +218,7 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
pos.set(baseX + relX, baseY + relY, baseZ + relZ);
|
||||
buffers.setRenderOffset(pos.x - renderOffset.getX(), pos.y - renderOffset.getY(), pos.z - renderOffset.getZ());
|
||||
|
||||
if(AngelicaConfig.enableIris) buffers.iris$setLocalPos(relX, relY, relZ);
|
||||
if(Iris.enabled) buffers.iris$setLocalPos(relX, relY, relZ);
|
||||
|
||||
if (rendersOffThread(block)) {
|
||||
// Do regular block rendering
|
||||
@@ -226,14 +227,14 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
if (ModStatus.isFluidLoggedLoaded) {
|
||||
if (fluid != null && canRenderInPass(fluid.getBlock(), pass)) {
|
||||
ChunkRenderManager.setWorldRenderPass(pass);
|
||||
if(AngelicaConfig.enableIris) buffers.iris$setMaterialId(fluid.getBlock(), ExtendedDataHelper.FLUID_RENDER_TYPE);
|
||||
if(Iris.enabled) buffers.iris$setMaterialId(fluid.getBlock(), ExtendedDataHelper.FLUID_RENDER_TYPE);
|
||||
|
||||
cache.getBlockRenderer().renderFluidLogged(cache.getWorldSlice(), fluid, renderBlocks, pos, buffers.get(pass), seed);
|
||||
}
|
||||
}
|
||||
if (canRenderInPass(block, pass) && !shouldUseSodiumFluidRendering(block)) {
|
||||
ChunkRenderManager.setWorldRenderPass(pass);
|
||||
if(AngelicaConfig.enableIris) buffers.iris$setMaterialId(block, ExtendedDataHelper.BLOCK_RENDER_TYPE);
|
||||
if(Iris.enabled) buffers.iris$setMaterialId(block, ExtendedDataHelper.BLOCK_RENDER_TYPE);
|
||||
|
||||
if (cache.getBlockRenderer().renderModel(cache.getWorldSlice(), renderBlocks, block, meta, pos, buffers.get(pass), true, seed)) {
|
||||
bounds.addBlock(relX, relY, relZ);
|
||||
@@ -251,7 +252,7 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
for (BlockRenderPass pass : BlockRenderPass.VALUES) {
|
||||
if (canRenderInPass(block, pass)) {
|
||||
ChunkRenderManager.setWorldRenderPass(pass);
|
||||
if(AngelicaConfig.enableIris) buffers.iris$setMaterialId(block, ExtendedDataHelper.FLUID_RENDER_TYPE);
|
||||
if(Iris.enabled) buffers.iris$setMaterialId(block, ExtendedDataHelper.FLUID_RENDER_TYPE);
|
||||
|
||||
if (cache.getFluidRenderer().render(slice, cache.getWorldSlice(), block, pos, buffers.get(pass))) {
|
||||
bounds.addBlock(relX, relY, relZ);
|
||||
@@ -260,7 +261,7 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
}
|
||||
}
|
||||
|
||||
if(AngelicaConfig.enableIris) buffers.iris$resetBlockContext();
|
||||
if(Iris.enabled) buffers.iris$resetBlockContext();
|
||||
|
||||
if (block.hasTileEntity(meta)) {
|
||||
final TileEntity entity = slice.getTileEntity(pos.x, pos.y, pos.z);
|
||||
@@ -355,14 +356,14 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
final int meta = slice.getBlockMetadataRelative(relX + 16, relY + 16, relZ + 16);
|
||||
|
||||
buffers.setRenderOffset(pos.x - renderOffset.getX(), pos.y - renderOffset.getY(), pos.z - renderOffset.getZ());
|
||||
if(AngelicaConfig.enableIris) buffers.iris$setLocalPos(relX, relY, relZ);
|
||||
if(Iris.enabled) buffers.iris$setLocalPos(relX, relY, relZ);
|
||||
|
||||
// Do regular block rendering
|
||||
for (BlockRenderPass pass : BlockRenderPass.VALUES) {
|
||||
if (canRenderInPass(block, pass) && !shouldUseSodiumFluidRendering(block)) {
|
||||
ChunkRenderManager.setWorldRenderPass(pass);
|
||||
final long seed = MathUtil.hashPos(pos.x, pos.y, pos.z);
|
||||
if(AngelicaConfig.enableIris) buffers.iris$setMaterialId(block, ExtendedDataHelper.BLOCK_RENDER_TYPE);
|
||||
if(Iris.enabled) buffers.iris$setMaterialId(block, ExtendedDataHelper.BLOCK_RENDER_TYPE);
|
||||
|
||||
if (cache.getBlockRenderer().renderModel(slice.getWorld(), rb, block, meta, pos, buffers.get(pass), true, seed)) {
|
||||
bounds.addBlock(relX, relY, relZ);
|
||||
@@ -370,7 +371,7 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
|
||||
}
|
||||
}
|
||||
|
||||
if(AngelicaConfig.enableIris) buffers.iris$resetBlockContext();
|
||||
if(Iris.enabled) buffers.iris$resetBlockContext();
|
||||
}
|
||||
|
||||
if(rb instanceof ITexturesCache) {
|
||||
|
||||
@@ -9,8 +9,8 @@ import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadViewMuta
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadOrientation;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.util.ModelQuadUtil;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import java.util.List;
|
||||
import net.coderbot.iris.Iris;
|
||||
import java.util.Random;
|
||||
import me.jellysquid.mods.sodium.client.SodiumClientMod;
|
||||
import me.jellysquid.mods.sodium.client.model.light.LightMode;
|
||||
@@ -97,7 +97,7 @@ public class BlockRenderer {
|
||||
|
||||
boolean rendered = false;
|
||||
|
||||
this.useSeparateAo = AngelicaConfig.enableIris && BlockRenderingSettings.INSTANCE.shouldUseSeparateAo();
|
||||
this.useSeparateAo = Iris.enabled && BlockRenderingSettings.INSTANCE.shouldUseSeparateAo();
|
||||
final int emitted = block.getLightValue(world, pos.x, pos.y, pos.z);
|
||||
|
||||
try {
|
||||
|
||||
@@ -14,8 +14,8 @@ import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadView;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadViewMutable;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFlags;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import java.util.Arrays;
|
||||
import net.coderbot.iris.Iris;
|
||||
import me.jellysquid.mods.sodium.client.model.light.LightMode;
|
||||
import me.jellysquid.mods.sodium.client.model.light.LightPipeline;
|
||||
import me.jellysquid.mods.sodium.client.model.light.LightPipelineProvider;
|
||||
@@ -89,7 +89,7 @@ public class FluidRenderer {
|
||||
}
|
||||
|
||||
public boolean render(IBlockAccess world, WorldSlice slice, Block block, BlockPos pos, ChunkModelBuffers buffers) {
|
||||
this.useSeparateAo = AngelicaConfig.enableIris && BlockRenderingSettings.INSTANCE.shouldUseSeparateAo();
|
||||
this.useSeparateAo = Iris.enabled && BlockRenderingSettings.INSTANCE.shouldUseSeparateAo();
|
||||
|
||||
int posX = pos.x;
|
||||
int posY = pos.y;
|
||||
|
||||
@@ -71,6 +71,9 @@ public class Iris {
|
||||
|
||||
public static final IrisLogging logger = new IrisLogging(MODNAME);
|
||||
|
||||
// Cached at class load - config must be loaded before Iris. Do not change at runtime.
|
||||
public static final boolean enabled = AngelicaConfig.enableIris;
|
||||
|
||||
private static Path shaderpacksDirectory;
|
||||
private static ShaderpackDirectoryManager shaderpacksDirectoryManager;
|
||||
|
||||
@@ -103,7 +106,9 @@ public class Iris {
|
||||
public static Iris INSTANCE = new Iris();
|
||||
|
||||
private Iris() {
|
||||
isDevelopmentEnvironment = (boolean) Launch.blackboard.get("fml.deobfuscatedEnvironment");
|
||||
// Guard against null blackboard in test environments
|
||||
final Object deobfEnv = Launch.blackboard != null ? Launch.blackboard.get("fml.deobfuscatedEnvironment") : null;
|
||||
isDevelopmentEnvironment = deobfEnv != null && (boolean) deobfEnv;
|
||||
}
|
||||
|
||||
@SubscribeEvent
|
||||
@@ -663,7 +668,7 @@ public class Iris {
|
||||
}
|
||||
|
||||
public static void setShaderMaterialOverride(Block block, int meta) {
|
||||
if (!AngelicaConfig.enableIris)
|
||||
if (!enabled)
|
||||
return;
|
||||
|
||||
int blockId = getShaderMaterialOverrideId(block, meta);
|
||||
@@ -673,7 +678,7 @@ public class Iris {
|
||||
}
|
||||
|
||||
public static void resetShaderMaterialOverride() {
|
||||
if (!AngelicaConfig.enableIris)
|
||||
if (!enabled)
|
||||
return;
|
||||
if (TessellatorManager.get() instanceof CapturingTessellator tess)
|
||||
tess.setShaderBlockId(-1);
|
||||
|
||||
@@ -54,10 +54,7 @@ public class BlendModeStorage {
|
||||
}
|
||||
|
||||
public static void deferBlendFunc(int srcRgb, int dstRgb, int srcAlpha, int dstAlpha) {
|
||||
originalBlend.setSrcRgb(srcRgb);
|
||||
originalBlend.setDstRgb(dstRgb);
|
||||
originalBlend.setSrcAlpha(srcAlpha);
|
||||
originalBlend.setDstAlpha(dstAlpha);
|
||||
originalBlend.setAll(srcRgb, dstRgb, srcAlpha, dstAlpha);
|
||||
}
|
||||
|
||||
public static void restoreBlend() {
|
||||
|
||||
Reference in new issue
Block a user