mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-16 10:45:09 +00:00
Compare commits
57
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
f5c9fa3301 | ||
|
|
d6a6d3b525 | ||
|
|
f079bed977 | ||
|
|
c9ec40e94b | ||
|
|
8380f3853d | ||
|
|
534ae6b05c | ||
|
|
68d523d3df | ||
|
|
2f22a7b3ad | ||
|
|
7b79b90dd6 | ||
|
|
417f23f826 | ||
|
|
ca3c46c873 | ||
|
|
82fa9ade2b | ||
|
|
aaab8fd0bc | ||
|
|
bd56ccc4b8 | ||
|
|
e17f60308d | ||
|
|
1dd98978ad | ||
|
|
dae986eb0b | ||
|
|
5fdf84edd0 | ||
|
|
b19d023c11 | ||
|
|
41eafbd151 | ||
|
|
dd970b4c6a | ||
|
|
f79ad7f22a | ||
|
|
6947ffa3e2 | ||
|
|
969d2c3710 | ||
|
|
c5988d29c3 | ||
|
|
dc68c2c265 | ||
|
|
51533a81ec | ||
|
|
90eabb5d40 | ||
|
|
74843cb1f9 | ||
|
|
5e0344a529 | ||
|
|
3cdd934987 | ||
|
|
9d90ff137c | ||
|
|
bee9541797 | ||
|
|
b75a5d8f7d | ||
|
|
8d3ab41c53 | ||
|
|
48d032e654 | ||
|
|
1968914582 | ||
|
|
a70bd76ff3 | ||
|
|
db919b5f37 | ||
|
|
cde47ea423 | ||
|
|
5ef6cb11c0 | ||
|
|
b7015bf10e | ||
|
|
46602ab921 | ||
|
|
63e9fa0df1 | ||
|
|
dcea970a77 | ||
|
|
b29240d6da | ||
|
|
9d5a02ed21 | ||
|
|
b454483aae | ||
|
|
72b13543c6 | ||
|
|
36d98fcb22 | ||
|
|
44c5b9617a | ||
|
|
f3f1677db8 | ||
|
|
d396b611ad | ||
|
|
08f4c0f9db | ||
|
|
50b0d22dc2 | ||
|
|
7fed54264e | ||
|
|
be87401be6 |
No files matched your search
+7
-6
@@ -71,9 +71,10 @@ dependencies {
|
||||
|
||||
// Iris Shaders
|
||||
compileOnly('org.jetbrains:annotations:26.0.2')
|
||||
api("com.github.GTNewHorizons:GTNHLib:0.9.0:dev")
|
||||
api("com.github.GTNewHorizons:GTNHLib:0.9.10:dev")
|
||||
|
||||
shadowImplementation("org.anarres:jcpp:1.4.14") // Apache 2.0
|
||||
shadowImplementation("org.taumc:glsl-transformation-lib:0.2.0-25.g3a943bb") {
|
||||
shadowImplementation("org.taumc:glsl-transformation-lib:0.2.0-26.g5ee7d96-GTNH") {
|
||||
exclude module: "antlr4" // we only want to shadow the runtime module
|
||||
}
|
||||
shadowImplementation("org.antlr:antlr4-runtime:4.13.2")
|
||||
@@ -107,14 +108,14 @@ dependencies {
|
||||
|
||||
compileOnly("curse.maven:minefactory-reloaded-66672:2277486")
|
||||
|
||||
compileOnly("com.github.GTNewHorizons:NotEnoughIds:2.1.10:dev") // Mixin Version
|
||||
compileOnly("com.github.GTNewHorizons:NotEnoughIds-Legacy:1.4.7:dev") // ASM Version
|
||||
compileOnly("com.github.GTNewHorizons:NotEnoughIds:2.1.10:dev")
|
||||
|
||||
compileOnly(rfg.deobf("curse.maven:ntm-space-1121235:6974420"))
|
||||
compileOnly(rfg.deobf("maven.modrinth:ntmspace:X5593_H261"))
|
||||
|
||||
compileOnly(rfg.deobf("curse.maven:campfirebackport-387444:4611675"))
|
||||
compileOnly(rfg.deobf("curse.maven:xaeros-minimap-263420:5060684"))
|
||||
compileOnly(rfg.deobf("curse.maven:security-craft-64760:2818228"))
|
||||
compileOnly(rfg.deobf("curse.maven:et-futurum-requiem-441392:5873837"))
|
||||
|
||||
// runtimeOnlyNonPublishable("com.github.GTNewHorizons:CoreTweaks:0.3.3.6-GTNH")
|
||||
// For testing alternative splash screens, can be sourced from https://github.com/MalTeeez/ModernSplash/releases
|
||||
@@ -124,7 +125,7 @@ dependencies {
|
||||
transformedMod("net.industrial-craft:industrialcraft-2:2.2.828-experimental:dev")
|
||||
|
||||
// Better Crashes
|
||||
compileOnly("com.github.GTNewHorizons:BetterCrashes:1.4.0-GTNH:dev")
|
||||
compileOnly("com.github.GTNewHorizons:BetterCrashes:1.4.1-GTNH:dev")
|
||||
|
||||
afterEvaluate {
|
||||
dependencies {
|
||||
|
||||
+1
-1
@@ -16,5 +16,5 @@ pluginManagement {
|
||||
}
|
||||
|
||||
plugins {
|
||||
id("com.gtnewhorizons.gtnhsettingsconvention") version("2.0.13")
|
||||
id("com.gtnewhorizons.gtnhsettingsconvention") version("2.0.19")
|
||||
}
|
||||
@@ -1,19 +1,21 @@
|
||||
package com.gtnewhorizons.angelica;
|
||||
|
||||
import static com.gtnewhorizons.angelica.AngelicaMod.MOD_ID;
|
||||
|
||||
import com.gtnewhorizons.angelica.common.BlockError;
|
||||
import com.gtnewhorizons.angelica.compat.ModStatus;
|
||||
import com.gtnewhorizons.angelica.config.ConfigMigrator;
|
||||
import com.gtnewhorizons.angelica.proxy.CommonProxy;
|
||||
import com.gtnewhorizons.angelica.utils.AnimationMode;
|
||||
import com.gtnewhorizons.angelica.utils.ManagedEnum;
|
||||
import cpw.mods.fml.common.Mod;
|
||||
import cpw.mods.fml.common.SidedProxy;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import cpw.mods.fml.common.event.FMLInitializationEvent;
|
||||
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
|
||||
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
|
||||
import me.jellysquid.mods.sodium.client.gui.SodiumGameOptions;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
|
||||
import static com.gtnewhorizons.angelica.AngelicaMod.MOD_ID;
|
||||
|
||||
@Mod(
|
||||
modid = MOD_ID,
|
||||
@@ -33,6 +35,15 @@ public class AngelicaMod {
|
||||
public static final String MOD_ID = "angelica";
|
||||
public static final Logger LOGGER = LogManager.getLogger("Angelica");
|
||||
|
||||
private static SodiumGameOptions CONFIG;
|
||||
|
||||
public static SodiumGameOptions options() {
|
||||
if (CONFIG == null) {
|
||||
CONFIG = SodiumGameOptions.load(ConfigMigrator.handleConfigMigration("angelica-options.json"));
|
||||
}
|
||||
return CONFIG;
|
||||
}
|
||||
|
||||
@SidedProxy(clientSide = "com.gtnewhorizons.angelica.proxy.ClientProxy", serverSide = "com.gtnewhorizons.angelica.proxy.CommonProxy")
|
||||
public static CommonProxy proxy;
|
||||
|
||||
|
||||
@@ -75,11 +75,9 @@ public class BatchingFontRenderer {
|
||||
}
|
||||
}
|
||||
|
||||
public BatchingFontRenderer(FontRenderer underlying, int[] charWidth, byte[] glyphWidth,
|
||||
int[] colorCode, ResourceLocation locationFontTexture) {
|
||||
public BatchingFontRenderer(FontRenderer underlying, int[] charWidth, int[] colorCode, ResourceLocation locationFontTexture) {
|
||||
this.underlying = underlying;
|
||||
this.charWidth = charWidth;
|
||||
this.glyphWidth = glyphWidth;
|
||||
this.colorCode = colorCode;
|
||||
this.locationFontTexture = locationFontTexture;
|
||||
|
||||
@@ -92,7 +90,6 @@ public class BatchingFontRenderer {
|
||||
|
||||
FontProviderMC.get(this.isSGA).charWidth = this.charWidth;
|
||||
FontProviderMC.get(this.isSGA).locationFontTexture = this.locationFontTexture;
|
||||
FontProviderUnicode.get().glyphWidth = this.glyphWidth;
|
||||
|
||||
//noinspection deprecation
|
||||
fontShaderId = FontAAShader.getProgram().getProgramId();
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
package com.gtnewhorizons.angelica.client.font;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.config.ConfigurationManager;
|
||||
import com.gtnewhorizons.angelica.config.FontConfig;
|
||||
import lombok.Setter;
|
||||
import lombok.Value;
|
||||
@@ -46,7 +45,7 @@ public final class FontProviderCustom implements FontProvider {
|
||||
default -> null;
|
||||
};
|
||||
if (Objects.equals(myFontName, "(none)")) {
|
||||
font = null;
|
||||
this.font = null;
|
||||
return;
|
||||
}
|
||||
int fontPos = -1;
|
||||
@@ -58,10 +57,10 @@ public final class FontProviderCustom implements FontProvider {
|
||||
}
|
||||
if (fontPos == -1) {
|
||||
LOGGER.info("Could not find previously set font \"{}\". ", myFontName);
|
||||
font = null;
|
||||
this.font = null;
|
||||
return;
|
||||
}
|
||||
font = availableFonts[fontPos].deriveFont(currentFontQuality);
|
||||
this.font = availableFonts[fontPos].deriveFont(this.currentFontQuality);
|
||||
}
|
||||
private static class InstLoader {
|
||||
static final FontProviderCustom instance0 = new FontProviderCustom((byte)0);
|
||||
@@ -71,8 +70,8 @@ public final class FontProviderCustom implements FontProvider {
|
||||
public static FontProviderCustom getFallback() { return InstLoader.instance1; }
|
||||
|
||||
public void reloadFont(int fontID) {
|
||||
currentFontQuality = FontConfig.customFontQuality;
|
||||
font = FontStrategist.getAvailableFonts()[fontID].deriveFont(currentFontQuality);
|
||||
this.currentFontQuality = FontConfig.customFontQuality;
|
||||
this.font = FontStrategist.getAvailableFonts()[fontID].deriveFont(this.currentFontQuality);
|
||||
|
||||
File[] files = new File(getFontDir()).listFiles();
|
||||
if (files != null) {
|
||||
@@ -94,7 +93,7 @@ public final class FontProviderCustom implements FontProvider {
|
||||
}
|
||||
}
|
||||
|
||||
fontAtlases = new FontAtlas[ATLAS_COUNT];
|
||||
this.fontAtlases = new FontAtlas[ATLAS_COUNT];
|
||||
}
|
||||
|
||||
private String getFontDir() {
|
||||
@@ -134,50 +133,44 @@ public final class FontProviderCustom implements FontProvider {
|
||||
}
|
||||
|
||||
void construct(Font font) {
|
||||
float separator = currentFontQuality / 3f;
|
||||
int atlasChars = 0;
|
||||
for (int i = 0; i < ATLAS_SIZE; i++) {
|
||||
final char ch = (char) (i + ATLAS_SIZE * this.id);
|
||||
if (font.canDisplay(ch)) { atlasChars++; }
|
||||
}
|
||||
if (atlasChars == 0) { return; }
|
||||
|
||||
BufferedImage image = new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB);
|
||||
Graphics2D g2d = image.createGraphics();
|
||||
g2d.setFont(font);
|
||||
FontMetrics fm = g2d.getFontMetrics();
|
||||
g2d.dispose();
|
||||
int width = 0;
|
||||
int actualChars = 0;
|
||||
for (int i = 0; i < ATLAS_SIZE; i++) {
|
||||
final char ch = (char)(i + ATLAS_SIZE * this.id);
|
||||
if (font.canDisplay(ch)) {
|
||||
width += (int) (separator + fm.charWidth(ch));
|
||||
actualChars++;
|
||||
}
|
||||
}
|
||||
if (actualChars == 0) {
|
||||
return;
|
||||
}
|
||||
final int atlasTilesX = (int) Math.ceil(Math.sqrt(actualChars) * 1.5f);
|
||||
final int atlasTilesY = (int) Math.ceil((double) actualChars / atlasTilesX);
|
||||
LOGGER.info("constructing custom font atlas (ID {}) of nominal size {} chars, actual: {}, {} rows by {} columns",
|
||||
this.id, ATLAS_SIZE, actualChars, atlasTilesX, atlasTilesY);
|
||||
width = 0;
|
||||
actualChars = 0;
|
||||
|
||||
final int atlasTilesX = (int) Math.ceil(Math.sqrt(atlasChars) * 1.5f);
|
||||
final int atlasTilesY = (int) Math.ceil((double) atlasChars / atlasTilesX);
|
||||
final float charSeparator = currentFontQuality / 3f;
|
||||
int rowWidth = 0;
|
||||
int maxRowWidth = 0;
|
||||
atlasChars = 0;
|
||||
|
||||
for (int i = 0; i < ATLAS_SIZE; i++) {
|
||||
if (actualChars % atlasTilesX == 0) {
|
||||
maxRowWidth = Math.max(maxRowWidth, width);
|
||||
width = 0;
|
||||
if (atlasChars % atlasTilesX == 0) {
|
||||
maxRowWidth = Math.max(maxRowWidth, rowWidth);
|
||||
rowWidth = 0;
|
||||
}
|
||||
final char ch = (char)(i + ATLAS_SIZE * this.id);
|
||||
if (font.canDisplay(ch)) {
|
||||
width += (int) (separator + fm.charWidth(ch));
|
||||
actualChars++;
|
||||
rowWidth += (int) (charSeparator + fm.charWidth(ch));
|
||||
atlasChars++;
|
||||
}
|
||||
}
|
||||
maxRowWidth = Math.max(maxRowWidth, width);
|
||||
maxRowWidth = Math.max(maxRowWidth, rowWidth);
|
||||
|
||||
final int lineHeight = fm.getHeight();
|
||||
final float desc = fm.getDescent();
|
||||
|
||||
final int imageWidth = (int) (maxRowWidth + separator);
|
||||
final int imageHeight = (int) ((separator + lineHeight) * atlasTilesY + separator);
|
||||
final int imageWidth = (int) (maxRowWidth + charSeparator);
|
||||
final int imageHeight = (int) ((charSeparator + lineHeight) * atlasTilesY + charSeparator);
|
||||
|
||||
image = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_ARGB);
|
||||
g2d = image.createGraphics();
|
||||
@@ -192,35 +185,34 @@ public final class FontProviderCustom implements FontProvider {
|
||||
fm = g2d.getFontMetrics();
|
||||
|
||||
int tileX = 0, tileY = 0; // position in atlas tiles
|
||||
int imgX = (int) separator; // position in pixels
|
||||
int imgX = (int) charSeparator; // position in pixels
|
||||
|
||||
for (int i = 0; i < ATLAS_SIZE; i++) {
|
||||
final char ch = (char)(i + ATLAS_SIZE * this.id);
|
||||
final char ch = (char) (i + ATLAS_SIZE * this.id);
|
||||
if (!font.canDisplay(ch)) { continue; }
|
||||
|
||||
if (tileX >= atlasTilesX) {
|
||||
tileX = 0;
|
||||
imgX = (int) separator;
|
||||
imgX = (int) charSeparator;
|
||||
tileY++;
|
||||
}
|
||||
|
||||
final int charWidth = fm.charWidth(ch);
|
||||
final float charAspectRatio = (float) charWidth / lineHeight;
|
||||
final float inset = currentFontQuality / 16;
|
||||
g2d.drawString(Character.toString(ch), imgX, (lineHeight + separator) * (tileY + 1) - desc);
|
||||
g2d.drawString(Character.toString(ch), imgX, (lineHeight + charSeparator) * (tileY + 1) - desc);
|
||||
final float uStart = (float) (imgX - inset * charAspectRatio) / imageWidth;
|
||||
final float vStart = ((lineHeight + separator) * (tileY + 1) - lineHeight - inset) / imageHeight;
|
||||
final float vStart = ((lineHeight + charSeparator) * (tileY + 1) - lineHeight - inset) / imageHeight;
|
||||
final float xAdvance = charAspectRatio * 8 * charWidth / (charWidth + 2 * inset * charAspectRatio);
|
||||
final float glyphW = charAspectRatio * 8 + 1;
|
||||
final float uSz = (float) (charWidth + 2 * inset * charAspectRatio) / imageWidth;
|
||||
final float vSz = (float) (lineHeight + 2 * inset) / imageHeight;
|
||||
glyphData[i] = new GlyphData(uStart, vStart, xAdvance, glyphW, uSz, vSz);
|
||||
imgX += (int) (charWidth + separator);
|
||||
this.glyphData[i] = new GlyphData(uStart, vStart, xAdvance, glyphW, uSz, vSz);
|
||||
imgX += (int) (charWidth + charSeparator);
|
||||
tileX++;
|
||||
}
|
||||
g2d.dispose();
|
||||
try {
|
||||
LOGGER.info("writing custom font atlas texture ({}x{} px) to {}", imageWidth, imageHeight, getAtlasFullPath(this.id));
|
||||
Files.createDirectories(Paths.get(getFontDir()));
|
||||
ImageIO.write(image, "png", new File(getAtlasFullPath(this.id)));
|
||||
} catch (IOException e) {
|
||||
@@ -232,18 +224,18 @@ public final class FontProviderCustom implements FontProvider {
|
||||
|
||||
private FontAtlas getAtlas(char chr) {
|
||||
int id = chr / ATLAS_SIZE;
|
||||
FontAtlas fa = fontAtlases[id];
|
||||
FontAtlas fa = this.fontAtlases[id];
|
||||
if (fa == null) {
|
||||
fa = new FontAtlas(id);
|
||||
fa.construct(font);
|
||||
fa.construct(this.font);
|
||||
this.fontAtlases[id] = fa;
|
||||
}
|
||||
fontAtlases[id] = fa;
|
||||
return fa;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isGlyphAvailable(char chr) {
|
||||
if (font == null) { return false; }
|
||||
if (this.font == null) { return false; }
|
||||
return (getAtlas(chr).glyphData[chr % ATLAS_SIZE] != null);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,16 +1,31 @@
|
||||
package com.gtnewhorizons.angelica.client.font;
|
||||
|
||||
import com.gtnewhorizons.angelica.config.FontConfig;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
|
||||
public final class FontProviderUnicode implements FontProvider {
|
||||
|
||||
private FontProviderUnicode() {}
|
||||
private FontProviderUnicode() {
|
||||
try {
|
||||
InputStream inputstream = Minecraft.getMinecraft().getResourceManager()
|
||||
.getResource(new ResourceLocation("font/glyph_sizes.bin")).getInputStream();
|
||||
//noinspection ResultOfMethodCallIgnored
|
||||
inputstream.read(this.glyphWidth);
|
||||
}
|
||||
catch (IOException ioexception) {
|
||||
throw new RuntimeException(ioexception);
|
||||
}
|
||||
}
|
||||
|
||||
private static class InstLoader { static final FontProviderUnicode instance = new FontProviderUnicode(); }
|
||||
public static FontProviderUnicode get() { return FontProviderUnicode.InstLoader.instance; }
|
||||
|
||||
private static final ResourceLocation[] unicodePageLocations = new ResourceLocation[256];
|
||||
public byte[] glyphWidth;
|
||||
private final byte[] glyphWidth = new byte[65536];
|
||||
|
||||
private ResourceLocation getUnicodePageLocation(int page) {
|
||||
final ResourceLocation lookup = unicodePageLocations[page];
|
||||
|
||||
@@ -72,7 +72,6 @@ public class FontStrategist {
|
||||
DefaultResourcePack fontResourcePack = new DefaultResourcePack(packMap);
|
||||
List defaultResourcePacks = ((ResourceAccessor) Minecraft.getMinecraft()).angelica$getDefaultResourcePacks();
|
||||
defaultResourcePacks.add(fontResourcePack);
|
||||
Minecraft.getMinecraft().refreshResources();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
package com.gtnewhorizons.angelica.compat;
|
||||
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.lwjgl.opengl.ARBDebugOutput;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
|
||||
/**
|
||||
* Checks for known problematic driver configurations and applies workarounds. Adapted from Embeddium/Sodium's LateDriverScanner.
|
||||
*
|
||||
* <p>The NVIDIA workaround can be disabled via: {@code -Dangelica.disableNvidiaWorkaround=true}
|
||||
*/
|
||||
public class DriverCompatabilityCheck {
|
||||
private static final Logger LOGGER = LogManager.getLogger("Angelica");
|
||||
|
||||
private static final boolean DISABLE_NVIDIA_WORKAROUND = Boolean.getBoolean("angelica.disableNvidiaWorkaround");
|
||||
|
||||
/**
|
||||
* Should be called after GL context is created and GLStateManager is initialized.
|
||||
*/
|
||||
public static void checkDriverCompatibility() {
|
||||
final String vendor = GL11.glGetString(GL11.GL_VENDOR);
|
||||
final String renderer = GL11.glGetString(GL11.GL_RENDERER);
|
||||
final String version = GL11.glGetString(GL11.GL_VERSION);
|
||||
|
||||
LOGGER.info("OpenGL Vendor: {}", vendor);
|
||||
LOGGER.info("OpenGL Renderer: {}", renderer);
|
||||
LOGGER.info("OpenGL Version: {}", version);
|
||||
|
||||
if (vendor != null && vendor.contains("NVIDIA")) {
|
||||
if (DISABLE_NVIDIA_WORKAROUND) {
|
||||
LOGGER.info("NVIDIA workaround disabled via -Dangelica.disableNvidiaWorkaround=true");
|
||||
} else {
|
||||
applyNvidiaWorkaround();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* https://github.com/godotengine/godot/issues/33969#issuecomment-917846774
|
||||
* Attempt to force the driver to disable its submission thread by enabling synchronous debug output.
|
||||
* This usually suppresses bad behavior from NVIDIA's "Threaded Optimizations" feature.
|
||||
*/
|
||||
private static void applyNvidiaWorkaround() {
|
||||
if (!GLStateManager.capabilities.GL_ARB_debug_output) {
|
||||
LOGGER.warn("Cannot apply NVIDIA workaround: ARB_debug_output not available");
|
||||
return;
|
||||
}
|
||||
|
||||
LOGGER.info("Enabling workaround for NVIDIA threaded optimizations");
|
||||
GL11.glEnable(ARBDebugOutput.GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
|
||||
}
|
||||
}
|
||||
@@ -6,7 +6,6 @@ import com.gtnewhorizons.neid.mixins.interfaces.IExtendedBlockStorageMixin;
|
||||
import net.minecraft.world.chunk.Chunk;
|
||||
import net.minecraft.world.chunk.NibbleArray;
|
||||
import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
|
||||
import ru.fewizz.idextender.Hooks;
|
||||
|
||||
public class ExtendedBlockStorageExt extends ExtendedBlockStorage {
|
||||
public boolean hasSky;
|
||||
@@ -39,12 +38,6 @@ public class ExtendedBlockStorageExt extends ExtendedBlockStorage {
|
||||
System.arraycopy(((IExtendedBlockStorageMixin)(Object)storage).getBlock16BMetaArray(), 0, block16BMetaArray, 0, block16BMetaArray.length);
|
||||
}
|
||||
}
|
||||
else if (ModStatus.isOldNEIDLoaded){
|
||||
final short[] blockLSBArray = Hooks.get(this);
|
||||
System.arraycopy(Hooks.get(storage), 0, blockLSBArray, 0, blockLSBArray.length);
|
||||
// getBlockMSBArray is nuked in asm version
|
||||
arrayLen = blockLSBArray.length;
|
||||
}
|
||||
else {
|
||||
final byte[] blockLSBArray = this.getBlockLSBArray();
|
||||
System.arraycopy(storage.getBlockLSBArray(), 0, blockLSBArray, 0, blockLSBArray.length);
|
||||
|
||||
@@ -12,15 +12,8 @@ public class ModStatus {
|
||||
public static final Logger LOGGER = LogManager.getLogger("ModCompat");
|
||||
|
||||
public static BackhandReflectionCompat backhandCompat;
|
||||
/**
|
||||
* Mixin Version
|
||||
*/
|
||||
public static boolean isNEIDLoaded;
|
||||
/**
|
||||
* ASM Version
|
||||
*/
|
||||
public static boolean isOldNEIDLoaded;
|
||||
public static boolean isBetterCrashesLoaded;
|
||||
public static boolean isNEIDLoaded;
|
||||
public static boolean isNEIDMetadataExtended;
|
||||
public static boolean isLotrLoaded;
|
||||
public static boolean isChunkAPILoaded;
|
||||
@@ -42,7 +35,6 @@ public class ModStatus {
|
||||
|
||||
isBetterCrashesLoaded = Loader.isModLoaded("bettercrashes");
|
||||
isNEIDLoaded = Loader.isModLoaded("neid");
|
||||
isOldNEIDLoaded = Loader.isModLoaded("notenoughIDs");
|
||||
isLotrLoaded = Loader.isModLoaded("lotr");
|
||||
isChunkAPILoaded = Loader.isModLoaded("chunkapi");
|
||||
isEIDBiomeLoaded = Loader.isModLoaded("endlessids_biome");
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
package com.gtnewhorizons.angelica.compat.iris;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.ModStatus;
|
||||
import net.coderbot.iris.parsing.BiomeCategories;
|
||||
import net.minecraft.world.biome.BiomeGenBase;
|
||||
|
||||
@@ -8,7 +9,7 @@ import java.util.Map;
|
||||
|
||||
/**
|
||||
* Detects and categorizes biomes from popular modded biome mods using cached class checks.
|
||||
* Currently supports: BiomesOPlenty (BOP), Realistic World Gen (RWG)
|
||||
* Currently supports: BiomesOPlenty (BOP), Realistic World Gen (RWG), lotr (b36.15)
|
||||
*/
|
||||
public class ModdedBiomeDetector {
|
||||
private static boolean initialized = false;
|
||||
@@ -23,12 +24,15 @@ public class ModdedBiomeDetector {
|
||||
// LinkedHashMap maintains insertion order for deterministic behavior
|
||||
private static final Map<Class<?>, BiomeCategories> rwgClassMap = new LinkedHashMap<>();
|
||||
|
||||
private static Class<?> lotrBiomeClass = null;
|
||||
|
||||
private static synchronized void initialize() {
|
||||
if (initialized) return;
|
||||
initialized = true;
|
||||
|
||||
initializeBOP();
|
||||
initializeRWG();
|
||||
initializeLOTR();
|
||||
}
|
||||
|
||||
private static void initializeBOP() {
|
||||
@@ -59,6 +63,16 @@ public class ModdedBiomeDetector {
|
||||
tryAddRWGClass("rwg.biomes.base.BaseBiomeSnowForest", BiomeCategories.TAIGA); // Snow forests are taiga
|
||||
}
|
||||
|
||||
private static void initializeLOTR() {
|
||||
if (ModStatus.isLotrLoaded) {
|
||||
try {
|
||||
lotrBiomeClass = Class.forName("lotr.common.world.biome.LOTRBiome");
|
||||
} catch (ClassNotFoundException ignored) {
|
||||
// lotr not installed
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void tryAddRWGClass(String className, BiomeCategories category) {
|
||||
try {
|
||||
final Class<?> clazz = Class.forName(className);
|
||||
@@ -91,12 +105,64 @@ public class ModdedBiomeDetector {
|
||||
// fall through to name/property-based detection
|
||||
|
||||
// Realistic World Gen detection
|
||||
for (Map.Entry<Class<?>, BiomeCategories> entry : rwgClassMap.entrySet()) {
|
||||
if (entry.getKey().isInstance(biome)) {
|
||||
return entry.getValue();
|
||||
if (biome.getBiomeClass().getName().contains("rwg.biomes")) {
|
||||
for (Map.Entry<Class<?>, BiomeCategories> entry : rwgClassMap.entrySet()) {
|
||||
if (entry.getKey().isInstance(biome)) {
|
||||
return entry.getValue();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// lotr
|
||||
if (lotrBiomeClass!= null && lotrBiomeClass.isInstance(biome)) {
|
||||
return detectLOTRBiome(biome);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
private static BiomeCategories detectLOTRBiome(BiomeGenBase biome) {
|
||||
return switch (biome.biomeName) {
|
||||
case "river", "farHaradJungleLake", "lake" -> BiomeCategories.RIVER;
|
||||
case "rohan", "rivendell", "rhunIsland", "rhunLandHills", "rhunLandSteppe", "rhunLand", "andrast",
|
||||
"blackrootVale", "lamedon", "imlothMelui", "towerHills", "dorwinion", "dale", "shireMoors", "wold",
|
||||
"anduinVale", "rhun", "lebennin", "pertorogwaith", "breeland", "island", "pinnathGelin",
|
||||
"minhiriath", "pelennor", "adornland", "nanCurunir", "ithilienWasteland", "fangornClearing",
|
||||
"barrowDowns", "dorEnErnilHills", "dorEnErnil", "nurn", "wilderland", "eastBight", "lindon",
|
||||
"eregion", "enedwaith", "meneltarma", "anduinHills", "eriador", "angle", "loneLandsHills",
|
||||
"loneLands", "pelargir", "rohanUrukHighlands", "celebrant", "gondor", "shire", "nurnen", "farHarad" ->
|
||||
BiomeCategories.PLAINS;
|
||||
case "mistyMountains", "windMountains", "farHaradVolcano", "redMountains", "haradMountains",
|
||||
"angmarMountains", "blueMountains", "greyMountains", "whiteMountains", "mordorMountains" ->
|
||||
BiomeCategories.MOUNTAIN;
|
||||
case "shireWoodlands", "rhunIslandForest", "rhunRedForest", "pukel", "lossarnach", "gulfHaradForest",
|
||||
"nearHaradFertileForest", "dolGuldur", "rhunForest", "tauredainClearing", "umbarForest",
|
||||
"farHaradForest", "chetwood", "woodlandRealmHills", "mirkwoodNorth", "whiteDowns", "ithilienHills",
|
||||
"gondorWoodlands", "rohanWoodlands", "fangornWasteland", "mirkwoodMountains", "lindonWoodlands",
|
||||
"lothlorienEdge", "erynVorn", "oldForest", "fangorn", "dunland", "ithilien", "mirkwoodCorrupted",
|
||||
"woodlandRealm", "trollshaws", "lothlorien", "farHaradKanuka" -> BiomeCategories.FOREST;
|
||||
case "mordor", "lastDesert", "harnedor", "easternDesolation", "morgulVale", "gorgoroth", "udun",
|
||||
"nearHaradRedDesert", "nearHaradSemiDesert", "lostladen",
|
||||
"nearHaradHills", "nearHarad", "nanUngol", "dagorlad", "brownLands" -> BiomeCategories.DESERT;
|
||||
case "ironHills", "rivendellHills", "windMountainsFoothills", "lamedonHills", "redMountainsFoothills",
|
||||
"tolfalas", "dorwinionHills", "whiteMountainsFoothills", "blueMountainsFoothills",
|
||||
"greyMountainsFoothills", "mistyMountainsFoothills", "erebor", "angmar", "eriadorDowns",
|
||||
"ettenmoors", "emynMuil" -> BiomeCategories.EXTREME_HILLS;
|
||||
case "deadMarshes", "shireMarshes", "farHaradMangrove", "farHaradSwamp", "swanfleet", "nindalf",
|
||||
"longMarshes", "entwashMouth", "nurnMarshes", "gladdenFields", "midgewater", "anduinMouth" ->
|
||||
BiomeCategories.SWAMP;
|
||||
case "harondor", "nearHaradOasis", "nearHaradRiverbank", "farHaradBushlandHills", "farHaradBushland",
|
||||
"gulfHarad", "nearHaradFertile", "umbarHills", "umbar", "farHaradAridHills", "farHaradArid" ->
|
||||
BiomeCategories.SAVANNA;
|
||||
case "ocean" -> BiomeCategories.OCEAN;
|
||||
case "forodwaith", "forodwaithGlacier", "tundra", "forodwaithMountains" -> BiomeCategories.ICY;
|
||||
case "lindonCoast", "beachWhite", "farHaradCoast", "forodwaithCoast", "beachGravel", "beach" ->
|
||||
BiomeCategories.BEACH;
|
||||
case "coldfells", "wilderlandNorth", "taiga" -> BiomeCategories.TAIGA;
|
||||
case "farHaradJungle", "halfTrollForest", "farHaradJungleMountains",
|
||||
"farHaradCloudForest", "farHaradJungleEdge" -> BiomeCategories.JUNGLE;
|
||||
case "utumno" -> BiomeCategories.NONE;
|
||||
default -> null;
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -19,6 +19,7 @@ public class Camera {
|
||||
public static final Camera INSTANCE = new Camera();
|
||||
|
||||
private final Vector3d pos = new Vector3d();
|
||||
private final Vector3d entityPos = new Vector3d();
|
||||
private final BlockPos blockPos = new BlockPos();
|
||||
private final Vector3f offset = new Vector3f();
|
||||
private final Matrix4f inverseModelView = new Matrix4f();
|
||||
@@ -42,12 +43,14 @@ public class Camera {
|
||||
this.partialTicks = partialTicks;
|
||||
this.entity = entity;
|
||||
|
||||
// Entity position (interpolated, at feet level)
|
||||
// Entity position (interpolated, at eye level)
|
||||
final double entityX = entity.lastTickPosX + (entity.posX - entity.lastTickPosX) * partialTicks;
|
||||
final double entityY = entity.lastTickPosY + (entity.posY - entity.lastTickPosY) * partialTicks;
|
||||
final double entityZ = entity.lastTickPosZ + (entity.posZ - entity.lastTickPosZ) * partialTicks;
|
||||
final double eyeHeight = entity.getEyeHeight();
|
||||
|
||||
entityPos.set(entityX, entityY + eyeHeight, entityZ);
|
||||
|
||||
thirdPerson = Minecraft.getMinecraft().gameSettings.thirdPersonView > 0;
|
||||
|
||||
final double camX, camY, camZ;
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
package com.gtnewhorizons.angelica.compat.toremove;
|
||||
|
||||
import com.gtnewhorizons.angelica.AngelicaMod;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import me.jellysquid.mods.sodium.client.SodiumClientMod;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.renderer.texture.TextureManager;
|
||||
import net.minecraft.client.renderer.texture.TextureMap;
|
||||
@@ -147,7 +147,7 @@ public abstract class RenderPhase {
|
||||
FOG = new Fog("fog", () -> {
|
||||
// Unclear what this should do
|
||||
// BackgroundRenderer.setFogBlack(), also levelFogColor()
|
||||
SodiumClientMod.LOGGER.debug("Fog - Not setting level fog color");
|
||||
AngelicaMod.LOGGER.debug("Fog - Not setting level fog color");
|
||||
GLStateManager.enableFog();
|
||||
}, GLStateManager::disableFog);
|
||||
BLACK_FOG = new Fog("black_fog", () -> {
|
||||
@@ -156,7 +156,7 @@ public abstract class RenderPhase {
|
||||
}, () -> {
|
||||
// Unclear what this should do
|
||||
// BackgroundRenderer.setFogBlack(), also levelFogColor()
|
||||
SodiumClientMod.LOGGER.debug("Fog - Not setting level fog color");
|
||||
AngelicaMod.LOGGER.debug("Fog - Not setting level fog color");
|
||||
GLStateManager.disableFog();
|
||||
});
|
||||
MAIN_TARGET = new Target("main_target", () -> {
|
||||
@@ -164,7 +164,7 @@ public abstract class RenderPhase {
|
||||
});
|
||||
OUTLINE_TARGET = new Target("outline_target", () -> {
|
||||
// TODO: Sodium
|
||||
SodiumClientMod.LOGGER.debug("NOT enabling the entity outline framebuffer");
|
||||
AngelicaMod.LOGGER.debug("NOT enabling the entity outline framebuffer");
|
||||
//MinecraftClient.getInstance().worldRenderer.getEntityOutlinesFramebuffer().beginWrite(false);
|
||||
}, () -> {
|
||||
Minecraft.getMinecraft().getFramebuffer().bindFramebuffer(false);
|
||||
@@ -172,7 +172,7 @@ public abstract class RenderPhase {
|
||||
TRANSLUCENT_TARGET = new Target("translucent_target", () -> {
|
||||
if (Minecraft.isFancyGraphicsEnabled()) {
|
||||
// TODO: Sodium
|
||||
SodiumClientMod.LOGGER.debug("NOT enabling the translucent framebuffer");
|
||||
AngelicaMod.LOGGER.debug("NOT enabling the translucent framebuffer");
|
||||
// MinecraftClient.getInstance().worldRenderer.getTranslucentFramebuffer().beginWrite(false);
|
||||
}
|
||||
|
||||
@@ -345,7 +345,7 @@ public abstract class RenderPhase {
|
||||
super("lightmap", () -> {
|
||||
if (lightmap) {
|
||||
// TODO: Sodium - LightmapTextureManager
|
||||
SodiumClientMod.LOGGER.debug("Lightmap - enable (not implemented)");
|
||||
AngelicaMod.LOGGER.debug("Lightmap - enable (not implemented)");
|
||||
// throw new RuntimeException("Not Implemented Yet");
|
||||
// MinecraftClient.getInstance().gameRenderer.getLightmapTextureManager().enable();
|
||||
|
||||
@@ -354,7 +354,7 @@ public abstract class RenderPhase {
|
||||
}, () -> {
|
||||
if (lightmap) {
|
||||
// TODO: Sodium - LightmapTextureManager
|
||||
SodiumClientMod.LOGGER.debug("Lightmap - disable (not implemented)");
|
||||
AngelicaMod.LOGGER.debug("Lightmap - disable (not implemented)");
|
||||
// throw new RuntimeException("Not Implemented Yet");
|
||||
// MinecraftClient.getInstance().gameRenderer.getLightmapTextureManager().disable();
|
||||
}
|
||||
|
||||
@@ -88,12 +88,16 @@ public class AngelicaConfig {
|
||||
@Config.RequiresMcRestart
|
||||
public static boolean enableHudCachingEventTransformer;
|
||||
|
||||
@Config.Comment("Enable HUD Caching at runtime. Requires enableHudCaching to be on at startup. [Experimental]")
|
||||
@Config.DefaultBoolean(false)
|
||||
public static boolean hudCachingActive;
|
||||
|
||||
@Config.Comment("The amount of frames to wait before updating the HUD elements. [Experimental]")
|
||||
@Config.DefaultInt(20)
|
||||
@Config.RangeInt(min = 1, max = 60)
|
||||
public static int hudCachingFPS = 20;
|
||||
|
||||
@Config.Comment("Batch drawScreen fonts [Experimental]")
|
||||
@Config.Comment("Batch drawScreen fonts")
|
||||
@Config.DefaultBoolean(true)
|
||||
@Config.RequiresMcRestart
|
||||
public static boolean enableFontRenderer;
|
||||
@@ -200,7 +204,7 @@ public class AngelicaConfig {
|
||||
"net.minecraft.block.BlockStairs"
|
||||
})
|
||||
public static String[] blockCrackFixBlacklist;
|
||||
|
||||
|
||||
@Config.Comment({"Block classes that have render pass other than 0 but still need to be manipulated.",
|
||||
"Add a block class here if you see flickering (z-fighting) with fixBlockCrack enabled"
|
||||
})
|
||||
@@ -210,6 +214,8 @@ public class AngelicaConfig {
|
||||
"shukaro.artifice.block.world.BlockOre",
|
||||
"bartworks.system.material.BWMetaGeneratedOres",
|
||||
"gtPlusPlus.core.block.base.BlockBaseOre",
|
||||
"org.pfaa.geologica.block.BrokenGeoBlock",
|
||||
"org.pfaa.geologica.block.BrickGeoBlock",
|
||||
})
|
||||
public static String[] blockCrackFixRenderPassWhitelist__;
|
||||
|
||||
@@ -217,8 +223,16 @@ public class AngelicaConfig {
|
||||
@Config.DefaultBoolean(false)
|
||||
public static boolean enableHardcodedCustomUniforms;
|
||||
|
||||
@Config.Comment("Define IS_IRIS in shader macros.")
|
||||
@Config.DefaultBoolean(true)
|
||||
public static boolean defineIsIris;
|
||||
|
||||
@Config.Comment("Renders chunks before neighbors are ready. Improves loading at render distance edges, useful for low render distance servers.")
|
||||
@Config.DefaultBoolean(false)
|
||||
public static boolean useVanillaChunkTracking;
|
||||
|
||||
@Config.Comment("Disables additional F3 information added by Angelica.")
|
||||
@Config.DefaultBoolean(false)
|
||||
public static boolean disableF3Additions;
|
||||
|
||||
}
|
||||
@@ -19,7 +19,7 @@ import static org.lwjgl.opengl.GL11.glEnable;
|
||||
import static org.lwjgl.opengl.GL11.glEnableClientState;
|
||||
import static org.lwjgl.opengl.GL15.GL_ARRAY_BUFFER;
|
||||
import static org.lwjgl.opengl.GL15.GL_STATIC_DRAW;
|
||||
import static org.lwjgl.opengl.GL15.glBindBuffer;
|
||||
import static com.gtnewhorizons.angelica.glsm.GLStateManager.glBindBuffer;
|
||||
import static org.lwjgl.opengl.GL15.glBufferData;
|
||||
import static org.lwjgl.opengl.GL15.glGenBuffers;
|
||||
import static org.lwjgl.opengl.GL20.glDisableVertexAttribArray;
|
||||
|
||||
@@ -52,6 +52,7 @@ public class DynamicLights {
|
||||
private static final double MAX_RADIUS_SQUARED = MAX_RADIUS * MAX_RADIUS;
|
||||
private final Set<IDynamicLightSource> dynamicLightSources = new ObjectOpenHashSet<>();
|
||||
private final ReentrantReadWriteLock lightSourcesLock = new ReentrantReadWriteLock();
|
||||
private volatile int lightSourceCount = 0;
|
||||
private final ChunkRebuildManager chunkRebuildManager = new ChunkRebuildManager();
|
||||
private long lastUpdate = System.currentTimeMillis();
|
||||
private int lastUpdateCount = 0;
|
||||
@@ -70,6 +71,10 @@ public class DynamicLights {
|
||||
(ShaderForce || !IrisApi.getInstance().isShaderPackInUse());
|
||||
}
|
||||
|
||||
public boolean hasLightSources() {
|
||||
return lightSourceCount > 0;
|
||||
}
|
||||
|
||||
public static IDynamicLightWorldRenderer getActiveRenderer() {
|
||||
return activeRenderer;
|
||||
}
|
||||
@@ -142,7 +147,9 @@ public class DynamicLights {
|
||||
|
||||
public void addLightSource(IDynamicLightSource lightSource) {
|
||||
this.lightSourcesLock.writeLock().lock();
|
||||
this.dynamicLightSources.add(lightSource);
|
||||
if (this.dynamicLightSources.add(lightSource)) {
|
||||
this.lightSourceCount = this.dynamicLightSources.size();
|
||||
}
|
||||
this.lightSourcesLock.writeLock().unlock();
|
||||
}
|
||||
|
||||
@@ -160,6 +167,7 @@ public class DynamicLights {
|
||||
it = dynamicLightSources.next();
|
||||
if (it.equals(lightSource)) {
|
||||
dynamicLightSources.remove();
|
||||
this.lightSourceCount = this.dynamicLightSources.size();
|
||||
if (activeRenderer != null)
|
||||
lightSource.angelica$scheduleTrackedChunksRebuild(activeRenderer);
|
||||
break;
|
||||
@@ -183,6 +191,7 @@ public class DynamicLights {
|
||||
it = dynamicLightSources.next();
|
||||
if (filter.test(it)) {
|
||||
dynamicLightSources.remove();
|
||||
this.lightSourceCount = this.dynamicLightSources.size();
|
||||
if (activeRenderer != null) {
|
||||
if (it.angelica$getLuminance() > 0)
|
||||
it.angelica$resetDynamicLight();
|
||||
@@ -212,6 +221,7 @@ public class DynamicLights {
|
||||
it.angelica$scheduleTrackedChunksRebuild(activeRenderer);
|
||||
}
|
||||
}
|
||||
this.lightSourceCount = 0;
|
||||
|
||||
this.lightSourcesLock.writeLock().unlock();
|
||||
}
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.opengl.UniversalVAO;
|
||||
import com.mitchej123.glsm.GLStateManagerService;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
@@ -149,17 +150,17 @@ public class AngelicaGLStateManagerService implements GLStateManagerService {
|
||||
|
||||
@Override
|
||||
public int glGenVertexArrays() {
|
||||
return GL30.glGenVertexArrays();
|
||||
return UniversalVAO.genVertexArrays();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glBindVertexArray(int array) {
|
||||
GL30.glBindVertexArray(array);
|
||||
GLStateManager.glBindVertexArray(array);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void glDeleteVertexArrays(int array) {
|
||||
GL30.glDeleteVertexArrays(array);
|
||||
UniversalVAO.deleteVertexArrays(array);
|
||||
}
|
||||
|
||||
// ===================== BUFFER OPERATIONS =====================
|
||||
@@ -171,7 +172,7 @@ public class AngelicaGLStateManagerService implements GLStateManagerService {
|
||||
|
||||
@Override
|
||||
public void glBindBuffer(int target, int buffer) {
|
||||
GL15.glBindBuffer(target, buffer);
|
||||
GLStateManager.glBindBuffer(target, buffer);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -1,238 +1,67 @@
|
||||
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 org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
|
||||
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.
|
||||
* Transforms are already collapsed to MultMatrix during recording; the optimizer
|
||||
* tracks transform state to emit deltas when draws need a different transform.
|
||||
* Bridges the gap between VBO compilation (glsm types) and buffer processing (recording types).
|
||||
*/
|
||||
public final class CommandBufferBuilder {
|
||||
|
||||
private static final Logger LOGGER = LogManager.getLogger("CommandBufferBuilder");
|
||||
|
||||
private CommandBufferBuilder() {}
|
||||
|
||||
/** Build with transform delta optimization and merged draw ranges. */
|
||||
public static void buildOptimizedFromRawBuffer(
|
||||
/**
|
||||
* 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 buildFromRawBuffer(
|
||||
CommandBuffer rawBuffer,
|
||||
Map<CapturingTessellator.Flags, CompiledFormatBuffer> compiledQuadBuffers,
|
||||
final CompiledLineBuffer compiledLineBuffer,
|
||||
final Map<CapturingTessellator.Flags, CompiledPrimitiveBuffers> compiledPrimitiveBuffers,
|
||||
VertexBuffer[] ownedVbos,
|
||||
int glListId,
|
||||
List<AccumulatedDraw> accumulatedDraws,
|
||||
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, compiledPrimitiveBuffers);
|
||||
|
||||
// Buffer optimizer state
|
||||
final BufferTransformOptimizer opt = new BufferTransformOptimizer();
|
||||
|
||||
rawBuffer.resetRead();
|
||||
int cmdIndex = 0;
|
||||
int rangeIndex = 0;
|
||||
|
||||
AccumulatedDraw draw;
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
/** Debug build: no optimizations, 1:1 draw commands. */
|
||||
public static void buildUnoptimizedFromRawBuffer(
|
||||
CommandBuffer rawBuffer,
|
||||
Map<CapturingTessellator.Flags, CompiledFormatBuffer> compiledQuadBuffers,
|
||||
CompiledLineBuffer compiledLineBuffer,
|
||||
Map<CapturingTessellator.Flags, CompiledPrimitiveBuffers> compiledPrimitiveBuffers,
|
||||
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 per-draw ranges (no merging) sorted by command index
|
||||
final List<DrawRangeWithBuffer> allRanges = collectDrawRangesUnoptimized(compiledQuadBuffers, compiledLineBuffer, compiledPrimitiveBuffers);
|
||||
|
||||
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());
|
||||
DisplayListManager.trackDrawRangeSource(drb.source().toString());
|
||||
}
|
||||
}
|
||||
|
||||
// Copy the command directly
|
||||
CommandBufferProcessor.copyCommand(rawBuffer, finalBuffer);
|
||||
|
||||
// Emit draw ranges at this command position
|
||||
while (rangeIndex < accumulatedDraws.size() && (draw = accumulatedDraws.get(rangeIndex)).commandIndex == cmdIndex) {
|
||||
emitDrawRangeToBuffer(draw, finalBuffer, rangeIndex);
|
||||
rangeIndex++;
|
||||
}
|
||||
|
||||
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());
|
||||
DisplayListManager.trackDrawRangeSource(drb.source().toString());
|
||||
}
|
||||
while (rangeIndex < accumulatedDraws.size()) {
|
||||
emitDrawRangeToBuffer(accumulatedDraws.get(rangeIndex), finalBuffer, rangeIndex);
|
||||
rangeIndex++;
|
||||
}
|
||||
}
|
||||
|
||||
/** Collect merged draw ranges, sorted by command index. */
|
||||
static List<DrawRangeWithBuffer> collectDrawRanges(
|
||||
Map<CapturingTessellator.Flags, CompiledFormatBuffer> compiledQuadBuffers,
|
||||
CompiledLineBuffer compiledLineBuffer,
|
||||
Map<CapturingTessellator.Flags, CompiledPrimitiveBuffers> compiledPrimitiveBuffers) {
|
||||
return collectDrawRangesInternal(compiledQuadBuffers, compiledLineBuffer, compiledPrimitiveBuffers, true);
|
||||
}
|
||||
|
||||
/** Collect unmerged draw ranges for debug mode. */
|
||||
static List<DrawRangeWithBuffer> collectDrawRangesUnoptimized(
|
||||
Map<CapturingTessellator.Flags, CompiledFormatBuffer> compiledQuadBuffers,
|
||||
CompiledLineBuffer compiledLineBuffer,
|
||||
Map<CapturingTessellator.Flags, CompiledPrimitiveBuffers> compiledPrimitiveBuffers) {
|
||||
return collectDrawRangesInternal(compiledQuadBuffers, compiledLineBuffer, compiledPrimitiveBuffers, false);
|
||||
}
|
||||
|
||||
private static List<DrawRangeWithBuffer> collectDrawRangesInternal(
|
||||
Map<CapturingTessellator.Flags, CompiledFormatBuffer> compiledQuadBuffers,
|
||||
CompiledLineBuffer compiledLineBuffer,
|
||||
Map<CapturingTessellator.Flags, CompiledPrimitiveBuffers> compiledPrimitiveBuffers,
|
||||
boolean useMerged) {
|
||||
|
||||
final List<DrawRangeWithBuffer> allRanges = new ArrayList<>();
|
||||
|
||||
// Add quad ranges
|
||||
final CompiledFormatBuffer[] quadBufferArray = compiledQuadBuffers.values().toArray(new CompiledFormatBuffer[0]);
|
||||
for (int b = 0; b < quadBufferArray.length; b++) {
|
||||
final CompiledFormatBuffer compiledBuffer = quadBufferArray[b];
|
||||
final DrawRange[] ranges = useMerged ? compiledBuffer.mergedRanges() : compiledBuffer.perDrawRanges();
|
||||
for (int i = 0; i < ranges.length; i++) {
|
||||
allRanges.add(new DrawRangeWithBuffer(ranges[i], compiledBuffer.vbo(), compiledBuffer.flags(),
|
||||
DrawRangeWithBuffer.DrawSource.TESSELLATOR_QUADS));
|
||||
}
|
||||
}
|
||||
|
||||
// Add immediate mode line ranges
|
||||
// Lines use a minimal flags (color only, no texture/brightness/normals)
|
||||
if (compiledLineBuffer != null) {
|
||||
final CapturingTessellator.Flags lineFlags = new CapturingTessellator.Flags(false, false, true, false);
|
||||
final DrawRange[] ranges = useMerged ? compiledLineBuffer.mergedRanges() : compiledLineBuffer.perDrawRanges();
|
||||
for (int i = 0; i < ranges.length; i++) {
|
||||
allRanges.add(new DrawRangeWithBuffer(ranges[i], compiledLineBuffer.vbo(), lineFlags,
|
||||
DrawRangeWithBuffer.DrawSource.IMMEDIATE_MODE_LINES));
|
||||
}
|
||||
}
|
||||
|
||||
// Add tessellator primitive ranges (lines and triangles) - grouped by format
|
||||
if (compiledPrimitiveBuffers != null && !compiledPrimitiveBuffers.isEmpty()) {
|
||||
final CompiledPrimitiveBuffers[] primBufferArray = compiledPrimitiveBuffers.values().toArray(new CompiledPrimitiveBuffers[0]);
|
||||
for (int p = 0; p < primBufferArray.length; p++) {
|
||||
final CompiledPrimitiveBuffers primBuffers = primBufferArray[p];
|
||||
final CapturingTessellator.Flags primFlags = primBuffers.flags();
|
||||
// Tessellator lines
|
||||
if (primBuffers.hasLines()) {
|
||||
final DrawRange[] ranges = useMerged ? primBuffers.lineMergedRanges() : primBuffers.linePerDrawRanges();
|
||||
final VertexBuffer vbo = primBuffers.lineVbo();
|
||||
for (int i = 0; i < ranges.length; i++) {
|
||||
allRanges.add(new DrawRangeWithBuffer(ranges[i], vbo, primFlags,
|
||||
DrawRangeWithBuffer.DrawSource.TESSELLATOR_LINES));
|
||||
}
|
||||
}
|
||||
// Tessellator triangles
|
||||
if (primBuffers.hasTriangles()) {
|
||||
final DrawRange[] ranges = useMerged ? primBuffers.triangleMergedRanges() : primBuffers.trianglePerDrawRanges();
|
||||
final VertexBuffer vbo = primBuffers.triangleVbo();
|
||||
for (int i = 0; i < ranges.length; i++) {
|
||||
allRanges.add(new DrawRangeWithBuffer(ranges[i], vbo, primFlags,
|
||||
DrawRangeWithBuffer.DrawSource.TESSELLATOR_TRIANGLES));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
allRanges.sort(Comparator.comparingInt(r -> r.range().commandIndex()));
|
||||
return allRanges;
|
||||
}
|
||||
|
||||
/** Emit draw range with delta transform. Uses writeDrawRangeRestore for immediate mode. */
|
||||
/**
|
||||
* Emit a draw range to the output buffer, with transform if needed.
|
||||
*/
|
||||
private static void emitDrawRangeToBuffer(
|
||||
DrawRangeWithBuffer drb,
|
||||
BufferTransformOptimizer opt,
|
||||
AccumulatedDraw draw,
|
||||
CommandBuffer out,
|
||||
Object2IntMap<VertexBuffer> vboIndexMap) {
|
||||
int vboIdx) {
|
||||
|
||||
// Emit transform to reach the draw's expected transform
|
||||
opt.emitTransformTo(out, drb.range().transform());
|
||||
if (draw.restoreData != null) {
|
||||
out.writeDrawRangeRestore(vboIdx, draw.restoreData);
|
||||
return;
|
||||
}
|
||||
|
||||
// Write the draw range command
|
||||
final int vboIdx = vboIndexMap.getInt(drb.vbo());
|
||||
if (vboIdx >= 0) {
|
||||
final var restoreData = drb.range().restoreData();
|
||||
if (restoreData != null) {
|
||||
// Immediate mode draw with attribute restoration
|
||||
final var flags = drb.flags();
|
||||
out.writeDrawRangeRestore(
|
||||
vboIdx, drb.range().startVertex(), drb.range().vertexCount(),
|
||||
drb.hasBrightness(), flags.hasColor, flags.hasNormals, flags.hasTexture,
|
||||
restoreData.lastColorR(), restoreData.lastColorG(),
|
||||
restoreData.lastColorB(), restoreData.lastColorA(),
|
||||
restoreData.lastNormalX(), restoreData.lastNormalY(), restoreData.lastNormalZ(),
|
||||
restoreData.lastTexCoordS(), restoreData.lastTexCoordT()
|
||||
);
|
||||
} else {
|
||||
// Regular tessellator draw (no restoration needed)
|
||||
out.writeDrawRange(vboIdx, drb.range().startVertex(), drb.range().vertexCount(), drb.hasBrightness());
|
||||
}
|
||||
DisplayListManager.trackDrawRangeSource(drb.source().toString());
|
||||
}
|
||||
out.writeDrawRange(vboIdx);
|
||||
}
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
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
|
||||
public record CompiledFormatBuffer(
|
||||
VertexBuffer vbo,
|
||||
CapturingTessellator.Flags flags,
|
||||
DrawRange[] mergedRanges,
|
||||
DrawRange[] perDrawRanges
|
||||
) {}
|
||||
@@ -1,21 +0,0 @@
|
||||
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
|
||||
public record CompiledLineBuffer(
|
||||
VertexBuffer vbo,
|
||||
DrawRange[] mergedRanges,
|
||||
DrawRange[] perDrawRanges
|
||||
) {}
|
||||
@@ -1,31 +0,0 @@
|
||||
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;
|
||||
|
||||
/**
|
||||
* Compiled VBOs containing tessellator primitives (lines and triangles) for a single vertex format.
|
||||
* Separate VBOs are used for lines (GL_LINES) and triangles (GL_TRIANGLES) since they have different draw modes.
|
||||
* <p>
|
||||
* Contains range arrays for both optimized (merged) and unoptimized (per-draw) paths.
|
||||
* Similar to CompiledFormatBuffer but handles primitives instead of quads.
|
||||
*/
|
||||
@Desugar
|
||||
public record CompiledPrimitiveBuffers(
|
||||
CapturingTessellator.Flags flags,
|
||||
VertexBuffer lineVbo,
|
||||
DrawRange[] lineMergedRanges,
|
||||
DrawRange[] linePerDrawRanges,
|
||||
VertexBuffer triangleVbo,
|
||||
DrawRange[] triangleMergedRanges,
|
||||
DrawRange[] trianglePerDrawRanges
|
||||
) {
|
||||
public boolean hasLines() {
|
||||
return lineVbo != null;
|
||||
}
|
||||
|
||||
public boolean hasTriangles() {
|
||||
return triangleVbo != null;
|
||||
}
|
||||
}
|
||||
@@ -1,26 +1,20 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.primitive.ModelPrimitiveView;
|
||||
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.AccumulatedPrimitiveDraw;
|
||||
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.DisplayListVBO;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.DisplayListVBOBuilder;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.GLCommand;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.ImmediateModeRecorder;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.commands.DisplayListCommand;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.commands.OptimizationContext;
|
||||
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
|
||||
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
|
||||
import lombok.Getter;
|
||||
@@ -38,9 +32,9 @@ import java.util.ArrayDeque;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.Deque;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*;
|
||||
|
||||
/**
|
||||
* VBO-based display list emulation with command recording, transform collapsing, and format-based batching.
|
||||
@@ -49,8 +43,8 @@ import java.util.Map;
|
||||
* emitted at barriers (draws, CallList, exit). Vertices stay canonical in VBOs. Handles nested
|
||||
* display lists correctly and maintains Push/Pop semantics.
|
||||
*
|
||||
* <p><b>Format-Based Batching:</b> Draws with same vertex format share a VBO via {@link FormatBuffer}.
|
||||
* Each draw's position is tracked as a {@link DrawRange}. Consecutive same-transform draws merge.
|
||||
* <p><b>Format-Based Batching:</b> Draws with same vertex format share a VBO via {@link DisplayListVBO}.
|
||||
* Consecutive same-transform draws merge.
|
||||
* Delta transforms handled via {@link TransformOptimizer}.
|
||||
*/
|
||||
@UtilityClass
|
||||
@@ -92,28 +86,16 @@ public class DisplayListManager {
|
||||
// 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 immediate mode line draws
|
||||
private static List<AccumulatedPrimitiveDraw> accumulatedPrimitiveDraws = null; // Accumulates tessellator primitive draws (lines, triangles)
|
||||
private static Matrix4fStack relativeTransform = null; // Tracks delta from current GL state (reset to I after each flush)
|
||||
/**
|
||||
* -- GETTER --
|
||||
* Get the current matrix generation (for draw batching).
|
||||
*/
|
||||
@Getter
|
||||
private static int matrixGeneration = 0; // Increments when relativeTransform changes; used for draw batching
|
||||
private static int lastFlushedGeneration = -1; // Generation at last flush; draws trigger flush when gen changes
|
||||
private static Matrix4fStack relativeTransform = null; // Tracks relative transforms during compilation (with push/pop support)
|
||||
/**
|
||||
* -- GETTER --
|
||||
* Get the current state generation (for draw merging).
|
||||
*/
|
||||
@Getter
|
||||
private static int stateGeneration = 0; // Increments at draw barriers (state commands); used for draw merging
|
||||
private static Matrix4f lastFlushedTransform = null; // The transform that was flushed; consecutive same-gen draws share this
|
||||
@Getter private static ImmediateModeRecorder immediateModeRecorder = null; // Records glBegin/glEnd/glVertex during compilation
|
||||
private static StackTraceElement[] compilationStackTrace = null; // For logging: captured at glNewList()
|
||||
|
||||
// Debug logging: track sources of MULT_MATRIX commands and draw origins; only populated when LOG_DISPLAY_LIST_COMPILATION is true
|
||||
@@ -140,11 +122,7 @@ public class DisplayListManager {
|
||||
int listMode,
|
||||
CommandRecorder recorder,
|
||||
List<AccumulatedDraw> draws,
|
||||
List<AccumulatedLineDraw> lineDraws,
|
||||
List<AccumulatedPrimitiveDraw> primitiveDraws,
|
||||
Matrix4fStack transform,
|
||||
boolean wasTessellatorCompiling,
|
||||
ImmediateModeRecorder immediateRecorder,
|
||||
StackTraceElement[] stackTrace,
|
||||
|
||||
// Debug logging fields (only used when LOG_DISPLAY_LIST_COMPILATION)
|
||||
@@ -169,16 +147,19 @@ public class DisplayListManager {
|
||||
return glListMode == GL11.GL_COMPILE_AND_EXECUTE;
|
||||
}
|
||||
|
||||
/** Emit accumulated transform as MultMatrix if non-identity, then reset. */
|
||||
public static boolean flushMatrix() {
|
||||
/**
|
||||
* Emit accumulated transform as MultMatrix if non-identity, then reset.
|
||||
*/
|
||||
public static void flushMatrix() {
|
||||
if (relativeTransform == null || isIdentity(relativeTransform)) {
|
||||
// Clear pending ops even if we don't emit - they were no-ops (identity)
|
||||
if (pendingTransformOps != null) {
|
||||
pendingTransformOps.clear();
|
||||
}
|
||||
return false;
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
// Save pending transform ops for logging (before we clear them)
|
||||
if (multMatrixSources != null && pendingTransformOps != null) {
|
||||
if (pendingTransformOps.isEmpty()) {
|
||||
@@ -193,6 +174,7 @@ public class DisplayListManager {
|
||||
// Record the collapsed MultMatrix command (for playback)
|
||||
if (currentRecorder != null) {
|
||||
currentRecorder.recordMultMatrix(relativeTransform);
|
||||
stateGeneration++;
|
||||
}
|
||||
|
||||
// COMPILE_AND_EXECUTE: execute now. Bypass GLSM to avoid re-entering recording path.
|
||||
@@ -206,7 +188,6 @@ public class DisplayListManager {
|
||||
// Reset to identity - we're now synchronized with GL
|
||||
relativeTransform.identity();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
public static void matrixBarrier() {
|
||||
@@ -232,7 +213,7 @@ public class DisplayListManager {
|
||||
}
|
||||
|
||||
// Draw barriers: state commands that prevent draw merging
|
||||
private static void drawBarrier() {
|
||||
static void drawBarrier() {
|
||||
stateGeneration++;
|
||||
}
|
||||
|
||||
@@ -369,8 +350,6 @@ public class DisplayListManager {
|
||||
// Flush any pending delta, then record pop.
|
||||
flushMatrix();
|
||||
currentRecorder.recordPopMatrix();
|
||||
// Invalidate cached transform
|
||||
matrixGeneration++;
|
||||
}
|
||||
|
||||
public static void recordViewport(int x, int y, int width, int height) {
|
||||
@@ -592,6 +571,18 @@ public class DisplayListManager {
|
||||
if (currentRecorder != null) currentRecorder.recordLoadIdentity();
|
||||
}
|
||||
|
||||
public static void recordDrawArrays(int mode, int start, int count) {
|
||||
if (currentRecorder != null) currentRecorder.recordDrawArrays(mode, start, count);
|
||||
}
|
||||
|
||||
public static void recordDrawElements(int mode, int indices_count, int type, long indices_buffer_offset) {
|
||||
if (currentRecorder != null) currentRecorder.recordDrawElements(mode, indices_count, type, indices_buffer_offset);
|
||||
}
|
||||
|
||||
public static void recordBindVBO(int vbo) { if (currentRecorder != null) currentRecorder.recordBindVBO(vbo); }
|
||||
public static void recordBindVAO(int vao) { if (currentRecorder != null) currentRecorder.recordBindVAO(vao); }
|
||||
|
||||
|
||||
// recordOrtho/recordFrustum removed - these now accumulate into relativeTransform
|
||||
// via updateRelativeTransformOrtho/updateRelativeTransformFrustum
|
||||
|
||||
@@ -603,51 +594,13 @@ public class DisplayListManager {
|
||||
* 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;
|
||||
}
|
||||
|
||||
if (matrixGeneration != lastFlushedGeneration) {
|
||||
if (lastFlushedTransform == null) {
|
||||
lastFlushedTransform = new Matrix4f();
|
||||
}
|
||||
lastFlushedTransform.set(relativeTransform);
|
||||
flushMatrix();
|
||||
lastFlushedGeneration = matrixGeneration;
|
||||
}
|
||||
|
||||
final Matrix4f currentTransform = new Matrix4f(lastFlushedTransform);
|
||||
final int currentGeneration = matrixGeneration;
|
||||
final int currentBatchId = stateGeneration;
|
||||
final int cmdIndex = getCommandCount();
|
||||
|
||||
if (!result.quads().isEmpty()) {
|
||||
final var flags = result.flags();
|
||||
final AccumulatedDraw.RestoreData restoreData;
|
||||
if (flags.hasColor || flags.hasNormals || flags.hasTexture) {
|
||||
restoreData = new AccumulatedDraw.RestoreData(
|
||||
result.lastColorR(), result.lastColorG(), result.lastColorB(), result.lastColorA(),
|
||||
result.lastNormalX(), result.lastNormalY(), result.lastNormalZ(),
|
||||
result.lastTexCoordS(), result.lastTexCoordT()
|
||||
);
|
||||
} else {
|
||||
restoreData = null; // Position-only draw, no attributes to restore
|
||||
}
|
||||
final AccumulatedDraw quadDraw = new AccumulatedDraw(
|
||||
result.quads(), currentTransform, flags,
|
||||
cmdIndex, currentGeneration, currentBatchId, restoreData
|
||||
);
|
||||
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(), currentBatchId);
|
||||
accumulatedLineDraws.add(lineDraw);
|
||||
public static void addImmediateModeDraw(DirectTessellator tessellator) {
|
||||
if (!tessellator.isEmpty()) {
|
||||
// Get relative transform (changes since glNewList, not absolute matrix state)
|
||||
addAccumulatedDraw(tessellator, tessellator.getVertexFormat() != DefaultVertexFormat.POSITION);
|
||||
}
|
||||
tessellator.reset();
|
||||
}
|
||||
|
||||
private static void applyTransformOp(Matrix4f m, float x, float y, float z, TransformOp op, Vector3f axis) {
|
||||
@@ -675,7 +628,6 @@ public class DisplayListManager {
|
||||
}
|
||||
|
||||
applyTransformOp(relativeTransform, x, y, z, op, rotationAxis);
|
||||
matrixGeneration++;
|
||||
|
||||
if (pendingTransformOps != null) {
|
||||
final String log = switch (op) {
|
||||
@@ -716,7 +668,6 @@ public class DisplayListManager {
|
||||
}
|
||||
|
||||
relativeTransform.mul(matrix);
|
||||
matrixGeneration++;
|
||||
|
||||
if (pendingTransformOps != null) {
|
||||
pendingTransformOps.add("glMultMatrixf(...)");
|
||||
@@ -744,7 +695,6 @@ public class DisplayListManager {
|
||||
}
|
||||
|
||||
relativeTransform.mul(orthoFrustumTemp);
|
||||
matrixGeneration++;
|
||||
if (pendingTransformOps != null) {
|
||||
pendingTransformOps.add(String.format("glOrtho(%.4f, %.4f, %.4f, %.4f, %.4f, %.4f)", left, right, bottom, top, zNear, zFar));
|
||||
}
|
||||
@@ -768,7 +718,6 @@ public class DisplayListManager {
|
||||
}
|
||||
|
||||
relativeTransform.mul(orthoFrustumTemp);
|
||||
matrixGeneration++;
|
||||
if (pendingTransformOps != null) {
|
||||
pendingTransformOps.add(String.format("glFrustum(%.4f, %.4f, %.4f, %.4f, %.4f, %.4f)", left, right, bottom, top, zNear, zFar));
|
||||
}
|
||||
@@ -821,11 +770,6 @@ public class DisplayListManager {
|
||||
* GL_COMPILE_AND_EXECUTE: Commands are recorded AND executed (GLSM cache updated)
|
||||
*/
|
||||
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;
|
||||
|
||||
@@ -833,10 +777,8 @@ public class DisplayListManager {
|
||||
// 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,
|
||||
accumulatedPrimitiveDraws, relativeTransform,
|
||||
tessellatorCompiling, immediateModeRecorder, compilationStackTrace,
|
||||
pendingTransformOps, multMatrixSources, drawRangeSources
|
||||
glListId, glListMode, currentRecorder, accumulatedDraws, relativeTransform,
|
||||
compilationStackTrace, pendingTransformOps, multMatrixSources, drawRangeSources
|
||||
);
|
||||
compilationStack.push(parentContext);
|
||||
}
|
||||
@@ -846,15 +788,9 @@ public class DisplayListManager {
|
||||
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); // Immediate mode line draws are less common
|
||||
accumulatedPrimitiveDraws = new ArrayList<>(16); // Tessellator primitive draws are less common
|
||||
accumulatedDraws = new ArrayList<>(16); // Fewer draws than commands typically
|
||||
relativeTransform = new Matrix4fStack(GLStateManager.MAX_MODELVIEW_STACK_DEPTH);
|
||||
relativeTransform.identity(); // Delta from current GL state, starts at identity
|
||||
lastFlushedGeneration = -1; // Reset so first draw triggers flush
|
||||
lastFlushedTransform = null; // Will be set on first flush
|
||||
stateGeneration = 0; // Reset state generation for fresh list
|
||||
immediateModeRecorder = new ImmediateModeRecorder(); // For glBegin/glEnd/glVertex
|
||||
compilationStackTrace = LOG_DISPLAY_LIST_COMPILATION ? Thread.currentThread().getStackTrace() : null;
|
||||
|
||||
// Initialize debug logging fields (only when logging enabled)
|
||||
@@ -868,44 +804,12 @@ public class DisplayListManager {
|
||||
drawRangeSources = null;
|
||||
}
|
||||
|
||||
// Start compiling mode with per-draw callback (works for both root and nested lists now)
|
||||
// Callback receives quads (GL_QUADS) and primitives (GL_TRIANGLES, GL_LINES, etc.)
|
||||
TessellatorManager.setCompiling((quads, primitives, flags) -> {
|
||||
final boolean hasQuads = !quads.isEmpty();
|
||||
final boolean hasPrimitives = !primitives.isEmpty();
|
||||
|
||||
// Early exit to avoid allocations when nothing to accumulate
|
||||
if (!hasQuads && !hasPrimitives) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (matrixGeneration != lastFlushedGeneration) {
|
||||
if (lastFlushedTransform == null) {
|
||||
lastFlushedTransform = new Matrix4f();
|
||||
}
|
||||
lastFlushedTransform.set(relativeTransform);
|
||||
flushMatrix();
|
||||
lastFlushedGeneration = matrixGeneration;
|
||||
}
|
||||
|
||||
final Matrix4f currentTransform = new Matrix4f(lastFlushedTransform);
|
||||
final int currentGeneration = matrixGeneration;
|
||||
final int currentBatchId = stateGeneration;
|
||||
final int cmdIndex = getCommandCount();
|
||||
|
||||
// Accumulate quads for batching at glEndList()
|
||||
if (hasQuads) {
|
||||
accumulatedDraws.add(new AccumulatedDraw(quads, currentTransform, flags, cmdIndex, currentGeneration, currentBatchId));
|
||||
}
|
||||
|
||||
// Accumulate primitives (lines, triangles) for batching at glEndList()
|
||||
if (hasPrimitives) {
|
||||
accumulatedPrimitiveDraws.add(new AccumulatedPrimitiveDraw(primitives, currentTransform, flags, cmdIndex, currentGeneration, currentBatchId));
|
||||
TessellatorManager.startCapturingDirect((tessellator) -> {
|
||||
if (!tessellator.isEmpty()) {
|
||||
addAccumulatedDraw(tessellator, false);
|
||||
}
|
||||
return true;
|
||||
});
|
||||
tessellatorCompiling = true;
|
||||
|
||||
// We hijack display list compilation completely - no GL11.glNewList() calls
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -919,44 +823,26 @@ public class DisplayListManager {
|
||||
final boolean isNested = !compilationStack.isEmpty();
|
||||
|
||||
// Stop compiling mode (works for both root and nested lists now)
|
||||
if (tessellatorCompiling) {
|
||||
TessellatorManager.stopCompiling();
|
||||
tessellatorCompiling = false;
|
||||
}
|
||||
TessellatorManager.stopCapturingDirect();
|
||||
|
||||
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 CommandBuffer rawCommandBuffer = currentRecorder.getBuffer();
|
||||
final boolean hasCommands = !rawCommandBuffer.isEmpty();
|
||||
final boolean hasDraws = accumulatedDraws != null && !accumulatedDraws.isEmpty();
|
||||
final boolean hasLineDraws = accumulatedLineDraws != null && !accumulatedLineDraws.isEmpty();
|
||||
final boolean hasPrimitiveDraws = accumulatedPrimitiveDraws != null && !accumulatedPrimitiveDraws.isEmpty();
|
||||
|
||||
if (hasCommands || hasDraws || hasLineDraws || hasPrimitiveDraws) {
|
||||
if (hasCommands || hasDraws) {
|
||||
// Phase 1: Compile format-based VBOs (shared by both optimized and unoptimized paths)
|
||||
final Map<CapturingTessellator.Flags, CompiledFormatBuffer> compiledQuadBuffers = compileFormatBasedVBOs(accumulatedDraws);
|
||||
|
||||
// Phase 2: Compile immediate mode line VBO (shared by both paths)
|
||||
final CompiledLineBuffer compiledLineBuffer = compileLineBuffer(accumulatedLineDraws);
|
||||
|
||||
// Phase 3: Compile tessellator primitive VBOs (lines, triangles) - grouped by format
|
||||
final Map<CapturingTessellator.Flags, CompiledPrimitiveBuffers> compiledPrimitiveBuffers = compilePrimitiveBuffers(accumulatedPrimitiveDraws);
|
||||
|
||||
// Collect all owned VBOs (quads + immediate mode lines + tessellator primitives)
|
||||
final VertexBuffer[] ownedVbos = extractOwnedVbos(compiledQuadBuffers, compiledLineBuffer, compiledPrimitiveBuffers);
|
||||
final DisplayListVBO compiledBuffers = new DisplayListVBOBuilder().addDraws(accumulatedDraws).build();
|
||||
|
||||
// Build to CommandBuffer - optimize raw buffer to final buffer
|
||||
final CommandBuffer finalBuffer = new CommandBuffer();
|
||||
if (DEBUG_DISPLAY_LISTS) {
|
||||
CommandBufferBuilder.buildUnoptimizedFromRawBuffer(rawCommandBuffer, compiledQuadBuffers, compiledLineBuffer, compiledPrimitiveBuffers, ownedVbos, finalBuffer);
|
||||
} else {
|
||||
CommandBufferBuilder.buildOptimizedFromRawBuffer(rawCommandBuffer, compiledQuadBuffers, compiledLineBuffer, compiledPrimitiveBuffers, ownedVbos, glListId, finalBuffer);
|
||||
}
|
||||
CommandBufferBuilder.buildFromRawBuffer(rawCommandBuffer, accumulatedDraws, finalBuffer);
|
||||
|
||||
// Free the recorder (and its buffer) after optimization
|
||||
currentRecorder.free();
|
||||
|
||||
compiled = new CompiledDisplayList(finalBuffer.toBuffer(), finalBuffer.getComplexObjects(), ownedVbos);
|
||||
compiled = new CompiledDisplayList(finalBuffer.toBuffer(), finalBuffer.getComplexObjects(), compiledBuffers);
|
||||
} else {
|
||||
// Free the recorder even if empty
|
||||
if (currentRecorder != null) {
|
||||
@@ -982,11 +868,7 @@ public class DisplayListManager {
|
||||
glListMode = parentContext.listMode;
|
||||
currentRecorder = parentContext.recorder;
|
||||
accumulatedDraws = parentContext.draws;
|
||||
accumulatedLineDraws = parentContext.lineDraws;
|
||||
accumulatedPrimitiveDraws = parentContext.primitiveDraws;
|
||||
relativeTransform = parentContext.transform;
|
||||
tessellatorCompiling = parentContext.wasTessellatorCompiling;
|
||||
immediateModeRecorder = parentContext.immediateRecorder;
|
||||
compilationStackTrace = parentContext.stackTrace;
|
||||
pendingTransformOps = parentContext.pendingOps;
|
||||
multMatrixSources = parentContext.matrixSources;
|
||||
@@ -999,10 +881,7 @@ public class DisplayListManager {
|
||||
currentRecorder = null;
|
||||
recordingThread = null;
|
||||
accumulatedDraws = null;
|
||||
accumulatedLineDraws = null;
|
||||
accumulatedPrimitiveDraws = null;
|
||||
relativeTransform = null;
|
||||
immediateModeRecorder = null;
|
||||
compilationStackTrace = null;
|
||||
pendingTransformOps = null;
|
||||
multMatrixSources = null;
|
||||
@@ -1012,6 +891,31 @@ public class DisplayListManager {
|
||||
}
|
||||
}
|
||||
|
||||
private static void addAccumulatedDraw(DirectTessellator tessellator, boolean copyLast) {
|
||||
final int cmdIndex = getCommandCount();
|
||||
matrixBarrier();
|
||||
|
||||
if (accumulatedDraws.isEmpty()) {
|
||||
accumulatedDraws.add(
|
||||
new AccumulatedDraw(
|
||||
tessellator, cmdIndex, stateGeneration, copyLast
|
||||
)
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
// Merge the previous draw call if possible
|
||||
final AccumulatedDraw previous = accumulatedDraws.get(accumulatedDraws.size() - 1);
|
||||
if (previous.format == tessellator.getVertexFormat() && previous.stateGeneration == stateGeneration) {
|
||||
previous.mergeDraw(tessellator, copyLast);
|
||||
return;
|
||||
}
|
||||
|
||||
accumulatedDraws.add(
|
||||
new AccumulatedDraw(tessellator, cmdIndex, stateGeneration, copyLast)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute a compiled display list.
|
||||
*/
|
||||
@@ -1019,11 +923,22 @@ public class DisplayListManager {
|
||||
if (currentRecorder != null) {
|
||||
recordCallList(list);
|
||||
|
||||
if (glListMode == GL11.GL_COMPILE) {
|
||||
return;
|
||||
if (getListMode() != GL11.GL_COMPILE) {
|
||||
// Don't record the GL calls, we already recorded glCallList
|
||||
final CommandRecorder recorder = currentRecorder;
|
||||
currentRecorder = null;
|
||||
|
||||
executeDisplayList(list);
|
||||
|
||||
currentRecorder = recorder;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
executeDisplayList(list);
|
||||
}
|
||||
|
||||
private static void executeDisplayList(int list) {
|
||||
final CompiledDisplayList compiled = displayListCache.get(list);
|
||||
if (compiled != null) {
|
||||
final int prevList = currentRenderingList;
|
||||
@@ -1056,326 +971,19 @@ public class DisplayListManager {
|
||||
CompiledDisplayList compiled = displayListCache.remove(i);
|
||||
if (compiled != null) {
|
||||
compiled.delete();
|
||||
} else {
|
||||
GL11.glDeleteLists(i, 1);
|
||||
}
|
||||
}
|
||||
// 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,
|
||||
Map<CapturingTessellator.Flags, CompiledPrimitiveBuffers> compiledPrimitiveBuffers) {
|
||||
final List<VertexBuffer> vbos = new ArrayList<>();
|
||||
|
||||
// Add quad VBOs
|
||||
final CompiledFormatBuffer[] quadBufferArray = compiledQuadBuffers.values().toArray(new CompiledFormatBuffer[0]);
|
||||
for (int i = 0; i < quadBufferArray.length; i++) {
|
||||
vbos.add(quadBufferArray[i].vbo());
|
||||
}
|
||||
|
||||
// Add immediate mode line VBO if present
|
||||
if (compiledLineBuffer != null) {
|
||||
vbos.add(compiledLineBuffer.vbo());
|
||||
}
|
||||
|
||||
// Add tessellator primitive VBOs if present (one per format, separate for lines/triangles)
|
||||
if (!compiledPrimitiveBuffers.isEmpty()) {
|
||||
final CompiledPrimitiveBuffers[] primBufferArray = compiledPrimitiveBuffers.values().toArray(new CompiledPrimitiveBuffers[0]);
|
||||
for (int i = 0; i < primBufferArray.length; i++) {
|
||||
final CompiledPrimitiveBuffers primBuffers = primBufferArray[i];
|
||||
if (primBuffers.hasLines()) {
|
||||
vbos.add(primBuffers.lineVbo());
|
||||
}
|
||||
if (primBuffers.hasTriangles()) {
|
||||
vbos.add(primBuffers.triangleVbo());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return vbos.toArray(new VertexBuffer[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile tessellator primitives (lines, triangles) into format-based VBOs.
|
||||
* Groups draws by vertex format for optimal memory usage.
|
||||
*
|
||||
* @param primitiveDraws The accumulated primitive draws from tessellator callback
|
||||
* @return Map of flags to compiled primitive buffers, empty map if no primitives
|
||||
*/
|
||||
private static Map<CapturingTessellator.Flags, CompiledPrimitiveBuffers> compilePrimitiveBuffers(
|
||||
List<AccumulatedPrimitiveDraw> primitiveDraws) {
|
||||
if (primitiveDraws == null || primitiveDraws.isEmpty()) {
|
||||
return Collections.emptyMap();
|
||||
}
|
||||
|
||||
// Group draws by vertex format
|
||||
final Map<CapturingTessellator.Flags, TessellatorPrimitiveBuffer> formatBuffers = new HashMap<>();
|
||||
final int size = primitiveDraws.size();
|
||||
for (int i = 0; i < size; i++) {
|
||||
final AccumulatedPrimitiveDraw draw = primitiveDraws.get(i);
|
||||
formatBuffers.computeIfAbsent(draw.flags, TessellatorPrimitiveBuffer::new).addDraw(draw);
|
||||
}
|
||||
|
||||
// Compile each format's geometry into VBOs
|
||||
final Map<CapturingTessellator.Flags, CompiledPrimitiveBuffers> compiled = new HashMap<>();
|
||||
@SuppressWarnings("unchecked")
|
||||
final Map.Entry<CapturingTessellator.Flags, TessellatorPrimitiveBuffer>[] entries =
|
||||
formatBuffers.entrySet().toArray(new Map.Entry[0]);
|
||||
for (int i = 0; i < entries.length; i++) {
|
||||
final Map.Entry<CapturingTessellator.Flags, TessellatorPrimitiveBuffer> entry = entries[i];
|
||||
final CompiledPrimitiveBuffers result = entry.getValue().finish();
|
||||
if (result != null) {
|
||||
compiled.put(entry.getKey(), result);
|
||||
}
|
||||
}
|
||||
return compiled;
|
||||
}
|
||||
|
||||
// ==================== 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,
|
||||
Map<CapturingTessellator.Flags, CompiledPrimitiveBuffers> compiledPrimitiveBuffers,
|
||||
int glListId) {
|
||||
|
||||
final List<DisplayListCommand> optimized = new ArrayList<>();
|
||||
final TransformOptimizer transformOpt = new TransformOptimizer(glListId);
|
||||
|
||||
// Collect all merged draw ranges (quads + lines + primitives) sorted by command index
|
||||
final List<DrawRangeWithBuffer> allRanges = CommandBufferBuilder.collectDrawRanges(
|
||||
compiledQuadBuffers, compiledLineBuffer, compiledPrimitiveBuffers);
|
||||
|
||||
// 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<AccumulatedPrimitiveDraw> accumulatedPrimitiveDraws,
|
||||
int glListId) {
|
||||
// Compile quad VBOs
|
||||
final Map<CapturingTessellator.Flags, CompiledFormatBuffer> compiledQuadBuffers = compileFormatBasedVBOs(accumulatedDraws);
|
||||
|
||||
// Compile tessellator primitive VBOs (lines, triangles) - grouped by format
|
||||
final Map<CapturingTessellator.Flags, CompiledPrimitiveBuffers> compiledPrimitiveBuffers = compilePrimitiveBuffers(accumulatedPrimitiveDraws);
|
||||
|
||||
// Extract owned VBOs (quads + primitives, no immediate mode lines in test path)
|
||||
final VertexBuffer[] ownedVbos = extractOwnedVbos(compiledQuadBuffers, null, compiledPrimitiveBuffers);
|
||||
|
||||
// Build optimized commands using the new unified path
|
||||
final DisplayListCommand[] optimized = buildOptimizedCommands(currentCommands, compiledQuadBuffers, null, compiledPrimitiveBuffers, 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.
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
// ==================== DEBUG LOGGING ====================
|
||||
|
||||
private static void logCompiledDisplayList(int listId, CompiledDisplayList compiled, StackTraceElement[] stackTrace) {
|
||||
public static void logCompiledDisplayList(int listId, CompiledDisplayList compiled, StackTraceElement[] stackTrace) {
|
||||
LOGGER.debug(getCompiledDisplayListString(listId, compiled, stackTrace));
|
||||
}
|
||||
|
||||
public static String getCompiledDisplayListString(int listId, CompiledDisplayList compiled, StackTraceElement[] stackTrace) {
|
||||
final StringBuilder sb = new StringBuilder();
|
||||
sb.append("\n========== Display List Compiled: ID=").append(listId).append(" ==========\n");
|
||||
|
||||
@@ -1391,7 +999,7 @@ public class DisplayListManager {
|
||||
sb.append("Contents: No commands\n");
|
||||
} else {
|
||||
sb.append("Commands (").append(buffer.limit()).append(" bytes):\n");
|
||||
dumpCommandBuffer(buffer, compiled.getComplexObjects(), compiled.getOwnedVbos(), sb);
|
||||
dumpCommandBuffer(buffer, compiled.getComplexObjects(), sb);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1406,7 +1014,7 @@ public class DisplayListManager {
|
||||
}
|
||||
|
||||
sb.append("========== End Display List ").append(listId).append(" ==========\n");
|
||||
LOGGER.debug(sb.toString());
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
private static String identifySourceFromStackTrace(StackTraceElement[] stackTrace) {
|
||||
@@ -1487,143 +1095,97 @@ public class DisplayListManager {
|
||||
return className;
|
||||
}
|
||||
|
||||
private static void dumpCommandBuffer(ByteBuffer buffer, Object[] complexObjects, VertexBuffer[] ownedVbos, StringBuilder sb) {
|
||||
private static void dumpCommandBuffer(ByteBuffer buffer, Object[] complexObjects, StringBuilder sb) {
|
||||
if (buffer == null) return;
|
||||
|
||||
final long basePtr = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAddress(buffer);
|
||||
final long basePtr = memAddress(buffer);
|
||||
long ptr = basePtr;
|
||||
final long end = basePtr + buffer.limit();
|
||||
int cmdNum = 0;
|
||||
int multMatrixIdx = 0; // Index into multMatrixSources for source tracking
|
||||
int drawRangeIdx = 0; // Index into drawRangeSources for source tracking
|
||||
|
||||
while (ptr < end) {
|
||||
final int opcode = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr);
|
||||
final int opcode = memGetInt(ptr);
|
||||
final String cmdName = GLCommand.getName(opcode);
|
||||
sb.append(" ").append(cmdNum++).append(": ").append(cmdName);
|
||||
|
||||
// Add command-specific details
|
||||
switch (opcode) {
|
||||
case GLCommand.ENABLE, GLCommand.DISABLE -> {
|
||||
final int cap = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 4);
|
||||
final int cap = memGetInt(ptr + 4);
|
||||
sb.append("(").append(GLDebug.getCapabilityName(cap)).append(")");
|
||||
ptr += 8;
|
||||
}
|
||||
case GLCommand.BIND_TEXTURE -> {
|
||||
final int target = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 4);
|
||||
final int texture = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 8);
|
||||
final int target = memGetInt(ptr + 4);
|
||||
final int texture = memGetInt(ptr + 8);
|
||||
sb.append("(target=").append(target).append(", texture=").append(texture).append(")");
|
||||
ptr += 12;
|
||||
}
|
||||
case GLCommand.DRAW_RANGE -> {
|
||||
final int vboIdx = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 4);
|
||||
final int start = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 8);
|
||||
final int count = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 12);
|
||||
final int brightness = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 16);
|
||||
sb.append("(vbo=").append(vboIdx).append(", start=").append(start)
|
||||
.append(", count=").append(count).append(", brightness=").append(brightness != 0).append(")");
|
||||
final int vboIdx = memGetInt(ptr + 4);
|
||||
sb.append("(vbo=").append(vboIdx).append(")");
|
||||
// Show draw source if available
|
||||
if (drawRangeSources != null && drawRangeIdx < drawRangeSources.size()) {
|
||||
sb.append(" [from: ").append(drawRangeSources.get(drawRangeIdx)).append("]");
|
||||
}
|
||||
drawRangeIdx++;
|
||||
}
|
||||
case GLCommand.DRAW_RANGE_RESTORE -> {
|
||||
final int vboIdx = memGetInt(ptr + 4);
|
||||
final int start = memGetInt(ptr + 8);
|
||||
final int count = memGetInt(ptr + 12);
|
||||
final int brightness = memGetInt(ptr + 16);
|
||||
sb.append("(vbo=").append(vboIdx).append(", start=").append(start)
|
||||
.append(", count=").append(count).append(", brightness=").append(brightness != 0).append(")");
|
||||
// Show draw source if available
|
||||
if (drawRangeSources != null && drawRangeIdx < drawRangeSources.size()) {
|
||||
sb.append(" [from: ").append(drawRangeSources.get(drawRangeIdx)).append("]");
|
||||
}
|
||||
drawRangeIdx++;
|
||||
ptr += 20;
|
||||
}
|
||||
case GLCommand.MULT_MATRIX, GLCommand.LOAD_MATRIX -> {
|
||||
// Show source ops if available (only for MULT_MATRIX from recording phase)
|
||||
if (opcode == GLCommand.MULT_MATRIX && multMatrixSources != null && multMatrixIdx < multMatrixSources.size()) {
|
||||
final List<String> sources = multMatrixSources.get(multMatrixIdx);
|
||||
sb.append(" [from: ").append(String.join(" -> ", sources)).append("]");
|
||||
sb.append("(");
|
||||
for (int i = 0; i < 16; i++) {
|
||||
float value = MemoryUtilities.memGetFloat(ptr + 4 + i * 4);
|
||||
sb.append(i == 0 ? value : ", " + value);
|
||||
}
|
||||
multMatrixIdx++;
|
||||
ptr += 68; // cmd + 16 floats
|
||||
sb.append(")");
|
||||
}
|
||||
case GLCommand.COLOR -> {
|
||||
final float r = Float.intBitsToFloat(com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 4));
|
||||
final float g = Float.intBitsToFloat(com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 8));
|
||||
final float b = Float.intBitsToFloat(com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 12));
|
||||
final float a = Float.intBitsToFloat(com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 16));
|
||||
final float r = Float.intBitsToFloat(memGetInt(ptr + 4));
|
||||
final float g = Float.intBitsToFloat(memGetInt(ptr + 8));
|
||||
final float b = Float.intBitsToFloat(memGetInt(ptr + 12));
|
||||
final float a = Float.intBitsToFloat(memGetInt(ptr + 16));
|
||||
sb.append("(").append(r).append(", ").append(g).append(", ").append(b).append(", ").append(a).append(")");
|
||||
ptr += 20;
|
||||
}
|
||||
case GLCommand.DEPTH_MASK -> {
|
||||
final int flag = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 4);
|
||||
final int flag = memGetInt(ptr + 4);
|
||||
sb.append("(").append(flag != 0).append(")");
|
||||
ptr += 8;
|
||||
}
|
||||
case GLCommand.BLEND_FUNC -> {
|
||||
final int srcRgb = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 4);
|
||||
final int dstRgb = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 8);
|
||||
final int srcAlpha = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 12);
|
||||
final int dstAlpha = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 16);
|
||||
final int srcRgb = memGetInt(ptr + 4);
|
||||
final int dstRgb = memGetInt(ptr + 8);
|
||||
final int srcAlpha = memGetInt(ptr + 12);
|
||||
final int dstAlpha = memGetInt(ptr + 16);
|
||||
sb.append("(srcRgb=").append(srcRgb).append(", dstRgb=").append(dstRgb)
|
||||
.append(", srcAlpha=").append(srcAlpha).append(", dstAlpha=").append(dstAlpha).append(")");
|
||||
ptr += 20;
|
||||
}
|
||||
case GLCommand.CALL_LIST -> {
|
||||
final int calledList = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 4);
|
||||
final int calledList = memGetInt(ptr + 4);
|
||||
sb.append("(").append(calledList).append(")");
|
||||
ptr += 8;
|
||||
}
|
||||
case GLCommand.MATRIX_MODE -> {
|
||||
final int mode = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 4);
|
||||
final int mode = memGetInt(ptr + 4);
|
||||
sb.append("(").append(mode == GL11.GL_MODELVIEW ? "MODELVIEW" : mode == GL11.GL_PROJECTION ? "PROJECTION" : mode).append(")");
|
||||
ptr += 8;
|
||||
}
|
||||
case GLCommand.PUSH_MATRIX, GLCommand.POP_MATRIX, GLCommand.LOAD_IDENTITY -> ptr += 4;
|
||||
case GLCommand.COMPLEX_REF -> {
|
||||
final int idx = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 4);
|
||||
final int idx = memGetInt(ptr + 4);
|
||||
final Object obj = complexObjects != null && idx < complexObjects.length ? complexObjects[idx] : null;
|
||||
sb.append("(idx=").append(idx).append(", type=").append(obj != null ? obj.getClass().getSimpleName() : "null").append(")");
|
||||
ptr += 8;
|
||||
}
|
||||
default -> {
|
||||
// Skip based on command size (from CompiledDisplayList.getCommandSize logic)
|
||||
ptr += getCommandSize(opcode, ptr);
|
||||
}
|
||||
}
|
||||
ptr += GLCommand.getCommandSize(opcode, ptr);
|
||||
sb.append("\n");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the size of a command in bytes for buffer iteration.
|
||||
*/
|
||||
private static int getCommandSize(int cmd, long ptr) {
|
||||
return switch (cmd) {
|
||||
case GLCommand.LOAD_IDENTITY, GLCommand.PUSH_MATRIX, GLCommand.POP_MATRIX -> 4;
|
||||
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.STENCIL_MASK,
|
||||
GLCommand.DEPTH_MASK, GLCommand.FRONT_FACE, GLCommand.POINT_SIZE, GLCommand.LINE_WIDTH,
|
||||
GLCommand.CALL_LIST, GLCommand.COMPLEX_REF, GLCommand.DRAW_BUFFER -> 8;
|
||||
case GLCommand.BIND_TEXTURE, GLCommand.POLYGON_MODE, GLCommand.COLOR_MATERIAL,
|
||||
GLCommand.LINE_STIPPLE, GLCommand.STENCIL_MASK_SEPARATE, GLCommand.FOGI,
|
||||
GLCommand.HINT, GLCommand.POLYGON_OFFSET, GLCommand.ALPHA_FUNC, GLCommand.FOGF,
|
||||
GLCommand.LIGHT_MODELF, GLCommand.LIGHT_MODELI, GLCommand.CLEAR_DEPTH -> 12;
|
||||
case GLCommand.STENCIL_FUNC, GLCommand.STENCIL_OP, GLCommand.TEX_PARAMETERI,
|
||||
GLCommand.LIGHTF, GLCommand.LIGHTI, GLCommand.MATERIALF, GLCommand.TEX_PARAMETERF,
|
||||
GLCommand.NORMAL -> 16;
|
||||
case GLCommand.VIEWPORT, GLCommand.BLEND_FUNC, GLCommand.COLOR_MASK,
|
||||
GLCommand.STENCIL_FUNC_SEPARATE, GLCommand.STENCIL_OP_SEPARATE,
|
||||
GLCommand.COLOR, GLCommand.CLEAR_COLOR, GLCommand.BLEND_COLOR,
|
||||
GLCommand.DRAW_RANGE -> 20;
|
||||
case GLCommand.TRANSLATE, GLCommand.SCALE -> 28;
|
||||
case GLCommand.ROTATE -> 36;
|
||||
case GLCommand.ORTHO, GLCommand.FRUSTUM -> 52;
|
||||
case GLCommand.MULT_MATRIX, GLCommand.LOAD_MATRIX -> 68;
|
||||
case GLCommand.FOG, GLCommand.LIGHT_MODEL -> {
|
||||
final int count = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 8);
|
||||
yield 12 + count * 4;
|
||||
}
|
||||
case GLCommand.LIGHT, GLCommand.MATERIAL -> {
|
||||
final int count = com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt(ptr + 12);
|
||||
yield 16 + count * 4;
|
||||
}
|
||||
case GLCommand.DRAW_BUFFERS -> 40;
|
||||
default -> 8; // Default to 8 bytes to avoid infinite loop
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.AccumulatedDraw;
|
||||
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.
|
||||
*
|
||||
* <p>The restoreData field holds last vertex attributes for GL state restoration
|
||||
* after VBO rendering (immediate mode draws only). Null for tessellator draws.
|
||||
*/
|
||||
@Desugar
|
||||
public record DrawRange(
|
||||
int startVertex,
|
||||
int vertexCount,
|
||||
Matrix4f transform,
|
||||
int commandIndex,
|
||||
AccumulatedDraw.RestoreData restoreData
|
||||
) {
|
||||
DrawRange(int startVertex, int vertexCount, Matrix4f transform, int commandIndex) {
|
||||
this(startVertex, vertexCount, transform, commandIndex, null);
|
||||
}
|
||||
}
|
||||
@@ -1,43 +0,0 @@
|
||||
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;
|
||||
|
||||
/**
|
||||
* Helper record pairing a DrawRange with its VBO and vertex format flags.
|
||||
* 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,
|
||||
CapturingTessellator.Flags flags,
|
||||
DrawSource source
|
||||
) {
|
||||
boolean hasBrightness() {
|
||||
return flags != null && flags.hasBrightness;
|
||||
}
|
||||
|
||||
/**
|
||||
* Source of a draw command for debug logging.
|
||||
*/
|
||||
enum DrawSource {
|
||||
TESSELLATOR_QUADS("tessellator quads"),
|
||||
TESSELLATOR_LINES("tessellator lines"),
|
||||
TESSELLATOR_TRIANGLES("tessellator triangles"),
|
||||
IMMEDIATE_MODE_LINES("immediate mode lines");
|
||||
|
||||
private final String description;
|
||||
|
||||
DrawSource(String description) {
|
||||
this.description = description;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return description;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,106 +0,0 @@
|
||||
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.
|
||||
* Tracks merged ranges (same-transform draws combined) and per-draw ranges (1:1).
|
||||
*/
|
||||
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;
|
||||
private int pendingGeneration = -1;
|
||||
private int pendingStateGen = -1;
|
||||
// Track last restore data for merged draws (uses the LAST draw's data)
|
||||
private AccumulatedDraw.RestoreData pendingRestoreData = null;
|
||||
|
||||
FormatBuffer(CapturingTessellator.Flags flags) {
|
||||
this.flags = flags;
|
||||
}
|
||||
|
||||
/** Add a draw, tracking both merged and per-draw ranges. */
|
||||
void addDraw(AccumulatedDraw draw) {
|
||||
final int vertexCount = draw.quads.size() * 4; // 4 vertices per quad
|
||||
|
||||
// Always track per-draw range for unoptimized path (includes restoreData)
|
||||
perDrawRanges.add(new DrawRange(
|
||||
currentVertexOffset, vertexCount, draw.transform, draw.commandIndex, draw.restoreData
|
||||
));
|
||||
|
||||
// Merge logic for optimized path:
|
||||
// - same matrixGeneration = same matrix transform context
|
||||
// - same stateGeneration = no state commands (draw barriers) between draws
|
||||
boolean canMerge = pendingGeneration != -1
|
||||
&& pendingGeneration == draw.matrixGeneration
|
||||
&& pendingStateGen == draw.stateGeneration;
|
||||
|
||||
if (canMerge) {
|
||||
// Extend the pending range
|
||||
pendingVertexCount += vertexCount;
|
||||
// Update restoreData to the LAST draw's data (used after merged draw completes)
|
||||
pendingRestoreData = draw.restoreData;
|
||||
} else {
|
||||
// Flush pending range if any
|
||||
flushPendingRange();
|
||||
|
||||
// Start new pending range
|
||||
pendingStartVertex = currentVertexOffset;
|
||||
pendingVertexCount = vertexCount;
|
||||
pendingTransform = new Matrix4f(draw.transform);
|
||||
pendingCommandIndex = draw.commandIndex;
|
||||
pendingGeneration = draw.matrixGeneration;
|
||||
pendingStateGen = draw.stateGeneration;
|
||||
pendingRestoreData = draw.restoreData;
|
||||
}
|
||||
|
||||
allQuads.addAll(draw.quads);
|
||||
currentVertexOffset += vertexCount;
|
||||
}
|
||||
|
||||
private void flushPendingRange() {
|
||||
if (pendingGeneration != -1) {
|
||||
mergedRanges.add(new DrawRange(
|
||||
pendingStartVertex, pendingVertexCount, pendingTransform, pendingCommandIndex, pendingRestoreData
|
||||
));
|
||||
pendingTransform = null;
|
||||
pendingGeneration = -1;
|
||||
pendingStateGen = -1;
|
||||
pendingRestoreData = null;
|
||||
}
|
||||
}
|
||||
|
||||
/** Compile accumulated quads into a VBO. */
|
||||
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])
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -19,9 +19,6 @@ import org.lwjgl.opengl.GL43;
|
||||
import org.lwjgl.opengl.KHRDebug;
|
||||
import org.lwjgl.opengl.KHRDebugCallback;
|
||||
|
||||
import java.io.PrintStream;
|
||||
import java.util.function.Consumer;
|
||||
|
||||
import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
|
||||
import static org.lwjgl.opengl.ARBDebugOutput.glDebugMessageCallbackARB;
|
||||
|
||||
@@ -35,20 +32,9 @@ public final class GLDebug {
|
||||
LOGGER.warn("setupDebugMessageCallback called from non-main thread!");
|
||||
return 0;
|
||||
}
|
||||
return setupDebugMessageCallback(System.err);
|
||||
return setupDebugMessageCallbackImpl();
|
||||
}
|
||||
|
||||
private static void trace(Consumer<String> output) {
|
||||
/*
|
||||
* We can not just use a fixed stacktrace element offset, because some methods
|
||||
* are intercepted and some are not. So, check the package name.
|
||||
*/
|
||||
StackTraceElement[] elems = filterStackTrace(new Throwable(), 4).getStackTrace();
|
||||
for (StackTraceElement ste : elems) {
|
||||
output.accept(ste.toString());
|
||||
}
|
||||
}
|
||||
|
||||
public static Throwable filterStackTrace(Throwable throwable, int offset) {
|
||||
StackTraceElement[] elems = throwable.getStackTrace();
|
||||
StackTraceElement[] filtered = new StackTraceElement[elems.length];
|
||||
@@ -66,36 +52,48 @@ public final class GLDebug {
|
||||
return throwable;
|
||||
}
|
||||
|
||||
public static void printTrace(PrintStream stream) {
|
||||
trace(new Consumer<String>() {
|
||||
boolean first = true;
|
||||
private static String buildStackTrace() {
|
||||
StackTraceElement[] elems = filterStackTrace(new Throwable(), 4).getStackTrace();
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (StackTraceElement elem : elems) {
|
||||
sb.append("\n\t").append(elem.toString());
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
public void accept(String str) {
|
||||
if (first) {
|
||||
printDetail(stream, "Stacktrace", str);
|
||||
first = false;
|
||||
} else {
|
||||
printDetailLine(stream, "Stacktrace", str);
|
||||
}
|
||||
}
|
||||
});
|
||||
private static void logDebugMessage(int id, String source, String type, String severity, String message) {
|
||||
String fullMessage = String.format("[GL] %s %s (0x%X) from %s: %s%s", severity, type, id, source, message, buildStackTrace());
|
||||
|
||||
if ("HIGH".equals(severity)) {
|
||||
LOGGER.error(fullMessage);
|
||||
} else if ("MEDIUM".equals(severity)) {
|
||||
LOGGER.warn(fullMessage);
|
||||
} else {
|
||||
LOGGER.info(fullMessage);
|
||||
}
|
||||
}
|
||||
|
||||
private static void logDebugMessageAMD(int id, String category, String severity, String message) {
|
||||
String fullMessage = String.format("[GL] %s %s (0x%X): %s%s", severity, category, id, message, buildStackTrace());
|
||||
|
||||
if ("HIGH".equals(severity)) {
|
||||
LOGGER.error(fullMessage);
|
||||
} else if ("MEDIUM".equals(severity)) {
|
||||
LOGGER.warn(fullMessage);
|
||||
} else {
|
||||
LOGGER.info(fullMessage);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets up debug callbacks
|
||||
* @return 0 for failure, 1 for success, 2 for restart required.
|
||||
*/
|
||||
public static int setupDebugMessageCallback(PrintStream stream) {
|
||||
private static int setupDebugMessageCallbackImpl() {
|
||||
if (GLStateManager.capabilities.OpenGL43 || GLStateManager.capabilities.GL_KHR_debug) {
|
||||
LOGGER.info("[GL] Using OpenGL 4.3 for error logging.");
|
||||
KHRDebugCallback proc = new KHRDebugCallback((source, type, id, severity, message) -> {
|
||||
stream.println("[LWJGL] OpenGL debug message");
|
||||
printDetail(stream, "ID", String.format("0x%X", id));
|
||||
printDetail(stream, "Source", getDebugSource(source));
|
||||
printDetail(stream, "Type", getDebugType(type));
|
||||
printDetail(stream, "Severity", getDebugSeverity(severity));
|
||||
printDetail(stream, "Message", message);
|
||||
printTrace(stream);
|
||||
final KHRDebugCallback proc = new KHRDebugCallback((source, type, id, severity, message) -> {
|
||||
logDebugMessage(id, getDebugSource(source), getDebugType(type), getDebugSeverity(severity), message);
|
||||
});
|
||||
GL43.glDebugMessageControl(GL11.GL_DONT_CARE, GL11.GL_DONT_CARE, GL43.GL_DEBUG_SEVERITY_HIGH, null, true);
|
||||
GL43.glDebugMessageControl(GL11.GL_DONT_CARE, GL11.GL_DONT_CARE, GL43.GL_DEBUG_SEVERITY_MEDIUM, null, false);
|
||||
@@ -114,14 +112,8 @@ public final class GLDebug {
|
||||
return 1;
|
||||
} else if (GLStateManager.capabilities.GL_ARB_debug_output) {
|
||||
LOGGER.info("[GL] Using ARB_debug_output for error logging.");
|
||||
ARBDebugOutputCallback proc = new ARBDebugOutputCallback((source, type, id, severity, message) -> {
|
||||
stream.println("[LWJGL] ARB_debug_output message");
|
||||
printDetail(stream, "ID", String.format("0x%X", id));
|
||||
printDetail(stream, "Source", getSourceARB(source));
|
||||
printDetail(stream, "Type", getTypeARB(type));
|
||||
printDetail(stream, "Severity", getSeverityARB(severity));
|
||||
printDetail(stream, "Message", message);
|
||||
printTrace(stream);
|
||||
final ARBDebugOutputCallback proc = new ARBDebugOutputCallback((source, type, id, severity, message) -> {
|
||||
logDebugMessage(id, getSourceARB(source), getTypeARB(type), getSeverityARB(severity), message);
|
||||
});
|
||||
ARBDebugOutput.glDebugMessageControlARB(GL11.GL_DONT_CARE, GL11.GL_DONT_CARE, GL43.GL_DEBUG_SEVERITY_HIGH, null, true);
|
||||
ARBDebugOutput.glDebugMessageControlARB(GL11.GL_DONT_CARE, GL11.GL_DONT_CARE, GL43.GL_DEBUG_SEVERITY_MEDIUM, null, false);
|
||||
@@ -134,13 +126,8 @@ public final class GLDebug {
|
||||
return 1;
|
||||
} else if (GLStateManager.capabilities.GL_AMD_debug_output) {
|
||||
LOGGER.info("[GL] Using AMD_debug_output for error logging.");
|
||||
AMDDebugOutputCallback proc = new AMDDebugOutputCallback((id, category, severity, message) -> {
|
||||
stream.println("[LWJGL] AMD_debug_output message");
|
||||
printDetail(stream, "ID", String.format("0x%X", id));
|
||||
printDetail(stream, "Category", getCategoryAMD(category));
|
||||
printDetail(stream, "Severity", getSeverityAMD(severity));
|
||||
printDetail(stream, "Message", message);
|
||||
printTrace(stream);
|
||||
final AMDDebugOutputCallback proc = new AMDDebugOutputCallback((id, category, severity, message) -> {
|
||||
logDebugMessageAMD(id, getCategoryAMD(category), getSeverityAMD(severity), message);
|
||||
});
|
||||
AMDDebugOutput.glDebugMessageEnableAMD(0, GL43.GL_DEBUG_SEVERITY_HIGH, null, true);
|
||||
AMDDebugOutput.glDebugMessageEnableAMD(0, GL43.GL_DEBUG_SEVERITY_MEDIUM, null, false);
|
||||
@@ -176,17 +163,6 @@ public final class GLDebug {
|
||||
}
|
||||
}
|
||||
|
||||
private static void printDetail(PrintStream stream, String type, String message) {
|
||||
stream.printf("\t%s: %s\n", type, message);
|
||||
}
|
||||
|
||||
private static void printDetailLine(PrintStream stream, String type, String message) {
|
||||
stream.append(" ");
|
||||
for (int i = 0; i < type.length(); i++) {
|
||||
stream.append(" ");
|
||||
}
|
||||
stream.append(message).append("\n");
|
||||
}
|
||||
|
||||
private static String getDebugSource(int source) {
|
||||
return switch (source) {
|
||||
@@ -577,6 +553,57 @@ public final class GLDebug {
|
||||
};
|
||||
}
|
||||
|
||||
public static String getFramebufferStatusName(int status) {
|
||||
return switch (status) {
|
||||
case GL30.GL_FRAMEBUFFER_COMPLETE -> "COMPLETE";
|
||||
case GL30.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT -> "INCOMPLETE_ATTACHMENT";
|
||||
case GL30.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT -> "INCOMPLETE_MISSING_ATTACHMENT";
|
||||
case GL30.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER -> "INCOMPLETE_DRAW_BUFFER";
|
||||
case GL30.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER -> "INCOMPLETE_READ_BUFFER";
|
||||
case GL30.GL_FRAMEBUFFER_UNSUPPORTED -> "UNSUPPORTED";
|
||||
case GL30.GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE -> "INCOMPLETE_MULTISAMPLE";
|
||||
case 0 -> "NO_FRAMEBUFFER_BOUND";
|
||||
default -> String.format("UNKNOWN(0x%X)", status);
|
||||
};
|
||||
}
|
||||
|
||||
public static String getInternalFormatName(int format) {
|
||||
return switch (format) {
|
||||
// Basic
|
||||
case GL11.GL_RGBA -> "RGBA";
|
||||
case GL11.GL_RGB -> "RGB";
|
||||
// 8-bit normalized
|
||||
case GL30.GL_R8 -> "R8";
|
||||
case GL30.GL_RG8 -> "RG8";
|
||||
case GL11.GL_RGB8 -> "RGB8";
|
||||
case GL11.GL_RGBA8 -> "RGBA8";
|
||||
// 8-bit signed normalized
|
||||
case 0x8F94 -> "R8_SNORM";
|
||||
case 0x8F95 -> "RG8_SNORM";
|
||||
case 0x8F96 -> "RGB8_SNORM";
|
||||
case 0x8F97 -> "RGBA8_SNORM";
|
||||
// 16-bit normalized
|
||||
case GL30.GL_R16 -> "R16";
|
||||
case GL30.GL_RG16 -> "RG16";
|
||||
case GL11.GL_RGB16 -> "RGB16";
|
||||
case GL11.GL_RGBA16 -> "RGBA16";
|
||||
// 16-bit float
|
||||
case GL30.GL_R16F -> "R16F";
|
||||
case GL30.GL_RG16F -> "RG16F";
|
||||
case GL30.GL_RGB16F -> "RGB16F";
|
||||
case GL30.GL_RGBA16F -> "RGBA16F";
|
||||
// 32-bit float
|
||||
case GL30.GL_R32F -> "R32F";
|
||||
case GL30.GL_RG32F -> "RG32F";
|
||||
case GL30.GL_RGB32F -> "RGB32F";
|
||||
case GL30.GL_RGBA32F -> "RGBA32F";
|
||||
// Packed
|
||||
case GL30.GL_R11F_G11F_B10F -> "R11F_G11F_B10F";
|
||||
case GL11.GL_RGB10_A2 -> "RGB10_A2";
|
||||
default -> String.format("0x%X", format);
|
||||
};
|
||||
}
|
||||
|
||||
private static DebugState debugState;
|
||||
|
||||
private interface DebugState {
|
||||
|
||||
@@ -1,8 +1,10 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
|
||||
import com.gtnewhorizons.angelica.AngelicaMod;
|
||||
import com.gtnewhorizons.angelica.glsm.DisplayListManager.RecordMode;
|
||||
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.TexImage2DCmd;
|
||||
@@ -23,7 +25,6 @@ import com.gtnewhorizons.angelica.glsm.stacks.MatrixModeStack;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.PointStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.PolygonStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.StencilStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.TextureBindingStack;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.ViewPortStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.states.ClientArrayState;
|
||||
import com.gtnewhorizons.angelica.glsm.states.Color4;
|
||||
@@ -57,15 +58,19 @@ import org.joml.Vector3d;
|
||||
import org.joml.Vector3f;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.LWJGLException;
|
||||
import com.gtnewhorizon.gtnhlib.client.opengl.UniversalVAO;
|
||||
import org.lwjgl.opengl.ARBMultitexture;
|
||||
import org.lwjgl.opengl.ContextCapabilities;
|
||||
import org.lwjgl.opengl.Display;
|
||||
import org.lwjgl.opengl.Drawable;
|
||||
import org.lwjgl.opengl.EXTTextureFilterAnisotropic;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL12;
|
||||
import org.lwjgl.opengl.GL13;
|
||||
import org.lwjgl.opengl.GL14;
|
||||
import org.lwjgl.opengl.GL15;
|
||||
import org.lwjgl.opengl.GL20;
|
||||
import org.lwjgl.opengl.GL30;
|
||||
import org.lwjgl.opengl.Display;
|
||||
import org.lwjgl.opengl.GLContext;
|
||||
import org.lwjgl.opengl.KHRDebug;
|
||||
@@ -88,6 +93,8 @@ import static com.gtnewhorizons.angelica.glsm.Vendor.MESA;
|
||||
import static com.gtnewhorizons.angelica.glsm.Vendor.NVIDIA;
|
||||
import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
|
||||
|
||||
import static com.gtnewhorizon.gtnhlib.client.opengl.GLCaps.*;
|
||||
|
||||
/**
|
||||
* OpenGL State Manager - Provides cached state tracking and management for OpenGL operations.
|
||||
*
|
||||
@@ -330,6 +337,9 @@ public class GLStateManager {
|
||||
@Getter protected static int activeProgram = 0;
|
||||
@Getter protected static int listBase = 0;
|
||||
|
||||
@Getter protected static int boundVBO;
|
||||
@Getter protected static int boundVAO;
|
||||
|
||||
public static void reset() {
|
||||
runningSplash = true;
|
||||
while(!attribs.isEmpty()) {
|
||||
@@ -811,15 +821,21 @@ public class GLStateManager {
|
||||
case GL11.GL_MATRIX_MODE -> matrixMode.getMode();
|
||||
case GL11.GL_SHADE_MODEL -> shadeModelState.getValue();
|
||||
case GL11.GL_TEXTURE_BINDING_2D -> getBoundTextureForServerState();
|
||||
case GL11.GL_COLOR_MATERIAL_FACE -> colorMaterialFace.getValue();
|
||||
case GL11.GL_COLOR_MATERIAL_PARAMETER -> colorMaterialParameter.getValue();
|
||||
case GL11.GL_MODELVIEW_STACK_DEPTH -> getMatrixStackDepth(modelViewMatrix);
|
||||
case GL11.GL_PROJECTION_STACK_DEPTH -> getMatrixStackDepth(projectionMatrix);
|
||||
|
||||
case GL14.GL_BLEND_DST_ALPHA -> blendState.getDstAlpha();
|
||||
case GL14.GL_BLEND_DST_RGB -> blendState.getDstRgb();
|
||||
case GL14.GL_BLEND_SRC_ALPHA -> blendState.getSrcAlpha();
|
||||
case GL14.GL_BLEND_SRC_RGB -> blendState.getSrcRgb();
|
||||
case GL11.GL_COLOR_MATERIAL_FACE -> colorMaterialFace.getValue();
|
||||
case GL11.GL_COLOR_MATERIAL_PARAMETER -> colorMaterialParameter.getValue();
|
||||
|
||||
case GL15.GL_ARRAY_BUFFER_BINDING -> boundVBO;
|
||||
|
||||
case GL20.GL_CURRENT_PROGRAM -> activeProgram;
|
||||
case GL11.GL_MODELVIEW_STACK_DEPTH -> getMatrixStackDepth(modelViewMatrix);
|
||||
case GL11.GL_PROJECTION_STACK_DEPTH -> getMatrixStackDepth(projectionMatrix);
|
||||
|
||||
case GL30.GL_VERTEX_ARRAY_BINDING -> boundVAO;
|
||||
|
||||
default -> GL11.glGetInteger(pname);
|
||||
};
|
||||
@@ -1063,42 +1079,34 @@ public class GLStateManager {
|
||||
throw new UnsupportedOperationException("Not yet implemented (" + name + ")");
|
||||
}
|
||||
}
|
||||
|
||||
// Records glBegin/glEnd/glVertex and compiles them to a VBO
|
||||
// Currently only used inside of display lists
|
||||
|
||||
public static void glNormal3b(byte nx, byte ny, byte nz) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.setNormal(b2f(nx), b2f(ny), b2f(nz));
|
||||
}
|
||||
ImmediateModeRecorder.setNormal(b2f(nx), b2f(ny), b2f(nz));
|
||||
return;
|
||||
}
|
||||
GL11.glNormal3b(nx, ny, nz);
|
||||
}
|
||||
public static void glNormal3d(double nx, double ny, double nz) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.setNormal((float) nx, (float) ny, (float) nz);
|
||||
}
|
||||
ImmediateModeRecorder.setNormal((float) nx, (float) ny, (float) nz);
|
||||
return;
|
||||
}
|
||||
GL11.glNormal3d(nx, ny, nz);
|
||||
}
|
||||
public static void glNormal3f(float nx, float ny, float nz) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.setNormal(nx, ny, nz);
|
||||
}
|
||||
ImmediateModeRecorder.setNormal(nx, ny, nz);
|
||||
return;
|
||||
}
|
||||
GL11.glNormal3f(nx, ny, nz);
|
||||
}
|
||||
public static void glNormal3i(int nx, int ny, int nz) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.setNormal((float) nx, (float) ny, (float) nz);
|
||||
}
|
||||
ImmediateModeRecorder.setNormal((float) nx, (float) ny, (float) nz);
|
||||
return;
|
||||
}
|
||||
GL11.glNormal3i(nx, ny, nz);
|
||||
@@ -1534,80 +1542,56 @@ public class GLStateManager {
|
||||
|
||||
public static void glTexCoord1f(float s) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.setTexCoord(s, 0.0f);
|
||||
}
|
||||
ImmediateModeRecorder.setTexCoord(s, 0.0f);
|
||||
return;
|
||||
}
|
||||
GL11.glTexCoord1f(s);
|
||||
}
|
||||
public static void glTexCoord1d(double s) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.setTexCoord((float) s, 0.0f);
|
||||
}
|
||||
ImmediateModeRecorder.setTexCoord((float) s, 0.0f);
|
||||
return;
|
||||
}
|
||||
GL11.glTexCoord1d(s);
|
||||
}
|
||||
public static void glTexCoord2f(float s, float t) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.setTexCoord(s, t);
|
||||
}
|
||||
ImmediateModeRecorder.setTexCoord(s, t);
|
||||
return;
|
||||
}
|
||||
GL11.glTexCoord2f(s, t);
|
||||
}
|
||||
public static void glTexCoord2d(double s, double t) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.setTexCoord((float) s, (float) t);
|
||||
}
|
||||
ImmediateModeRecorder.setTexCoord((float) s, (float) t);
|
||||
return;
|
||||
}
|
||||
GL11.glTexCoord2d(s, t);
|
||||
}
|
||||
public static void glTexCoord3f(float s, float t, float r) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.setTexCoord(s, t); // Only track s,t for 2D textures
|
||||
}
|
||||
ImmediateModeRecorder.setTexCoord(s, t); // Only track s,t for 2D textures
|
||||
return;
|
||||
}
|
||||
GL11.glTexCoord3f(s, t, r);
|
||||
}
|
||||
public static void glTexCoord3d(double s, double t, double r) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.setTexCoord((float) s, (float) t);
|
||||
}
|
||||
ImmediateModeRecorder.setTexCoord((float) s, (float) t);
|
||||
return;
|
||||
}
|
||||
GL11.glTexCoord3d(s, t, r);
|
||||
}
|
||||
public static void glTexCoord4f(float s, float t, float r, float q) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.setTexCoord(s, t);
|
||||
}
|
||||
ImmediateModeRecorder.setTexCoord(s, t);
|
||||
return;
|
||||
}
|
||||
GL11.glTexCoord4f(s, t, r, q);
|
||||
}
|
||||
public static void glTexCoord4d(double s, double t, double r, double q) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.setTexCoord((float) s, (float) t);
|
||||
}
|
||||
ImmediateModeRecorder.setTexCoord((float) s, (float) t);
|
||||
return;
|
||||
}
|
||||
GL11.glTexCoord4d(s, t, r, q);
|
||||
@@ -1747,10 +1731,7 @@ public class GLStateManager {
|
||||
public static void glBegin(int mode) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
// Record to immediate mode recorder
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.begin(mode);
|
||||
}
|
||||
ImmediateModeRecorder.begin(mode);
|
||||
return; // Don't call actual GL during recording
|
||||
}
|
||||
GL11.glBegin(mode);
|
||||
@@ -1759,14 +1740,10 @@ public class GLStateManager {
|
||||
public static void glEnd() {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
// Record to immediate mode recorder and flush geometry immediately
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
// end() returns quads immediately (like tessellator callback)
|
||||
final ImmediateModeRecorder.Result result = recorder.end();
|
||||
if (result != null) {
|
||||
// Add draw at current command position for correct interleaving
|
||||
DisplayListManager.addImmediateModeDraw(result);
|
||||
}
|
||||
final DirectTessellator result = ImmediateModeRecorder.end();
|
||||
if (result != null) {
|
||||
// Add draw at current command position for correct interleaving
|
||||
DisplayListManager.addImmediateModeDraw(result);
|
||||
}
|
||||
return; // Don't call actual GL during recording
|
||||
}
|
||||
@@ -1778,10 +1755,7 @@ public class GLStateManager {
|
||||
public static void glVertex2f(float x, float y) {
|
||||
final boolean recording = DisplayListManager.isRecording();
|
||||
if (recording) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.vertex(x, y, 0.0f);
|
||||
}
|
||||
ImmediateModeRecorder.vertex(x, y, 0.0f);
|
||||
return;
|
||||
}
|
||||
GL11.glVertex2f(x, y);
|
||||
@@ -1789,10 +1763,7 @@ public class GLStateManager {
|
||||
|
||||
public static void glVertex2d(double x, double y) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.vertex((float) x, (float) y, 0.0f);
|
||||
}
|
||||
ImmediateModeRecorder.vertex((float) x, (float) y, 0.0f);
|
||||
return;
|
||||
}
|
||||
GL11.glVertex2d(x, y);
|
||||
@@ -1800,10 +1771,7 @@ public class GLStateManager {
|
||||
|
||||
public static void glVertex3f(float x, float y, float z) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.vertex(x, y, z);
|
||||
}
|
||||
ImmediateModeRecorder.vertex(x, y, z);
|
||||
return;
|
||||
}
|
||||
GL11.glVertex3f(x, y, z);
|
||||
@@ -1811,10 +1779,7 @@ public class GLStateManager {
|
||||
|
||||
public static void glVertex3d(double x, double y, double z) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
recorder.vertex((float) x, (float) y, (float) z);
|
||||
}
|
||||
ImmediateModeRecorder.vertex((float) x, (float) y, (float) z);
|
||||
return;
|
||||
}
|
||||
GL11.glVertex3d(x, y, z);
|
||||
@@ -1840,13 +1805,6 @@ public class GLStateManager {
|
||||
GL11.glDrawElements(mode, indices);
|
||||
}
|
||||
|
||||
public static void glDrawElements(int mode, int indices_count, int type, long indices_buffer_offset) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
throw new UnsupportedOperationException("glDrawElements in display lists not yet implemented - if you see this, please report!");
|
||||
}
|
||||
GL11.glDrawElements(mode, indices_count, type, indices_buffer_offset);
|
||||
}
|
||||
|
||||
public static void glDrawElements(int mode, int count, int type, ByteBuffer indices) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
throw new UnsupportedOperationException("glDrawElements in display lists not yet implemented - if you see this, please report!");
|
||||
@@ -1854,6 +1812,21 @@ public class GLStateManager {
|
||||
GL11.glDrawElements(mode, count, type, indices);
|
||||
}
|
||||
|
||||
public static void glDrawElements(int mode, int indices_count, int type, long indices_buffer_offset) {
|
||||
final RecordMode recordMode = DisplayListManager.getRecordMode();
|
||||
if (recordMode != RecordMode.NONE) {
|
||||
if (isVAOBound()) {
|
||||
DisplayListManager.recordDrawElements(mode, indices_count, type, indices_buffer_offset);
|
||||
} else {
|
||||
throw new UnsupportedOperationException("glDrawElements in display lists not yet implemented - if you see this, please report!");
|
||||
}
|
||||
if (recordMode == RecordMode.COMPILE) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
GL11.glDrawElements(mode, indices_count, type, indices_buffer_offset);
|
||||
}
|
||||
|
||||
public static void glDrawBuffer(int mode) {
|
||||
final RecordMode recordMode = DisplayListManager.getRecordMode();
|
||||
if (recordMode != RecordMode.NONE) {
|
||||
@@ -1867,12 +1840,13 @@ public class GLStateManager {
|
||||
|
||||
public static void glDrawArrays(int mode, int first, int count) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
final ImmediateModeRecorder recorder = DisplayListManager.getImmediateModeRecorder();
|
||||
if (recorder != null) {
|
||||
final ImmediateModeRecorder.Result result = recorder.processDrawArrays(mode, first, count);
|
||||
if (result != null) {
|
||||
DisplayListManager.addImmediateModeDraw(result);
|
||||
}
|
||||
if (isVAOBound() || isVBOBound()) { // TODO VBO rendering needs to be replaced with proper VAO compilation
|
||||
DisplayListManager.recordDrawArrays(mode, first, count);
|
||||
return;
|
||||
}
|
||||
final DirectTessellator result = ImmediateModeRecorder.processDrawArrays(mode, first, count);
|
||||
if (result != null) {
|
||||
DisplayListManager.addImmediateModeDraw(result);
|
||||
}
|
||||
return;
|
||||
}
|
||||
@@ -1883,52 +1857,70 @@ public class GLStateManager {
|
||||
// State is tracked globally in clientArrayState, which ImmediateModeRecorder reads from directly.
|
||||
|
||||
public static void glVertexPointer(int size, int stride, FloatBuffer pointer) {
|
||||
clientArrayState.setVertexPointer(size, GL11.GL_FLOAT, stride, pointer);
|
||||
if (!isVAOBound()) {
|
||||
clientArrayState.setVertexPointer(size, GL11.GL_FLOAT, stride, pointer);
|
||||
}
|
||||
GL11.glVertexPointer(size, stride, pointer);
|
||||
}
|
||||
|
||||
public static void glVertexPointer(int size, int type, int stride, ByteBuffer pointer) {
|
||||
clientArrayState.setVertexPointer(size, type, stride, pointer);
|
||||
if (!isVAOBound()) {
|
||||
clientArrayState.setVertexPointer(size, type, stride, pointer);
|
||||
}
|
||||
GL11.glVertexPointer(size, type, stride, pointer);
|
||||
}
|
||||
|
||||
public static void glVertexPointer(int size, int type, int stride, long pointer_buffer_offset) {
|
||||
// VBO offset - can't track buffer reference, clear it
|
||||
clientArrayState.setVertexPointer(size, type, stride, null);
|
||||
if (!isVAOBound()) {
|
||||
// VBO offset - can't track buffer reference, clear it
|
||||
clientArrayState.setVertexPointer(size, type, stride, null);
|
||||
}
|
||||
GL11.glVertexPointer(size, type, stride, pointer_buffer_offset);
|
||||
}
|
||||
|
||||
public static void glColorPointer(int size, int stride, FloatBuffer pointer) {
|
||||
clientArrayState.setColorPointer(size, GL11.GL_FLOAT, stride, pointer);
|
||||
if (!isVAOBound()) {
|
||||
clientArrayState.setColorPointer(size, GL11.GL_FLOAT, stride, pointer);
|
||||
}
|
||||
GL11.glColorPointer(size, stride, pointer);
|
||||
}
|
||||
|
||||
public static void glColorPointer(int size, int type, int stride, ByteBuffer pointer) {
|
||||
clientArrayState.setColorPointer(size, type, stride, pointer);
|
||||
if (!isVAOBound()) {
|
||||
clientArrayState.setColorPointer(size, type, stride, pointer);
|
||||
}
|
||||
GL11.glColorPointer(size, type, stride, pointer);
|
||||
}
|
||||
|
||||
public static void glColorPointer(int size, boolean unsigned, int stride, ByteBuffer pointer) {
|
||||
final int type = unsigned ? GL11.GL_UNSIGNED_BYTE : GL11.GL_BYTE;
|
||||
clientArrayState.setColorPointer(size, type, stride, pointer);
|
||||
if (!isVAOBound()) {
|
||||
final int type = unsigned ? GL11.GL_UNSIGNED_BYTE : GL11.GL_BYTE;
|
||||
clientArrayState.setColorPointer(size, type, stride, pointer);
|
||||
}
|
||||
GL11.glColorPointer(size, unsigned, stride, pointer);
|
||||
}
|
||||
|
||||
public static void glColorPointer(int size, int type, int stride, long pointer_buffer_offset) {
|
||||
// VBO offset - can't track buffer reference, clear it
|
||||
clientArrayState.setColorPointer(size, type, stride, null);
|
||||
if (!isVAOBound()) {
|
||||
// VBO offset - can't track buffer reference, clear it
|
||||
clientArrayState.setColorPointer(size, type, stride, null);
|
||||
}
|
||||
GL11.glColorPointer(size, type, stride, pointer_buffer_offset);
|
||||
}
|
||||
|
||||
public static void glEnableClientState(int cap) {
|
||||
if (cap == GL11.GL_VERTEX_ARRAY) clientArrayState.setVertexArrayEnabled(true);
|
||||
else if (cap == GL11.GL_COLOR_ARRAY) clientArrayState.setColorArrayEnabled(true);
|
||||
if (!isVAOBound()) {
|
||||
if (cap == GL11.GL_VERTEX_ARRAY) clientArrayState.setVertexArrayEnabled(true);
|
||||
else if (cap == GL11.GL_COLOR_ARRAY) clientArrayState.setColorArrayEnabled(true);
|
||||
}
|
||||
GL11.glEnableClientState(cap);
|
||||
}
|
||||
|
||||
public static void glDisableClientState(int cap) {
|
||||
if (cap == GL11.GL_VERTEX_ARRAY) clientArrayState.setVertexArrayEnabled(false);
|
||||
else if (cap == GL11.GL_COLOR_ARRAY) clientArrayState.setColorArrayEnabled(false);
|
||||
if (!isVAOBound()) {
|
||||
if (cap == GL11.GL_VERTEX_ARRAY) clientArrayState.setVertexArrayEnabled(false);
|
||||
else if (cap == GL11.GL_COLOR_ARRAY) clientArrayState.setColorArrayEnabled(false);
|
||||
}
|
||||
GL11.glDisableClientState(cap);
|
||||
}
|
||||
|
||||
@@ -2815,7 +2807,7 @@ public class GLStateManager {
|
||||
if (isRecordingDisplayList()) {
|
||||
throw new IllegalStateException(String.format(
|
||||
"glGetTexParameteri called during display list recording with no cached TextureInfo for texture %d. " +
|
||||
"Cannot query OpenGL state during compilation!", texture));
|
||||
"Cannot query OpenGL state during compilation!", texture));
|
||||
}
|
||||
return defaultSupplier.getAsInt();
|
||||
}
|
||||
@@ -2831,7 +2823,7 @@ public class GLStateManager {
|
||||
if (isRecordingDisplayList()) {
|
||||
throw new IllegalStateException(String.format(
|
||||
"glGetTexParameteri called during display list recording with uncached pname 0x%s for texture %d. " +
|
||||
"Cannot query OpenGL state during compilation!", Integer.toHexString(pname), texture));
|
||||
"Cannot query OpenGL state during compilation!", Integer.toHexString(pname), texture));
|
||||
}
|
||||
yield defaultSupplier.getAsInt();
|
||||
}
|
||||
@@ -3770,6 +3762,38 @@ public class GLStateManager {
|
||||
}
|
||||
}
|
||||
|
||||
public static void glBindBuffer(int target, int buffer) {
|
||||
if (target == GL15.GL_ARRAY_BUFFER) {
|
||||
// if (boundVBO == buffer) return; TODO figure out why this breaks switching async occlusion mode
|
||||
boundVBO = buffer;
|
||||
}
|
||||
GL15.glBindBuffer(target, buffer);
|
||||
}
|
||||
|
||||
public static void glBindVertexArray(int array) {
|
||||
if (DisplayListManager.isRecording()) {
|
||||
DisplayListManager.recordBindVAO(array);
|
||||
// Since the vao needs to be bound to do stuff like state setup & data upload, it'll still execute the bind call.
|
||||
// This is technically wrong, but I'm not sure if there's a better solution here.
|
||||
}
|
||||
if (boundVAO != array) {
|
||||
boundVAO = array;
|
||||
UniversalVAO.bindVertexArray(array);
|
||||
}
|
||||
}
|
||||
|
||||
public static void glBindVertexArrayAPPLE(int array) {
|
||||
glBindVertexArray(array);
|
||||
}
|
||||
|
||||
public static boolean isVBOBound() {
|
||||
return boundVBO != 0;
|
||||
}
|
||||
|
||||
public static boolean isVAOBound() {
|
||||
return boundVAO != 0;
|
||||
}
|
||||
|
||||
public static boolean vendorIsAMD() {
|
||||
return VENDOR == AMD;
|
||||
}
|
||||
@@ -3786,4 +3810,62 @@ public class GLStateManager {
|
||||
return VENDOR == NVIDIA;
|
||||
}
|
||||
|
||||
@Getter protected static int drawFramebuffer = 0;
|
||||
@Getter protected static int readFramebuffer = 0;
|
||||
|
||||
public static void glBindFramebuffer(int target, int framebuffer) {
|
||||
if (target == GL30.GL_FRAMEBUFFER) {
|
||||
if (drawFramebuffer == framebuffer && readFramebuffer == framebuffer) return;
|
||||
drawFramebuffer = framebuffer;
|
||||
readFramebuffer = framebuffer;
|
||||
} else if (target == GL30.GL_DRAW_FRAMEBUFFER) {
|
||||
if (drawFramebuffer == framebuffer) return;
|
||||
drawFramebuffer = framebuffer;
|
||||
} else if (target == GL30.GL_READ_FRAMEBUFFER) {
|
||||
if (readFramebuffer == framebuffer) return;
|
||||
readFramebuffer = framebuffer;
|
||||
}
|
||||
GL30.glBindFramebuffer(target, framebuffer);
|
||||
}
|
||||
|
||||
public static void glDeleteFramebuffers(int framebuffer) {
|
||||
if (drawFramebuffer == framebuffer) drawFramebuffer = 0;
|
||||
if (readFramebuffer == framebuffer) readFramebuffer = 0;
|
||||
GL30.glDeleteFramebuffers(framebuffer);
|
||||
}
|
||||
|
||||
public static int glGenFramebuffers() {
|
||||
return GL30.glGenFramebuffers();
|
||||
}
|
||||
|
||||
public static int glCheckFramebufferStatus(int target) {
|
||||
return GL30.glCheckFramebufferStatus(target);
|
||||
}
|
||||
|
||||
public static void glFramebufferTexture2D(int target, int attachment, int textarget, int texture, int level) {
|
||||
GL30.glFramebufferTexture2D(target, attachment, textarget, texture, level);
|
||||
}
|
||||
|
||||
public static void setActiveTexture(int textureUnit) {
|
||||
glActiveTexture(textureUnit);
|
||||
}
|
||||
|
||||
public static void setLightmapTextureCoords(int unit, float x, float y) {
|
||||
GL13.glMultiTexCoord2f(unit, x, y);
|
||||
if (unit == GL13.GL_TEXTURE1) {
|
||||
OpenGlHelper.lastBrightnessX = x;
|
||||
OpenGlHelper.lastBrightnessY = y;
|
||||
}
|
||||
}
|
||||
|
||||
private static void checkMismatch(int cap) {
|
||||
if (GLStateManager.glGetInteger(cap) != GL11.glGetInteger(cap)) {
|
||||
throw new IllegalStateException("GLSM Mismatch! Cached: " + GLStateManager.glGetInteger(cap) + ", actual: " + GL11.glGetInteger(cap));
|
||||
}
|
||||
}
|
||||
|
||||
public static boolean isFramebufferEnabled() {
|
||||
return OpenGlHelper.framebufferSupported && Minecraft.getMinecraft().gameSettings.fboEnable;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,134 +0,0 @@
|
||||
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;
|
||||
private int pendingStateGen = -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:
|
||||
// - same transform
|
||||
// - same stateGeneration = no state commands (draw barriers) between draws
|
||||
boolean canMerge = pendingTransform != null
|
||||
&& pendingTransform.equals(draw.transform)
|
||||
&& pendingStateGen == draw.stateGeneration;
|
||||
|
||||
if (canMerge) {
|
||||
// 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;
|
||||
pendingStateGen = draw.stateGeneration;
|
||||
}
|
||||
|
||||
allVertices.addAll(draw.lines);
|
||||
currentVertexOffset += vertexCount;
|
||||
}
|
||||
|
||||
private void flushPendingRange() {
|
||||
if (pendingTransform != null) {
|
||||
mergedRanges.add(new DrawRange(pendingStartVertex, pendingVertexCount, pendingTransform, pendingCommandIndex));
|
||||
pendingTransform = null;
|
||||
pendingStateGen = -1;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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;
|
||||
}
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
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) {}
|
||||
@@ -4,6 +4,7 @@ import com.gtnewhorizons.angelica.glsm.dsa.DSAARB;
|
||||
import com.gtnewhorizons.angelica.glsm.dsa.DSAAccess;
|
||||
import com.gtnewhorizons.angelica.glsm.dsa.DSACore;
|
||||
import com.gtnewhorizons.angelica.glsm.dsa.DSAUnsupported;
|
||||
import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
@@ -28,6 +29,8 @@ import org.lwjgl.opengl.GL43;
|
||||
import org.lwjgl.opengl.GL44;
|
||||
import org.lwjgl.opengl.NVXGpuMemoryInfo;
|
||||
|
||||
import net.coderbot.iris.gl.shader.StandardMacros;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
import java.nio.IntBuffer;
|
||||
@@ -44,9 +47,12 @@ public class RenderSystem {
|
||||
private static boolean supportsSSBO;
|
||||
private static boolean supportsBufferStorage;
|
||||
private static boolean supportsClearTexture;
|
||||
private static boolean supportsTesselation;
|
||||
private static boolean supportsSamplerObjects;
|
||||
private static int maxImageUnits;
|
||||
private static int maxSSBOBindings;
|
||||
private static int maxGlslVersion;
|
||||
private static boolean supportsGpuShader4;
|
||||
|
||||
// Sampler object state tracking (null if unsupported)
|
||||
private static int[] samplers;
|
||||
@@ -73,6 +79,7 @@ public class RenderSystem {
|
||||
}
|
||||
|
||||
supportsCompute = supportsCompute();
|
||||
supportsTesselation = GLStateManager.capabilities.GL_ARB_tessellation_shader || GLStateManager.capabilities.OpenGL40;
|
||||
|
||||
supportsImageLoadStore = GLStateManager.capabilities.OpenGL42 || GLStateManager.capabilities.GL_ARB_shader_image_load_store || GLStateManager.capabilities.GL_EXT_shader_image_load_store;
|
||||
supportsSSBO = GLStateManager.capabilities.OpenGL43 || GLStateManager.capabilities.GL_ARB_shader_storage_buffer_object;
|
||||
@@ -110,6 +117,10 @@ public class RenderSystem {
|
||||
samplers = new int[GL11.glGetInteger(GL20.GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS)];
|
||||
}
|
||||
|
||||
maxGlslVersion = Integer.parseInt(StandardMacros.getGlVersion(GL20.GL_SHADING_LANGUAGE_VERSION));
|
||||
supportsGpuShader4 = GLStateManager.capabilities.GL_EXT_gpu_shader4;
|
||||
|
||||
LOGGER.info("Max GLSL version: {}, GPU Shader4: {}", maxGlslVersion, supportsGpuShader4);
|
||||
LOGGER.info("Image Load/Store: {}, Max Image Units: {}", supportsImageLoadStore, maxImageUnits);
|
||||
LOGGER.info("SSBO: {}, Max SSBO Bindings: {}", supportsSSBO, maxSSBOBindings);
|
||||
LOGGER.info("Buffer Storage: {}, Clear Texture: {}, Sampler Objects: {}", supportsBufferStorage, supportsClearTexture, supportsSamplerObjects);
|
||||
@@ -124,8 +135,11 @@ public class RenderSystem {
|
||||
}
|
||||
|
||||
public static void texImage2D(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable ByteBuffer pixels) {
|
||||
GL11.glBindTexture(target, texture);
|
||||
GLStateManager.glBindTexture(target, texture);
|
||||
GL11.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
|
||||
if (target == GL11.GL_TEXTURE_2D && level == 0) {
|
||||
TextureInfoCache.INSTANCE.onTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
|
||||
}
|
||||
}
|
||||
|
||||
public static void uniformMatrix4fv(int location, boolean transpose, FloatBuffer matrix) {
|
||||
@@ -318,7 +332,7 @@ public class RenderSystem {
|
||||
}
|
||||
|
||||
public static void bindBuffer(int target, int buffer) {
|
||||
GL15.glBindBuffer(target, buffer);
|
||||
GLStateManager.glBindBuffer(target, buffer);
|
||||
}
|
||||
|
||||
public static void memoryBarrier(int barriers) {
|
||||
@@ -407,10 +421,12 @@ public class RenderSystem {
|
||||
}
|
||||
|
||||
public static void clearBufferSubData(int target, int internalFormat, long offset, long size, int format, int type, int[] data) {
|
||||
final ByteBuffer buf = BufferUtils.createByteBuffer(data.length * 4);
|
||||
buf.asIntBuffer().put(data);
|
||||
if (GLStateManager.capabilities.OpenGL43) {
|
||||
GL43.glClearBufferSubData(target, internalFormat, offset, size, format, type, (ByteBuffer) null);
|
||||
GL43.glClearBufferSubData(target, internalFormat, offset, size, format, type, buf);
|
||||
} else if (GLStateManager.capabilities.GL_ARB_clear_buffer_object) {
|
||||
ARBClearBufferObject.glClearBufferSubData(target, internalFormat, offset, size, format, type, (ByteBuffer) null);
|
||||
ARBClearBufferObject.glClearBufferSubData(target, internalFormat, offset, size, format, type, buf);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -447,6 +463,26 @@ public class RenderSystem {
|
||||
dsaState.textureStorage3D(texture, target, levels, internalFormat, width, height, depth);
|
||||
}
|
||||
|
||||
public static int getMaxGlslVersion() {
|
||||
return maxGlslVersion;
|
||||
}
|
||||
|
||||
public static boolean supportsGpuShader4() {
|
||||
return supportsGpuShader4;
|
||||
}
|
||||
|
||||
public static boolean supportsSnormFormats() {
|
||||
return GLStateManager.capabilities.OpenGL31;
|
||||
}
|
||||
|
||||
public static boolean supportsPackedFloatRenderable() {
|
||||
return GLStateManager.capabilities.OpenGL30 && maxGlslVersion >= 130;
|
||||
}
|
||||
|
||||
public static boolean supportsTesselation() {
|
||||
return supportsTesselation;
|
||||
}
|
||||
|
||||
public static boolean supportsSamplerObjects() {
|
||||
return supportsSamplerObjects;
|
||||
}
|
||||
|
||||
@@ -1,246 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.line.ModelLine;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.primitive.ModelPrimitiveView;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.tri.ModelTriangle;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.VAOManager;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.glsm.recording.AccumulatedPrimitiveDraw;
|
||||
import org.joml.Matrix4f;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Accumulates tessellator primitives (lines, triangles) for a single vertex format during display list compilation.
|
||||
* Similar to FormatBuffer but handles ModelPrimitiveView instances instead of quads.
|
||||
* <p>
|
||||
* Unlike LineBuffer which handles ImmediateModeRecorder.LineVertex (fixed 16-byte: pos+color),
|
||||
* this handles ModelLine/ModelTriangle from the tessellator with format-optimized vertex size.
|
||||
* <p>
|
||||
* Primitives are separated by draw mode (GL_LINES, GL_TRIANGLES) into separate VBOs.
|
||||
*/
|
||||
class TessellatorPrimitiveBuffer {
|
||||
final CapturingTessellator.Flags flags;
|
||||
|
||||
// Accumulated primitives separated by type
|
||||
final List<ModelLine> allLines = new ArrayList<>();
|
||||
final List<ModelTriangle> allTriangles = new ArrayList<>();
|
||||
|
||||
// Ranges for lines
|
||||
final List<DrawRange> lineMergedRanges = new ArrayList<>();
|
||||
final List<DrawRange> linePerDrawRanges = new ArrayList<>();
|
||||
int currentLineVertexOffset = 0;
|
||||
private int pendingLineStartVertex = -1;
|
||||
private int pendingLineVertexCount = 0;
|
||||
private Matrix4f pendingLineTransform = null;
|
||||
private int pendingLineCommandIndex = -1;
|
||||
private int pendingLineStateGen = -1;
|
||||
|
||||
// Ranges for triangles
|
||||
final List<DrawRange> triangleMergedRanges = new ArrayList<>();
|
||||
final List<DrawRange> trianglePerDrawRanges = new ArrayList<>();
|
||||
int currentTriangleVertexOffset = 0;
|
||||
private int pendingTriangleStartVertex = -1;
|
||||
private int pendingTriangleVertexCount = 0;
|
||||
private Matrix4f pendingTriangleTransform = null;
|
||||
private int pendingTriangleCommandIndex = -1;
|
||||
private int pendingTriangleStateGen = -1;
|
||||
|
||||
TessellatorPrimitiveBuffer(CapturingTessellator.Flags flags) {
|
||||
this.flags = flags;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a primitive draw to this buffer.
|
||||
* Separates lines and triangles, tracking ranges for both merged and per-draw paths.
|
||||
*/
|
||||
void addDraw(AccumulatedPrimitiveDraw draw) {
|
||||
final List<ModelPrimitiveView> primitives = draw.primitives;
|
||||
final int size = primitives.size();
|
||||
|
||||
// Single pass: count and collect primitives by type
|
||||
int lineCount = 0;
|
||||
int triangleCount = 0;
|
||||
for (int i = 0; i < size; i++) {
|
||||
final ModelPrimitiveView prim = primitives.get(i);
|
||||
if (prim instanceof ModelLine ml) {
|
||||
allLines.add(ml);
|
||||
lineCount++;
|
||||
} else if (prim instanceof ModelTriangle mt) {
|
||||
allTriangles.add(mt);
|
||||
triangleCount++;
|
||||
}
|
||||
}
|
||||
|
||||
// Process lines
|
||||
if (lineCount > 0) {
|
||||
final int lineVertexCount = lineCount * 2; // 2 vertices per line
|
||||
linePerDrawRanges.add(new DrawRange(currentLineVertexOffset, lineVertexCount, draw.transform, draw.commandIndex));
|
||||
|
||||
// Merge logic for optimized path:
|
||||
// - same transform
|
||||
// - same stateGeneration = no state commands (draw barriers) between draws
|
||||
boolean canMerge = pendingLineTransform != null
|
||||
&& pendingLineTransform.equals(draw.transform)
|
||||
&& pendingLineStateGen == draw.stateGeneration;
|
||||
|
||||
if (canMerge) {
|
||||
pendingLineVertexCount += lineVertexCount;
|
||||
} else {
|
||||
flushPendingLineRange();
|
||||
pendingLineStartVertex = currentLineVertexOffset;
|
||||
pendingLineVertexCount = lineVertexCount;
|
||||
pendingLineTransform = new Matrix4f(draw.transform);
|
||||
pendingLineCommandIndex = draw.commandIndex;
|
||||
pendingLineStateGen = draw.stateGeneration;
|
||||
}
|
||||
currentLineVertexOffset += lineVertexCount;
|
||||
}
|
||||
|
||||
// Process triangles
|
||||
if (triangleCount > 0) {
|
||||
final int triangleVertexCount = triangleCount * 3; // 3 vertices per triangle
|
||||
trianglePerDrawRanges.add(new DrawRange(currentTriangleVertexOffset, triangleVertexCount, draw.transform, draw.commandIndex));
|
||||
|
||||
// Merge logic for optimized path:
|
||||
// - same transform
|
||||
// - same stateGeneration = no state commands (draw barriers) between draws
|
||||
boolean canMerge = pendingTriangleTransform != null
|
||||
&& pendingTriangleTransform.equals(draw.transform)
|
||||
&& pendingTriangleStateGen == draw.stateGeneration;
|
||||
|
||||
if (canMerge) {
|
||||
pendingTriangleVertexCount += triangleVertexCount;
|
||||
} else {
|
||||
flushPendingTriangleRange();
|
||||
pendingTriangleStartVertex = currentTriangleVertexOffset;
|
||||
pendingTriangleVertexCount = triangleVertexCount;
|
||||
pendingTriangleTransform = new Matrix4f(draw.transform);
|
||||
pendingTriangleCommandIndex = draw.commandIndex;
|
||||
pendingTriangleStateGen = draw.stateGeneration;
|
||||
}
|
||||
currentTriangleVertexOffset += triangleVertexCount;
|
||||
}
|
||||
}
|
||||
|
||||
private void flushPendingLineRange() {
|
||||
if (pendingLineTransform != null) {
|
||||
lineMergedRanges.add(new DrawRange(pendingLineStartVertex, pendingLineVertexCount, pendingLineTransform, pendingLineCommandIndex));
|
||||
pendingLineTransform = null;
|
||||
pendingLineStateGen = -1;
|
||||
}
|
||||
}
|
||||
|
||||
private void flushPendingTriangleRange() {
|
||||
if (pendingTriangleTransform != null) {
|
||||
triangleMergedRanges.add(new DrawRange(pendingTriangleStartVertex, pendingTriangleVertexCount, pendingTriangleTransform, pendingTriangleCommandIndex));
|
||||
pendingTriangleTransform = null;
|
||||
pendingTriangleStateGen = -1;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile all accumulated primitives into VBOs using optimal vertex format.
|
||||
* @return The compiled buffers with separate VBOs for lines and triangles, or null if empty
|
||||
*/
|
||||
CompiledPrimitiveBuffers finish() {
|
||||
flushPendingLineRange();
|
||||
flushPendingTriangleRange();
|
||||
|
||||
if (allLines.isEmpty() && allTriangles.isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// Use optimal format based on flags (same logic as quads)
|
||||
final VertexFormat format = DisplayListManager.selectOptimalFormat(flags);
|
||||
|
||||
final VertexBuffer lineVbo = allLines.isEmpty() ? null : compileLinesToVBO(format);
|
||||
final VertexBuffer triangleVbo = allTriangles.isEmpty() ? null : compileTrianglesToVBO(format);
|
||||
|
||||
return new CompiledPrimitiveBuffers(
|
||||
flags,
|
||||
lineVbo,
|
||||
lineMergedRanges.toArray(new DrawRange[0]),
|
||||
linePerDrawRanges.toArray(new DrawRange[0]),
|
||||
triangleVbo,
|
||||
triangleMergedRanges.toArray(new DrawRange[0]),
|
||||
trianglePerDrawRanges.toArray(new DrawRange[0])
|
||||
);
|
||||
}
|
||||
|
||||
private VertexBuffer compileLinesToVBO(VertexFormat format) {
|
||||
final int vertexSize = format.getVertexSize();
|
||||
final int size = allLines.size();
|
||||
final ByteBuffer buffer = BufferUtils.createByteBuffer(vertexSize * size * 2);
|
||||
|
||||
for (int i = 0; i < size; i++) {
|
||||
writePrimitiveToBuffer(allLines.get(i), buffer);
|
||||
}
|
||||
buffer.flip();
|
||||
|
||||
final VertexBuffer vbo = VAOManager.createVAO(format, GL11.GL_LINES);
|
||||
vbo.upload(buffer);
|
||||
return vbo;
|
||||
}
|
||||
|
||||
private VertexBuffer compileTrianglesToVBO(VertexFormat format) {
|
||||
final int vertexSize = format.getVertexSize();
|
||||
final int size = allTriangles.size();
|
||||
final ByteBuffer buffer = BufferUtils.createByteBuffer(vertexSize * size * 3);
|
||||
|
||||
for (int i = 0; i < size; i++) {
|
||||
writePrimitiveToBuffer(allTriangles.get(i), buffer);
|
||||
}
|
||||
buffer.flip();
|
||||
|
||||
final VertexBuffer vbo = VAOManager.createVAO(format, GL11.GL_TRIANGLES);
|
||||
vbo.upload(buffer);
|
||||
return vbo;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a primitive's vertices to the buffer using the format specified by flags.
|
||||
* Only writes attributes that are present in the format.
|
||||
*/
|
||||
private void writePrimitiveToBuffer(ModelPrimitiveView prim, ByteBuffer buffer) {
|
||||
final int vertexCount = prim.getVertexCount();
|
||||
final boolean hasTexture = flags.hasTexture;
|
||||
final boolean hasBrightness = flags.hasBrightness;
|
||||
final boolean hasColor = flags.hasColor;
|
||||
final boolean hasNormals = flags.hasNormals;
|
||||
|
||||
for (int i = 0; i < vertexCount; i++) {
|
||||
// Position (always present) - 12 bytes
|
||||
buffer.putFloat(prim.getX(i));
|
||||
buffer.putFloat(prim.getY(i));
|
||||
buffer.putFloat(prim.getZ(i));
|
||||
|
||||
// Color (4 bytes, ABGR) - if present
|
||||
if (hasColor) {
|
||||
buffer.putInt(prim.getColor(i));
|
||||
}
|
||||
|
||||
// Texture (2 floats = 8 bytes) - if present
|
||||
if (hasTexture) {
|
||||
buffer.putFloat(prim.getTexU(i));
|
||||
buffer.putFloat(prim.getTexV(i));
|
||||
}
|
||||
|
||||
// Light/Brightness (4 bytes, packed) - if present
|
||||
if (hasBrightness) {
|
||||
buffer.putInt(prim.getLight(i));
|
||||
}
|
||||
|
||||
// Normal (4 bytes, packed) - if present
|
||||
if (hasNormals) {
|
||||
buffer.putInt(prim.getForgeNormal(i));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2,7 +2,6 @@ package com.gtnewhorizons.angelica.glsm.dsa;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import net.minecraft.client.renderer.OpenGlHelper;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL12;
|
||||
import org.lwjgl.opengl.GL13;
|
||||
@@ -77,13 +76,13 @@ public class DSAUnsupported implements DSAAccess {
|
||||
|
||||
@Override
|
||||
public void readBuffer(int framebuffer, int buffer) {
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_FRAMEBUFFER, framebuffer);
|
||||
GLStateManager.glBindFramebuffer(GL30.GL_FRAMEBUFFER, framebuffer);
|
||||
GL11.glReadBuffer(buffer);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void drawBuffers(int framebuffer, IntBuffer buffers) {
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_FRAMEBUFFER, framebuffer);
|
||||
GLStateManager.glBindFramebuffer(GL30.GL_FRAMEBUFFER, framebuffer);
|
||||
GL20.glDrawBuffers(buffers);
|
||||
}
|
||||
|
||||
@@ -125,9 +124,9 @@ public class DSAUnsupported implements DSAAccess {
|
||||
@Override
|
||||
public int bufferStorage(int target, FloatBuffer data, int usage) {
|
||||
final int buffer = GL15.glGenBuffers();
|
||||
GL15.glBindBuffer(target, buffer);
|
||||
GLStateManager.glBindBuffer(target, buffer);
|
||||
RenderSystem.bufferData(target, data, usage);
|
||||
GL15.glBindBuffer(target, 0);
|
||||
GLStateManager.glBindBuffer(target, 0);
|
||||
|
||||
return buffer;
|
||||
}
|
||||
@@ -135,21 +134,21 @@ public class DSAUnsupported implements DSAAccess {
|
||||
@Override
|
||||
public void blitFramebuffer(int source, int dest, int offsetX, int offsetY, int width, int height, int offsetX2, int offsetY2, int width2, int height2,
|
||||
int bufferChoice, int filter) {
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_READ_FRAMEBUFFER, source);
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_DRAW_FRAMEBUFFER, dest);
|
||||
GLStateManager.glBindFramebuffer(GL30.GL_READ_FRAMEBUFFER, source);
|
||||
GLStateManager.glBindFramebuffer(GL30.GL_DRAW_FRAMEBUFFER, dest);
|
||||
GL30.glBlitFramebuffer(offsetX, offsetY, width, height, offsetX2, offsetY2, width2, height2, bufferChoice, filter);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void framebufferTexture2D(int fb, int fbtarget, int attachment, int target, int texture, int levels) {
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(fbtarget, fb);
|
||||
GLStateManager.glBindFramebuffer(fbtarget, fb);
|
||||
GL30.glFramebufferTexture2D(fbtarget, attachment, target, texture, levels);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int createFramebuffer() {
|
||||
final int framebuffer = OpenGlHelper.func_153165_e/*glGenFramebuffers*/();
|
||||
OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_FRAMEBUFFER, framebuffer);
|
||||
final int framebuffer = GLStateManager.glGenFramebuffers();
|
||||
GLStateManager.glBindFramebuffer(GL30.GL_FRAMEBUFFER, framebuffer);
|
||||
return framebuffer;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,11 +1,10 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
import com.github.bsideup.jabel.Desugar;
|
||||
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 com.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
@@ -13,54 +12,53 @@ import java.util.List;
|
||||
* 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 class AccumulatedDraw {
|
||||
public final VertexFormat format;
|
||||
public final List<ByteBuffer> drawBuffers;
|
||||
public final int drawMode;
|
||||
public final int commandIndex; // Position in command list for state tracking
|
||||
public final int matrixGeneration; // For batching: same generation = same transform context
|
||||
public final int stateGeneration; // Same value = no state commands between draws, can merge
|
||||
public final int stateGeneration; // Position in command list for state tracking
|
||||
public RestoreData restoreData;
|
||||
|
||||
/**
|
||||
* Last vertex restoration data for immediate mode draws.
|
||||
* Null for tessellator draws (no restoration needed).
|
||||
*/
|
||||
public final RestoreData restoreData;
|
||||
public AccumulatedDraw(DirectTessellator tessellator, int commandIndex, int stateGeneration, boolean copyLast) {
|
||||
this.format = tessellator.getVertexFormat();
|
||||
this.drawMode = tessellator.drawMode;
|
||||
this.drawBuffers = new ArrayList<>();
|
||||
this.drawBuffers.add(tessellator.allocateBufferCopy());
|
||||
this.commandIndex = commandIndex;
|
||||
this.stateGeneration = stateGeneration;
|
||||
|
||||
if (copyLast) {
|
||||
this.restoreData = new RestoreData(tessellator);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public void mergeDraw(DirectTessellator tessellator, boolean copyLast) {
|
||||
this.drawBuffers.add(tessellator.allocateBufferCopy());
|
||||
|
||||
if (copyLast) {
|
||||
this.restoreData = new RestoreData(tessellator);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Holds last vertex attribute values for GL state restoration after VBO draw.
|
||||
* Used to sync GLSM cache with actual GL state after VBO rendering.
|
||||
*/
|
||||
@Desugar
|
||||
public record RestoreData(
|
||||
float lastColorR, float lastColorG, float lastColorB, float lastColorA,
|
||||
float lastNormalX, float lastNormalY, float lastNormalZ,
|
||||
float lastTexCoordS, float lastTexCoordT) {}
|
||||
public static final class RestoreData {
|
||||
public final int lastColor;
|
||||
public final int lastNormal;
|
||||
public final float lastTexCoordU;
|
||||
public final float lastTexCoordV;
|
||||
public final int flags;
|
||||
|
||||
public AccumulatedDraw(List<ModelQuadViewMutable> quads, Matrix4f transform, CapturingTessellator.Flags flags, int commandIndex, int matrixGeneration) {
|
||||
this(quads, transform, flags, commandIndex, matrixGeneration, 0, null);
|
||||
}
|
||||
|
||||
public AccumulatedDraw(List<ModelQuadViewMutable> quads, Matrix4f transform, CapturingTessellator.Flags flags, int commandIndex, int matrixGeneration, int stateGeneration) {
|
||||
this(quads, transform, flags, commandIndex, matrixGeneration, stateGeneration, null);
|
||||
}
|
||||
|
||||
public AccumulatedDraw(List<ModelQuadViewMutable> quads, Matrix4f transform, CapturingTessellator.Flags flags, int commandIndex, int matrixGeneration, int stateGeneration, RestoreData restoreData) {
|
||||
// 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;
|
||||
this.matrixGeneration = matrixGeneration;
|
||||
this.stateGeneration = stateGeneration;
|
||||
this.restoreData = restoreData;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return String.format("AccumulatedDraw[quads=%d, cmdIdx=%d, matrixGen=%d, stateGen=%d, flags=C%dT%dL%dN%d, restore=%s]",
|
||||
quads.size(), commandIndex, matrixGeneration, stateGeneration, flags.hasColor ? 1 : 0, flags.hasTexture ? 1 : 0, flags.hasBrightness ? 1 : 0, flags.hasNormals ? 1 : 0,
|
||||
restoreData != null ? "yes" : "no");
|
||||
public RestoreData(DirectTessellator tessellator) {
|
||||
this.lastColor = tessellator.getPackedColor();
|
||||
this.lastNormal = tessellator.getPackedNormal();
|
||||
this.lastTexCoordU = (float) tessellator.getLastTextureU();
|
||||
this.lastTexCoordV = (float) tessellator.getLastTextureV();
|
||||
this.flags = tessellator.getVertexFormat().getVertexFlags();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
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 final int stateGeneration; // Same value = no state commands between draws, can merge
|
||||
|
||||
public AccumulatedLineDraw(List<ImmediateModeRecorder.LineVertex> lines, Matrix4f transform, CapturingTessellator.Flags flags, int commandIndex) {
|
||||
this(lines, transform, flags, commandIndex, 0);
|
||||
}
|
||||
|
||||
public AccumulatedLineDraw(List<ImmediateModeRecorder.LineVertex> lines, Matrix4f transform, CapturingTessellator.Flags flags, int commandIndex, int stateGeneration) {
|
||||
// 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;
|
||||
this.stateGeneration = stateGeneration;
|
||||
}
|
||||
|
||||
@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);
|
||||
}
|
||||
}
|
||||
@@ -1,66 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.line.ModelLine;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.primitive.ModelPrimitiveView;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.tri.ModelTriangle;
|
||||
import org.joml.Matrix4f;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Represents an accumulated primitive draw call during display list compilation.
|
||||
* Stores primitives (lines, triangles) from tessellator callback with their transform.
|
||||
* <p>
|
||||
* Unlike AccumulatedLineDraw which stores ImmediateModeRecorder.LineVertex (16-byte: pos+color),
|
||||
* this stores ModelPrimitiveView (32-byte: pos+color+tex+light+normal) from the tessellator.
|
||||
*/
|
||||
public class AccumulatedPrimitiveDraw {
|
||||
public final List<ModelPrimitiveView> primitives;
|
||||
public final Matrix4f transform;
|
||||
public final CapturingTessellator.Flags flags;
|
||||
public final int commandIndex;
|
||||
public final int matrixGeneration; // For batching: same generation = same transform context
|
||||
public final int stateGeneration; // Same value = no state commands between draws, can merge
|
||||
|
||||
public AccumulatedPrimitiveDraw(List<ModelPrimitiveView> primitives, Matrix4f transform, CapturingTessellator.Flags flags, int commandIndex, int matrixGeneration) {
|
||||
this(primitives, transform, flags, commandIndex, matrixGeneration, 0);
|
||||
}
|
||||
|
||||
public AccumulatedPrimitiveDraw(List<ModelPrimitiveView> primitives, Matrix4f transform, CapturingTessellator.Flags flags, int commandIndex, int matrixGeneration, int stateGeneration) {
|
||||
// Deep copy primitives - pooled primitives are reused after callback
|
||||
this.primitives = deepCopyPrimitives(primitives);
|
||||
this.transform = new Matrix4f(transform);
|
||||
this.flags = flags;
|
||||
this.commandIndex = commandIndex;
|
||||
this.matrixGeneration = matrixGeneration;
|
||||
this.stateGeneration = stateGeneration;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates deep copies of all primitives in the list.
|
||||
* Required because CapturingTessellator pools and reuses primitive objects.
|
||||
*/
|
||||
private static List<ModelPrimitiveView> deepCopyPrimitives(List<ModelPrimitiveView> source) {
|
||||
final int size = source.size();
|
||||
final List<ModelPrimitiveView> copies = new ArrayList<>(size);
|
||||
for (int i = 0; i < size; i++) {
|
||||
final ModelPrimitiveView prim = source.get(i);
|
||||
if (prim instanceof ModelLine ml) {
|
||||
copies.add(new ModelLine().copyFrom(ml));
|
||||
} else if (prim instanceof ModelTriangle mt) {
|
||||
copies.add(new ModelTriangle().copyFrom(mt));
|
||||
}
|
||||
}
|
||||
return copies;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return String.format("AccumulatedPrimitiveDraw[primitives=%d, cmdIdx=%d, matrixGen=%d, stateGen=%d, mode=%d, flags=C%dT%dL%dN%d]",
|
||||
primitives.size(), commandIndex, matrixGeneration, stateGeneration, flags.drawMode,
|
||||
flags.hasColor ? 1 : 0, flags.hasTexture ? 1 : 0,
|
||||
flags.hasBrightness ? 1 : 0, flags.hasNormals ? 1 : 0);
|
||||
}
|
||||
}
|
||||
@@ -14,12 +14,6 @@ import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*;
|
||||
public final class CommandBuffer {
|
||||
private static final int DEFAULT_CAPACITY = 4096; // Guess at typical display list size
|
||||
|
||||
// Flag bits for DRAW_RANGE_RESTORE command
|
||||
public static final int FLAG_HAS_BRIGHTNESS = 1 << 0;
|
||||
public static final int FLAG_HAS_COLOR = 1 << 1;
|
||||
public static final int FLAG_HAS_NORMALS = 1 << 2;
|
||||
public static final int FLAG_HAS_TEXTURE = 1 << 3;
|
||||
|
||||
private ByteBuffer buffer;
|
||||
private long basePointer;
|
||||
private long writePointer;
|
||||
@@ -42,6 +36,11 @@ public final class CommandBuffer {
|
||||
writePointer += 4;
|
||||
}
|
||||
|
||||
private void writeLong(long value) {
|
||||
memPutLong(writePointer, value);
|
||||
writePointer += 8;
|
||||
}
|
||||
|
||||
private void writeFloat(float value) {
|
||||
memPutFloat(writePointer, value);
|
||||
writePointer += 4;
|
||||
@@ -548,13 +547,10 @@ public final class CommandBuffer {
|
||||
|
||||
// === Draw commands ===
|
||||
|
||||
public void writeDrawRange(int vboIndex, int startVertex, int vertexCount, boolean hasBrightness) {
|
||||
ensureCapacity(20);
|
||||
public void writeDrawRange(int vboIndex) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.DRAW_RANGE);
|
||||
writeInt(vboIndex);
|
||||
writeInt(startVertex);
|
||||
writeInt(vertexCount);
|
||||
writeInt(hasBrightness ? 1 : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -562,51 +558,21 @@ public final class CommandBuffer {
|
||||
* Used for immediate mode VBOs to restore GL_CURRENT_COLOR, GL_CURRENT_NORMAL, GL_CURRENT_TEXTURE_COORDS.
|
||||
*
|
||||
* @param vboIndex Index into ownedVbos array
|
||||
* @param startVertex First vertex to draw
|
||||
* @param vertexCount Number of vertices to draw
|
||||
* @param hasBrightness True if VBO has brightness/lightmap data
|
||||
* @param hasColor True if color should be restored after draw
|
||||
* @param hasNormals True if normal should be restored after draw
|
||||
* @param hasTexture True if texcoord should be restored after draw
|
||||
* @param lastColorR Last vertex's red color component
|
||||
* @param lastColorG Last vertex's green color component
|
||||
* @param lastColorB Last vertex's blue color component
|
||||
* @param lastColorA Last vertex's alpha color component
|
||||
* @param lastNormalX Last vertex's normal X
|
||||
* @param lastNormalY Last vertex's normal Y
|
||||
* @param lastNormalZ Last vertex's normal Z
|
||||
* @param lastTexS Last vertex's texture S coordinate
|
||||
* @param lastTexT Last vertex's texture T coordinate
|
||||
*/
|
||||
public void writeDrawRangeRestore(
|
||||
int vboIndex, int startVertex, int vertexCount,
|
||||
boolean hasBrightness, boolean hasColor, boolean hasNormals, boolean hasTexture,
|
||||
float lastColorR, float lastColorG, float lastColorB, float lastColorA,
|
||||
float lastNormalX, float lastNormalY, float lastNormalZ,
|
||||
float lastTexS, float lastTexT
|
||||
int vboIndex, AccumulatedDraw.RestoreData restoreData
|
||||
) {
|
||||
ensureCapacity(56);
|
||||
ensureCapacity(28);
|
||||
writeInt(GLCommand.DRAW_RANGE_RESTORE);
|
||||
writeInt(vboIndex);
|
||||
writeInt(startVertex);
|
||||
writeInt(vertexCount);
|
||||
int flags = (hasBrightness ? FLAG_HAS_BRIGHTNESS : 0)
|
||||
| (hasColor ? FLAG_HAS_COLOR : 0)
|
||||
| (hasNormals ? FLAG_HAS_NORMALS : 0)
|
||||
| (hasTexture ? FLAG_HAS_TEXTURE : 0);
|
||||
writeInt(flags);
|
||||
// Last color (4 floats = 16 bytes)
|
||||
writeFloat(lastColorR);
|
||||
writeFloat(lastColorG);
|
||||
writeFloat(lastColorB);
|
||||
writeFloat(lastColorA);
|
||||
// Last normal (3 floats = 12 bytes)
|
||||
writeFloat(lastNormalX);
|
||||
writeFloat(lastNormalY);
|
||||
writeFloat(lastNormalZ);
|
||||
writeInt(restoreData.flags);
|
||||
// Last color (4 bytes)
|
||||
writeInt(restoreData.lastColor);
|
||||
// Last normal (4 bytes)
|
||||
writeInt(restoreData.lastNormal);
|
||||
// Last texcoord (2 floats = 8 bytes)
|
||||
writeFloat(lastTexS);
|
||||
writeFloat(lastTexT);
|
||||
writeFloat(restoreData.lastTexCoordU);
|
||||
writeFloat(restoreData.lastTexCoordV);
|
||||
}
|
||||
|
||||
public void writeCallList(int listId) {
|
||||
@@ -615,6 +581,35 @@ public final class CommandBuffer {
|
||||
writeInt(listId);
|
||||
}
|
||||
|
||||
public void writeDrawArrays(int mode, int start, int count) {
|
||||
ensureCapacity(16);
|
||||
writeInt(GLCommand.DRAW_ARRAYS);
|
||||
writeInt(mode);
|
||||
writeInt(start);
|
||||
writeInt(count);
|
||||
}
|
||||
|
||||
public void writeDrawElements(int mode, int indices_count, int type, long indices_buffer_offset) {
|
||||
ensureCapacity(24);
|
||||
writeInt(GLCommand.DRAW_ELEMENTS);
|
||||
writeInt(mode);
|
||||
writeInt(indices_count);
|
||||
writeInt(type);
|
||||
writeLong(indices_buffer_offset);
|
||||
}
|
||||
|
||||
public void writeBindVBO(int vbo) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.BIND_VBO);
|
||||
writeInt(vbo);
|
||||
}
|
||||
|
||||
public void writeBindVAO(int vao) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.BIND_VAO);
|
||||
writeInt(vao);
|
||||
}
|
||||
|
||||
public void writeDrawBuffer(int mode) {
|
||||
ensureCapacity(8);
|
||||
writeInt(GLCommand.DRAW_BUFFER);
|
||||
@@ -685,6 +680,12 @@ public final class CommandBuffer {
|
||||
return value;
|
||||
}
|
||||
|
||||
public long readLong() {
|
||||
final long value = memGetLong(readPointer);
|
||||
readPointer += 8;
|
||||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read a float from the current position.
|
||||
*/
|
||||
|
||||
+41
-32
@@ -1,17 +1,19 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
|
||||
import com.gtnewhorizon.gtnhlib.client.opengl.UniversalVAO;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFlags;
|
||||
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 org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL15;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*;
|
||||
import static com.gtnewhorizons.angelica.glsm.recording.CommandBuffer.*;
|
||||
|
||||
/**
|
||||
* Executes commands from a CommandBuffer
|
||||
@@ -34,7 +36,7 @@ public final class CommandBufferExecutor {
|
||||
* @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) {
|
||||
public static void execute(ByteBuffer buffer, Object[] complexObjects, DisplayListVBO ownedVbos) {
|
||||
long ptr = memAddress(buffer);
|
||||
final long end = ptr + buffer.limit();
|
||||
|
||||
@@ -450,48 +452,39 @@ public final class CommandBufferExecutor {
|
||||
// === 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();
|
||||
ptr += 4;
|
||||
ownedVbos.render(vboIndex);
|
||||
}
|
||||
case GLCommand.DRAW_RANGE_RESTORE -> {
|
||||
// Draw VBO range then restore GL current state from last vertex attributes
|
||||
final int vboIndex = memGetInt(ptr);
|
||||
final int start = memGetInt(ptr + 4);
|
||||
final int count = memGetInt(ptr + 8);
|
||||
final int flags = memGetInt(ptr + 12);
|
||||
final int flags = memGetInt(ptr + 4);
|
||||
|
||||
// Draw the VBO
|
||||
final VertexBuffer vbo = ownedVbos[vboIndex];
|
||||
vbo.setupState();
|
||||
vbo.draw(start, count);
|
||||
vbo.cleanupState();
|
||||
ownedVbos.render(vboIndex);
|
||||
|
||||
// Restore attributes based on flags
|
||||
if ((flags & FLAG_HAS_COLOR) != 0) {
|
||||
final float r = memGetFloat(ptr + 16);
|
||||
final float g = memGetFloat(ptr + 20);
|
||||
final float b = memGetFloat(ptr + 24);
|
||||
final float a = memGetFloat(ptr + 28);
|
||||
GLStateManager.glColor4f(r, g, b, a);
|
||||
if ((flags & VertexFlags.COLOR_BIT) != 0) {
|
||||
final int color = memGetInt(ptr + 8);
|
||||
byte a = (byte) ((color >> 24) & 0xFF);
|
||||
byte r = (byte) ((color >> 16) & 0xFF);
|
||||
byte g = (byte) ((color >> 8) & 0xFF);
|
||||
byte b = (byte) ((color & 0xFF));
|
||||
GLStateManager.glColor4ub(r, g, b, a);
|
||||
}
|
||||
if ((flags & FLAG_HAS_NORMALS) != 0) {
|
||||
final float nx = memGetFloat(ptr + 32);
|
||||
final float ny = memGetFloat(ptr + 36);
|
||||
final float nz = memGetFloat(ptr + 40);
|
||||
if ((flags & VertexFlags.NORMAL_BIT) != 0) {
|
||||
final int normal = memGetInt(ptr + 12);
|
||||
float nx = (byte)(normal) / 127.0f;
|
||||
float ny = (byte)(normal >> 8) / 127.0f;
|
||||
float nz = (byte)(normal >> 16) / 127.0f;
|
||||
GLStateManager.glNormal3f(nx, ny, nz);
|
||||
}
|
||||
if ((flags & FLAG_HAS_TEXTURE) != 0) {
|
||||
final float s = memGetFloat(ptr + 44);
|
||||
final float t = memGetFloat(ptr + 48);
|
||||
if ((flags & VertexFlags.TEXTURE_BIT) != 0) {
|
||||
final float s = memGetFloat(ptr + 16);
|
||||
final float t = memGetFloat(ptr + 20);
|
||||
GLStateManager.glTexCoord2f(s, t);
|
||||
}
|
||||
ptr += 52; // Skip full command size (56 - 4 for cmd already read)
|
||||
ptr += 24; // Skip full command size (28 - 4 for cmd already read)
|
||||
}
|
||||
case GLCommand.CALL_LIST -> {
|
||||
final int listId = memGetInt(ptr);
|
||||
@@ -513,6 +506,22 @@ public final class CommandBufferExecutor {
|
||||
ptr += 4 * MAX_DRAW_BUFFERS;
|
||||
GLStateManager.glDrawBuffers(DRAW_BUFFERS_BUFFER);
|
||||
}
|
||||
case GLCommand.DRAW_ARRAYS -> {
|
||||
GLStateManager.glDrawArrays(memGetInt(ptr), memGetInt(ptr + 4), memGetInt(ptr + 8));
|
||||
ptr += 12;
|
||||
}
|
||||
case GLCommand.DRAW_ELEMENTS -> {
|
||||
GLStateManager.glDrawElements(memGetInt(ptr), memGetInt(ptr + 4), memGetInt(ptr + 8), memGetLong(ptr + 12));
|
||||
ptr += 20;
|
||||
}
|
||||
case GLCommand.BIND_VBO -> {
|
||||
GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, memGetInt(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
case GLCommand.BIND_VAO -> {
|
||||
UniversalVAO.bindVertexArray(memGetInt(ptr));
|
||||
ptr += 4;
|
||||
}
|
||||
|
||||
// === Complex object reference ===
|
||||
case GLCommand.COMPLEX_REF -> {
|
||||
|
||||
+5
-158
@@ -17,73 +17,6 @@ public final class CommandBufferProcessor {
|
||||
|
||||
private CommandBufferProcessor() {}
|
||||
|
||||
public static void processCommandForOptimization(int opcode, CommandBuffer raw, BufferTransformOptimizer opt, CommandBuffer out) {
|
||||
switch (opcode) {
|
||||
// === MultMatrix - already collapsed transforms from flushMatrix() ===
|
||||
case GLCommand.MULT_MATRIX -> {
|
||||
raw.readMatrix4f(tempMatrix);
|
||||
opt.multMatrix(tempMatrix); // accumulated = accumulated * tempMatrix
|
||||
out.writeMultMatrix(tempMatrix); // Copy to output
|
||||
opt.markLastEmittedAsAccumulated(); // lastEmitted = accumulated (what GL now has)
|
||||
}
|
||||
|
||||
// === Load commands - flush pending, emit, reset accumulator ===
|
||||
case GLCommand.LOAD_IDENTITY -> {
|
||||
opt.emitPendingTransform(out); // Emit any pending transforms first
|
||||
out.writeLoadIdentity(); // Always emit LoadIdentity
|
||||
opt.loadIdentity(); // Reset accumulated to identity
|
||||
opt.resetLastEmitted(); // Reset lastEmitted to identity
|
||||
opt.checkAndClearAbsoluteMatrix(); // Clear the flag if set
|
||||
}
|
||||
case GLCommand.LOAD_MATRIX -> {
|
||||
raw.readMatrix4f(tempMatrix);
|
||||
opt.emitPendingTransform(out);
|
||||
out.writeLoadMatrix(tempMatrix);
|
||||
opt.loadIdentity();
|
||||
opt.resetLastEmitted(); // Reset lastEmitted to identity
|
||||
opt.markAbsoluteMatrix();
|
||||
}
|
||||
|
||||
// === Stack operations - flush/update optimizer state and copy ===
|
||||
case GLCommand.PUSH_MATRIX -> {
|
||||
opt.emitPendingTransform(out);
|
||||
opt.push();
|
||||
// Reset accumulated/lastEmitted to identity after push.
|
||||
opt.loadIdentity();
|
||||
opt.resetLastEmitted();
|
||||
out.writePushMatrix();
|
||||
}
|
||||
case GLCommand.POP_MATRIX -> {
|
||||
opt.pop();
|
||||
out.writePopMatrix();
|
||||
}
|
||||
|
||||
// === Barriers - emit pending transform before copying ===
|
||||
case GLCommand.MATRIX_MODE -> {
|
||||
final int mode = raw.readInt();
|
||||
opt.emitPendingTransform(out); // Pending transforms apply to OLD mode
|
||||
out.writeMatrixMode(mode);
|
||||
opt.loadIdentity(); // Reset accumulated for new mode
|
||||
opt.resetLastEmitted(); // Reset lastEmitted for new mode
|
||||
}
|
||||
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.
|
||||
*/
|
||||
@@ -210,8 +143,12 @@ public final class CommandBufferProcessor {
|
||||
}
|
||||
|
||||
// Draw/call commands
|
||||
case GLCommand.DRAW_RANGE -> out.writeDrawRange(raw.readInt(), raw.readInt(), raw.readInt(), raw.readInt() != 0);
|
||||
case GLCommand.DRAW_RANGE -> out.writeDrawRange(raw.readInt());
|
||||
case GLCommand.CALL_LIST -> out.writeCallList(raw.readInt());
|
||||
case GLCommand.DRAW_ARRAYS -> out.writeDrawArrays(raw.readInt(), raw.readInt(), raw.readInt());
|
||||
case GLCommand.DRAW_ELEMENTS -> out.writeDrawElements(raw.readInt(), raw.readInt(), raw.readInt(), raw.readLong());
|
||||
case GLCommand.BIND_VBO -> out.writeBindVBO(raw.readInt());
|
||||
case GLCommand.BIND_VAO -> out.writeBindVAO(raw.readInt());
|
||||
|
||||
// Complex object reference - transfer the object to output buffer
|
||||
case GLCommand.COMPLEX_REF -> {
|
||||
@@ -223,94 +160,4 @@ public final class CommandBufferProcessor {
|
||||
default -> LOGGER.warn("[CommandBufferProcessor] Unknown opcode in buffer copy: {}", opcode);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Lightweight transform optimizer for buffer-to-buffer processing.
|
||||
* Tracks accumulated transform (mode-agnostic) and emits MultMatrix commands when needed.
|
||||
*
|
||||
* <p>This optimizer processes raw transform commands (TRANSLATE, ROTATE, SCALE) and
|
||||
* collapses them into single MultMatrix commands at barriers. It must stay synchronized
|
||||
* with the relativeTransform tracking in DisplayListManager - both systems must reset
|
||||
* at the same barriers (MatrixMode, LoadIdentity, LoadMatrix, Push/Pop).</p>
|
||||
*/
|
||||
public static class BufferTransformOptimizer {
|
||||
private final Matrix4f accumulated = new Matrix4f();
|
||||
private final Matrix4f lastEmitted = new Matrix4f();
|
||||
private final Matrix4f delta = new Matrix4f(); // Reused for delta computation
|
||||
private final Deque<Matrix4f> stack = new ArrayDeque<>();
|
||||
private boolean absoluteMatrixFlag = false;
|
||||
|
||||
public BufferTransformOptimizer() {
|
||||
accumulated.identity();
|
||||
lastEmitted.identity();
|
||||
}
|
||||
|
||||
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 DisplayListManager.isIdentity(accumulated);
|
||||
}
|
||||
|
||||
public void markAbsoluteMatrix() {
|
||||
absoluteMatrixFlag = true;
|
||||
}
|
||||
|
||||
public boolean checkAndClearAbsoluteMatrix() {
|
||||
final boolean was = absoluteMatrixFlag;
|
||||
absoluteMatrixFlag = false;
|
||||
return was;
|
||||
}
|
||||
|
||||
public void resetLastEmitted() {
|
||||
lastEmitted.identity();
|
||||
}
|
||||
|
||||
public void setLastEmitted(Matrix4f m) {
|
||||
lastEmitted.set(m);
|
||||
}
|
||||
|
||||
public void markLastEmittedAsAccumulated() {
|
||||
lastEmitted.set(accumulated);
|
||||
}
|
||||
|
||||
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 (DisplayListManager.isIdentity(lastEmitted)) {
|
||||
out.writeMultMatrix(target);
|
||||
} else {
|
||||
delta.set(lastEmitted).invert().mul(target);
|
||||
out.writeMultMatrix(delta);
|
||||
}
|
||||
lastEmitted.set(target);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -9,7 +9,7 @@ import java.nio.IntBuffer;
|
||||
/**
|
||||
* Records GL commands to a CommandBuffer during display list compilation.
|
||||
*/
|
||||
public class CommandRecorder {
|
||||
public final class CommandRecorder {
|
||||
private final CommandBuffer buffer;
|
||||
private int commandCount;
|
||||
|
||||
@@ -337,6 +337,26 @@ public class CommandRecorder {
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordDrawArrays(int mode, int start, int count) {
|
||||
buffer.writeDrawArrays(mode, start, count);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordDrawElements(int mode, int indices_count, int type, long indices_buffer_offset) {
|
||||
buffer.writeDrawElements(mode, indices_count, type, indices_buffer_offset);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordBindVBO(int vbo) {
|
||||
buffer.writeBindVBO(vbo);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordBindVAO(int vao) {
|
||||
buffer.writeBindVAO(vao);
|
||||
commandCount++;
|
||||
}
|
||||
|
||||
public void recordComplexCommand(DisplayListCommand cmd) {
|
||||
buffer.writeComplexRef(cmd);
|
||||
commandCount++;
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
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.recording.commands.DisplayListCommand;
|
||||
import it.unimi.dsi.fastutil.ints.Int2IntMap;
|
||||
import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
|
||||
@@ -30,9 +30,9 @@ 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
|
||||
private final DisplayListVBO ownedVbos; // GPU resources referenced by index
|
||||
|
||||
public CompiledDisplayList(ByteBuffer commandBuffer, Object[] complexObjects, VertexBuffer[] ownedVbos) {
|
||||
public CompiledDisplayList(ByteBuffer commandBuffer, Object[] complexObjects, DisplayListVBO ownedVbos) {
|
||||
this.commandBuffer = commandBuffer;
|
||||
this.complexObjects = complexObjects;
|
||||
this.ownedVbos = ownedVbos;
|
||||
@@ -62,11 +62,7 @@ public final class CompiledDisplayList {
|
||||
|
||||
// Close VBOs
|
||||
if (ownedVbos != null) {
|
||||
for (VertexBuffer vbo : ownedVbos) {
|
||||
if (vbo != null) {
|
||||
vbo.close();
|
||||
}
|
||||
}
|
||||
ownedVbos.delete();
|
||||
}
|
||||
|
||||
// Free the command buffer (off-heap memory)
|
||||
@@ -89,10 +85,7 @@ public final class CompiledDisplayList {
|
||||
return complexObjects;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get owned VBOs for inlining into another display list.
|
||||
*/
|
||||
public VertexBuffer[] getOwnedVbos() {
|
||||
public DisplayListVBO getOwnedVbos() {
|
||||
return ownedVbos;
|
||||
}
|
||||
|
||||
@@ -112,7 +105,7 @@ public final class CompiledDisplayList {
|
||||
while (ptr < end) {
|
||||
final int cmd = memGetInt(ptr);
|
||||
counts.mergeInt(cmd, 1, Integer::sum);
|
||||
ptr += getCommandSize(cmd, ptr);
|
||||
ptr += GLCommand.getCommandSize(cmd, ptr);
|
||||
}
|
||||
return counts;
|
||||
}
|
||||
@@ -131,74 +124,13 @@ public final class CompiledDisplayList {
|
||||
while (ptr < end) {
|
||||
final int cmd = memGetInt(ptr);
|
||||
opcodes.add(cmd);
|
||||
ptr += getCommandSize(cmd, ptr);
|
||||
ptr += GLCommand.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) {
|
||||
// Opcode-only commands (4 bytes)
|
||||
case GLCommand.LOAD_IDENTITY, GLCommand.PUSH_MATRIX, GLCommand.POP_MATRIX -> 4;
|
||||
|
||||
// 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.STENCIL_MASK,
|
||||
GLCommand.DEPTH_MASK, GLCommand.FRONT_FACE, 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.HINT, 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.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.BLEND_COLOR,
|
||||
GLCommand.DRAW_RANGE -> 20;
|
||||
|
||||
// DRAW_RANGE_RESTORE: 56 bytes
|
||||
// [cmd:4][vboIndex:4][start:4][count:4][flags:4][color:16f][normal:12f][texcoord:8f]
|
||||
case GLCommand.DRAW_RANGE_RESTORE -> 56;
|
||||
|
||||
// DRAW_BUFFER: 8 bytes [cmd:4][mode:4]
|
||||
case GLCommand.DRAW_BUFFER -> 8;
|
||||
|
||||
// DRAW_BUFFERS: 40 bytes [cmd:4][count:4][bufs:4*8]
|
||||
case GLCommand.DRAW_BUFFERS -> 40;
|
||||
|
||||
// Double commands
|
||||
case GLCommand.TRANSLATE, GLCommand.SCALE -> 28; // cmd + 3 doubles
|
||||
case GLCommand.CLEAR_DEPTH -> 12; // cmd + 1 double
|
||||
case GLCommand.ROTATE -> 36; // cmd + 4 doubles
|
||||
case GLCommand.ORTHO, GLCommand.FRUSTUM -> 52; // cmd + 6 doubles
|
||||
|
||||
// Matrix commands
|
||||
case GLCommand.MULT_MATRIX, GLCommand.LOAD_MATRIX -> 68; // cmd + 16 floats
|
||||
|
||||
// Buffer commands (variable, read count)
|
||||
case GLCommand.FOG, GLCommand.LIGHT_MODEL -> {
|
||||
final int count = memGetInt(ptr + 8); // pname at +4, count at +8
|
||||
yield 12 + count * 4;
|
||||
}
|
||||
case GLCommand.LIGHT, GLCommand.MATERIAL -> {
|
||||
final 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);
|
||||
};
|
||||
@Override
|
||||
public String toString() {
|
||||
return DisplayListManager.getCompiledDisplayListString(0, this, null);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.IVertexArrayObject;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.IVertexBuffer;
|
||||
import org.lwjgl.opengl.GL15;
|
||||
|
||||
/**
|
||||
* A class that stores multiple vertex formats & their corresponding buffers.
|
||||
*/
|
||||
public final class DisplayListVBO {
|
||||
|
||||
private final SubVBO[] vbos;
|
||||
|
||||
DisplayListVBO(SubVBO[] vbos) {
|
||||
this.vbos = vbos;
|
||||
}
|
||||
|
||||
public void delete() {
|
||||
for (SubVBO vbo : vbos) {
|
||||
vbo.delete();
|
||||
}
|
||||
}
|
||||
|
||||
public SubVBO[] getVBOs() {
|
||||
return vbos;
|
||||
}
|
||||
|
||||
public void render(int index) {
|
||||
vbos[index].render();
|
||||
}
|
||||
|
||||
public static final class SubVBO {
|
||||
|
||||
private final IVertexArrayObject vao;
|
||||
private final int drawMode;
|
||||
private final int start;
|
||||
private final int count;
|
||||
|
||||
public SubVBO(IVertexArrayObject vao, int drawMode, int start, int count) {
|
||||
this.vao = vao;
|
||||
this.drawMode = drawMode;
|
||||
this.start = start;
|
||||
this.count = count;
|
||||
}
|
||||
|
||||
public void delete() {
|
||||
vao.delete();
|
||||
}
|
||||
|
||||
public void render() {
|
||||
vao.bind();
|
||||
vao.draw(drawMode, start, count);
|
||||
vao.unbind();
|
||||
}
|
||||
|
||||
public IVertexArrayObject getVAO() {
|
||||
return vao;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,127 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.IVertexArrayObject;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.IndexBuffer;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.IndexedVAO;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.VAOManager;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.IVertexBuffer;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFlags;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*;
|
||||
|
||||
/**
|
||||
* Compiles multiple ByteBuffers of the same Vertex format into a VBO. Any buffer added to the builder will be freed afterward.
|
||||
*/
|
||||
public final class DisplayListVBOBuilder {
|
||||
|
||||
// Removes the need for a HashMap. Since it's only an array of 16 values, this should be faster
|
||||
private final List<FormatData>[] formats = new List[VertexFlags.BITSET_SIZE];
|
||||
private int count;
|
||||
|
||||
public DisplayListVBOBuilder addDraw(VertexFormat format, int drawMode, List<ByteBuffer> buffers) {
|
||||
List<FormatData> data = formats[format.getVertexFlags()];
|
||||
if (data == null) {
|
||||
data = new ArrayList<>();
|
||||
formats[format.getVertexFlags()] = data;
|
||||
}
|
||||
data.add(new FormatData(buffers, drawMode, count));
|
||||
count++;
|
||||
return this;
|
||||
}
|
||||
|
||||
public DisplayListVBOBuilder addDraws(List<AccumulatedDraw> draws) {
|
||||
for (AccumulatedDraw draw : draws) {
|
||||
addDraw(draw.format, draw.drawMode, draw.drawBuffers);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public DisplayListVBO build() {
|
||||
final DisplayListVBO.SubVBO[] vbos = new DisplayListVBO.SubVBO[count];
|
||||
final ArrayList<ByteBuffer> allBuffers = new ArrayList<>();
|
||||
for (int i = 0; i < VertexFlags.BITSET_SIZE; i++) {
|
||||
List<FormatData> formatData = formats[i];
|
||||
if (formatData == null) continue;
|
||||
final VertexFormat format = DefaultVertexFormat.ALL_FORMATS[i];
|
||||
int start = 0;
|
||||
final IVertexArrayObject vao = VAOManager.createStorageVAO(format, -1, 0); // drawMode will be ignored
|
||||
final IVertexBuffer vbo = vao.getVBO();
|
||||
for (FormatData data : formatData) {
|
||||
int vertexCount;
|
||||
final List<ByteBuffer> drawBuffers = data.buffers;
|
||||
if (drawBuffers.size() == 1) {
|
||||
final ByteBuffer buffer = drawBuffers.get(0);
|
||||
allBuffers.add(buffer);
|
||||
vertexCount = format.getVertexCount(buffer);
|
||||
} else {
|
||||
allBuffers.addAll(drawBuffers);
|
||||
int size = 0;
|
||||
for (ByteBuffer buffer : drawBuffers) {
|
||||
size += buffer.remaining();
|
||||
}
|
||||
vertexCount = format.getVertexCount(size);
|
||||
}
|
||||
if (data.drawMode == GL11.GL_QUADS) {
|
||||
IVertexArrayObject indexedVAO = new IndexedVAO(vbo, IndexBuffer.convertQuadsToTrigs(start, start + vertexCount));
|
||||
vbos[data.drawIndex] = new DisplayListVBO.SubVBO(indexedVAO, GL11.GL_TRIANGLES, 0, vertexCount / 4 * 6);
|
||||
} else {
|
||||
vbos[data.drawIndex] = new DisplayListVBO.SubVBO(vao, data.drawMode, start, vertexCount);
|
||||
}
|
||||
|
||||
|
||||
start += vertexCount;
|
||||
}
|
||||
ByteBuffer bigBuffer = mergeAndDelete(allBuffers);
|
||||
vbo.allocate(bigBuffer, start);
|
||||
memFree(bigBuffer);
|
||||
|
||||
allBuffers.clear();
|
||||
}
|
||||
return new DisplayListVBO(vbos);
|
||||
}
|
||||
|
||||
private static ByteBuffer mergeAndDelete(List<ByteBuffer> buffers) {
|
||||
if (buffers.size() == 1) {
|
||||
return buffers.get(0);
|
||||
}
|
||||
int needed = 0;
|
||||
for (ByteBuffer buffer : buffers) {
|
||||
needed += buffer.remaining();
|
||||
}
|
||||
|
||||
ByteBuffer out = memAlloc(needed);
|
||||
long dst = memAddress0(out);
|
||||
|
||||
for (ByteBuffer buffer : buffers) {
|
||||
final int len = buffer.limit();
|
||||
final long address = memAddress0(buffer);
|
||||
memCopy(address, dst, len);
|
||||
dst += len;
|
||||
|
||||
nmemFree(address);
|
||||
}
|
||||
|
||||
out.limit(needed);
|
||||
return out;
|
||||
}
|
||||
|
||||
private static final class FormatData {
|
||||
|
||||
private final List<ByteBuffer> buffers;
|
||||
private final int drawMode;
|
||||
private final int drawIndex;
|
||||
|
||||
public FormatData(List<ByteBuffer> buffers, int drawMode, int drawIndex) {
|
||||
this.buffers = buffers;
|
||||
this.drawMode = drawMode;
|
||||
this.drawIndex = drawIndex;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,7 @@
|
||||
package com.gtnewhorizons.angelica.glsm.recording;
|
||||
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt;
|
||||
|
||||
/**
|
||||
* Command opcodes for ByteBuffer-based display list serialization.
|
||||
* Each command has a fixed layout described in comments.
|
||||
@@ -88,16 +90,24 @@ public final class GLCommand {
|
||||
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
|
||||
public static final int DRAW_BUFFER = 102; // [cmd:4][mode:4] = 8 bytes
|
||||
public static final int DRAW_BUFFERS = 103; // [cmd:4][count:4][bufs:4*8] = 40 bytes (up to 8 buffers)
|
||||
public static final int DRAW_RANGE = 100; // [cmd:4][vboIndex:4] = 8 bytes
|
||||
public static final int DRAW_RANGE_RESTORE = 101; // [cmd:4][vboIndex:4][flags:4][color:4][normal:4][lastTexCoord:8f] = 28 bytes
|
||||
public static final int CALL_LIST = 102; // [cmd:4][listId:4] = 8 bytes
|
||||
|
||||
|
||||
public static final int DRAW_ARRAYS = 110; // [cmd:4][drawMode:4][start:4][count:4] = 20 bytes
|
||||
public static final int DRAW_ELEMENTS = 111; // [cmd:4][mode:4][indices_count:4][type:4][indices_buffer_offset:8] = 28 bytes
|
||||
public static final int DRAW_BUFFER = 112; // [cmd:4][mode:4] = 8 bytes
|
||||
public static final int DRAW_BUFFERS = 113; // [cmd:4][count:4][bufs:4*8] = 40 bytes (up to 8 buffers)
|
||||
/**
|
||||
* Draw VBO range with attribute restoration after draw.
|
||||
* Used for immediate mode VBOs to restore GL current state (color, normal, texcoord).
|
||||
*/
|
||||
public static final int DRAW_RANGE_RESTORE = 104; // [cmd:4][vboIndex:4][start:4][count:4][flags:4]
|
||||
// [lastColor:16f][lastNormal:12f][lastTexCoord:8f] = 56 bytes
|
||||
|
||||
|
||||
// === Bind commands ===
|
||||
public static final int BIND_VBO = 120;
|
||||
public static final int BIND_VAO = 121;
|
||||
|
||||
// === Complex object reference ===
|
||||
public static final int COMPLEX_REF = 255; // [cmd:4][index:4] = 8 bytes
|
||||
@@ -171,9 +181,78 @@ public final class GLCommand {
|
||||
case CALL_LIST -> "CALL_LIST";
|
||||
case DRAW_BUFFER -> "DRAW_BUFFER";
|
||||
case DRAW_BUFFERS -> "DRAW_BUFFERS";
|
||||
case DRAW_RANGE_RESTORE -> "DRAW_RANGE_RESTORE";
|
||||
case COMPLEX_REF -> "COMPLEX_REF";
|
||||
case DRAW_RANGE_RESTORE -> "DRAW_RANGE_RESTORE";
|
||||
case BIND_VAO -> "BIND_VAO";
|
||||
case BIND_VBO -> "BIND_VBO";
|
||||
default -> "UNKNOWN(" + opcode + ")";
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Get size of a command in bytes (including the opcode).
|
||||
*/
|
||||
public static int getCommandSize(int cmd, long ptr) {
|
||||
return switch (cmd) {
|
||||
// Opcode-only commands (4 bytes)
|
||||
case GLCommand.LOAD_IDENTITY, GLCommand.PUSH_MATRIX, GLCommand.POP_MATRIX -> 4;
|
||||
|
||||
// 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.STENCIL_MASK,
|
||||
GLCommand.DEPTH_MASK, GLCommand.FRONT_FACE, GLCommand.POINT_SIZE, GLCommand.LINE_WIDTH,
|
||||
GLCommand.CALL_LIST, GLCommand.COMPLEX_REF, GLCommand.DRAW_RANGE, GLCommand.BIND_VBO,
|
||||
GLCommand.BIND_VAO -> 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.HINT, 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.LIGHTF, GLCommand.LIGHTI,
|
||||
GLCommand.MATERIALF, GLCommand.TEX_PARAMETERF, GLCommand.DRAW_ARRAYS -> 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.BLEND_COLOR -> 20;
|
||||
|
||||
case GLCommand.DRAW_ELEMENTS -> 24;
|
||||
|
||||
// DRAW_RANGE_RESTORE: 28 bytes
|
||||
case GLCommand.DRAW_RANGE_RESTORE -> 28;
|
||||
|
||||
// DRAW_BUFFER: 8 bytes [cmd:4][mode:4]
|
||||
case GLCommand.DRAW_BUFFER -> 8;
|
||||
|
||||
// DRAW_BUFFERS: 40 bytes [cmd:4][count:4][bufs:4*8]
|
||||
case GLCommand.DRAW_BUFFERS -> 40;
|
||||
|
||||
// Double commands
|
||||
case GLCommand.TRANSLATE, GLCommand.SCALE -> 28; // cmd + 3 doubles
|
||||
case GLCommand.CLEAR_DEPTH -> 12; // cmd + 1 double
|
||||
case GLCommand.ROTATE -> 36; // cmd + 4 doubles
|
||||
case GLCommand.ORTHO, GLCommand.FRUSTUM -> 52; // cmd + 6 doubles
|
||||
|
||||
// Matrix commands
|
||||
case GLCommand.MULT_MATRIX, GLCommand.LOAD_MATRIX -> 68; // cmd + 16 floats
|
||||
|
||||
// Buffer commands (variable, read count)
|
||||
case GLCommand.FOG, GLCommand.LIGHT_MODEL -> {
|
||||
final int count = memGetInt(ptr + 8); // pname at +4, count at +8
|
||||
yield 12 + count * 4;
|
||||
}
|
||||
case GLCommand.LIGHT, GLCommand.MATERIAL -> {
|
||||
final 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);
|
||||
};
|
||||
}
|
||||
}
|
||||
+41
-530
@@ -1,156 +1,58 @@
|
||||
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.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import com.gtnewhorizons.angelica.glsm.states.ClientArrayState;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.Buffer;
|
||||
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>
|
||||
* Converts immediate mode geometry to ByteBuffer directly via {@link DirectTessellator}
|
||||
* <p>
|
||||
* Currently only used for display list compilation, should be perfectly usable outside of display lists too though.
|
||||
*/
|
||||
public class ImmediateModeRecorder {
|
||||
private static final Logger LOGGER = LogManager.getLogger("ImmediateModeRecorder");
|
||||
public final class ImmediateModeRecorder {
|
||||
private static final DirectTessellator tessellator = new DirectTessellator(TessellatorManager.DEFAULT_BUFFER_SIZE);
|
||||
|
||||
// Accumulated quads from completed primitives
|
||||
private final List<ModelQuadViewMutable> quads = new ArrayList<>();
|
||||
private ImmediateModeRecorder() {
|
||||
|
||||
// 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
|
||||
public static DirectTessellator getInternalTessellator() {
|
||||
return tessellator;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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;
|
||||
public static void setTexCoord(float s, float t) {
|
||||
tessellator.setTextureUV(s, t);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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;
|
||||
public static void setNormal(float x, float y, float z) {
|
||||
tessellator.setNormal(x, y, z);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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;
|
||||
public static void begin(int primitiveType) {
|
||||
tessellator.startDrawing(primitiveType);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -159,346 +61,27 @@ public class ImmediateModeRecorder {
|
||||
*
|
||||
* @return Result containing quads, lines, and flags, or null if no geometry was produced
|
||||
*/
|
||||
public Result end() {
|
||||
if (!inPrimitive) {
|
||||
public static DirectTessellator end() {
|
||||
if (!tessellator.isDrawing) {
|
||||
throw new IllegalStateException("glEnd called without glBegin");
|
||||
}
|
||||
|
||||
// Capture last vertex attributes BEFORE clearing currentVertices
|
||||
// These will be used to restore GL current state after VBO playback
|
||||
float lastColorR = 1.0f, lastColorG = 1.0f, lastColorB = 1.0f, lastColorA = 1.0f;
|
||||
float lastNormalX = 0.0f, lastNormalY = 0.0f, lastNormalZ = 1.0f;
|
||||
float lastTexS = 0.0f, lastTexT = 0.0f;
|
||||
tessellator.isDrawing = false;
|
||||
|
||||
if (!currentVertices.isEmpty()) {
|
||||
ImmediateVertex last = currentVertices.get(currentVertices.size() - 1);
|
||||
if (tessellator.isEmpty()) return null;
|
||||
|
||||
// Unpack color from ABGR format
|
||||
lastColorR = (last.color & 0xFF) / 255.0f;
|
||||
lastColorG = ((last.color >> 8) & 0xFF) / 255.0f;
|
||||
lastColorB = ((last.color >> 16) & 0xFF) / 255.0f;
|
||||
lastColorA = ((last.color >> 24) & 0xFF) / 255.0f;
|
||||
|
||||
// Unpack normal from NormI8 format (signed bytes packed into int)
|
||||
lastNormalX = NormI8.unpackX(last.normal);
|
||||
lastNormalY = NormI8.unpackY(last.normal);
|
||||
lastNormalZ = NormI8.unpackZ(last.normal);
|
||||
|
||||
// Texture coords are stored directly as floats
|
||||
lastTexS = last.texU;
|
||||
lastTexT = last.texV;
|
||||
}
|
||||
|
||||
// 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,
|
||||
lastColorR, lastColorG, lastColorB, lastColorA,
|
||||
lastNormalX, lastNormalY, lastNormalZ,
|
||||
lastTexS, lastTexT);
|
||||
return tessellator;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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) {
|
||||
public static void vertex(float x, float y, float z) {
|
||||
if (!tessellator.isDrawing) {
|
||||
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);
|
||||
tessellator.addVertex(x, y, z);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -508,87 +91,16 @@ public class ImmediateModeRecorder {
|
||||
* 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();
|
||||
public static boolean hasGeometry() {
|
||||
return tessellator.vertexCount != 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
|
||||
// For getQuadsAndClear, we don't have last vertex data (it was cleared in end())
|
||||
// Use default values - this method is for edge cases/cleanup anyway
|
||||
return new Result(resultQuads, resultLines, flags,
|
||||
1.0f, 1.0f, 1.0f, 1.0f, // Default white color
|
||||
0.0f, 0.0f, 1.0f, // Default +Z normal
|
||||
0.0f, 0.0f); // Default (0,0) texcoord
|
||||
}
|
||||
|
||||
/**
|
||||
* Result of immediate mode recording: quads, lines, attribute flags, and last vertex state.
|
||||
* The last vertex state is used to restore GL_CURRENT_COLOR etc. after VBO playback.
|
||||
*/
|
||||
@com.github.bsideup.jabel.Desugar
|
||||
public record Result(
|
||||
List<ModelQuadViewMutable> quads,
|
||||
List<LineVertex> lines,
|
||||
CapturingTessellator.Flags flags,
|
||||
// Last vertex attributes for restoration after VBO draw
|
||||
float lastColorR, float lastColorG, float lastColorB, float lastColorA,
|
||||
float lastNormalX, float lastNormalY, float lastNormalZ,
|
||||
float lastTexCoordS, float lastTexCoordT
|
||||
) {}
|
||||
|
||||
/**
|
||||
* 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;
|
||||
public static void reset() {
|
||||
tessellator.reset();
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -600,10 +112,10 @@ public class ImmediateModeRecorder {
|
||||
* @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;
|
||||
public static DirectTessellator processDrawArrays(int mode, int first, int count) {
|
||||
final ClientArrayState cas = GLStateManager.getClientArrayState();
|
||||
final Buffer vertexPointer = cas.isVertexArrayEnabled() ? cas.getVertexPointer() : null;
|
||||
final Buffer colorPointer = cas.isColorArrayEnabled() ? cas.getColorPointer() : null;
|
||||
|
||||
return convertClientArrays(
|
||||
mode, first, count,
|
||||
@@ -632,7 +144,7 @@ public class ImmediateModeRecorder {
|
||||
* @param colorStride Stride in bytes (0 for tightly packed)
|
||||
* @return Result containing converted geometry, or null if no geometry produced
|
||||
*/
|
||||
public Result convertClientArrays(
|
||||
public static DirectTessellator 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
|
||||
@@ -645,12 +157,10 @@ public class ImmediateModeRecorder {
|
||||
|
||||
// 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 colorEffectiveStride = (colorStride == 0) ? colorSize * 4 : colorStride;
|
||||
final int strideInFloats = colorEffectiveStride / 4;
|
||||
colorReader = (idx) -> {
|
||||
final int offset = idx * strideInFloats;
|
||||
@@ -661,7 +171,7 @@ public class ImmediateModeRecorder {
|
||||
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;
|
||||
final int colorEffectiveStride = (colorStride == 0) ? colorSize : colorStride;
|
||||
colorReader = (idx) -> {
|
||||
final int offset = idx * colorEffectiveStride;
|
||||
final float r = (bb.get(offset) & 0xFF) / 255.0f;
|
||||
@@ -672,7 +182,6 @@ public class ImmediateModeRecorder {
|
||||
};
|
||||
} else {
|
||||
// Unsupported color type - use white
|
||||
colorEffectiveStride = 0;
|
||||
colorReader = (idx) -> GLStateManager.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
|
||||
}
|
||||
|
||||
@@ -738,6 +247,8 @@ public class ImmediateModeRecorder {
|
||||
return end();
|
||||
}
|
||||
|
||||
|
||||
|
||||
@FunctionalInterface
|
||||
private interface ColorReader {
|
||||
void read(int index);
|
||||
|
||||
-18
@@ -17,22 +17,4 @@ public interface DisplayListCommand {
|
||||
default void delete() {
|
||||
// Most commands don't hold resources
|
||||
}
|
||||
|
||||
/**
|
||||
* 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;
|
||||
}
|
||||
}
|
||||
@@ -1,14 +0,0 @@
|
||||
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
|
||||
) {}
|
||||
@@ -1,42 +0,0 @@
|
||||
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 + ")";
|
||||
}
|
||||
}
|
||||
@@ -5,7 +5,6 @@ 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;
|
||||
|
||||
|
||||
-42
@@ -1,42 +0,0 @@
|
||||
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();
|
||||
}
|
||||
@@ -1,8 +1,9 @@
|
||||
package com.gtnewhorizons.angelica.glsm.states;
|
||||
|
||||
import java.nio.Buffer;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.Buffer;
|
||||
|
||||
/**
|
||||
* Tracks OpenGL client array state (glVertexPointer, glColorPointer, etc.)
|
||||
* This state is NOT part of the server attribute stack (push/pop attrib),
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
package com.gtnewhorizons.angelica.glsm.states;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.TextureUnitBooleanStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.TextureBindingStack;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.TextureUnitBooleanStateStack;
|
||||
import lombok.Getter;
|
||||
import org.joml.Matrix4fStack;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
@@ -1,11 +1,12 @@
|
||||
package com.gtnewhorizons.angelica.hudcaching;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.postprocessing.CustomFramebuffer;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.postprocessing.SharedDepthFramebuffer;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.VertexArrayBuffer;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.IVertexArrayObject;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.VertexBufferType;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.IVertexBuffer;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.ModStatus;
|
||||
import com.gtnewhorizons.angelica.compat.holoinventory.HoloInventoryReflectionCompat;
|
||||
@@ -20,7 +21,6 @@ import net.minecraft.client.gui.Gui;
|
||||
import net.minecraft.client.gui.GuiIngame;
|
||||
import net.minecraft.client.gui.ScaledResolution;
|
||||
import net.minecraft.client.renderer.EntityRenderer;
|
||||
import net.minecraft.client.renderer.OpenGlHelper;
|
||||
import net.minecraftforge.client.GuiIngameForge;
|
||||
import net.minecraftforge.client.event.RenderGameOverlayEvent;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
@@ -36,7 +36,7 @@ public class HUDCaching {
|
||||
private static boolean dirty = true;
|
||||
private static long nextHudRefresh;
|
||||
|
||||
private static VertexBuffer quadVAO;
|
||||
private static IVertexArrayObject quadVAO;
|
||||
private static float quadWidth;
|
||||
private static float quadHeight;
|
||||
|
||||
@@ -68,7 +68,7 @@ public class HUDCaching {
|
||||
XaeroMinimapCore.beforeIngameGuiRender(partialTicks);
|
||||
}
|
||||
|
||||
if (!OpenGlHelper.isFramebufferEnabled()) {
|
||||
if (!AngelicaConfig.hudCachingActive || !GLStateManager.isFramebufferEnabled()) {
|
||||
ingame.renderGameOverlay(partialTicks, hasScreen, mouseX, mouseY);
|
||||
return;
|
||||
}
|
||||
@@ -189,14 +189,19 @@ public class HUDCaching {
|
||||
|
||||
|
||||
private static void rebuildVAO(float width, float height) {
|
||||
final CapturingTessellator tessellator = TessellatorManager.startCapturingAndGet();
|
||||
final DirectTessellator tessellator = TessellatorManager.startCapturingDirect(DefaultVertexFormat.POSITION_TEXTURE);
|
||||
tessellator.startDrawingQuads();
|
||||
tessellator.addVertexWithUV(0, height, 0.0, 0, 0);
|
||||
tessellator.addVertexWithUV(width, height, 0.0, 1, 0);
|
||||
tessellator.addVertexWithUV(width, 0, 0.0, 1, 1);
|
||||
tessellator.addVertexWithUV(0, 0, 0.0, 0, 1);
|
||||
tessellator.draw();
|
||||
quadVAO = TessellatorManager.stopCapturingToVAO(quadVAO, DefaultVertexFormat.POSITION_TEXTURE);
|
||||
if (quadVAO == null) {
|
||||
quadVAO = tessellator.uploadToVBO(VertexBufferType.MUTABLE);
|
||||
} else {
|
||||
tessellator.updateToVBO(quadVAO.getVBO());
|
||||
}
|
||||
TessellatorManager.stopCapturingDirect();
|
||||
}
|
||||
|
||||
public static void disableHoloInventory() {
|
||||
|
||||
+116
-12
@@ -41,14 +41,31 @@ 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 GL11C = "org/lwjgl/opengl/GL11C";
|
||||
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 GL15 = "org/lwjgl/opengl/GL15";
|
||||
private static final String GL20 = "org/lwjgl/opengl/GL20";
|
||||
private static final String GL30 = "org/lwjgl/opengl/GL30";
|
||||
private static final String ARBVertexArrayObject = "org/lwjgl/opengl/ARBVertexArrayObject";
|
||||
private static final String APPLEVertexArrayObject = "org/lwjgl/opengl/APPLEVertexArrayObject";
|
||||
private static final String Project = "org/lwjgl/util/glu/Project";
|
||||
private static final String OpenGlHelper = "net/minecraft/client/renderer/OpenGlHelper";
|
||||
private static final String EXTBlendFunc = "org/lwjgl/opengl/EXTBlendFuncSeparate";
|
||||
private static final String ARBMultiTexture = "org/lwjgl/opengl/ARBMultitexture";
|
||||
|
||||
// Redirect VAO related calls from NHLib and LWJGLService
|
||||
private static final String UniversalVAO = "com/gtnewhorizon/gtnhlib/client/opengl/UniversalVAO";
|
||||
private static final String UniversalVAODot = "com.gtnewhorizon.gtnhlib.client.opengl.UniversalVAO";
|
||||
private static final String VaoFunctions = "com/gtnewhorizon/gtnhlib/client/renderer/vao/VaoFunctions";
|
||||
private static final String LWJGLService = "com/mitchej123/lwjgl/LWJGLService";
|
||||
|
||||
// Don't redirect these items inside of UniversalVAO, since we might be delegating to them
|
||||
private static final Set<String> UniversalVAOSkippedMethods = ImmutableSet.of(
|
||||
"glBindVertexArray", "glGenVertexArrays", "glDeleteVertexArrays", "glIsVertexArray"
|
||||
);
|
||||
|
||||
private static final String MinecraftClient = "net.minecraft.client";
|
||||
private static final String SplashProgress = "cpw.mods.fml.client.SplashProgress";
|
||||
private static final Set<String> ExcludedMinecraftMainThreadChecks = ImmutableSet.of(
|
||||
@@ -58,6 +75,7 @@ public final class AngelicaRedirector {
|
||||
|
||||
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<String, Map<String, String>> interfaceRedirects = new HashMap<>();
|
||||
private static final Map<Integer, String> glCapRedirects = new HashMap<>();
|
||||
|
||||
static {
|
||||
@@ -223,6 +241,9 @@ public final class AngelicaRedirector {
|
||||
.add("glBlendColor")
|
||||
.add("glBlendEquation")
|
||||
);
|
||||
methodRedirects.put(GL15, RedirectMap.newMap()
|
||||
.add("glBindBuffer")
|
||||
);
|
||||
methodRedirects.put(GL20, RedirectMap.newMap()
|
||||
.add("glBlendEquationSeparate")
|
||||
.add("glDrawBuffers")
|
||||
@@ -231,12 +252,67 @@ public final class AngelicaRedirector {
|
||||
.add("glStencilOpSeparate")
|
||||
.add("glUseProgram")
|
||||
);
|
||||
methodRedirects.put(GL30, RedirectMap.newMap()
|
||||
.add("glBindVertexArray")
|
||||
.add("glBindFramebuffer")
|
||||
);
|
||||
|
||||
// MINECRAFT
|
||||
methodRedirects.put(OpenGlHelper, RedirectMap.newMap()
|
||||
.add("glBlendFunc", "tryBlendFuncSeparate")
|
||||
.add("func_148821_a", "tryBlendFuncSeparate"));
|
||||
.add("func_148821_a", "tryBlendFuncSeparate")
|
||||
.add("func_153171_g", "glBindFramebuffer")
|
||||
.add("func_153174_h", "glDeleteFramebuffers")
|
||||
.add("func_153165_e", "glGenFramebuffers")
|
||||
.add("func_153167_i", "glCheckFramebufferStatus")
|
||||
.add("func_153188_a", "glFramebufferTexture2D")
|
||||
.add("setActiveTexture")
|
||||
.add("setLightmapTextureCoords")
|
||||
.add("isFramebufferEnabled")
|
||||
);
|
||||
methodRedirects.put(EXTBlendFunc, RedirectMap.newMap().add("glBlendFuncSeparateEXT", "tryBlendFuncSeparate"));
|
||||
methodRedirects.put(ARBMultiTexture, RedirectMap.newMap().add("glActiveTextureARB"));
|
||||
|
||||
// ARB
|
||||
methodRedirects.put(ARBMultiTexture, RedirectMap.newMap()
|
||||
.add("glActiveTextureARB")
|
||||
);
|
||||
methodRedirects.put(ARBVertexArrayObject, RedirectMap.newMap()
|
||||
.add("glBindVertexArray")
|
||||
);
|
||||
|
||||
|
||||
// APPLE
|
||||
methodRedirects.put(APPLEVertexArrayObject, RedirectMap.newMap()
|
||||
.add("glBindVertexArrayAPPLE", "glBindVertexArray")
|
||||
);
|
||||
|
||||
// GTNHLib VAO
|
||||
methodRedirects.put(UniversalVAO, RedirectMap.newMap()
|
||||
.add("bindVertexArray", "glBindVertexArray")
|
||||
);
|
||||
|
||||
// OTHER
|
||||
methodRedirects.put(Project, RedirectMap.newMap().add("gluPerspective"));
|
||||
|
||||
// Interface/virtual redirects — callers invoke these on a receiver object
|
||||
interfaceRedirects.put(VaoFunctions, RedirectMap.newMap()
|
||||
.add("glBindVertexArray")
|
||||
);
|
||||
interfaceRedirects.put(LWJGLService, RedirectMap.newMap()
|
||||
.add("glBindVertexArray")
|
||||
);
|
||||
|
||||
cstPoolParser.addString(UniversalVAO);
|
||||
cstPoolParser.addString(VaoFunctions);
|
||||
cstPoolParser.addString(LWJGLService);
|
||||
|
||||
final String glPrefix = "org/lwjgl/opengl/GL";
|
||||
for (var entry : new HashMap<>(methodRedirects).entrySet()) {
|
||||
if (entry.getKey().startsWith(glPrefix)) {
|
||||
methodRedirects.put(entry.getKey() + "C", entry.getValue());
|
||||
cstPoolParser.addString(entry.getKey() + "C");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public String[] getTransformerExclusions() {
|
||||
@@ -267,7 +343,7 @@ public final class AngelicaRedirector {
|
||||
boolean redirectInMethod = false;
|
||||
for (AbstractInsnNode node : mn.instructions.toArray()) {
|
||||
if (node instanceof MethodInsnNode mNode) {
|
||||
if (mNode.owner.equals(GL11) && (mNode.name.equals("glEnable") || mNode.name.equals("glDisable")) && mNode.desc.equals("(I)V")) {
|
||||
if ((mNode.owner.equals(GL11) || mNode.owner.equals(GL11C)) && (mNode.name.equals("glEnable") || mNode.name.equals("glDisable")) && mNode.desc.equals("(I)V")) {
|
||||
final AbstractInsnNode prevNode = node.getPrevious();
|
||||
String name = null;
|
||||
if (prevNode instanceof LdcInsnNode ldcNode) {
|
||||
@@ -308,15 +384,43 @@ public final class AngelicaRedirector {
|
||||
}
|
||||
} else {
|
||||
final Map<String, String> redirects = methodRedirects.get(mNode.owner);
|
||||
if (redirects != null && redirects.containsKey(mNode.name)) {
|
||||
if (LOG_SPAM) {
|
||||
final String shortOwner = mNode.owner.substring(mNode.owner.lastIndexOf("/") + 1);
|
||||
LOGGER.info("Redirecting call in {} from {}.{}{} to GLStateManager.{}{}", transformedName, shortOwner, mNode.name, mNode.desc, redirects.get(mNode.name), mNode.desc);
|
||||
if (redirects != null) {
|
||||
final String glsmName = redirects.get(mNode.name);
|
||||
// Skip VAO method redirects inside UniversalVAO
|
||||
if (glsmName != null && !(transformedName.startsWith(UniversalVAODot) && UniversalVAOSkippedMethods.contains(glsmName))) {
|
||||
if (LOG_SPAM) {
|
||||
final String shortOwner = mNode.owner.substring(mNode.owner.lastIndexOf("/") + 1);
|
||||
LOGGER.info("Redirecting call in {} from {}.{}{} to GLStateManager.{}{}", transformedName, shortOwner, mNode.name, mNode.desc, glsmName, mNode.desc);
|
||||
}
|
||||
mNode.owner = GLStateManager;
|
||||
mNode.name = glsmName;
|
||||
changed = true;
|
||||
redirectInMethod = true;
|
||||
}
|
||||
}
|
||||
// Interface/virtual redirects: rewrite receiver-based calls to static GLStateManager calls
|
||||
if ((mNode.getOpcode() == Opcodes.INVOKEINTERFACE || mNode.getOpcode() == Opcodes.INVOKEVIRTUAL) && mNode.desc.equals("(I)V")) {
|
||||
final Map<String, String> ifaceRedirects = interfaceRedirects.get(mNode.owner);
|
||||
if (ifaceRedirects != null) {
|
||||
final String glsmName = ifaceRedirects.get(mNode.name);
|
||||
if (glsmName != null && !(transformedName.startsWith(UniversalVAODot) && UniversalVAOSkippedMethods.contains(glsmName))) {
|
||||
if (LOG_SPAM) {
|
||||
final String shortOwner = mNode.owner.substring(mNode.owner.lastIndexOf("/") + 1);
|
||||
LOGGER.info("Redirecting interface call in {} from {}.{}{} to GLStateManager.{}{}", transformedName, shortOwner, mNode.name, mNode.desc, glsmName, "(I)V");
|
||||
}
|
||||
// Stack is: [receiver, int_arg]. We need just [int_arg] for static call.
|
||||
// Insert SWAP + POP before the call to remove the receiver.
|
||||
mn.instructions.insertBefore(mNode, new InsnNode(Opcodes.SWAP));
|
||||
mn.instructions.insertBefore(mNode, new InsnNode(Opcodes.POP));
|
||||
mNode.setOpcode(Opcodes.INVOKESTATIC);
|
||||
mNode.owner = GLStateManager;
|
||||
mNode.name = glsmName;
|
||||
mNode.desc = "(I)V";
|
||||
mNode.itf = false;
|
||||
changed = true;
|
||||
redirectInMethod = true;
|
||||
}
|
||||
}
|
||||
mNode.owner = GLStateManager;
|
||||
mNode.name = redirects.get(mNode.name);
|
||||
changed = true;
|
||||
redirectInMethod = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -329,7 +433,7 @@ public final class AngelicaRedirector {
|
||||
return changed;
|
||||
}
|
||||
|
||||
private static class RedirectMap<K> extends HashMap<K, K> {
|
||||
private static final class RedirectMap<K> extends HashMap<K, K> {
|
||||
|
||||
public static RedirectMap<String> newMap() {
|
||||
return new RedirectMap<>();
|
||||
|
||||
@@ -162,6 +162,7 @@ public enum Mixins implements IMixins {
|
||||
, "rendering.MixinPlayerManager"
|
||||
, "rendering.MixinRenderBlocks"
|
||||
, "rendering.MixinRenderingRegistry"
|
||||
, "rendering.MixinTessellator"
|
||||
, "rendering.MixinTileEntity"
|
||||
, "rendering.MixinTileEntityMobSpawner"
|
||||
, "rendering.MixinTileEntityRendererDispatcher"
|
||||
@@ -178,6 +179,8 @@ public enum Mixins implements IMixins {
|
||||
, "celeritas.terrain.MixinRenderGlobal"
|
||||
, "celeritas.terrain.MixinRenderSectionManager"
|
||||
, "celeritas.terrain.MixinWorldClient"
|
||||
, "celeritas.frustum.MixinClippingHelper"
|
||||
, "celeritas.frustum.MixinClippingHelperImpl"
|
||||
, "celeritas.frustum.MixinFrustrum"
|
||||
, "celeritas.features.culling.MixinEffectRenderer"
|
||||
, "celeritas.features.mipmaps.MixinTextureAtlasSprite"
|
||||
@@ -188,6 +191,7 @@ public enum Mixins implements IMixins {
|
||||
, "celeritas.biome_blending.MixinBlockLeaves"
|
||||
, "celeritas.biome_blending.MixinBlockLiquid"
|
||||
, "celeritas.threading.MixinForgeHooksClient"
|
||||
, "celeritas.terrain.MixinChunk"
|
||||
)
|
||||
),
|
||||
|
||||
@@ -195,21 +199,27 @@ public enum Mixins implements IMixins {
|
||||
.setPhase(Phase.EARLY)
|
||||
.setApplyIf(() -> AngelicaConfig.enableIris)
|
||||
.addClientMixins(
|
||||
"shaders.MixinEntityRenderer"
|
||||
"shaders.MixinDroppedItemGlintEdges"
|
||||
, "shaders.MixinEntityPickupFX"
|
||||
, "shaders.MixinEntityRenderer"
|
||||
, "shaders.MixinGuiIngameForge"
|
||||
, "shaders.MixinFramebuffer"
|
||||
, "shaders.MixinItem"
|
||||
, "shaders.MixinLocale"
|
||||
, "shaders.MixinOpenGlHelper"
|
||||
, "shaders.MixinRender"
|
||||
, "shaders.MixinRenderBiped"
|
||||
, "shaders.MixinRenderDragon"
|
||||
, "shaders.MixinRenderEntityFlame"
|
||||
, "shaders.MixinRendererLivingEntity"
|
||||
, "shaders.MixinRenderGlobal"
|
||||
, "shaders.MixinRenderHorse"
|
||||
, "shaders.MixinRenderItem"
|
||||
, "shaders.MixinRenderManager"
|
||||
, "shaders.MixinRenderNameTag"
|
||||
, "shaders.MixinRenderPlayerArmor"
|
||||
, "shaders.MixinTileEntityBeaconRenderer"
|
||||
, "shaders.MixinRenderEndPortal"
|
||||
, "shaders.MixinTileEntityRendererDispatcher"
|
||||
)
|
||||
),
|
||||
|
||||
@@ -315,7 +325,7 @@ public enum Mixins implements IMixins {
|
||||
.setPhase(Phase.LATE)
|
||||
.addRequiredMod(TargetedMod.NTM_SPACE)
|
||||
.setApplyIf(() -> CompatConfig.fixNTMSpace && AngelicaConfig.enableIris)
|
||||
.addClientMixins("client.ntmSpace.MixinSkyProviderCelestial_ShaderCompat")),
|
||||
.addClientMixins("client.ntmSpace.MixinSkyProviderCelestial_ShaderCompat", "client.ntmSpace.MixinSkyProviderLaytheSunset")),
|
||||
|
||||
SPEEDUP_CAMPFIRE_BACKPORT_ANIMATIONS(new MixinBuilder("Add animation speedup support to Campfire Backport")
|
||||
.setPhase(Phase.LATE)
|
||||
@@ -448,6 +458,12 @@ public enum Mixins implements IMixins {
|
||||
"MixinBlockTFMagicLeaves"
|
||||
))
|
||||
),
|
||||
ET_FUTURUM_ELYTRA_CAPE(new MixinBuilder("Set custom item ID for elytra with cape texture")
|
||||
.setPhase(Phase.LATE)
|
||||
.addRequiredMod(TargetedMod.ET_FUTURUM_REQUIEM)
|
||||
.setApplyIf(() -> AngelicaConfig.enableIris)
|
||||
.addClientMixins("client.etfuturum.MixinLayerBetterElytra")
|
||||
),
|
||||
MCPATCHER_FORGE(new MixinBuilder()
|
||||
.setPhase(Phase.EARLY)
|
||||
.setApplyIf(() -> AngelicaConfig.enableMCPatcherForgeFeatures)
|
||||
|
||||
@@ -14,6 +14,7 @@ public enum TargetedMod implements ITargetMod {
|
||||
DYNAMIC_SURROUNDINGS_MIST("org.blockartistry.mod.DynSurround.mixinplugin.DynamicSurroundingsEarlyMixins", "dsurround"),
|
||||
DYNAMIC_SURROUNDINGS_ORIGINAL("org.blockartistry.mod.DynSurround.asm.TransformLoader", "dsurround"),
|
||||
DRAGON_API("Reika.DragonAPI.Auxiliary.DragonAPIASMHandler", "DragonAPI"),
|
||||
ET_FUTURUM_REQUIEM(null, "etfuturum"),
|
||||
EXTRAUTILS(null, "ExtraUtilities"),
|
||||
FALSETWEAKS("com.falsepattern.falsetweaks.asm.CoreLoadingPlugin", "falsetweaks"),
|
||||
MINEFACTORY_RELOADED(null, "MineFactoryReloaded"),
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
package com.gtnewhorizons.angelica.mixins.interfaces;
|
||||
|
||||
import org.joml.FrustumIntersection;
|
||||
|
||||
public interface ClippingHelperExt {
|
||||
FrustumIntersection celeritas$getFrustumIntersection();
|
||||
void celeritas$updateFrustumIntersection();
|
||||
}
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
package com.gtnewhorizons.angelica.mixins.interfaces;
|
||||
|
||||
import com.gtnewhorizons.angelica.utils.ConcurrentTileEntityMap;
|
||||
|
||||
public interface IChunkTileEntityMapHolder {
|
||||
ConcurrentTileEntityMap angelica$getConcurrentTEMap();
|
||||
}
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
package com.gtnewhorizons.angelica.mixins.interfaces;
|
||||
|
||||
import net.minecraft.util.AxisAlignedBB;
|
||||
|
||||
public interface ITileEntityBoundingBoxCache {
|
||||
AxisAlignedBB angelica$getCachedRenderBoundingBox();
|
||||
|
||||
boolean angelica$isInfiniteExtent();
|
||||
}
|
||||
@@ -1,11 +1,9 @@
|
||||
package com.gtnewhorizons.angelica.proxy;
|
||||
|
||||
import static com.gtnewhorizons.angelica.AngelicaMod.MOD_ID;
|
||||
import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
|
||||
|
||||
import com.google.common.base.Objects;
|
||||
import com.gtnewhorizon.gtnhlib.client.model.loading.ModelRegistry;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.VAOManager;
|
||||
import com.gtnewhorizons.angelica.commands.AngelicaCommand;
|
||||
import com.gtnewhorizons.angelica.compat.ModStatus;
|
||||
import com.gtnewhorizons.angelica.compat.bettercrashes.BetterCrashesCompat;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
@@ -18,6 +16,7 @@ import com.gtnewhorizons.angelica.dynamiclights.config.EntityLightConfig;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.debug.OpenGLDebugging;
|
||||
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
|
||||
import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.IGameSettingsExt;
|
||||
import com.gtnewhorizons.angelica.render.CloudRenderer;
|
||||
import com.gtnewhorizons.angelica.rendering.AngelicaBlockSafetyRegistry;
|
||||
@@ -27,10 +26,7 @@ import com.gtnewhorizons.angelica.rendering.celeritas.threading.ChunkTaskRegistr
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.threading.DefaultChunkTaskProvider;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.threading.ThreadedChunkTaskProvider;
|
||||
import com.gtnewhorizons.angelica.zoom.Zoom;
|
||||
import com.gtnewhorizons.angelica.commands.AngelicaCommand;
|
||||
import cpw.mods.fml.client.registry.ClientRegistry;
|
||||
import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
|
||||
import net.minecraftforge.client.ClientCommandHandler;
|
||||
import cpw.mods.fml.common.FMLCommonHandler;
|
||||
import cpw.mods.fml.common.event.FMLInitializationEvent;
|
||||
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
|
||||
@@ -40,10 +36,11 @@ import cpw.mods.fml.common.eventhandler.SubscribeEvent;
|
||||
import cpw.mods.fml.common.gameevent.TickEvent;
|
||||
import cpw.mods.fml.common.registry.GameData;
|
||||
import cpw.mods.fml.relauncher.ReflectionHelper;
|
||||
import java.lang.management.ManagementFactory;
|
||||
import java.util.Locale;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import jss.notfine.core.Settings;
|
||||
import jss.notfine.gui.GuiCustomMenu;
|
||||
import jss.notfine.gui.NotFineGameOptionPages;
|
||||
import me.flashyreese.mods.reeses_sodium_options.client.gui.ReeseSodiumVideoOptionsScreen;
|
||||
import me.jellysquid.mods.sodium.client.gui.SodiumOptionsGUI;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.client.IrisDebugScreenHandler;
|
||||
import net.minecraft.block.Block;
|
||||
@@ -51,6 +48,8 @@ import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.gui.FontRenderer;
|
||||
import net.minecraft.client.gui.Gui;
|
||||
import net.minecraft.client.gui.GuiMainMenu;
|
||||
import net.minecraft.client.gui.GuiScreen;
|
||||
import net.minecraft.client.gui.GuiVideoSettings;
|
||||
import net.minecraft.client.gui.ScaledResolution;
|
||||
import net.minecraft.client.network.NetHandlerPlayClient;
|
||||
import net.minecraft.client.settings.GameSettings;
|
||||
@@ -61,14 +60,23 @@ import net.minecraft.util.MathHelper;
|
||||
import net.minecraft.util.MovingObjectPosition;
|
||||
import net.minecraft.world.EnumSkyBlock;
|
||||
import net.minecraft.world.chunk.Chunk;
|
||||
import net.minecraftforge.client.ClientCommandHandler;
|
||||
import net.minecraftforge.client.event.EntityViewRenderEvent;
|
||||
import net.minecraftforge.client.event.FOVUpdateEvent;
|
||||
import net.minecraftforge.client.event.GuiOpenEvent;
|
||||
import net.minecraftforge.client.event.GuiScreenEvent;
|
||||
import net.minecraftforge.client.event.RenderGameOverlayEvent;
|
||||
import net.minecraftforge.common.MinecraftForge;
|
||||
import net.minecraftforge.event.world.WorldEvent;
|
||||
import org.lwjgl.input.Keyboard;
|
||||
|
||||
import java.lang.management.ManagementFactory;
|
||||
import java.util.Locale;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
import static com.gtnewhorizons.angelica.AngelicaMod.MOD_ID;
|
||||
import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
|
||||
|
||||
public class ClientProxy extends CommonProxy {
|
||||
|
||||
final Minecraft mc = Minecraft.getMinecraft();
|
||||
@@ -323,6 +331,20 @@ public class ClientProxy extends CommonProxy {
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeEvent
|
||||
public void onGuiInit(GuiScreenEvent.InitGuiEvent.Pre event) {
|
||||
if(event.gui instanceof GuiVideoSettings eventGui) {
|
||||
event.setCanceled(true);
|
||||
if(AngelicaConfig.enableNotFineOptions || GuiScreen.isShiftKeyDown()) {
|
||||
Minecraft.getMinecraft().displayGuiScreen(new GuiCustomMenu(eventGui.parentGuiScreen, NotFineGameOptionPages.general(), NotFineGameOptionPages.detail(), NotFineGameOptionPages.atmosphere(), NotFineGameOptionPages.particles(), NotFineGameOptionPages.other()));
|
||||
} else if(!AngelicaConfig.enableReesesSodiumOptions || GuiScreen.isCtrlKeyDown()) {
|
||||
Minecraft.getMinecraft().displayGuiScreen(new SodiumOptionsGUI(eventGui.parentGuiScreen));
|
||||
} else {
|
||||
Minecraft.getMinecraft().displayGuiScreen(new ReeseSodiumVideoOptionsScreen(eventGui.parentGuiScreen));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* coerce NaN fog values back to 0 (https://bugs.mojang.com/browse/MC-10480) - from ArchaicFix */
|
||||
@SubscribeEvent(priority = EventPriority.LOWEST)
|
||||
public void onFogColor(EntityViewRenderEvent.FogColors event) {
|
||||
|
||||
@@ -21,17 +21,18 @@
|
||||
|
||||
package com.gtnewhorizons.angelica.render;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
|
||||
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.gtnewhorizon.gtnhlib.client.renderer.vao.IVertexArrayObject;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.VertexBufferType;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vbo.IVertexBuffer;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import jss.notfine.core.Settings;
|
||||
import jss.notfine.gui.options.named.GraphicsQualityOff;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.renderer.EntityRenderer;
|
||||
import net.minecraft.client.renderer.OpenGlHelper;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
import net.minecraft.client.renderer.texture.DynamicTexture;
|
||||
import net.minecraft.client.resources.IReloadableResourceManager;
|
||||
import net.minecraft.client.resources.IResourceManager;
|
||||
@@ -40,13 +41,13 @@ import net.minecraft.entity.Entity;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
import net.minecraft.util.Vec3;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL13;
|
||||
|
||||
public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
// Shared constants.
|
||||
private static final float PX_SIZE = 1 / 256F;
|
||||
|
||||
// Building constants.
|
||||
private static final VertexFormat FORMAT = DefaultVertexFormat.POSITION_TEXTURE_COLOR;
|
||||
private static final int TOP_SECTIONS = 12; // Number of slices a top face will span.
|
||||
private static final int HEIGHT = 4;
|
||||
private static final float INSET = 0.001F;
|
||||
@@ -59,7 +60,7 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
private final Minecraft mc = Minecraft.getMinecraft();
|
||||
private final ResourceLocation texture = new ResourceLocation("textures/environment/clouds.png");
|
||||
|
||||
private VertexBuffer vbo;
|
||||
private IVertexArrayObject vao;
|
||||
private int cloudMode = -1;
|
||||
private int renderDistance = -1;
|
||||
private int cloudElevation = -1;
|
||||
@@ -92,7 +93,7 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
return (float)Math.ceil(value / scale) * scale;
|
||||
}
|
||||
|
||||
private void vertices(CapturingTessellator tessellator) {
|
||||
private void vertices(Tessellator tessellator) {
|
||||
GraphicsQualityOff cloudGraphicsQuality = (GraphicsQualityOff)Settings.MODE_CLOUDS.option.getStore();
|
||||
boolean fancy = cloudGraphicsQuality == GraphicsQualityOff.FANCY || cloudGraphicsQuality == GraphicsQualityOff.DEFAULT && mc.gameSettings.fancyGraphics;
|
||||
|
||||
@@ -133,18 +134,20 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
float v1 = sectZ1 * sectPx;
|
||||
|
||||
// Bottom
|
||||
tessellator.pos(sectX0, 0, sectZ0).tex(u0, v0).color(bCol, bCol, bCol, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, 0, sectZ0).tex(u1, v0).color(bCol, bCol, bCol, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, 0, sectZ1).tex(u1, v1).color(bCol, bCol, bCol, ALPHA).endVertex();
|
||||
tessellator.pos(sectX0, 0, sectZ1).tex(u0, v1).color(bCol, bCol, bCol, ALPHA).endVertex();
|
||||
tessellator.setColorRGBA_F(bCol, bCol, bCol, ALPHA);
|
||||
tessellator.addVertexWithUV(sectX0, 0, sectZ0, u0, v0);
|
||||
tessellator.addVertexWithUV(sectX1, 0, sectZ0, u1, v0);
|
||||
tessellator.addVertexWithUV(sectX1, 0, sectZ1, u1, v1);
|
||||
tessellator.addVertexWithUV(sectX0, 0, sectZ1, u0, v1);
|
||||
|
||||
if (fancy) {
|
||||
final int height = HEIGHT * scaleMult;
|
||||
// Top
|
||||
tessellator.pos(sectX0, height, sectZ0).tex(u0, v0).color(1, 1, 1, ALPHA).endVertex();
|
||||
tessellator.pos(sectX0, height, sectZ1).tex(u0, v1).color(1, 1, 1, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, height, sectZ1).tex(u1, v1).color(1, 1, 1, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, height, sectZ0).tex(u1, v0).color(1, 1, 1, ALPHA).endVertex();
|
||||
tessellator.setColorRGBA_F(1, 1, 1, ALPHA);
|
||||
tessellator.addVertexWithUV(sectX0, height, sectZ0, u0, v0);
|
||||
tessellator.addVertexWithUV(sectX0, height, sectZ1, u0, v1);
|
||||
tessellator.addVertexWithUV(sectX1, height, sectZ1, u1, v1);
|
||||
tessellator.addVertexWithUV(sectX1, height, sectZ0, u1, v0);
|
||||
|
||||
float slice;
|
||||
float sliceCoord0;
|
||||
@@ -157,10 +160,11 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
// X sides
|
||||
if (slice > -CULL_DIST) {
|
||||
slice += INSET;
|
||||
tessellator.pos(slice, 0, sectZ1).tex(sliceCoord0, v1).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, height, sectZ1).tex(sliceCoord1, v1).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, height, sectZ0).tex(sliceCoord1, v0).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, 0, sectZ0).tex(sliceCoord0, v0).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.setColorRGBA_F(0.9F, 0.9F, 0.9F, ALPHA);
|
||||
tessellator.addVertexWithUV(slice, 0, sectZ1, sliceCoord0, v1);
|
||||
tessellator.addVertexWithUV(slice, height, sectZ1, sliceCoord1, v1);
|
||||
tessellator.addVertexWithUV(slice, height, sectZ0, sliceCoord1, v0);
|
||||
tessellator.addVertexWithUV(slice, 0, sectZ0, sliceCoord0, v0);
|
||||
slice -= INSET;
|
||||
}
|
||||
|
||||
@@ -168,10 +172,11 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
|
||||
if (slice <= CULL_DIST) {
|
||||
slice -= INSET;
|
||||
tessellator.pos(slice, 0, sectZ0).tex(sliceCoord0, v0).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, height, sectZ0).tex(sliceCoord1, v0).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, height, sectZ1).tex(sliceCoord1, v1).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, 0, sectZ1).tex(sliceCoord0, v1).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.setColorRGBA_F(0.9F, 0.9F, 0.9F, ALPHA);
|
||||
tessellator.addVertexWithUV(slice, 0, sectZ0, sliceCoord0, v0);
|
||||
tessellator.addVertexWithUV(slice, height, sectZ0, sliceCoord1, v0);
|
||||
tessellator.addVertexWithUV(slice, height, sectZ1, sliceCoord1, v1);
|
||||
tessellator.addVertexWithUV(slice, 0, sectZ1, sliceCoord0, v1);
|
||||
slice += INSET;
|
||||
}
|
||||
}
|
||||
@@ -183,10 +188,11 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
// Z sides
|
||||
if (slice > -CULL_DIST) {
|
||||
slice += INSET;
|
||||
tessellator.pos(sectX0, 0, slice).tex(u0, sliceCoord0).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX0, height, slice).tex(u0, sliceCoord1).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, height, slice).tex(u1, sliceCoord1).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, 0, slice).tex(u1, sliceCoord0).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.setColorRGBA_F(0.8F, 0.8F, 0.8F, ALPHA);
|
||||
tessellator.addVertexWithUV(sectX0, 0, slice, u0, sliceCoord0);
|
||||
tessellator.addVertexWithUV(sectX0, height, slice, u0, sliceCoord1);
|
||||
tessellator.addVertexWithUV(sectX1, height, slice, u1, sliceCoord1);
|
||||
tessellator.addVertexWithUV(sectX1, 0, slice, u1, sliceCoord0);
|
||||
slice -= INSET;
|
||||
}
|
||||
|
||||
@@ -194,10 +200,11 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
|
||||
if (slice <= CULL_DIST) {
|
||||
slice -= INSET;
|
||||
tessellator.pos(sectX1, 0, slice).tex(u1, sliceCoord0).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, height, slice).tex(u1, sliceCoord1).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX0, height, slice).tex(u0, sliceCoord1).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX0, 0, slice).tex(u0, sliceCoord0).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.setColorRGBA_F(0.8F, 0.8F, 0.8F, ALPHA);
|
||||
tessellator.addVertexWithUV(sectX1, 0, slice, u1, sliceCoord0);
|
||||
tessellator.addVertexWithUV(sectX1, height, slice, u1, sliceCoord1);
|
||||
tessellator.addVertexWithUV(sectX0, height, slice, u0, sliceCoord1);
|
||||
tessellator.addVertexWithUV(sectX0, 0, slice, u0, sliceCoord0);
|
||||
slice += INSET;
|
||||
}
|
||||
}
|
||||
@@ -211,18 +218,16 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
}
|
||||
|
||||
private void dispose() {
|
||||
if (vbo != null) {
|
||||
vbo.close();
|
||||
vbo = null;
|
||||
if (vao != null) {
|
||||
vao.delete();
|
||||
vao = null;
|
||||
}
|
||||
}
|
||||
|
||||
private void build() {
|
||||
CapturingTessellator tess = TessellatorManager.startCapturingAndGet();
|
||||
|
||||
vertices(tess);
|
||||
|
||||
this.vbo = TessellatorManager.stopCapturingToVAO(FORMAT);
|
||||
final DirectTessellator tessellator = TessellatorManager.startCapturingDirect();
|
||||
this.vertices(tessellator);
|
||||
this.vao = DirectTessellator.stopCapturingToVBO(VertexBufferType.IMMUTABLE);
|
||||
}
|
||||
|
||||
private int fullCoord(double coord, int scale) { // Corrects misalignment of UV offset when on negative coords.
|
||||
@@ -230,7 +235,7 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
}
|
||||
|
||||
private boolean isBuilt() {
|
||||
return vbo != null;
|
||||
return vao != null;
|
||||
}
|
||||
|
||||
public void checkSettings() {
|
||||
@@ -337,20 +342,20 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
texColor = newColor;
|
||||
}
|
||||
|
||||
GLStateManager.glActiveTexture(OpenGlHelper.lightmapTexUnit);
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE1);
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, COLOR_TEX.getGlTextureId());
|
||||
GLStateManager.enableTexture();
|
||||
|
||||
// Bind the clouds texture last so the shader's sampler2D is correct.
|
||||
GLStateManager.glActiveTexture(OpenGlHelper.defaultTexUnit);
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
|
||||
mc.renderEngine.bindTexture(texture);
|
||||
|
||||
vbo.setupState();
|
||||
vao.bind();
|
||||
|
||||
// Depth pass to prevent insides rendering from the outside.
|
||||
GLStateManager.glColorMask(false, false, false, false);
|
||||
|
||||
vbo.draw();
|
||||
vao.draw();
|
||||
|
||||
// Full render.
|
||||
if (!mc.gameSettings.anaglyph) {
|
||||
@@ -373,20 +378,20 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
GLStateManager.disableTexture();
|
||||
GLStateManager.glDepthMask(false);
|
||||
GLStateManager.disableFog();
|
||||
vbo.draw();
|
||||
vao.draw();
|
||||
GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
|
||||
GLStateManager.glDepthMask(true);
|
||||
GLStateManager.enableTexture();
|
||||
GLStateManager.enableFog();
|
||||
}
|
||||
|
||||
vbo.draw();
|
||||
vbo.cleanupState(); // Unbind buffer and disable pointers.
|
||||
vao.draw();
|
||||
vao.unbind(); // Unbind buffer.
|
||||
|
||||
// Disable our coloring.
|
||||
GLStateManager.glActiveTexture(OpenGlHelper.lightmapTexUnit);
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE1);
|
||||
GLStateManager.disableTexture();
|
||||
GLStateManager.glActiveTexture(OpenGlHelper.defaultTexUnit);
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
|
||||
|
||||
// Reset texture matrix.
|
||||
GLStateManager.glMatrixMode(GL11.GL_TEXTURE);
|
||||
|
||||
@@ -25,38 +25,32 @@
|
||||
|
||||
package com.gtnewhorizons.angelica.rendering;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.IVertexArrayObject;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.IndexBuffer;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.IndexedVAO;
|
||||
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.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import it.unimi.dsi.fastutil.HashCommon;
|
||||
import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
|
||||
import java.nio.ByteBuffer;
|
||||
import lombok.Data;
|
||||
import lombok.NoArgsConstructor;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
public class ItemRenderListManager {
|
||||
// Least used element is at position 0. This is in theory slightly faster.
|
||||
private static final Object2ObjectLinkedOpenHashMap<ItemProp, CachedVBO> vboCache = new Object2ObjectLinkedOpenHashMap<>(64);
|
||||
|
||||
// Formula: (widthSubdivisions * 2 + heightSubdivisions * 2 + 2) * 4 * vertexSize
|
||||
// Using 256 as both variables due to enchants, to prevent later re-allocations.
|
||||
private static ByteBuffer quadBuffer = BufferUtils.createByteBuffer(
|
||||
(1026 * DefaultVertexFormat.POSITION_TEXTURE_NORMAL.getVertexSize()) << 2
|
||||
);
|
||||
|
||||
// 1 minute
|
||||
private static final int EXPIRY_TICKS = 1_200;
|
||||
private static int smallestExpiry;
|
||||
|
||||
private static final ItemProp prop = new ItemProp();
|
||||
|
||||
public static VertexBuffer pre(float minU, float minV, float maxU, float maxV, int widthSubdivisions, int heightSubdivisions, float thickness) {
|
||||
public static CachedVBO pre(float minU, float minV, float maxU, float maxV, int widthSubdivisions, int heightSubdivisions, float thickness) {
|
||||
prop.set(minU, minV, maxU, maxV, widthSubdivisions, heightSubdivisions, thickness);
|
||||
|
||||
if (!vboCache.isEmpty()) {
|
||||
@@ -92,42 +86,35 @@ public class ItemRenderListManager {
|
||||
|
||||
vbo.expiry = getElapsedTicks() + EXPIRY_TICKS;
|
||||
|
||||
TessellatorManager.startCapturing();
|
||||
|
||||
return vbo.vertexBuffer;
|
||||
return vbo;
|
||||
}
|
||||
|
||||
public static void post(CapturingTessellator tessellator, VertexBuffer vbo) {
|
||||
final var quads = TessellatorManager.stopCapturingToPooledQuads();
|
||||
final int size = quads.size();
|
||||
|
||||
final int needed = (DefaultVertexFormat.POSITION_TEXTURE_NORMAL.getVertexSize() * size) << 2;
|
||||
if (quadBuffer.capacity() < needed) {
|
||||
quadBuffer = BufferUtils.createByteBuffer(HashCommon.nextPowerOfTwo(needed));
|
||||
}
|
||||
|
||||
for (int i = 0; i < size; i++) {
|
||||
DefaultVertexFormat.POSITION_TEXTURE_NORMAL.writeQuad(quads.get(i), quadBuffer);
|
||||
}
|
||||
|
||||
quadBuffer.flip();
|
||||
vbo.upload(quadBuffer);
|
||||
quadBuffer.clear();
|
||||
|
||||
tessellator.clearQuads();
|
||||
vbo.render();
|
||||
public static void post(DirectTessellator tessellator, CachedVBO vbo) {
|
||||
vbo.allocate(tessellator);
|
||||
TessellatorManager.stopCapturingDirect();
|
||||
vbo.vertexBuffer.render();
|
||||
}
|
||||
|
||||
private static int getElapsedTicks() {
|
||||
return Minecraft.getMinecraft().thePlayer.ticksExisted;
|
||||
}
|
||||
|
||||
private static final class CachedVBO {
|
||||
private VertexBuffer vertexBuffer;
|
||||
public static final class CachedVBO {
|
||||
private final IVertexArrayObject vertexBuffer;
|
||||
private final IndexBuffer ebo;
|
||||
private int expiry;
|
||||
|
||||
public CachedVBO() {
|
||||
this.vertexBuffer = VAOManager.createVAO(DefaultVertexFormat.POSITION_TEXTURE_NORMAL, GL11.GL_QUADS);
|
||||
this.ebo = new IndexBuffer();
|
||||
this.vertexBuffer = VAOManager.createMutableVAO(
|
||||
DefaultVertexFormat.POSITION_TEXTURE_NORMAL,
|
||||
GL11.GL_TRIANGLES,
|
||||
ebo
|
||||
);
|
||||
}
|
||||
|
||||
private void allocate(DirectTessellator tessellator) {
|
||||
tessellator.allocateToVBO(vertexBuffer, ebo);
|
||||
}
|
||||
|
||||
private void render(int elapsedTicks) {
|
||||
@@ -136,8 +123,8 @@ public class ItemRenderListManager {
|
||||
}
|
||||
|
||||
private void delete() {
|
||||
vertexBuffer.close();
|
||||
vertexBuffer = null;
|
||||
vertexBuffer.delete();
|
||||
// EBO gets deleted by vertexBuffer.delete()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
package com.gtnewhorizons.angelica.rendering;
|
||||
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.world.WorldSlice;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
|
||||
public class RenderThreadContext {
|
||||
|
||||
private static final ThreadLocal<WorldSlice> currentWorldSlice = new ThreadLocal<>();
|
||||
|
||||
public static void set(WorldSlice slice) {
|
||||
currentWorldSlice.set(slice);
|
||||
}
|
||||
|
||||
public static void clear() {
|
||||
currentWorldSlice.remove();
|
||||
}
|
||||
|
||||
public static TileEntity getSnapshotTE(int x, int y, int z) {
|
||||
final WorldSlice slice = currentWorldSlice.get();
|
||||
if (slice == null) return null;
|
||||
return slice.getTileEntity(x, y, z);
|
||||
}
|
||||
|
||||
public static boolean hasWorldSlice() {
|
||||
return currentWorldSlice.get() != null;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
package com.gtnewhorizons.angelica.rendering;
|
||||
|
||||
public interface StateAwareTessellator {
|
||||
/**
|
||||
* True if the vertex originated from a RenderBlocks method call with the enableAO flag set.
|
||||
*/
|
||||
int RENDERED_WITH_VANILLA_AO = 0x1;
|
||||
|
||||
void angelica$setAppliedAo(boolean flag);
|
||||
|
||||
int[] angelica$getVertexStates();
|
||||
}
|
||||
+54
@@ -0,0 +1,54 @@
|
||||
package com.gtnewhorizons.angelica.rendering;
|
||||
|
||||
import it.unimi.dsi.fastutil.objects.Reference2ByteOpenHashMap;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import net.minecraft.util.AxisAlignedBB;
|
||||
|
||||
/**
|
||||
* Registry for tracking which TileEntity classes always return INFINITE_EXTENT_AABB.
|
||||
*/
|
||||
public final class TileEntityRenderBoundsRegistry {
|
||||
private static final byte UNKNOWN = 0;
|
||||
private static final byte FINITE = 1;
|
||||
private static final byte INFINITE = 2;
|
||||
|
||||
private static final Reference2ByteOpenHashMap<Class<? extends TileEntity>> classRegistry = new Reference2ByteOpenHashMap<>();
|
||||
|
||||
static {
|
||||
classRegistry.defaultReturnValue(UNKNOWN);
|
||||
}
|
||||
|
||||
private TileEntityRenderBoundsRegistry() {}
|
||||
|
||||
public static boolean isInfiniteExtentsBox(AxisAlignedBB box) {
|
||||
return box == null || Double.isInfinite(box.minX) || Double.isInfinite(box.minY) || Double.isInfinite(box.minZ) || Double.isInfinite(box.maxX) || Double.isInfinite(box.maxY) || Double.isInfinite(box.maxZ);
|
||||
}
|
||||
|
||||
public static boolean isAlwaysInfiniteExtent(TileEntity te) {
|
||||
final Class<? extends TileEntity> clazz = te.getClass();
|
||||
synchronized (classRegistry) {
|
||||
final byte result = classRegistry.getByte(clazz);
|
||||
if (result != UNKNOWN) return result == INFINITE;
|
||||
}
|
||||
return probeAndCache(te, clazz);
|
||||
}
|
||||
|
||||
private static boolean probeAndCache(TileEntity te, Class<? extends TileEntity> clazz) {
|
||||
boolean isInfinite = false;
|
||||
try {
|
||||
final AxisAlignedBB aabb = te.getRenderBoundingBox();
|
||||
isInfinite = isInfiniteExtentsBox(aabb);
|
||||
} catch (Exception ignored) {}
|
||||
|
||||
synchronized (classRegistry) {
|
||||
classRegistry.put(clazz, isInfinite ? INFINITE : FINITE);
|
||||
}
|
||||
return isInfinite;
|
||||
}
|
||||
|
||||
public static void clear() {
|
||||
synchronized (classRegistry) {
|
||||
classRegistry.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
+52
-44
@@ -1,30 +1,29 @@
|
||||
package com.gtnewhorizons.angelica.rendering.celeritas;
|
||||
|
||||
import com.gtnewhorizons.angelica.AngelicaMod;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.IDynamicLightSource;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import com.gtnewhorizons.angelica.rendering.StateAwareTessellator;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.iris.BlockRenderContext;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.iris.IrisExtendedChunkVertexEncoder;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.ChunkColorWriter;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.light.LightDataCache;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.light.QuadLightingHelper;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.light.VanillaDiffuseProvider;
|
||||
import org.embeddedt.embeddium.impl.model.light.smooth.SmoothLightPipeline;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.world.WorldSlice;
|
||||
import lombok.Getter;
|
||||
import me.jellysquid.mods.sodium.client.SodiumClientMod;
|
||||
import net.coderbot.iris.block_rendering.BlockRenderingSettings;
|
||||
import net.irisshaders.iris.api.v0.IrisApi;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.multiplayer.WorldClient;
|
||||
import net.minecraft.world.IBlockAccess;
|
||||
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import net.minecraft.world.IBlockAccess;
|
||||
import org.embeddedt.embeddium.impl.model.light.LightPipeline;
|
||||
import org.embeddedt.embeddium.impl.model.light.data.LightDataAccess;
|
||||
import org.embeddedt.embeddium.impl.model.light.data.QuadLightData;
|
||||
import org.embeddedt.embeddium.impl.model.light.flat.FlatLightPipeline;
|
||||
import org.embeddedt.embeddium.impl.model.light.smooth.SmoothLightPipeline;
|
||||
import org.embeddedt.embeddium.impl.model.quad.properties.ModelQuadFacing;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.ChunkColorWriter;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildBuffers;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildContext;
|
||||
@@ -34,6 +33,9 @@ import org.embeddedt.embeddium.impl.render.chunk.terrain.material.Material;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexEncoder;
|
||||
import org.embeddedt.embeddium.impl.util.QuadUtil;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
public class AngelicaChunkBuildContext extends ChunkBuildContext {
|
||||
public static final int NUM_PASSES = 2;
|
||||
|
||||
@@ -49,16 +51,19 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
|
||||
|
||||
private final LightDataCache lightDataCache = new LightDataCache();
|
||||
private final SmoothLightPipeline smoothLightPipeline;
|
||||
private final FlatLightPipeline flatLightPipeline;
|
||||
private final QuadLightData quadLightData = new QuadLightData();
|
||||
private final VertexArrayQuadView quadView;
|
||||
private boolean lightPipelineReady = false;
|
||||
private int originX, originY, originZ;
|
||||
private IBlockAccess blockAccess;
|
||||
|
||||
public AngelicaChunkBuildContext(RenderPassConfiguration<?> renderPassConfiguration, WorldClient world) {
|
||||
super(renderPassConfiguration);
|
||||
this.textureAtlas = (TextureMapExtension) Minecraft.getMinecraft().getTextureMapBlocks();
|
||||
this.worldSlice = new WorldSlice(world);
|
||||
this.smoothLightPipeline = new SmoothLightPipeline(lightDataCache, VanillaDiffuseProvider.INSTANCE, false);
|
||||
this.flatLightPipeline = new FlatLightPipeline(lightDataCache, VanillaDiffuseProvider.INSTANCE, false);
|
||||
this.quadView = new VertexArrayQuadView(vertices);
|
||||
}
|
||||
|
||||
@@ -67,12 +72,14 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
|
||||
}
|
||||
|
||||
public void setupLightPipeline(IBlockAccess blockAccess, int minBlockX, int minBlockY, int minBlockZ) {
|
||||
this.blockAccess = blockAccess;
|
||||
this.originX = minBlockX;
|
||||
this.originY = minBlockY;
|
||||
this.originZ = minBlockZ;
|
||||
lightDataCache.setWorld(blockAccess);
|
||||
lightDataCache.reset(minBlockX, minBlockY, minBlockZ);
|
||||
smoothLightPipeline.reset();
|
||||
flatLightPipeline.reset();
|
||||
lightPipelineReady = true;
|
||||
}
|
||||
|
||||
@@ -88,7 +95,7 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
|
||||
|
||||
private Material selectMaterial(Material material, TextureAtlasSprite sprite, boolean isShaderPackOverride) {
|
||||
// Don't apply transparency-based optimization when shader pack explicitly overrides the material
|
||||
if (isShaderPackOverride) {
|
||||
if (!AngelicaMod.options().performance.useRenderPassOptimization || isShaderPackOverride) {
|
||||
return material;
|
||||
}
|
||||
if (sprite != null && sprite.getClass() == TextureAtlasSprite.class && !sprite.hasAnimationMetadata()) {
|
||||
@@ -103,7 +110,9 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public void copyRawBuffer(int[] rawBuffer, int vertexCount, ChunkBuildBuffers buffers, Material material, boolean isShaderPackOverride) {
|
||||
public void copyRawBuffer(int[] rawBuffer, int vertexCount, int[] vertexStates,
|
||||
ChunkBuildBuffers buffers, Material material, boolean isShaderPackOverride,
|
||||
boolean blockAllowsSmoothLighting) {
|
||||
if (vertexCount == 0) {
|
||||
return;
|
||||
}
|
||||
@@ -116,19 +125,29 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
|
||||
|
||||
final boolean hasDynamicLights = chunkLightSources != null && !chunkLightSources.isEmpty();
|
||||
final boolean separateAo = BlockRenderingSettings.INSTANCE.shouldUseSeparateAo();
|
||||
final boolean celeritasSmoothLighting = SodiumClientMod.options().quality.useCeleritasSmoothLighting;
|
||||
final boolean celeritasSmoothLighting = AngelicaMod.options().quality.useCeleritasSmoothLighting;
|
||||
final boolean shaderActive = IrisApi.getInstance().isShaderPackInUse();
|
||||
final boolean useAoCalculation = lightPipelineReady && (separateAo || celeritasSmoothLighting || shaderActive);
|
||||
final boolean stripDiffuse = shaderActive && BlockRenderingSettings.INSTANCE.shouldDisableDirectionalShading();
|
||||
final boolean shade = false; // Vanilla bakes it, or we remove it - so no need to shade
|
||||
final boolean shouldApplyDiffuse = !BlockRenderingSettings.INSTANCE.shouldDisableDirectionalShading();
|
||||
final ChunkColorWriter colorEncoder = separateAo ? ChunkColorWriter.SEPARATE_AO : ChunkColorWriter.EMBEDDIUM;
|
||||
|
||||
int ptr = 0;
|
||||
final int numQuads = vertexCount / 4;
|
||||
|
||||
final int blockX = blockRenderContext.localPosX;
|
||||
final int blockY = blockRenderContext.localPosY;
|
||||
final int blockZ = blockRenderContext.localPosZ;
|
||||
final int worldX = originX + blockX;
|
||||
final int worldY = originY + blockY;
|
||||
final int worldZ = originZ + blockZ;
|
||||
|
||||
int stateIdx = 0;
|
||||
|
||||
for (int quadIdx = 0; quadIdx < numQuads; quadIdx++) {
|
||||
float uSum = 0, vSum = 0;
|
||||
|
||||
int quadState = -1;
|
||||
|
||||
for (int vIdx = 0; vIdx < 4; vIdx++) {
|
||||
final var vertex = vertices[vIdx];
|
||||
vertex.x = Float.intBitsToFloat(rawBuffer[ptr++]);
|
||||
@@ -145,6 +164,8 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
|
||||
vertex.color = rawBuffer[ptr++];
|
||||
vertex.vanillaNormal = rawBuffer[ptr++];
|
||||
vertex.light = rawBuffer[ptr++];
|
||||
|
||||
quadState &= vertexStates[stateIdx++];
|
||||
}
|
||||
|
||||
final int trueNormal = QuadUtil.calculateNormal(vertices);
|
||||
@@ -155,37 +176,16 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
|
||||
animatedSprites.add(sprite);
|
||||
}
|
||||
|
||||
// Strip vanilla's baked diffuse when shaders want oldLighting=false - multiply by an inversion factor
|
||||
// instead of attempting to mixin/asm all the places that bake it in
|
||||
if (stripDiffuse) {
|
||||
final float inverseDiffuse = VanillaDiffuseProvider.INSTANCE.getInverseDiffuse(facing);
|
||||
for (int vIdx = 0; vIdx < 4; vIdx++) {
|
||||
vertices[vIdx].color = VanillaDiffuseProvider.multiplyColor(vertices[vIdx].color, inverseDiffuse);
|
||||
}
|
||||
}
|
||||
|
||||
if (useAoCalculation) {
|
||||
final int blockX = blockRenderContext.localPosX;
|
||||
final int blockY = blockRenderContext.localPosY;
|
||||
final int blockZ = blockRenderContext.localPosZ;
|
||||
|
||||
final boolean isEmissive = LightDataAccess.unpackEM(lightDataCache.get(originX + blockX, originY + blockY, originZ + blockZ));
|
||||
final boolean quadIsFullBright = QuadLightingHelper.isQuadFullBright(vertices);
|
||||
|
||||
if (isEmissive || quadIsFullBright) {
|
||||
Arrays.fill(quadLightData.br, 1.0f);
|
||||
if (isEmissive) {
|
||||
Arrays.fill(quadLightData.lm, LightDataAccess.FULL_BRIGHT);
|
||||
} else {
|
||||
for (int i = 0; i < 4; i++) {
|
||||
quadLightData.lm[i] = vertices[i].light;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
quadView.setup(trueNormal, blockX, blockY, blockZ);
|
||||
final ModelQuadFacing lightFace = quadView.getLightFace();
|
||||
smoothLightPipeline.calculate(quadView, originX + blockX, originY + blockY, originZ + blockZ, quadLightData, lightFace, lightFace, shade, true);
|
||||
}
|
||||
// If block used vanilla AO, then we can safely compute our own lighting data and ignore what vanilla
|
||||
// computed. We suppress vanilla emitting the brightness/color in MixinRenderBlocks.
|
||||
// Otherwise, we need to use the block's lightmap values as they are as the ISBRH may have
|
||||
// specified its own lightmaps for visual purposes (e.g. fullbright)
|
||||
if (useAoCalculation && (quadState & StateAwareTessellator.RENDERED_WITH_VANILLA_AO) != 0) {
|
||||
quadView.setup(trueNormal, blockX, blockY, blockZ);
|
||||
final ModelQuadFacing lightFace = quadView.getLightFace();
|
||||
final LightPipeline pipeline = blockAllowsSmoothLighting ? smoothLightPipeline : flatLightPipeline;
|
||||
final ModelQuadFacing cullFace = quadView.getCullFace();
|
||||
pipeline.calculate(quadView, worldX, worldY, worldZ, quadLightData, cullFace, lightFace, shouldApplyDiffuse, true);
|
||||
|
||||
for (int vIdx = 0; vIdx < 4; vIdx++) {
|
||||
final var vertex = vertices[vIdx];
|
||||
@@ -194,6 +194,14 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
|
||||
vertex.light = quadLightData.lm[vIdx];
|
||||
}
|
||||
} else {
|
||||
if (!shouldApplyDiffuse) {
|
||||
// Calculate the inverse of the expected diffuse constant and apply it to the color to fake
|
||||
// diffuse not having been applied
|
||||
final float inverseDiffuse = VanillaDiffuseProvider.INSTANCE.getInverseDiffuse(facing);
|
||||
for (int vIdx = 0; vIdx < 4; vIdx++) {
|
||||
vertices[vIdx].color = VanillaDiffuseProvider.multiplyColor(vertices[vIdx].color, inverseDiffuse);
|
||||
}
|
||||
}
|
||||
for (int vIdx = 0; vIdx < 4; vIdx++) {
|
||||
vertices[vIdx].trueNormal = trueNormal;
|
||||
}
|
||||
|
||||
+10
-3
@@ -2,6 +2,8 @@ package com.gtnewhorizons.angelica.rendering.celeritas;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
|
||||
import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue;
|
||||
import com.gtnewhorizons.angelica.rendering.StateAwareTessellator;
|
||||
import com.gtnewhorizons.angelica.rendering.TileEntityRenderBoundsRegistry;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProvider;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.iris.BlockRenderContext;
|
||||
@@ -9,6 +11,7 @@ import com.gtnewhorizons.angelica.rendering.celeritas.iris.ContextAwareChunkVert
|
||||
import it.unimi.dsi.fastutil.objects.Reference2ReferenceMap;
|
||||
import net.coderbot.iris.vertices.ExtendedDataHelper;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.renderer.RenderBlocks;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
|
||||
@@ -134,8 +137,8 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
|
||||
|
||||
if (block.hasTileEntity(meta)) {
|
||||
final TileEntity tileEntity = region.getTileEntity(x, y, z);
|
||||
if (TileEntityRendererDispatcher.instance.hasSpecialRenderer(tileEntity)) {
|
||||
renderData.globalBlockEntities.add(tileEntity);
|
||||
if (tileEntity != null && TileEntityRendererDispatcher.instance.hasSpecialRenderer(tileEntity)) {
|
||||
(TileEntityRenderBoundsRegistry.isAlwaysInfiniteExtent(tileEntity) ? renderData.globalBlockEntities : renderData.culledBlockEntities).add(tileEntity);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -247,7 +250,11 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
|
||||
block.canRenderInPass(pass);
|
||||
tessellator.startDrawingQuads();
|
||||
renderBlocks.renderBlockByRenderType(block, x, y, z);
|
||||
buildContext.copyRawBuffer(tessellator.rawBuffer, tessellator.vertexCount, buffers, passMaterial, isShaderPackOverride);
|
||||
boolean blockAllowsSmoothLighting = Minecraft.isAmbientOcclusionEnabled() // smooth lighting on
|
||||
&& block.getLightValue() == 0; // does not emit real block light
|
||||
buildContext.copyRawBuffer(tessellator.rawBuffer, tessellator.vertexCount,
|
||||
((StateAwareTessellator)tessellator).angelica$getVertexStates(),
|
||||
buffers, passMaterial, isShaderPackOverride, blockAllowsSmoothLighting);
|
||||
tessellator.reset();
|
||||
tessellator.isDrawing = false;
|
||||
|
||||
|
||||
+25
-1
@@ -1,11 +1,17 @@
|
||||
package com.gtnewhorizons.angelica.rendering.celeritas;
|
||||
|
||||
import com.gtnewhorizons.angelica.AngelicaMod;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProvider;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder;
|
||||
import org.embeddedt.embeddium.impl.gl.device.RenderDevice;
|
||||
import org.embeddedt.embeddium.impl.gl.shader.GlProgram;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.named.MultiDrawMode;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.DefaultChunkRenderer;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.multidraw.DirectMultiDrawEmitter;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.multidraw.IndirectMultiDrawEmitter;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.multidraw.MultiDrawEmitter;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderInterface;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderTextureSlot;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass;
|
||||
@@ -15,7 +21,7 @@ class AngelicaChunkRenderer extends DefaultChunkRenderer {
|
||||
private boolean usingIrisProgram;
|
||||
|
||||
public AngelicaChunkRenderer(RenderDevice device, RenderPassConfiguration<?> renderPassConfiguration) {
|
||||
super(device, renderPassConfiguration);
|
||||
super(device, renderPassConfiguration, createEmitter());
|
||||
|
||||
final IrisShaderProvider provider = IrisShaderProviderHolder.getProvider();
|
||||
if (provider != null) {
|
||||
@@ -23,6 +29,24 @@ class AngelicaChunkRenderer extends DefaultChunkRenderer {
|
||||
}
|
||||
}
|
||||
|
||||
private static MultiDrawEmitter createEmitter() {
|
||||
MultiDrawMode mode = AngelicaMod.options().advanced.multiDrawMode;
|
||||
|
||||
if (mode == MultiDrawMode.INDIRECT) {
|
||||
boolean supported = GLStateManager.capabilities != null && (GLStateManager.capabilities.OpenGL43 || GLStateManager.capabilities.GL_ARB_multi_draw_indirect);
|
||||
if (!supported) {
|
||||
AngelicaMod.LOGGER.warn("Indirect multi-draw not supported (requires GL 4.3 / ARB_multi_draw_indirect), falling back to Direct");
|
||||
mode = MultiDrawMode.DIRECT;
|
||||
}
|
||||
}
|
||||
|
||||
return switch (mode) {
|
||||
case DIRECT -> new DirectMultiDrawEmitter();
|
||||
case INDIRECT -> new IndirectMultiDrawEmitter();
|
||||
case INDIVIDUAL -> new IndividualDrawEmitter();
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void begin(TerrainRenderPass pass) {
|
||||
final IrisShaderProvider provider = IrisShaderProviderHolder.getProvider();
|
||||
|
||||
+1
-1
@@ -28,9 +28,9 @@ public class AngelicaMainThreadMeshingTask extends AngelicaChunkBuilderMeshingTa
|
||||
final int minZ = this.render.getOriginZ();
|
||||
|
||||
final var world = Minecraft.getMinecraft().theWorld;
|
||||
this.blockAccess = new ChunkCache(world, minX - 1, minY - 1, minZ - 1, minX + 17, minY + 17, minZ + 17, 1);
|
||||
this.biomeColorCache = ((WorldClientExtension) world).celeritas$getSmoothBiomeColorCache();
|
||||
this.biomeColorCache.update(new SectionPos(this.render.getChunkX(), this.render.getChunkY(), this.render.getChunkZ()));
|
||||
this.blockAccess = new ChunkCache(world, minX - 1, minY - 1, minZ - 1, minX + 17, minY + 17, minZ + 17, 1);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
+13
-11
@@ -1,11 +1,12 @@
|
||||
package com.gtnewhorizons.angelica.rendering.celeritas;
|
||||
|
||||
import com.gtnewhorizons.angelica.AngelicaMod;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.RenderSectionManagerAccessor;
|
||||
import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.threading.ChunkTaskProvider;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.threading.ChunkTaskRegistry;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.world.cloned.ClonedChunkSectionCache;
|
||||
import me.jellysquid.mods.sodium.client.SodiumClientMod;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.multiplayer.WorldClient;
|
||||
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
|
||||
@@ -15,7 +16,6 @@ import org.embeddedt.embeddium.impl.render.chunk.ChunkRenderMatrices;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.RenderSection;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.RenderSectionManager;
|
||||
import org.embeddedt.embeddium.impl.render.viewport.CameraTransform;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildOutput;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.compile.tasks.ChunkBuilderTask;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.lists.SectionTicker;
|
||||
@@ -23,12 +23,11 @@ import org.embeddedt.embeddium.impl.render.chunk.occlusion.AsyncOcclusionMode;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.sprite.GenericSectionSpriteTicker;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType;
|
||||
import org.embeddedt.embeddium.impl.render.viewport.CameraTransform;
|
||||
import org.embeddedt.embeddium.impl.render.viewport.Viewport;
|
||||
import org.embeddedt.embeddium.impl.util.PositionUtil;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.RenderSectionManagerAccessor;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
@@ -88,7 +87,7 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
|
||||
|
||||
@Override
|
||||
protected AsyncOcclusionMode getAsyncOcclusionMode() {
|
||||
return AsyncOcclusionMode.EVERYTHING;
|
||||
return AngelicaMod.options().performance.asyncOcclusionMode;
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -98,7 +97,7 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
|
||||
|
||||
@Override
|
||||
protected boolean useFogOcclusion() {
|
||||
return true;
|
||||
return AngelicaMod.options().performance.useFogOcclusion && !IrisShaderProviderHolder.isActive();
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -108,10 +107,13 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
|
||||
|
||||
@Override
|
||||
protected boolean shouldUseOcclusionCulling(Viewport positionedViewport, boolean spectator) {
|
||||
if (!spectator) return true;
|
||||
|
||||
final var camBlockPos = positionedViewport.getBlockCoord();
|
||||
return !this.world.getBlock(camBlockPos.x(), camBlockPos.y(), camBlockPos.z()).isOpaqueCube();
|
||||
if (spectator) {
|
||||
final var camBlockPos = positionedViewport.getBlockCoord();
|
||||
if (this.world.getBlock(camBlockPos.x(), camBlockPos.y(), camBlockPos.z()).isOpaqueCube()) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return AngelicaMod.options().performance.useOcclusionCulling;
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -150,7 +152,7 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
|
||||
|
||||
@Override
|
||||
protected boolean allowImportantRebuilds() {
|
||||
return !SodiumClientMod.options().performance.alwaysDeferChunkUpdates;
|
||||
return !AngelicaMod.options().performance.alwaysDeferChunkUpdates;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
+2
-1
@@ -1,6 +1,7 @@
|
||||
package com.gtnewhorizons.angelica.rendering.celeritas;
|
||||
|
||||
import com.gtnewhorizons.angelica.Tags;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.states.FogState;
|
||||
@@ -20,7 +21,7 @@ public class CeleritasDebugScreenHandler {
|
||||
@SubscribeEvent(priority = EventPriority.LOW)
|
||||
public void onRenderGameOverlayTextEvent(RenderGameOverlayEvent.Text event) {
|
||||
final Minecraft mc = Minecraft.getMinecraft();
|
||||
if (!mc.gameSettings.showDebugInfo) {
|
||||
if (!mc.gameSettings.showDebugInfo || AngelicaConfig.disableF3Additions) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
package com.gtnewhorizons.angelica.rendering.celeritas;
|
||||
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.embeddedt.embeddium.impl.gl.device.GLRenderDevice;
|
||||
import org.lwjgl.opengl.GL15;
|
||||
import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
|
||||
@@ -10,7 +11,7 @@ public class CeleritasSetup {
|
||||
|
||||
public static void ensureInitialized() {
|
||||
if (!initialized && AngelicaConfig.enableCeleritas) {
|
||||
GLRenderDevice.VANILLA_STATE_RESETTER = () -> GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
|
||||
GLRenderDevice.VANILLA_STATE_RESETTER = () -> GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
|
||||
LOGGER.debug("Celeritas init");
|
||||
initialized = true;
|
||||
}
|
||||
|
||||
+159
-15
@@ -1,9 +1,14 @@
|
||||
package com.gtnewhorizons.angelica.rendering.celeritas;
|
||||
|
||||
import com.gtnewhorizons.angelica.AngelicaMod;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.IDynamicLightWorldRenderer;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.ITileEntityBoundingBoxCache;
|
||||
import com.gtnewhorizons.angelica.rendering.RenderingState;
|
||||
import com.gtnewhorizons.angelica.rendering.TileEntityRenderBoundsRegistry;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProvider;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder;
|
||||
import net.coderbot.iris.pipeline.ShadowRenderer;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.multiplayer.WorldClient;
|
||||
@@ -16,19 +21,19 @@ import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.embeddedt.embeddium.impl.gl.device.CommandList;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.ChunkRenderMatrices;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.RenderSection;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.data.MinecraftBuiltRenderSectionData;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.lists.ChunkRenderList;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.lists.SortedRenderLists;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkMeshFormats;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProvider;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder;
|
||||
import me.jellysquid.mods.sodium.client.SodiumClientMod;
|
||||
import org.embeddedt.embeddium.impl.render.terrain.SimpleWorldRenderer;
|
||||
import org.embeddedt.embeddium.impl.render.viewport.Viewport;
|
||||
import org.joml.Matrix4f;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Comparator;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
|
||||
@@ -46,6 +51,12 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
|
||||
// the volume of a section multiplied by the number of sections to be checked at most
|
||||
private static final double MAX_ENTITY_CHECK_VOLUME = 16 * 16 * 16 * 15;
|
||||
|
||||
// For sorting transparent TESRs
|
||||
private RenderSectionOrderer renderSectionOrderer = new RenderSectionOrderer();
|
||||
private TileEntityOrderer tileEntityOrderer = new TileEntityOrderer();
|
||||
private ArrayList<RenderSection> sortedRenderSections = new ArrayList<>();
|
||||
private ArrayList<TileEntity> sortedTileEntities = new ArrayList<>();
|
||||
|
||||
private CeleritasWorldRenderer(Minecraft mc) {
|
||||
// Private constructor for singleton
|
||||
this.mc = mc;
|
||||
@@ -116,7 +127,7 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
|
||||
}
|
||||
}
|
||||
|
||||
if (SodiumClientMod.options().advanced.useCompactVertexFormat) {
|
||||
if (AngelicaMod.options().performance.useCompactVertexFormat) {
|
||||
return ChunkMeshFormats.COMPACT;
|
||||
}
|
||||
return ChunkMeshFormats.VANILLA_LIKE;
|
||||
@@ -144,7 +155,7 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
|
||||
|
||||
renderSectionManager.setCameraPosition(transform.x, transform.y, transform.z);
|
||||
|
||||
this.useEntityCulling = true;
|
||||
this.useEntityCulling = AngelicaMod.options().performance.useEntityCulling;
|
||||
|
||||
super.setupTerrain(viewport, cameraState, frame, spectator, updateChunksImmediately);
|
||||
|
||||
@@ -217,9 +228,97 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
|
||||
GLStateManager.glColor4f(1, 1, 1, 1);
|
||||
}
|
||||
|
||||
private int renderCulledTileEntities(TileEntityRenderContext renderContext) {
|
||||
int count = 0;
|
||||
SortedRenderLists renderLists = renderSectionManager.getRenderLists();
|
||||
Iterator<ChunkRenderList> renderListIterator = renderLists.iterator();
|
||||
|
||||
while (renderListIterator.hasNext()) {
|
||||
var renderList = renderListIterator.next();
|
||||
|
||||
var renderRegion = renderList.getRegion();
|
||||
var renderSectionIterator = renderList.sectionsWithEntitiesIterator();
|
||||
|
||||
if (renderSectionIterator == null) {
|
||||
continue;
|
||||
}
|
||||
|
||||
while (renderSectionIterator.hasNext()) {
|
||||
var renderSectionId = renderSectionIterator.nextByteAsInt();
|
||||
var renderSection = renderRegion.getSection(renderSectionId);
|
||||
|
||||
if (renderSection == null) {
|
||||
continue;
|
||||
}
|
||||
|
||||
var context = renderSection.getBuiltContext();
|
||||
|
||||
if (!(context instanceof MinecraftBuiltRenderSectionData<?, ?> mcData)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// noinspection unchecked
|
||||
var blockEntities = (List<TileEntity>) mcData.culledBlockEntities;
|
||||
|
||||
if (blockEntities.isEmpty()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
for (TileEntity te : blockEntities) {
|
||||
if (te.shouldRenderInPass(renderContext.pass)) sortedTileEntities.add(te);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sortedTileEntities.sort(tileEntityOrderer.setLastCameraState(lastCameraState));
|
||||
this.renderBlockEntityList(sortedTileEntities, renderContext);
|
||||
|
||||
return sortedTileEntities.size();
|
||||
}
|
||||
|
||||
private int renderGlobalTileEntities(TileEntityRenderContext renderContext) {
|
||||
int count = 0;
|
||||
sortedRenderSections.clear();
|
||||
sortedRenderSections.addAll(renderSectionManager.getSectionsWithGlobalEntities());
|
||||
sortedRenderSections.sort(renderSectionOrderer.setLastCameraState(lastCameraState));
|
||||
for (var renderSection : sortedRenderSections) {
|
||||
sortedTileEntities.clear();
|
||||
var builtContext = renderSection.getBuiltContext();
|
||||
|
||||
if (!(builtContext instanceof MinecraftBuiltRenderSectionData<?, ?> mcData)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// noinspection unchecked
|
||||
var blockEntities = (List<TileEntity>) mcData.globalBlockEntities;
|
||||
|
||||
if (blockEntities.isEmpty()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
for (TileEntity te : blockEntities) {
|
||||
if (te.shouldRenderInPass(renderContext.pass)) sortedTileEntities.add(te);
|
||||
}
|
||||
|
||||
count += sortedTileEntities.size();
|
||||
|
||||
sortedTileEntities.sort(tileEntityOrderer.setLastCameraState(lastCameraState));
|
||||
this.renderBlockEntityList(sortedTileEntities, renderContext);
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
public int renderBlockEntities(float partialTicks) {
|
||||
final int pass = MinecraftForgeClient.getRenderPass();
|
||||
return super.renderBlockEntities(teRenderContext.set(partialTicks, pass));
|
||||
teRenderContext.set(partialTicks, pass);
|
||||
if (pass == 0 || !AngelicaMod.options().performance.translucencySorting) {
|
||||
return super.renderBlockEntities(teRenderContext);
|
||||
}
|
||||
int count = 0;
|
||||
count += this.renderCulledTileEntities(teRenderContext);
|
||||
count += this.renderGlobalTileEntities(teRenderContext);
|
||||
return count;
|
||||
}
|
||||
|
||||
private void renderTE(TileEntity tileEntity, int pass, float partialTicks) {
|
||||
@@ -227,10 +326,13 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
|
||||
return;
|
||||
}
|
||||
|
||||
final AxisAlignedBB aabb = tileEntity.getRenderBoundingBox();
|
||||
final ITileEntityBoundingBoxCache teCache = (ITileEntityBoundingBoxCache) tileEntity;
|
||||
|
||||
if (aabb != TileEntity.INFINITE_EXTENT_AABB && !this.currentViewport.isBoxVisible(aabb.minX, aabb.minY, aabb.minZ, aabb.maxX, aabb.maxY, aabb.maxZ)) {
|
||||
return;
|
||||
if (!teCache.angelica$isInfiniteExtent()) {
|
||||
final AxisAlignedBB aabb = teCache.angelica$getCachedRenderBoundingBox();
|
||||
if (aabb != null && !this.currentViewport.isBoxVisible(aabb.minX, aabb.minY, aabb.minZ, aabb.maxX, aabb.maxY, aabb.maxZ)) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
@@ -244,11 +346,6 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean isInfiniteExtentsBox(AxisAlignedBB box) {
|
||||
return box == null || Double.isInfinite(box.minX) || Double.isInfinite(box.minY) || Double.isInfinite(box.minZ)
|
||||
|| Double.isInfinite(box.maxX) || Double.isInfinite(box.maxY) || Double.isInfinite(box.maxZ);
|
||||
}
|
||||
|
||||
public boolean isEntityVisible(Entity entity) {
|
||||
// During shadow pass, don't cull entities - shadow rendering uses different frustum
|
||||
if (!this.useEntityCulling || this.renderSectionManager.isInShadowPass()) {
|
||||
@@ -260,7 +357,7 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
|
||||
box = entity.boundingBox;
|
||||
}
|
||||
|
||||
if (isInfiniteExtentsBox(box)) {
|
||||
if (TileEntityRenderBoundsRegistry.isInfiniteExtentsBox(box)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -284,4 +381,51 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
|
||||
return this;
|
||||
}
|
||||
}
|
||||
|
||||
private static class RenderSectionOrderer implements Comparator<RenderSection> {
|
||||
|
||||
public CameraState lastCameraState;
|
||||
|
||||
public RenderSectionOrderer() {
|
||||
super();
|
||||
}
|
||||
|
||||
public RenderSectionOrderer setLastCameraState(CameraState lastCameraState) {
|
||||
this.lastCameraState = lastCameraState;
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int compare(RenderSection render1, RenderSection render2) {
|
||||
final float x = (float) this.lastCameraState.x();
|
||||
final float y = (float) this.lastCameraState.y();
|
||||
final float z = (float) this.lastCameraState.z();
|
||||
final float d1 = render1.getSquaredDistance(x, y, z);
|
||||
final float d2 = render2.getSquaredDistance(x, y, z);
|
||||
return Float.compare(d2, d1);
|
||||
}
|
||||
}
|
||||
|
||||
private static class TileEntityOrderer implements Comparator<TileEntity> {
|
||||
public CameraState lastCameraState;
|
||||
|
||||
public TileEntityOrderer() {
|
||||
super();
|
||||
}
|
||||
|
||||
public TileEntityOrderer setLastCameraState(CameraState lastCameraState) {
|
||||
this.lastCameraState = lastCameraState;
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int compare(TileEntity te1, TileEntity te2) {
|
||||
final double x = this.lastCameraState.x();
|
||||
final double y = this.lastCameraState.y();
|
||||
final double z = this.lastCameraState.z();
|
||||
final double d1 = te1.getDistanceFrom(x, y, z);
|
||||
final double d2 = te2.getDistanceFrom(x, y, z);
|
||||
return Double.compare(d2, d1);
|
||||
}
|
||||
}
|
||||
}
|
||||
+76
@@ -0,0 +1,76 @@
|
||||
package com.gtnewhorizons.angelica.rendering.celeritas;
|
||||
|
||||
import static com.mitchej123.lwjgl.LWJGLServiceProvider.LWJGL;
|
||||
import static com.mitchej123.lwjgl.LWJGLServiceProvider.POINTER_SIZE;
|
||||
|
||||
import org.embeddedt.embeddium.impl.gl.device.CommandList;
|
||||
import org.embeddedt.embeddium.impl.gl.device.DrawCommandList;
|
||||
import org.embeddedt.embeddium.impl.gl.device.MultiDrawBatch;
|
||||
import org.embeddedt.embeddium.impl.gl.tessellation.GlIndexType;
|
||||
import org.embeddedt.embeddium.impl.gl.tessellation.GlPrimitiveType;
|
||||
import org.embeddedt.embeddium.impl.gl.tessellation.GlTessellation;
|
||||
import org.embeddedt.embeddium.impl.model.quad.properties.ModelQuadFacing;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.data.SectionRenderDataUnsafe;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.multidraw.MultiDrawEmitter;
|
||||
|
||||
public record IndividualDrawEmitter(MultiDrawBatch batch) implements MultiDrawEmitter {
|
||||
public IndividualDrawEmitter() {
|
||||
this(new MultiDrawBatch(MAX_COMMAND_COUNT));
|
||||
}
|
||||
|
||||
@Override
|
||||
@SuppressWarnings("IntegerMultiplicationImplicitCastToLong")
|
||||
public void addDrawCommands(long pMeshData, int mask, int indexPointerMask) {
|
||||
var batch = this.batch;
|
||||
final var pBaseVertex = batch.pBaseVertex;
|
||||
final var pElementCount = batch.pElementCount;
|
||||
final var pElementPointer = batch.pElementPointer;
|
||||
|
||||
int size = batch.size;
|
||||
|
||||
for (int facing = 0; facing < ModelQuadFacing.COUNT; facing++) {
|
||||
LWJGL.memPutInt(pBaseVertex + (size << 2), SectionRenderDataUnsafe.getVertexOffset(pMeshData, facing));
|
||||
LWJGL.memPutInt(pElementCount + (size << 2), SectionRenderDataUnsafe.getElementCount(pMeshData, facing));
|
||||
LWJGL.memPutAddress(pElementPointer + (size << 3), SectionRenderDataUnsafe.getIndexOffset(pMeshData, facing) & indexPointerMask);
|
||||
|
||||
size += (mask >> facing) & 1;
|
||||
}
|
||||
|
||||
batch.size = size;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void executeBatch(CommandList commandList, GlTessellation tessellation, GlPrimitiveType primitiveType) {
|
||||
try (DrawCommandList _ = commandList.beginTessellating(tessellation)) {
|
||||
final int mode = primitiveType.getId();
|
||||
final int type = GlIndexType.UNSIGNED_INT.getFormatId();
|
||||
|
||||
for (int i = 0; i < batch.size; i++) {
|
||||
final int count = LWJGL.memGetInt(batch.pElementCount + (long) i * Integer.BYTES);
|
||||
if (count > 0) {
|
||||
LWJGL.glDrawElementsBaseVertex(mode, count, type, LWJGL.memGetAddress(batch.pElementPointer + (long) i * POINTER_SIZE), LWJGL.memGetInt(batch.pBaseVertex + (long) i * Integer.BYTES));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getIndexBufferSize() {
|
||||
return this.batch.getIndexBufferSize();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
return this.batch.isEmpty();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clear() {
|
||||
this.batch.clear();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void delete() {
|
||||
this.batch.delete();
|
||||
}
|
||||
}
|
||||
+21
-1
@@ -12,6 +12,7 @@ public class VertexArrayQuadView implements ModelQuadView {
|
||||
private int trueNormal;
|
||||
private int blockX, blockY, blockZ;
|
||||
private ModelQuadFacing lightFace;
|
||||
private int flags;
|
||||
|
||||
public VertexArrayQuadView(ChunkVertexEncoder.Vertex[] vertices) {
|
||||
this.vertices = vertices;
|
||||
@@ -23,6 +24,7 @@ public class VertexArrayQuadView implements ModelQuadView {
|
||||
this.blockY = blockY;
|
||||
this.blockZ = blockZ;
|
||||
this.lightFace = null; // Reset cached lightFace
|
||||
this.flags = 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -62,7 +64,10 @@ public class VertexArrayQuadView implements ModelQuadView {
|
||||
|
||||
@Override
|
||||
public int getFlags() {
|
||||
return ModelQuadFlags.getQuadFlags(this, getLightFace());
|
||||
if (flags == 0) {
|
||||
flags = ModelQuadFlags.getQuadFlags(this, getLightFace());
|
||||
}
|
||||
return flags;
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -98,6 +103,21 @@ public class VertexArrayQuadView implements ModelQuadView {
|
||||
return trueNormal;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the cull face of a quad. This is distinct from the light face, as it will not be set for non-axis-aligned
|
||||
* and non-block-grid-aligned quads (i.e. quads on the surface of the 1x1x1 cube).
|
||||
* @return the cull face if present, or UNASSIGNED
|
||||
*/
|
||||
public ModelQuadFacing getCullFace() {
|
||||
// In modern, only quads that are aligned to the block grid can have a cull face, as otherwise
|
||||
// they should not participate in face culling (an adjacent block wouldn't obscure an inset quad)
|
||||
if ((getFlags() & ModelQuadFlags.IS_ALIGNED) == 0) {
|
||||
return ModelQuadFacing.UNASSIGNED;
|
||||
}
|
||||
|
||||
return getNormalFace();
|
||||
}
|
||||
|
||||
private static ModelQuadFacing computeLightFace(int normal) {
|
||||
final float nx = NormI8.unpackX(normal);
|
||||
final float ny = NormI8.unpackY(normal);
|
||||
|
||||
+1
-12
@@ -35,17 +35,6 @@ public class LightDataCache extends LightDataAccess {
|
||||
// Opacity check - true if block is view-blocking (solid blocks)
|
||||
final boolean op = block.getMaterial().isOpaque() && block.getLightOpacity() > 0;
|
||||
|
||||
boolean em;
|
||||
if (lu > 0) {
|
||||
em = true;
|
||||
} else {
|
||||
try {
|
||||
em = block.getMixedBrightnessForBlock(EmptyBlockAccess.INSTANCE, x, y, z) == QuadLightingHelper.FULL_BRIGHT_15;
|
||||
} catch (Exception e) {
|
||||
em = false;
|
||||
}
|
||||
}
|
||||
|
||||
return packFC(fc) | packFO(fo) | packOP(op) | packEM(em) | packAO(ao) | packLU(lu) | packSL(sl) | packBL(bl);
|
||||
return packFC(fc) | packFO(fo) | packOP(op) | packAO(ao) | packLU(lu) | packSL(sl) | packBL(bl);
|
||||
}
|
||||
}
|
||||
-28
@@ -1,28 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.rendering.celeritas.light;
|
||||
|
||||
import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexEncoder;
|
||||
|
||||
public final class QuadLightingHelper {
|
||||
private QuadLightingHelper() {}
|
||||
|
||||
// Known emissive brightness values set by mods/vanilla
|
||||
public static final int FULL_BRIGHT_15 = (15 << 20) | (15 << 4); // 15728880
|
||||
public static final int FULL_BRIGHT_14 = (14 << 20) | (14 << 4); // 14680288
|
||||
|
||||
public static boolean isQuadFullBright(ChunkVertexEncoder.Vertex[] vertices) {
|
||||
final int first = vertices[0].light;
|
||||
|
||||
// Must be a known emissive brightness value
|
||||
if (first != FULL_BRIGHT_15 && first != FULL_BRIGHT_14) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// All 4 vertices must have the same value
|
||||
for (int i = 1; i < 4; i++) {
|
||||
if (vertices[i].light != first) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
+7
-3
@@ -2,6 +2,7 @@ package com.gtnewhorizons.angelica.rendering.celeritas.threading;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
|
||||
import com.gtnewhorizons.angelica.rendering.AngelicaBlockSafetyRegistry;
|
||||
import com.gtnewhorizons.angelica.rendering.RenderThreadContext;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.AngelicaChunkBuilderMeshingTask;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.SmoothBiomeColorCache;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.WorldClientExtension;
|
||||
@@ -53,15 +54,14 @@ public class ThreadedAngelicaChunkBuilderMeshingTask extends AngelicaChunkBuilde
|
||||
final WorldSlice worldSlice = buildContext.getWorldSlice();
|
||||
worldSlice.copyData(this.renderContext);
|
||||
this.blockAccess = worldSlice;
|
||||
this.biomeColorCache = new SmoothBiomeColorCache(worldSlice);
|
||||
this.biomeColorCache.update(new SectionPos(this.render.getChunkX(), this.render.getChunkY(), this.render.getChunkZ()));
|
||||
this.biomeColorCache = worldSlice.getBiomeColorCache();
|
||||
buildContext.setupLightPipeline(minX, minY, minZ);
|
||||
} else {
|
||||
// Fallback: direct world access (main thread only)
|
||||
final var world = Minecraft.getMinecraft().theWorld;
|
||||
this.blockAccess = new ChunkCache(world, minX - 1, minY - 1, minZ - 1, minX + 17, minY + 17, minZ + 17, 1);
|
||||
this.biomeColorCache = ((WorldClientExtension) world).celeritas$getSmoothBiomeColorCache();
|
||||
this.biomeColorCache.update(new SectionPos(this.render.getChunkX(), this.render.getChunkY(), this.render.getChunkZ()));
|
||||
this.blockAccess = new ChunkCache(world, minX - 1, minY - 1, minZ - 1, minX + 17, minY + 17, minZ + 17, 1);
|
||||
buildContext.setupLightPipeline(this.blockAccess, minX, minY, minZ);
|
||||
}
|
||||
}
|
||||
@@ -103,12 +103,16 @@ public class ThreadedAngelicaChunkBuilderMeshingTask extends AngelicaChunkBuilde
|
||||
enteredLocalMode = !TessellatorManager.isOnMainThread();
|
||||
if (enteredLocalMode) {
|
||||
TessellatorManager.enterLocalMode();
|
||||
if (blockAccess instanceof WorldSlice worldSlice) {
|
||||
RenderThreadContext.set(worldSlice);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onExitExecute() {
|
||||
if (enteredLocalMode) {
|
||||
RenderThreadContext.clear();
|
||||
RenderPassHelper.resetWorldRenderPass();
|
||||
TessellatorManager.exitLocalMode();
|
||||
}
|
||||
|
||||
@@ -6,11 +6,13 @@ import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.CompatMathHelper;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.IDynamicLightSource;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.SmoothBiomeColorCache;
|
||||
|
||||
import java.util.List;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.world.cloned.ChunkRenderContext;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.world.cloned.ClonedChunkSection;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.world.cloned.ClonedChunkSectionCache;
|
||||
import org.embeddedt.embeddium.impl.util.position.SectionPos;
|
||||
import cpw.mods.fml.common.Optional;
|
||||
import mega.fluidlogged.api.FLBlockAccess;
|
||||
import net.minecraft.block.Block;
|
||||
@@ -98,6 +100,8 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess {
|
||||
private ChunkSectionPos origin;
|
||||
private StructureBoundingBox volume;
|
||||
|
||||
private final SmoothBiomeColorCache biomeColorCache;
|
||||
|
||||
private List<IDynamicLightSource> chunkLightSources;
|
||||
private DynamicLights dynamicLightsInstance;
|
||||
|
||||
@@ -175,6 +179,8 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this.biomeColorCache = new SmoothBiomeColorCache(this);
|
||||
}
|
||||
|
||||
public void copyData(ChunkRenderContext context) {
|
||||
@@ -182,6 +188,8 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess {
|
||||
this.sections = context.getSections();
|
||||
this.volume = context.getVolume();
|
||||
|
||||
this.biomeColorCache.update(new SectionPos(origin.x, origin.y, origin.z));
|
||||
|
||||
this.baseX = (this.origin.x - NEIGHBOR_CHUNK_RADIUS) << 4;
|
||||
this.baseY = (this.origin.y - NEIGHBOR_CHUNK_RADIUS) << 4;
|
||||
this.baseZ = (this.origin.z - NEIGHBOR_CHUNK_RADIUS) << 4;
|
||||
@@ -221,6 +229,10 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess {
|
||||
return this.origin;
|
||||
}
|
||||
|
||||
public SmoothBiomeColorCache getBiomeColorCache() {
|
||||
return this.biomeColorCache;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getLightBrightnessForSkyBlocks(int x, int y, int z, int min) {
|
||||
if (y < 0 || y >= 256 || x < -30_000_000 || z < -30_000_000 || x >= 30_000_000 || z >= 30_000_000) {
|
||||
|
||||
+38
-23
@@ -4,11 +4,17 @@ import com.falsepattern.endlessids.mixin.helpers.ChunkBiomeHook;
|
||||
import com.gtnewhorizons.angelica.compat.ExtendedBlockStorageExt;
|
||||
import com.gtnewhorizons.angelica.compat.ModStatus;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos;
|
||||
import it.unimi.dsi.fastutil.shorts.Short2ObjectMap;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.IChunkTileEntityMapHolder;
|
||||
import com.gtnewhorizons.angelica.utils.ConcurrentTileEntityMap;
|
||||
import it.unimi.dsi.fastutil.objects.Object2ObjectMap;
|
||||
import it.unimi.dsi.fastutil.objects.Object2ObjectMaps;
|
||||
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
|
||||
import it.unimi.dsi.fastutil.shorts.Short2ObjectOpenHashMap;
|
||||
import mega.fluidlogged.internal.mixin.hook.FLSubChunk;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import net.minecraft.world.ChunkPosition;
|
||||
import net.minecraft.world.EnumSkyBlock;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraft.world.biome.BiomeGenBase;
|
||||
@@ -27,7 +33,7 @@ public class ClonedChunkSection {
|
||||
private ChunkSectionPos pos;
|
||||
private ExtendedBlockStorageExt data;
|
||||
private BiomeGenBase[] biomeData;
|
||||
private final Short2ObjectMap<TileEntity> tileEntities;
|
||||
private final Short2ObjectOpenHashMap<TileEntity> tileEntities;
|
||||
|
||||
private long lastUsedTimestamp = Long.MAX_VALUE;
|
||||
|
||||
@@ -53,7 +59,7 @@ public class ClonedChunkSection {
|
||||
this.pos = pos;
|
||||
this.data = new ExtendedBlockStorageExt(chunk, section);
|
||||
|
||||
int bArrLength;
|
||||
final int bArrLength;
|
||||
if (ModStatus.isEIDBiomeLoaded) {
|
||||
bArrLength = ((ChunkBiomeHook) chunk).getBiomeShortArray().length;
|
||||
} else {
|
||||
@@ -61,26 +67,7 @@ public class ClonedChunkSection {
|
||||
}
|
||||
this.biomeData = new BiomeGenBase[bArrLength];
|
||||
|
||||
this.tileEntities.clear();
|
||||
|
||||
// Check for tile entities
|
||||
for (int y = pos.getMinY(); y <= pos.getMaxY(); y++) {
|
||||
for (int z = pos.getMinZ(); z <= pos.getMaxZ(); z++) {
|
||||
for (int x = pos.getMinX(); x <= pos.getMaxX(); x++) {
|
||||
final int lX = x & 15, lY = y & 15, lZ = z & 15;
|
||||
// We have to use this insanity because in 1.7 the tile entity isn't guaranteed to be created
|
||||
// when the chunk gets scheduled for rendering. So we might have to create it.
|
||||
// Cloning is done on the main thread so this will not introduce threading issues
|
||||
final Block block = data.getBlockByExtId(lX, lY, lZ);
|
||||
if (block.hasTileEntity(data.getExtBlockMetadata(lX, lY, lZ))) {
|
||||
final TileEntity tileEntity = chunk.func_150806_e(x & 15, y, z & 15);
|
||||
if (tileEntity != null) {
|
||||
this.tileEntities.put(ChunkSectionPos.packLocal(tileEntity.xCoord & 15, tileEntity.yCoord & 15, tileEntity.zCoord & 15), tileEntity);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
copyBlockEntities(chunk, pos);
|
||||
|
||||
// Fill biome data
|
||||
for (int z = pos.getMinZ(); z <= pos.getMaxZ(); z++) {
|
||||
@@ -90,6 +77,34 @@ public class ClonedChunkSection {
|
||||
}
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private void copyBlockEntities(Chunk chunk, ChunkSectionPos pos) {
|
||||
this.tileEntities.clear();
|
||||
|
||||
final ConcurrentTileEntityMap map = ((IChunkTileEntityMapHolder) chunk).angelica$getConcurrentTEMap();
|
||||
|
||||
map.withReadLock(() -> {
|
||||
final Object2ObjectOpenHashMap<ChunkPosition, TileEntity> delegate = map.getDelegate();
|
||||
|
||||
if (delegate.isEmpty()) return;
|
||||
|
||||
final int minY = pos.getMinY();
|
||||
final int maxY = pos.getMaxY();
|
||||
|
||||
for (Object2ObjectMap.Entry<ChunkPosition, TileEntity> entry : Object2ObjectMaps.fastIterable(delegate)) {
|
||||
final ChunkPosition tePos = entry.getKey();
|
||||
if (tePos.chunkPosY < minY || tePos.chunkPosY > maxY) continue;
|
||||
|
||||
final TileEntity te = entry.getValue();
|
||||
if (te != null && !te.isInvalid()) {
|
||||
this.tileEntities.put(ChunkSectionPos.packLocal(tePos.chunkPosX & 15, tePos.chunkPosY & 15, tePos.chunkPosZ & 15), te);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
this.tileEntities.trim();
|
||||
}
|
||||
|
||||
public Block getBlock(int x, int y, int z) {
|
||||
return data.getBlockByExtId(x, y, z);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,203 @@
|
||||
package com.gtnewhorizons.angelica.utils;
|
||||
|
||||
import com.gtnewhorizons.angelica.rendering.RenderThreadContext;
|
||||
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import net.minecraft.world.ChunkPosition;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.ConcurrentLinkedQueue;
|
||||
import java.util.concurrent.locks.ReentrantReadWriteLock;
|
||||
|
||||
/**
|
||||
* Thread-safe wrapper around Object2ObjectOpenHashMap for chunkTileEntityMap.
|
||||
*/
|
||||
public class ConcurrentTileEntityMap implements Map<ChunkPosition, TileEntity> {
|
||||
private final Object2ObjectOpenHashMap<ChunkPosition, TileEntity> delegate = new Object2ObjectOpenHashMap<>();
|
||||
private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
|
||||
private final ConcurrentLinkedQueue<ChunkPosition> invalidationQueue = new ConcurrentLinkedQueue<>();
|
||||
|
||||
public void queueInvalidation(ChunkPosition pos) {
|
||||
invalidationQueue.add(pos);
|
||||
}
|
||||
|
||||
private void processInvalidationQueue() {
|
||||
ChunkPosition pos;
|
||||
while ((pos = invalidationQueue.poll()) != null) {
|
||||
final TileEntity te = delegate.get(pos);
|
||||
if (te != null && te.isInvalid()) {
|
||||
delegate.remove(pos);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void withReadLock(Runnable action) {
|
||||
lock.readLock().lock();
|
||||
try {
|
||||
action.run();
|
||||
} finally {
|
||||
lock.readLock().unlock();
|
||||
}
|
||||
}
|
||||
|
||||
public void withWriteLock(Runnable action) {
|
||||
lock.writeLock().lock();
|
||||
try {
|
||||
action.run();
|
||||
} finally {
|
||||
lock.writeLock().unlock();
|
||||
}
|
||||
}
|
||||
|
||||
public Object2ObjectOpenHashMap<ChunkPosition, TileEntity> getDelegate() {
|
||||
return delegate;
|
||||
}
|
||||
|
||||
public TileEntity putDirect(ChunkPosition key, TileEntity value) {
|
||||
return delegate.put(key, value);
|
||||
}
|
||||
|
||||
private static boolean isRenderWorkerThread() {
|
||||
return RenderThreadContext.hasWorldSlice();
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public TileEntity get(Object key) {
|
||||
if (!isRenderWorkerThread()) return delegate.get(key);
|
||||
|
||||
lock.readLock().lock();
|
||||
try {
|
||||
final TileEntity te = delegate.get(key);
|
||||
if (te != null && te.isInvalid()) {
|
||||
if (key instanceof ChunkPosition pos) {
|
||||
invalidationQueue.add(pos);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
return te;
|
||||
} finally {
|
||||
lock.readLock().unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public TileEntity put(ChunkPosition key, TileEntity value) {
|
||||
lock.writeLock().lock();
|
||||
try {
|
||||
processInvalidationQueue();
|
||||
return delegate.put(key, value);
|
||||
} finally {
|
||||
lock.writeLock().unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public TileEntity remove(Object key) {
|
||||
if (isRenderWorkerThread()) {
|
||||
if (key instanceof ChunkPosition pos) {
|
||||
invalidationQueue.add(pos);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
lock.writeLock().lock();
|
||||
try {
|
||||
processInvalidationQueue();
|
||||
return delegate.remove(key);
|
||||
} finally {
|
||||
lock.writeLock().unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void putAll(Map<? extends ChunkPosition, ? extends TileEntity> m) {
|
||||
lock.writeLock().lock();
|
||||
try {
|
||||
processInvalidationQueue();
|
||||
delegate.putAll(m);
|
||||
} finally {
|
||||
lock.writeLock().unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clear() {
|
||||
lock.writeLock().lock();
|
||||
try {
|
||||
invalidationQueue.clear();
|
||||
delegate.clear();
|
||||
} finally {
|
||||
lock.writeLock().unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public int size() {
|
||||
if (!isRenderWorkerThread()) return delegate.size();
|
||||
lock.readLock().lock();
|
||||
try {
|
||||
return delegate.size();
|
||||
} finally {
|
||||
lock.readLock().unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
if (!isRenderWorkerThread()) return delegate.isEmpty();
|
||||
lock.readLock().lock();
|
||||
try {
|
||||
return delegate.isEmpty();
|
||||
} finally {
|
||||
lock.readLock().unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean containsKey(Object key) {
|
||||
if (!isRenderWorkerThread()) return delegate.containsKey(key);
|
||||
lock.readLock().lock();
|
||||
try {
|
||||
return delegate.containsKey(key);
|
||||
} finally {
|
||||
lock.readLock().unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean containsValue(Object value) {
|
||||
if (!isRenderWorkerThread()) return delegate.containsValue(value);
|
||||
lock.readLock().lock();
|
||||
try {
|
||||
return delegate.containsValue(value);
|
||||
} finally {
|
||||
lock.readLock().unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Set<ChunkPosition> keySet() {
|
||||
if (isRenderWorkerThread()) {
|
||||
throw new IllegalStateException("keySet() called from render worker. Use withReadLock() for iteration.");
|
||||
}
|
||||
return delegate.keySet();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Collection<TileEntity> values() {
|
||||
if (isRenderWorkerThread()) {
|
||||
throw new IllegalStateException("values() called from render worker. Use withReadLock() for iteration.");
|
||||
}
|
||||
return delegate.values();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Set<Entry<ChunkPosition, TileEntity>> entrySet() {
|
||||
if (isRenderWorkerThread()) {
|
||||
throw new IllegalStateException("entrySet() called from render worker. Use withReadLock() for iteration.");
|
||||
}
|
||||
return delegate.entrySet();
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
package com.prupe.mcpatcher.ctm;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.launchwrapper.Launch;
|
||||
import net.minecraft.util.IIcon;
|
||||
import net.minecraft.world.IBlockAccess;
|
||||
|
||||
@@ -8,6 +9,9 @@ import com.prupe.mcpatcher.mal.block.BlockStateMatcher;
|
||||
|
||||
final class BlockOrientation extends RenderBlockState {
|
||||
|
||||
private static final boolean fixedBottomFaceUV = (boolean) Launch.blackboard
|
||||
.getOrDefault("hodgepodge.FixesConfig.fixBottomFaceUV", Boolean.FALSE);
|
||||
|
||||
// NEIGHBOR_OFFSETS[a][b][c] = offset from starting block
|
||||
// a: face 0-5
|
||||
// b: neighbor 0-7
|
||||
@@ -16,7 +20,11 @@ final class BlockOrientation extends RenderBlockState {
|
||||
// 1 2 3
|
||||
// c: coordinate (x,y,z) 0-2
|
||||
private static final int[][][] NEIGHBOR_OFFSET = new int[][][] {
|
||||
makeNeighborOffset(WEST_FACE, SOUTH_FACE, EAST_FACE, NORTH_FACE), // BOTTOM_FACE
|
||||
(
|
||||
fixedBottomFaceUV
|
||||
? makeNeighborOffset(EAST_FACE, SOUTH_FACE, WEST_FACE, NORTH_FACE) // BOTTOM_FACE fixedBottomFaceUV
|
||||
: makeNeighborOffset(WEST_FACE, SOUTH_FACE, EAST_FACE, NORTH_FACE) // BOTTOM_FACE not fixed
|
||||
),
|
||||
makeNeighborOffset(WEST_FACE, SOUTH_FACE, EAST_FACE, NORTH_FACE), // TOP_FACE
|
||||
makeNeighborOffset(EAST_FACE, BOTTOM_FACE, WEST_FACE, TOP_FACE), // NORTH_FACE
|
||||
makeNeighborOffset(WEST_FACE, BOTTOM_FACE, EAST_FACE, TOP_FACE), // SOUTH_FACE
|
||||
|
||||
@@ -7,6 +7,8 @@ import java.util.IdentityHashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.locks.Lock;
|
||||
import java.util.concurrent.locks.ReentrantLock;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.util.IIcon;
|
||||
@@ -37,6 +39,7 @@ public class CTMUtils {
|
||||
private static TileLoader tileLoader;
|
||||
|
||||
private static TileOverride lastOverride;
|
||||
private static final Lock lock = new ReentrantLock();
|
||||
|
||||
private static final TileOverrideIterator.IJK ijkIterator = newIJKIterator();
|
||||
private static final TileOverrideIterator.Metadata metadataIterator = newMetadataIterator();
|
||||
@@ -52,64 +55,76 @@ public class CTMUtils {
|
||||
} catch (Exception ignore) {}
|
||||
|
||||
TexturePackChangeHandler.register(new TexturePackChangeHandler(MCPatcherUtils.CONNECTED_TEXTURES, 3) {
|
||||
|
||||
@Override
|
||||
public void initialize() {}
|
||||
public void initialize() {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void beforeChange() {
|
||||
RenderPassAPI.instance.clear();
|
||||
lock.lock();
|
||||
try {
|
||||
GlassPaneRenderer.clear();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
renderBlockState.clear();
|
||||
ijkIterator.clear();
|
||||
metadataIterator.clear();
|
||||
allOverrides.clear();
|
||||
blockOverrides.clear();
|
||||
tileOverrides.clear();
|
||||
lastOverride = null;
|
||||
RenderBlocksUtils.blankIcon = null;
|
||||
tileLoader = new TileLoader("textures/blocks", logger);
|
||||
RenderPassAPI.instance.refreshBlendingOptions();
|
||||
|
||||
if (MCPatcherForgeConfig.ConnectedTextures.standard || MCPatcherForgeConfig.ConnectedTextures.nonStandard) {
|
||||
for (ResourceLocation resource : ResourceList.getInstance()
|
||||
.listResources(TexturePackAPI.MCPATCHER_SUBDIR + "ctm", ".properties", true)) {
|
||||
registerOverride(TileOverride.create(resource, tileLoader));
|
||||
RenderPassAPI.instance.clear();
|
||||
try {
|
||||
GlassPaneRenderer.clear();
|
||||
} catch (NoClassDefFoundError e) {
|
||||
// nothing
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
for (ResourceLocation resource : BlendMethod.getAllBlankResources()) {
|
||||
tileLoader.preloadTile(resource, false);
|
||||
renderBlockState.clear();
|
||||
ijkIterator.clear();
|
||||
metadataIterator.clear();
|
||||
allOverrides.clear();
|
||||
blockOverrides.clear();
|
||||
tileOverrides.clear();
|
||||
lastOverride = null;
|
||||
RenderBlocksUtils.blankIcon = null;
|
||||
tileLoader = new TileLoader("textures/blocks", logger);
|
||||
RenderPassAPI.instance.refreshBlendingOptions();
|
||||
|
||||
if (MCPatcherForgeConfig.ConnectedTextures.standard || MCPatcherForgeConfig.ConnectedTextures.nonStandard) {
|
||||
for (ResourceLocation resource : ResourceList.getInstance()
|
||||
.listResources(TexturePackAPI.MCPATCHER_SUBDIR + "ctm", ".properties", true)) {
|
||||
registerOverride(TileOverride.create(resource, tileLoader));
|
||||
}
|
||||
}
|
||||
for (ResourceLocation resource : BlendMethod.getAllBlankResources()) {
|
||||
tileLoader.preloadTile(resource, false);
|
||||
}
|
||||
} finally {
|
||||
lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void afterChange() {
|
||||
for (TileOverride override : allOverrides) {
|
||||
override.registerIcons();
|
||||
}
|
||||
for (Map.Entry<Block, List<BlockStateMatcher>> entry : blockOverrides.entrySet()) {
|
||||
for (BlockStateMatcher matcher : entry.getValue()) {
|
||||
TileOverride override = (TileOverride) matcher.getData();
|
||||
if (override.getRenderPass() >= 0) {
|
||||
RenderPassAPI.instance.setRenderPassForBlock(entry.getKey(), override.getRenderPass());
|
||||
lock.lock();
|
||||
try {
|
||||
for (TileOverride override : allOverrides) {
|
||||
override.registerIcons();
|
||||
}
|
||||
for (Map.Entry<Block, List<BlockStateMatcher>> entry : blockOverrides.entrySet()) {
|
||||
for (BlockStateMatcher matcher : entry.getValue()) {
|
||||
TileOverride override = (TileOverride) matcher.getData();
|
||||
if (override.getRenderPass() >= 0) {
|
||||
RenderPassAPI.instance.setRenderPassForBlock(entry.getKey(), override.getRenderPass());
|
||||
}
|
||||
}
|
||||
}
|
||||
for (List<BlockStateMatcher> overrides : blockOverrides.values()) {
|
||||
overrides.sort((m1, m2) -> {
|
||||
TileOverride o1 = (TileOverride) m1.getData();
|
||||
TileOverride o2 = (TileOverride) m2.getData();
|
||||
return o1.compareTo(o2);
|
||||
});
|
||||
}
|
||||
for (List<TileOverride> overrides : tileOverrides.values()) {
|
||||
Collections.sort(overrides);
|
||||
}
|
||||
setBlankResource();
|
||||
} finally {
|
||||
lock.unlock();
|
||||
}
|
||||
for (List<BlockStateMatcher> overrides : blockOverrides.values()) {
|
||||
overrides.sort((m1, m2) -> {
|
||||
TileOverride o1 = (TileOverride) m1.getData();
|
||||
TileOverride o2 = (TileOverride) m2.getData();
|
||||
return o1.compareTo(o2);
|
||||
});
|
||||
}
|
||||
for (List<TileOverride> overrides : tileOverrides.values()) {
|
||||
Collections.sort(overrides);
|
||||
}
|
||||
setBlankResource();
|
||||
}
|
||||
});
|
||||
}
|
||||
@@ -118,40 +133,53 @@ public class CTMUtils {
|
||||
haveBlockFace = false;
|
||||
}
|
||||
|
||||
public static synchronized IIcon getBlockIcon(IIcon icon, Block block, IBlockAccess blockAccess,
|
||||
int x, int y, int z, int face) {
|
||||
lastOverride = null;
|
||||
if (blockAccess != null && checkFace(face)) {
|
||||
if (!haveBlockFace) {
|
||||
renderBlockState.setBlock(block, blockAccess, x, y, z);
|
||||
renderBlockState.setFace(face);
|
||||
}
|
||||
lastOverride = ijkIterator.go(renderBlockState, icon);
|
||||
if (lastOverride != null) {
|
||||
icon = ijkIterator.getIcon();
|
||||
public static IIcon getBlockIcon(IIcon icon, Block block, IBlockAccess blockAccess,
|
||||
int x, int y, int z, int face) {
|
||||
lock.lock();
|
||||
try {
|
||||
lastOverride = null;
|
||||
if (blockAccess != null && checkFace(face)) {
|
||||
if (!haveBlockFace) {
|
||||
renderBlockState.setBlock(block, blockAccess, x, y, z);
|
||||
renderBlockState.setFace(face);
|
||||
}
|
||||
lastOverride = ijkIterator.go(renderBlockState, icon);
|
||||
if (lastOverride != null) {
|
||||
icon = ijkIterator.getIcon();
|
||||
}
|
||||
}
|
||||
clearBlockFace();
|
||||
IIcon result = lastOverride == null && skipDefaultRendering(block) ? RenderBlocksUtils.blankIcon : icon;
|
||||
return result;
|
||||
} finally {
|
||||
lock.unlock();
|
||||
}
|
||||
clearBlockFace();
|
||||
return lastOverride == null && skipDefaultRendering(block) ? RenderBlocksUtils.blankIcon : icon;
|
||||
}
|
||||
|
||||
public static synchronized IIcon getBlockIcon(IIcon icon, Block block, int face, int metadata) {
|
||||
lastOverride = null;
|
||||
if (checkFace(face) && checkRenderType(block)) {
|
||||
renderBlockState.setBlockMetadata(block, metadata, face);
|
||||
lastOverride = metadataIterator.go(renderBlockState, icon);
|
||||
if (lastOverride != null) {
|
||||
icon = metadataIterator.getIcon();
|
||||
public static IIcon getBlockIcon(IIcon icon, Block block, int face, int metadata) {
|
||||
lock.lock();
|
||||
try {
|
||||
lastOverride = null;
|
||||
if (checkFace(face) && checkRenderType(block)) {
|
||||
renderBlockState.setBlockMetadata(block, metadata, face);
|
||||
lastOverride = metadataIterator.go(renderBlockState, icon);
|
||||
if (lastOverride != null) {
|
||||
icon = metadataIterator.getIcon();
|
||||
}
|
||||
}
|
||||
return icon;
|
||||
|
||||
} finally {
|
||||
lock.unlock();
|
||||
}
|
||||
return icon;
|
||||
}
|
||||
|
||||
public static IIcon getBlockIcon(IIcon icon, Block block, int face) {
|
||||
return getBlockIcon(icon, block, face, 0);
|
||||
}
|
||||
|
||||
public static void reset() {}
|
||||
public static void reset() {
|
||||
}
|
||||
|
||||
private static boolean checkFace(int face) {
|
||||
return face < 0 ? MCPatcherForgeConfig.ConnectedTextures.nonStandard : MCPatcherForgeConfig.ConnectedTextures.standard;
|
||||
@@ -165,50 +193,60 @@ public class CTMUtils {
|
||||
};
|
||||
}
|
||||
|
||||
private static synchronized boolean skipDefaultRendering(Block block) {
|
||||
private static boolean skipDefaultRendering(Block block) {
|
||||
return RenderPassAPI.instance.skipDefaultRendering(block);
|
||||
}
|
||||
|
||||
private static synchronized void registerOverride(TileOverride override) {
|
||||
if (override != null && !override.isDisabled()) {
|
||||
boolean registered = false;
|
||||
List<BlockStateMatcher> matchingBlocks = override.getMatchingBlocks();
|
||||
if (!MCPatcherUtils.isNullOrEmpty(matchingBlocks)) {
|
||||
for (BlockStateMatcher matcher : matchingBlocks) {
|
||||
if (matcher == null) {
|
||||
continue;
|
||||
private static void registerOverride(TileOverride override) {
|
||||
lock.lock();
|
||||
try {
|
||||
if (override != null && !override.isDisabled()) {
|
||||
boolean registered = false;
|
||||
List<BlockStateMatcher> matchingBlocks = override.getMatchingBlocks();
|
||||
if (!MCPatcherUtils.isNullOrEmpty(matchingBlocks)) {
|
||||
for (BlockStateMatcher matcher : matchingBlocks) {
|
||||
if (matcher == null) {
|
||||
continue;
|
||||
}
|
||||
Block block = matcher.getBlock();
|
||||
List<BlockStateMatcher> list = blockOverrides.computeIfAbsent(block, k -> new ArrayList<>());
|
||||
list.add(matcher);
|
||||
logger.fine("using %s for block %s", override, BlockAPI.getBlockName(block));
|
||||
registered = true;
|
||||
}
|
||||
Block block = matcher.getBlock();
|
||||
List<BlockStateMatcher> list = blockOverrides.computeIfAbsent(block, k -> new ArrayList<>());
|
||||
list.add(matcher);
|
||||
logger.fine("using %s for block %s", override, BlockAPI.getBlockName(block));
|
||||
registered = true;
|
||||
}
|
||||
Set<String> matchingTiles = override.getMatchingTiles();
|
||||
if (!MCPatcherUtils.isNullOrEmpty(matchingTiles)) {
|
||||
for (String name : matchingTiles) {
|
||||
List<TileOverride> list = tileOverrides.computeIfAbsent(name, k -> new ArrayList<>());
|
||||
list.add(override);
|
||||
logger.fine("using %s for tile %s", override, name);
|
||||
registered = true;
|
||||
}
|
||||
}
|
||||
if (registered) {
|
||||
allOverrides.add(override);
|
||||
}
|
||||
}
|
||||
Set<String> matchingTiles = override.getMatchingTiles();
|
||||
if (!MCPatcherUtils.isNullOrEmpty(matchingTiles)) {
|
||||
for (String name : matchingTiles) {
|
||||
List<TileOverride> list = tileOverrides.computeIfAbsent(name, k -> new ArrayList<>());
|
||||
list.add(override);
|
||||
logger.fine("using %s for tile %s", override, name);
|
||||
registered = true;
|
||||
}
|
||||
}
|
||||
if (registered) {
|
||||
allOverrides.add(override);
|
||||
}
|
||||
} finally {
|
||||
lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
public static synchronized void setBlankResource() {
|
||||
RenderBlocksUtils.blankIcon = tileLoader.getIcon(RenderPassAPI.instance.getBlankResource());
|
||||
public static void setBlankResource() {
|
||||
lock.lock();
|
||||
try {
|
||||
RenderBlocksUtils.blankIcon = tileLoader.getIcon(RenderPassAPI.instance.getBlankResource());
|
||||
} finally {
|
||||
lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
public static TileOverrideIterator.IJK newIJKIterator() {
|
||||
private static TileOverrideIterator.IJK newIJKIterator() {
|
||||
return new TileOverrideIterator.IJK(blockOverrides, tileOverrides);
|
||||
}
|
||||
|
||||
public static TileOverrideIterator.Metadata newMetadataIterator() {
|
||||
private static TileOverrideIterator.Metadata newMetadataIterator() {
|
||||
return new TileOverrideIterator.Metadata(blockOverrides, tileOverrides);
|
||||
}
|
||||
}
|
||||
@@ -37,7 +37,7 @@ abstract public class TileOverrideIterator implements Iterator<TileOverride> {
|
||||
this.allTileOverrides = allTileOverrides;
|
||||
}
|
||||
|
||||
synchronized void clear() {
|
||||
void clear() {
|
||||
currentIcon = null;
|
||||
blockOverrides = null;
|
||||
tileOverrides = null;
|
||||
@@ -46,7 +46,7 @@ abstract public class TileOverrideIterator implements Iterator<TileOverride> {
|
||||
skipOverrides.clear();
|
||||
}
|
||||
|
||||
private synchronized void resetForNextPass() {
|
||||
private void resetForNextPass() {
|
||||
blockOverrides = null;
|
||||
tileOverrides = allTileOverrides.get(currentIcon.getIconName());
|
||||
blockPos = 0;
|
||||
@@ -55,7 +55,7 @@ abstract public class TileOverrideIterator implements Iterator<TileOverride> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public synchronized boolean hasNext() {
|
||||
public boolean hasNext() {
|
||||
if (foundNext) {
|
||||
return true;
|
||||
}
|
||||
@@ -80,7 +80,7 @@ abstract public class TileOverrideIterator implements Iterator<TileOverride> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public synchronized TileOverride next() {
|
||||
public TileOverride next() {
|
||||
if (!foundNext) {
|
||||
throw new IllegalStateException("next called before hasNext() == true");
|
||||
}
|
||||
@@ -89,11 +89,11 @@ abstract public class TileOverrideIterator implements Iterator<TileOverride> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public synchronized void remove() {
|
||||
public void remove() {
|
||||
throw new UnsupportedOperationException("remove not supported");
|
||||
}
|
||||
|
||||
private synchronized boolean checkOverride(TileOverride override) {
|
||||
private boolean checkOverride(TileOverride override) {
|
||||
if (override != null && !override.isDisabled() && !skipOverrides.contains(override)) {
|
||||
foundNext = true;
|
||||
nextOverride = override;
|
||||
@@ -103,7 +103,7 @@ abstract public class TileOverrideIterator implements Iterator<TileOverride> {
|
||||
}
|
||||
}
|
||||
|
||||
public synchronized TileOverride go(RenderBlockState renderBlockState, IIcon origIcon) {
|
||||
public TileOverride go(RenderBlockState renderBlockState, IIcon origIcon) {
|
||||
this.renderBlockState = renderBlockState;
|
||||
renderBlockState.setFilter(null);
|
||||
currentIcon = origIcon;
|
||||
@@ -133,7 +133,7 @@ abstract public class TileOverrideIterator implements Iterator<TileOverride> {
|
||||
return lastMatchedOverride;
|
||||
}
|
||||
|
||||
public synchronized IIcon getIcon() {
|
||||
public IIcon getIcon() {
|
||||
return currentIcon;
|
||||
}
|
||||
|
||||
@@ -146,7 +146,7 @@ abstract public class TileOverrideIterator implements Iterator<TileOverride> {
|
||||
}
|
||||
|
||||
@Override
|
||||
protected synchronized IIcon getTile(TileOverride override, RenderBlockState renderBlockState, IIcon origIcon) {
|
||||
protected IIcon getTile(TileOverride override, RenderBlockState renderBlockState, IIcon origIcon) {
|
||||
return override.getTileWorld(renderBlockState, origIcon);
|
||||
}
|
||||
}
|
||||
@@ -158,7 +158,7 @@ abstract public class TileOverrideIterator implements Iterator<TileOverride> {
|
||||
}
|
||||
|
||||
@Override
|
||||
protected synchronized IIcon getTile(TileOverride override, RenderBlockState renderBlockState, IIcon origIcon) {
|
||||
protected IIcon getTile(TileOverride override, RenderBlockState renderBlockState, IIcon origIcon) {
|
||||
return override.getTileHeld(renderBlockState, origIcon);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
package jss.notfine.gui;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import jss.notfine.config.NotFineConfig;
|
||||
import jss.notfine.core.Settings;
|
||||
@@ -297,7 +296,7 @@ public class NotFineGameOptionPages {
|
||||
.setTooltip(I18n.format("sodium.options.use_block_face_culling.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setBinding((opts, value) -> opts.advanced.useBlockFaceCulling = value, opts -> opts.advanced.useBlockFaceCulling)
|
||||
.setBinding((opts, value) -> opts.performance.useBlockFaceCulling = value, opts -> opts.performance.useBlockFaceCulling)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build())
|
||||
.add(OptionImpl.createBuilder(boolean.class, sodiumOpts)
|
||||
@@ -305,14 +304,14 @@ public class NotFineGameOptionPages {
|
||||
.setTooltip(I18n.format("sodium.options.use_compact_vertex_format.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setBinding((opts, value) -> opts.advanced.useCompactVertexFormat = value, opts -> opts.advanced.useCompactVertexFormat)
|
||||
.setBinding((opts, value) -> opts.performance.useCompactVertexFormat = value, opts -> opts.performance.useCompactVertexFormat)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build())
|
||||
.add(OptionImpl.createBuilder(boolean.class, sodiumOpts)
|
||||
.setName(I18n.format("sodium.options.use_fog_occlusion.name"))
|
||||
.setTooltip(I18n.format("sodium.options.use_fog_occlusion.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setBinding((opts, value) -> opts.advanced.useFogOcclusion = value, opts -> opts.advanced.useFogOcclusion)
|
||||
.setBinding((opts, value) -> opts.performance.useFogOcclusion = value, opts -> opts.performance.useFogOcclusion)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build())
|
||||
@@ -320,7 +319,7 @@ public class NotFineGameOptionPages {
|
||||
.setName(I18n.format("sodium.options.translucency_sorting.name"))
|
||||
.setTooltip(I18n.format("sodium.options.translucency_sorting.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setBinding((opts, value) -> opts.advanced.translucencySorting = value, opts -> opts.advanced.translucencySorting)
|
||||
.setBinding((opts, value) -> opts.performance.translucencySorting = value, opts -> opts.performance.translucencySorting)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build())
|
||||
@@ -329,7 +328,7 @@ public class NotFineGameOptionPages {
|
||||
.setTooltip(I18n.format("sodium.options.use_entity_culling.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setBinding((opts, value) -> opts.advanced.useEntityCulling = value, opts -> opts.advanced.useEntityCulling)
|
||||
.setBinding((opts, value) -> opts.performance.useEntityCulling = value, opts -> opts.performance.useEntityCulling)
|
||||
.build())
|
||||
.add(OptionImpl.createBuilder(boolean.class, sodiumOpts)
|
||||
.setName(I18n.format("sodium.options.use_particle_culling.name"))
|
||||
@@ -345,7 +344,7 @@ public class NotFineGameOptionPages {
|
||||
.setTooltip(I18n.format("sodium.options.animate_only_visible_textures.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setBinding((opts, value) -> opts.advanced.animateOnlyVisibleTextures = value, opts -> opts.advanced.animateOnlyVisibleTextures)
|
||||
.setBinding((opts, value) -> opts.performance.animateOnlyVisibleTextures = value, opts -> opts.performance.animateOnlyVisibleTextures)
|
||||
.build())
|
||||
.build());
|
||||
groups.add(OptionGroup.createBuilder()
|
||||
|
||||
@@ -31,7 +31,7 @@ public class CyclingControlElement<T extends Enum<T>> extends NotFineControlElem
|
||||
@Override
|
||||
public boolean mousePressed(Minecraft mc, int mouseX, int mouseY) {
|
||||
if(super.mousePressed(mc, mouseX, mouseY)) {
|
||||
currentIndex = (option.getValue().ordinal() + 1) % allowedValues.length;
|
||||
currentIndex = (currentIndex + 1) % allowedValues.length;
|
||||
option.setValue(allowedValues[currentIndex]);
|
||||
onOptionValueChanged();
|
||||
return true;
|
||||
|
||||
+2
-2
@@ -4,7 +4,6 @@ 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;
|
||||
@@ -19,6 +18,7 @@ import me.jellysquid.mods.sodium.client.gui.options.OptionPage;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.storage.OptionStorage;
|
||||
import me.jellysquid.mods.sodium.client.gui.widgets.FlatButtonWidget;
|
||||
import me.jellysquid.mods.sodium.client.util.Dim2i;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.gui.screen.ShaderPackScreen;
|
||||
import net.irisshaders.iris.api.v0.IrisApi;
|
||||
import net.minecraft.client.gui.GuiScreen;
|
||||
@@ -283,7 +283,7 @@ public class ReeseSodiumVideoOptionsScreen extends SodiumOptionsGUI {
|
||||
}
|
||||
if (keyCode == Keyboard.KEY_P) {
|
||||
if(isShiftKeyDown()){
|
||||
this.mc.displayGuiScreen(new GuiCustomMenu(this.prevScreen, SodiumGameOptionPages.general(), SodiumGameOptionPages.quality(), SodiumGameOptionPages.advanced(), SodiumGameOptionPages.performance()));
|
||||
this.mc.displayGuiScreen(new GuiCustomMenu(this.prevScreen, SodiumGameOptionPages.general(), SodiumGameOptionPages.quality(), SodiumGameOptionPages.advanced(), SodiumGameOptionPages.performance(), SodiumGameOptionPages.appearance(), SodiumGameOptionPages.debug()));
|
||||
} else if (isCtrlKeyDown()) {
|
||||
this.mc.displayGuiScreen(new SodiumOptionsGUI(this.prevScreen));
|
||||
}
|
||||
|
||||
@@ -1,88 +0,0 @@
|
||||
package me.jellysquid.mods.sodium.client;
|
||||
|
||||
import com.gtnewhorizons.angelica.Tags;
|
||||
import com.gtnewhorizons.angelica.config.ConfigMigrator;
|
||||
import cpw.mods.fml.common.Mod;
|
||||
import cpw.mods.fml.common.SidedProxy;
|
||||
import cpw.mods.fml.common.event.FMLInitializationEvent;
|
||||
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
|
||||
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
|
||||
import lombok.Getter;
|
||||
import me.jellysquid.mods.sodium.client.gui.SodiumGameOptions;
|
||||
import me.jellysquid.mods.sodium.proxy.CommonProxy;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
|
||||
@Mod(modid = SodiumClientMod.MODID,
|
||||
name = SodiumClientMod.NAME,
|
||||
version = Tags.VERSION,
|
||||
acceptedMinecraftVersions = "[1.7.10]",
|
||||
acceptableRemoteVersions = "*")
|
||||
public class SodiumClientMod {
|
||||
@SidedProxy(clientSide = "me.jellysquid.mods.sodium.proxy.ClientProxy", serverSide = "me.jellysquid.mods.sodium.proxy.CommonProxy")
|
||||
public static CommonProxy proxy;
|
||||
|
||||
private static SodiumGameOptions CONFIG;
|
||||
public static Logger LOGGER = LogManager.getLogger("Embeddium");
|
||||
|
||||
private static String MOD_VERSION = Tags.VERSION;
|
||||
|
||||
public static final String MODID = "embeddium";
|
||||
public static final String NAME = "Embeddium";
|
||||
|
||||
@Getter
|
||||
private static Thread MainThread;
|
||||
|
||||
public SodiumClientMod() {
|
||||
MainThread = Thread.currentThread();
|
||||
}
|
||||
|
||||
|
||||
|
||||
public static SodiumGameOptions options() {
|
||||
if (CONFIG == null) {
|
||||
CONFIG = loadConfig();
|
||||
}
|
||||
|
||||
return CONFIG;
|
||||
}
|
||||
|
||||
public static Logger logger() {
|
||||
if (LOGGER == null) {
|
||||
LOGGER = LogManager.getLogger("Embeddium");
|
||||
}
|
||||
|
||||
return LOGGER;
|
||||
}
|
||||
|
||||
private static SodiumGameOptions loadConfig() {
|
||||
return SodiumGameOptions.load(ConfigMigrator.handleConfigMigration("angelica-options.json"));
|
||||
}
|
||||
|
||||
public static String getVersion() {
|
||||
if (MOD_VERSION == null) {
|
||||
throw new NullPointerException("Mod version hasn't been populated yet");
|
||||
}
|
||||
|
||||
return MOD_VERSION;
|
||||
}
|
||||
|
||||
@Mod.EventHandler
|
||||
public void preInit(FMLPreInitializationEvent event) {
|
||||
proxy.preInit(event);
|
||||
}
|
||||
|
||||
@Mod.EventHandler
|
||||
public void init(FMLInitializationEvent event) {
|
||||
proxy.init(event);
|
||||
}
|
||||
|
||||
@Mod.EventHandler
|
||||
public void postInit(FMLPostInitializationEvent event) {
|
||||
proxy.postInit(event);
|
||||
}
|
||||
|
||||
public static boolean isDirectMemoryAccessEnabled() {
|
||||
return options().advanced.allowDirectMemoryAccess;
|
||||
}
|
||||
}
|
||||
@@ -2,7 +2,6 @@ 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;
|
||||
@@ -19,6 +18,7 @@ import me.jellysquid.mods.sodium.client.gui.options.control.TickBoxControl;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.named.GraphicsMode;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.named.GraphicsQuality;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.named.LightingQuality;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.named.MultiDrawMode;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.named.ParticleMode;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.storage.AngelicaOptionsStorage;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.storage.MinecraftOptionsStorage;
|
||||
@@ -28,6 +28,7 @@ import net.coderbot.iris.gui.option.IrisVideoSettings;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.resources.I18n;
|
||||
import net.minecraft.client.settings.GameSettings;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.occlusion.AsyncOcclusionMode;
|
||||
import org.lwjgl.opengl.Display;
|
||||
|
||||
import java.io.IOException;
|
||||
@@ -80,19 +81,6 @@ public class SodiumGameOptionPages {
|
||||
.setControl(opt -> new SliderControl(opt, 0, 100, 1, ControlValueFormatter.brightness()))
|
||||
.setBinding((opts, value) -> opts.gammaSetting = value * 0.01F, (opts) -> (int) (opts.gammaSetting / 0.01F))
|
||||
.build());
|
||||
firstGroupBuilder.add(Settings.MODE_LIGHT_FLICKER.option)
|
||||
.add(Settings.MODE_SKY.option)
|
||||
.add(Settings.MODE_SUN_MOON.option)
|
||||
.add(Settings.RENDER_DISTANCE_CLOUDS.option)
|
||||
.add(Settings.CLOUD_HEIGHT.option)
|
||||
.add(Settings.CLOUD_SCALE.option)
|
||||
.add(Settings.MODE_CLOUD_TRANSLUCENCY.option)
|
||||
.add(Settings.MODE_STARS.option)
|
||||
.add(Settings.TOTAL_STARS.option)
|
||||
.add(Settings.HORIZON_DISABLE.option)
|
||||
.add(Settings.FOG_DISABLE.option)
|
||||
.add(Settings.FOG_NEAR_DISTANCE.option)
|
||||
.add(Settings.VOID_FOG.option);
|
||||
groups.add(firstGroupBuilder.build());
|
||||
|
||||
int maxGuiScale = Math.max(3, Math.min(Minecraft.getMinecraft().displayWidth / 320, Minecraft.getMinecraft().displayHeight / 240));
|
||||
@@ -166,24 +154,6 @@ public class SodiumGameOptionPages {
|
||||
.add(Settings.DYNAMIC_FOV.option)
|
||||
.add(Settings.MODE_WATER.option)
|
||||
.add(Settings.MODE_DROPPED_ITEMS.option)
|
||||
.add(
|
||||
OptionImpl.createBuilder(int.class, angelicaOpts)
|
||||
.setName(I18n.format("options.angelica.droppedItemLimit"))
|
||||
.setTooltip(I18n.format("options.angelica.droppedItemLimit.tooltip"))
|
||||
.setControl(option -> new SliderControl(option, 32, 2048, 32, ControlValueFormatter.droppedItemLimitLimit()))
|
||||
.setBinding((options, value) -> AngelicaConfig.droppedItemLimit = value, options -> AngelicaConfig.droppedItemLimit)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.build()
|
||||
)
|
||||
.add(
|
||||
OptionImpl.createBuilder(int.class, angelicaOpts)
|
||||
.setName(I18n.format("options.angelica.mobSpawnerRenderDistance"))
|
||||
.setTooltip(I18n.format("options.angelica.mobSpawnerRenderDistance.tooltip"))
|
||||
.setControl(option -> new SliderControl(option, 16, 64, 1, ControlValueFormatter.number()))
|
||||
.setBinding((options, value) -> AngelicaConfig.mobSpawnerRenderDistance = value, options -> (int) AngelicaConfig.mobSpawnerRenderDistance)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.build()
|
||||
)
|
||||
.build());
|
||||
|
||||
return new OptionPage(I18n.format("stat.generalButton"), ImmutableList.copyOf(groups));
|
||||
@@ -297,6 +267,19 @@ public class SodiumGameOptionPages {
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.setImpact(OptionImpact.LOW)
|
||||
.build())
|
||||
.add(OptionImpl.createBuilder(MultiDrawMode.class, sodiumOpts)
|
||||
.setName(I18n.format("sodium.options.multidraw_mode.name"))
|
||||
.setTooltip(I18n.format("sodium.options.multidraw_mode.tooltip"))
|
||||
.setControl(o -> {
|
||||
boolean indirectSupported = GLStateManager.capabilities != null && (GLStateManager.capabilities.OpenGL43 || GLStateManager.capabilities.GL_ARB_multi_draw_indirect);
|
||||
MultiDrawMode[] allowed = indirectSupported ? MultiDrawMode.values() : new MultiDrawMode[]{MultiDrawMode.DIRECT, MultiDrawMode.INDIVIDUAL};
|
||||
return new CyclingControl<>(o, MultiDrawMode.class, allowed);
|
||||
})
|
||||
.setBinding((opts, value) -> opts.advanced.multiDrawMode = value, opts -> opts.advanced.multiDrawMode)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.setImpact(OptionImpact.VARIES)
|
||||
.setEnabled(GLStateManager.capabilities != null)
|
||||
.build())
|
||||
.build());
|
||||
|
||||
groups.add(OptionGroup.createBuilder()
|
||||
@@ -305,7 +288,7 @@ public class SodiumGameOptionPages {
|
||||
.setTooltip(I18n.format("sodium.options.use_block_face_culling.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setBinding((opts, value) -> opts.advanced.useBlockFaceCulling = value, opts -> opts.advanced.useBlockFaceCulling)
|
||||
.setBinding((opts, value) -> opts.performance.useBlockFaceCulling = value, opts -> opts.performance.useBlockFaceCulling)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build()
|
||||
)
|
||||
@@ -314,7 +297,7 @@ public class SodiumGameOptionPages {
|
||||
.setTooltip(I18n.format("sodium.options.use_compact_vertex_format.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setBinding((opts, value) -> opts.advanced.useCompactVertexFormat = value, opts -> opts.advanced.useCompactVertexFormat)
|
||||
.setBinding((opts, value) -> opts.performance.useCompactVertexFormat = value, opts -> opts.performance.useCompactVertexFormat)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build()
|
||||
)
|
||||
@@ -322,7 +305,7 @@ public class SodiumGameOptionPages {
|
||||
.setName(I18n.format("sodium.options.use_fog_occlusion.name"))
|
||||
.setTooltip(I18n.format("sodium.options.use_fog_occlusion.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setBinding((opts, value) -> opts.advanced.useFogOcclusion = value, opts -> opts.advanced.useFogOcclusion)
|
||||
.setBinding((opts, value) -> opts.performance.useFogOcclusion = value, opts -> opts.performance.useFogOcclusion)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build()
|
||||
@@ -331,7 +314,7 @@ public class SodiumGameOptionPages {
|
||||
.setName(I18n.format("sodium.options.translucency_sorting.name"))
|
||||
.setTooltip(I18n.format("sodium.options.translucency_sorting.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setBinding((opts, value) -> opts.advanced.translucencySorting = value, opts -> opts.advanced.translucencySorting)
|
||||
.setBinding((opts, value) -> opts.performance.translucencySorting = value, opts -> opts.performance.translucencySorting)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build()
|
||||
@@ -341,7 +324,7 @@ public class SodiumGameOptionPages {
|
||||
.setTooltip(I18n.format("sodium.options.use_entity_culling.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setBinding((opts, value) -> opts.advanced.useEntityCulling = value, opts -> opts.advanced.useEntityCulling)
|
||||
.setBinding((opts, value) -> opts.performance.useEntityCulling = value, opts -> opts.performance.useEntityCulling)
|
||||
.build()
|
||||
)
|
||||
.add(OptionImpl.createBuilder(boolean.class, sodiumOpts)
|
||||
@@ -357,7 +340,34 @@ public class SodiumGameOptionPages {
|
||||
.setTooltip(I18n.format("sodium.options.animate_only_visible_textures.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setBinding((opts, value) -> opts.advanced.animateOnlyVisibleTextures = value, opts -> opts.advanced.animateOnlyVisibleTextures)
|
||||
.setBinding((opts, value) -> opts.performance.animateOnlyVisibleTextures = value, opts -> opts.performance.animateOnlyVisibleTextures)
|
||||
.build()
|
||||
)
|
||||
.add(OptionImpl.createBuilder(boolean.class, sodiumOpts)
|
||||
.setName(I18n.format("sodium.options.use_render_pass_optimization.name"))
|
||||
.setTooltip(I18n.format("sodium.options.use_render_pass_optimization.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setBinding((opts, value) -> opts.performance.useRenderPassOptimization = value, opts -> opts.performance.useRenderPassOptimization)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build()
|
||||
)
|
||||
.add(OptionImpl.createBuilder(boolean.class, sodiumOpts)
|
||||
.setName(I18n.format("sodium.options.use_occlusion_culling.name"))
|
||||
.setTooltip(I18n.format("sodium.options.use_occlusion_culling.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setImpact(OptionImpact.EXTREME)
|
||||
.setBinding((opts, value) -> opts.performance.useOcclusionCulling = value, opts -> opts.performance.useOcclusionCulling)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build()
|
||||
)
|
||||
.add(OptionImpl.createBuilder(AsyncOcclusionMode.class, sodiumOpts)
|
||||
.setName(I18n.format("sodium.options.async_occlusion_mode.name"))
|
||||
.setTooltip(I18n.format("sodium.options.async_occlusion_mode.tooltip"))
|
||||
.setControl(o -> new CyclingControl<>(o, AsyncOcclusionMode.class, new String[]{"None", "Only Shadow", "Everything"}))
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setBinding((opts, value) -> opts.performance.asyncOcclusionMode = value, opts -> opts.performance.asyncOcclusionMode)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build()
|
||||
)
|
||||
.build());
|
||||
@@ -383,22 +393,6 @@ public class SodiumGameOptionPages {
|
||||
)
|
||||
.build());
|
||||
|
||||
groups.add(OptionGroup.createBuilder()
|
||||
.add(OptionImpl.createBuilder(int.class, angelicaOpts)
|
||||
.setName(I18n.format("options.angelica.itemdisplaylistcount"))
|
||||
.setTooltip(I18n.format("options.angelica.itemdisplaylistcount.tooltip"))
|
||||
.setControl(o -> new SliderControl(o, 256, 1024, 16, ControlValueFormatter.number()))
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setBinding((opts, value) -> AngelicaConfig.itemRendererCacheSize = value, options -> AngelicaConfig.itemRendererCacheSize)
|
||||
.build()
|
||||
)
|
||||
.build());
|
||||
|
||||
groups.add(OptionGroup.createBuilder()
|
||||
.add(Settings.MODE_GUI_BACKGROUND.option)
|
||||
.add(Settings.GUI_BACKGROUND.option)
|
||||
.build());
|
||||
|
||||
return new OptionPage(I18n.format("sodium.options.pages.advanced"), ImmutableList.copyOf(groups));
|
||||
}
|
||||
|
||||
@@ -440,14 +434,6 @@ public class SodiumGameOptionPages {
|
||||
.setBinding((opts, value) -> opts.performance.useNoErrorGLContext = value, opts -> opts.performance.useNoErrorGLContext)
|
||||
.setFlags(OptionFlag.REQUIRES_GAME_RESTART)
|
||||
.build())
|
||||
.add(OptionImpl.createBuilder(boolean.class, sodiumOpts)
|
||||
.setName(I18n.format("sodium.options.use_gl_state_cache.name"))
|
||||
.setTooltip(I18n.format("sodium.options.use_gl_state_cache.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setImpact(OptionImpact.EXTREME)
|
||||
.setBinding((opts, value) -> GLStateManager.BYPASS_CACHE = !value, opts -> !GLStateManager.BYPASS_CACHE)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build())
|
||||
.add(OptionImpl.createBuilder(boolean.class, angelicaOpts)
|
||||
.setName(I18n.format("options.angelica.aggressiveChunkLoading"))
|
||||
.setTooltip(I18n.format("options.angelica.aggressiveChunkLoading.tooltip"))
|
||||
@@ -456,9 +442,102 @@ public class SodiumGameOptionPages {
|
||||
.setBinding((opts, value) -> AngelicaConfig.useVanillaChunkTracking = value, opts -> AngelicaConfig.useVanillaChunkTracking)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build())
|
||||
.add(OptionImpl.createBuilder(int.class, sodiumOpts)
|
||||
.setName(I18n.format("sodium.options.cpu_render_ahead_limit.name"))
|
||||
.setTooltip(I18n.format("sodium.options.cpu_render_ahead_limit.tooltip"))
|
||||
.setControl(o -> new SliderControl(o, 0, 9, 1, ControlValueFormatter.quantity("sodium.options.cpu_render_ahead_limit.value")))
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setBinding((opts, value) -> opts.performance.cpuRenderAheadLimit = value, opts -> opts.performance.cpuRenderAheadLimit)
|
||||
.setEnabled(GLStateManager.capabilities != null && GLStateManager.capabilities.OpenGL32)
|
||||
.build())
|
||||
|
||||
.build());
|
||||
|
||||
groups.add(OptionGroup.createBuilder()
|
||||
.add(OptionImpl.createBuilder(boolean.class, angelicaOpts)
|
||||
.setName(I18n.format("options.angelica.hudCaching"))
|
||||
.setTooltip(I18n.format("options.angelica.hudCaching.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setBinding((opts, value) -> AngelicaConfig.hudCachingActive = value, opts -> AngelicaConfig.hudCachingActive)
|
||||
.setEnabled(AngelicaConfig.enableHudCaching)
|
||||
.build())
|
||||
.add(OptionImpl.createBuilder(int.class, angelicaOpts)
|
||||
.setName(I18n.format("options.angelica.droppedItemLimit"))
|
||||
.setTooltip(I18n.format("options.angelica.droppedItemLimit.tooltip"))
|
||||
.setControl(option -> new SliderControl(option, 32, 2048, 32, ControlValueFormatter.droppedItemLimitLimit()))
|
||||
.setBinding((options, value) -> AngelicaConfig.droppedItemLimit = value, options -> AngelicaConfig.droppedItemLimit)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.build())
|
||||
.add(OptionImpl.createBuilder(int.class, angelicaOpts)
|
||||
.setName(I18n.format("options.angelica.mobSpawnerRenderDistance"))
|
||||
.setTooltip(I18n.format("options.angelica.mobSpawnerRenderDistance.tooltip"))
|
||||
.setControl(option -> new SliderControl(option, 16, 64, 1, ControlValueFormatter.number()))
|
||||
.setBinding((options, value) -> AngelicaConfig.mobSpawnerRenderDistance = value, options -> (int) AngelicaConfig.mobSpawnerRenderDistance)
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.build())
|
||||
.add(OptionImpl.createBuilder(int.class, angelicaOpts)
|
||||
.setName(I18n.format("options.angelica.itemdisplaylistcount"))
|
||||
.setTooltip(I18n.format("options.angelica.itemdisplaylistcount.tooltip"))
|
||||
.setControl(o -> new SliderControl(o, 256, 1024, 16, ControlValueFormatter.number()))
|
||||
.setImpact(OptionImpact.MEDIUM)
|
||||
.setBinding((opts, value) -> AngelicaConfig.itemRendererCacheSize = value, options -> AngelicaConfig.itemRendererCacheSize)
|
||||
.build())
|
||||
.build());
|
||||
|
||||
return new OptionPage(I18n.format("sodium.options.pages.performance"), ImmutableList.copyOf(groups));
|
||||
}
|
||||
|
||||
public static OptionPage appearance() {
|
||||
final List<OptionGroup> groups = new ArrayList<>();
|
||||
|
||||
groups.add(OptionGroup.createBuilder()
|
||||
.add(Settings.MODE_SKY.option)
|
||||
.add(Settings.MODE_SUN_MOON.option)
|
||||
.add(Settings.RENDER_DISTANCE_CLOUDS.option)
|
||||
.add(Settings.CLOUD_HEIGHT.option)
|
||||
.add(Settings.CLOUD_SCALE.option)
|
||||
.add(Settings.MODE_CLOUD_TRANSLUCENCY.option)
|
||||
.add(Settings.MODE_STARS.option)
|
||||
.add(Settings.TOTAL_STARS.option)
|
||||
.add(Settings.HORIZON_DISABLE.option)
|
||||
.add(Settings.MODE_LIGHT_FLICKER.option)
|
||||
.build());
|
||||
|
||||
groups.add(OptionGroup.createBuilder()
|
||||
.add(Settings.FOG_DISABLE.option)
|
||||
.add(Settings.FOG_NEAR_DISTANCE.option)
|
||||
.add(Settings.VOID_FOG.option)
|
||||
.build());
|
||||
|
||||
groups.add(OptionGroup.createBuilder()
|
||||
.add(Settings.MODE_GUI_BACKGROUND.option)
|
||||
.add(Settings.GUI_BACKGROUND.option)
|
||||
.add(OptionImpl.createBuilder(boolean.class, angelicaOpts)
|
||||
.setName(I18n.format("options.angelica.disablef3"))
|
||||
.setTooltip(I18n.format("options.angelica.disablef3.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setBinding((opts, value) -> AngelicaConfig.disableF3Additions = value, opts -> AngelicaConfig.disableF3Additions)
|
||||
.build())
|
||||
.build());
|
||||
|
||||
return new OptionPage(I18n.format("sodium.options.pages.appearance"), ImmutableList.copyOf(groups));
|
||||
}
|
||||
|
||||
public static OptionPage debug() {
|
||||
final List<OptionGroup> groups = new ArrayList<>();
|
||||
|
||||
groups.add(OptionGroup.createBuilder()
|
||||
.add(OptionImpl.createBuilder(boolean.class, sodiumOpts)
|
||||
.setName(I18n.format("sodium.options.use_gl_state_cache.name"))
|
||||
.setTooltip(I18n.format("sodium.options.use_gl_state_cache.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setImpact(OptionImpact.EXTREME)
|
||||
.setBinding((opts, value) -> GLStateManager.BYPASS_CACHE = !value, opts -> !GLStateManager.BYPASS_CACHE)
|
||||
.setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
|
||||
.build())
|
||||
.build());
|
||||
|
||||
return new OptionPage(I18n.format("sodium.options.pages.debug"), ImmutableList.copyOf(groups));
|
||||
}
|
||||
}
|
||||
@@ -4,9 +4,12 @@ import com.google.gson.FieldNamingPolicy;
|
||||
import com.google.gson.Gson;
|
||||
import com.google.gson.GsonBuilder;
|
||||
import com.google.gson.JsonSyntaxException;
|
||||
import me.jellysquid.mods.sodium.client.SodiumClientMod;
|
||||
import com.gtnewhorizons.angelica.AngelicaMod;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.named.GraphicsQuality;
|
||||
import me.jellysquid.mods.sodium.client.gui.options.named.MultiDrawMode;
|
||||
import net.coderbot.iris.Iris;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.occlusion.AsyncOcclusionMode;
|
||||
|
||||
import java.io.FileReader;
|
||||
import java.io.IOException;
|
||||
@@ -25,22 +28,28 @@ public class SodiumGameOptions {
|
||||
public static class AdvancedSettings {
|
||||
public boolean useVertexArrayObjects = true;
|
||||
public boolean useChunkMultidraw = true;
|
||||
public MultiDrawMode multiDrawMode = MultiDrawMode.DIRECT;
|
||||
|
||||
public boolean animateOnlyVisibleTextures = true;
|
||||
public boolean useEntityCulling = true;
|
||||
public boolean useParticleCulling = true;
|
||||
public boolean useFogOcclusion = true;
|
||||
public boolean useCompactVertexFormat = true;
|
||||
public boolean useBlockFaceCulling = true;
|
||||
public boolean allowDirectMemoryAccess = true;
|
||||
public boolean ignoreDriverBlacklist = false;
|
||||
public boolean translucencySorting = true;
|
||||
}
|
||||
|
||||
public static class PerformanceSettings {
|
||||
public int chunkBuilderThreads = 0;
|
||||
public boolean alwaysDeferChunkUpdates = true;
|
||||
public boolean useNoErrorGLContext = true;
|
||||
public AsyncOcclusionMode asyncOcclusionMode = AsyncOcclusionMode.EVERYTHING;
|
||||
public boolean useOcclusionCulling = true;
|
||||
|
||||
public boolean animateOnlyVisibleTextures = true;
|
||||
public boolean useEntityCulling = true;
|
||||
public boolean useFogOcclusion = true;
|
||||
public boolean useBlockFaceCulling = true;
|
||||
public boolean useCompactVertexFormat = true;
|
||||
public boolean translucencySorting = true;
|
||||
public boolean useRenderPassOptimization = true;
|
||||
public int cpuRenderAheadLimit = 3;
|
||||
}
|
||||
|
||||
public static class EntityRenderDistance {
|
||||
@@ -74,7 +83,7 @@ public class SodiumGameOptions {
|
||||
} catch (IOException e) {
|
||||
throw new RuntimeException("Could not parse config", e);
|
||||
} catch (JsonSyntaxException e) {
|
||||
SodiumClientMod.logger().error("Could not parse config, will fallback to default settings", e);
|
||||
AngelicaMod.LOGGER.error("Could not parse config, will fallback to default settings", e);
|
||||
config = new SodiumGameOptions();
|
||||
resaveConfig = false;
|
||||
}
|
||||
@@ -84,6 +93,15 @@ public class SodiumGameOptions {
|
||||
|
||||
config.configPath = path;
|
||||
|
||||
// Clamp render-ahead to 0 if GL 3.2 fences aren't available
|
||||
if (GLStateManager.capabilities == null || !GLStateManager.capabilities.OpenGL32) {
|
||||
config.performance.cpuRenderAheadLimit = 0;
|
||||
}
|
||||
|
||||
if (config.advanced.multiDrawMode == MultiDrawMode.INDIRECT && (GLStateManager.capabilities == null || (!GLStateManager.capabilities.OpenGL43 && !GLStateManager.capabilities.GL_ARB_multi_draw_indirect))) {
|
||||
config.advanced.multiDrawMode = MultiDrawMode.DIRECT;
|
||||
}
|
||||
|
||||
try {
|
||||
if(resaveConfig)
|
||||
config.writeChanges();
|
||||
|
||||
@@ -7,7 +7,6 @@ import com.gtnewhorizons.angelica.compat.mojang.Drawable;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.Element;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
|
||||
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;
|
||||
@@ -19,6 +18,7 @@ import me.jellysquid.mods.sodium.client.gui.options.control.element.SodiumContro
|
||||
import me.jellysquid.mods.sodium.client.gui.options.storage.OptionStorage;
|
||||
import me.jellysquid.mods.sodium.client.gui.widgets.FlatButtonWidget;
|
||||
import me.jellysquid.mods.sodium.client.util.Dim2i;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.gui.screen.ShaderPackScreen;
|
||||
import net.minecraft.client.gui.GuiScreen;
|
||||
import net.minecraft.client.resources.I18n;
|
||||
@@ -62,6 +62,7 @@ public class SodiumOptionsGUI extends ScrollableGuiScreen {
|
||||
this.pages.add(SodiumGameOptionPages.quality());
|
||||
this.pages.add(SodiumGameOptionPages.advanced());
|
||||
this.pages.add(SodiumGameOptionPages.performance());
|
||||
this.pages.add(SodiumGameOptionPages.appearance());
|
||||
|
||||
// Add Dynamic Lights page if enabled
|
||||
if (DynamicLights.configEnabled) {
|
||||
@@ -75,6 +76,8 @@ public class SodiumOptionsGUI extends ScrollableGuiScreen {
|
||||
shaderPacks = new OptionPage(I18n.format("options.iris.shaderPackSelection"), ImmutableList.of());
|
||||
this.pages.add(shaderPacks);
|
||||
}
|
||||
|
||||
this.pages.add(SodiumGameOptionPages.debug());
|
||||
}
|
||||
|
||||
public void setPage(OptionPage page) {
|
||||
@@ -298,7 +301,8 @@ public class SodiumOptionsGUI extends ScrollableGuiScreen {
|
||||
|
||||
if (keyCode == Keyboard.KEY_P && isShiftKeyDown()) {
|
||||
this.mc.displayGuiScreen(new GuiCustomMenu(this.prevScreen, SodiumGameOptionPages.general(),
|
||||
SodiumGameOptionPages.quality(), SodiumGameOptionPages.advanced(), SodiumGameOptionPages.performance()));
|
||||
SodiumGameOptionPages.quality(), SodiumGameOptionPages.advanced(), SodiumGameOptionPages.performance(),
|
||||
SodiumGameOptionPages.appearance(), SodiumGameOptionPages.debug()));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+2
-2
@@ -59,7 +59,7 @@ public class SodiumControlElementFactory implements ControlElementFactory {
|
||||
public boolean mouseClicked(double mouseX, double mouseY, int button) {
|
||||
if(AngelicaConfig.enableReesesSodiumOptions) {
|
||||
if (this.option.isAvailable() && this.dim.containsCursor(mouseX, mouseY) && (button == 0 || button == 1)) {
|
||||
this.currentIndex = Math.floorMod(this.option.getValue().ordinal() + (button == 0 ? 1 : -1), this.allowedValues.length);
|
||||
this.currentIndex = Math.floorMod(this.currentIndex + (button == 0 ? 1 : -1), this.allowedValues.length);
|
||||
this.option.setValue(this.allowedValues[this.currentIndex]);
|
||||
this.playClickSound();
|
||||
|
||||
@@ -67,7 +67,7 @@ public class SodiumControlElementFactory implements ControlElementFactory {
|
||||
}
|
||||
} else {
|
||||
if (this.option.isAvailable() && button == 0 && this.dim.containsCursor(mouseX, mouseY)) {
|
||||
this.currentIndex = (this.option.getValue().ordinal() + 1) % this.allowedValues.length;
|
||||
this.currentIndex = (this.currentIndex + 1) % this.allowedValues.length;
|
||||
this.option.setValue(this.allowedValues[this.currentIndex]);
|
||||
this.playClickSound();
|
||||
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
package me.jellysquid.mods.sodium.client.gui.options.named;
|
||||
|
||||
public enum MultiDrawMode implements NamedState {
|
||||
DIRECT("sodium.options.multidraw_mode.direct"),
|
||||
INDIRECT("sodium.options.multidraw_mode.indirect"),
|
||||
INDIVIDUAL("sodium.options.multidraw_mode.individual");
|
||||
|
||||
private final String key;
|
||||
|
||||
MultiDrawMode(String key) {
|
||||
this.key = key;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getKey() {
|
||||
return this.key;
|
||||
}
|
||||
}
|
||||
+2
-2
@@ -1,8 +1,8 @@
|
||||
package me.jellysquid.mods.sodium.client.gui.options.storage;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.config.ConfigurationManager;
|
||||
import com.gtnewhorizons.angelica.AngelicaMod;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import me.jellysquid.mods.sodium.client.SodiumClientMod;
|
||||
|
||||
public class AngelicaOptionsStorage implements OptionStorage<AngelicaConfig> {
|
||||
|
||||
@@ -18,6 +18,6 @@ public class AngelicaOptionsStorage implements OptionStorage<AngelicaConfig> {
|
||||
@Override
|
||||
public void save() {
|
||||
ConfigurationManager.save(AngelicaConfig.class);
|
||||
SodiumClientMod.logger().info("Flushed changes to Angelica configuration");
|
||||
AngelicaMod.LOGGER.info("Flushed changes to Angelica configuration");
|
||||
}
|
||||
}
|
||||
+2
-2
@@ -1,6 +1,6 @@
|
||||
package me.jellysquid.mods.sodium.client.gui.options.storage;
|
||||
|
||||
import me.jellysquid.mods.sodium.client.SodiumClientMod;
|
||||
import com.gtnewhorizons.angelica.AngelicaMod;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.settings.GameSettings;
|
||||
|
||||
@@ -20,6 +20,6 @@ public class MinecraftOptionsStorage implements OptionStorage<GameSettings> {
|
||||
public void save() {
|
||||
this.getData().saveOptions();
|
||||
|
||||
SodiumClientMod.logger().info("Flushed changes to Minecraft configuration");
|
||||
AngelicaMod.LOGGER.info("Flushed changes to Minecraft configuration");
|
||||
}
|
||||
}
|
||||
+3
-3
@@ -1,6 +1,6 @@
|
||||
package me.jellysquid.mods.sodium.client.gui.options.storage;
|
||||
|
||||
import me.jellysquid.mods.sodium.client.SodiumClientMod;
|
||||
import com.gtnewhorizons.angelica.AngelicaMod;
|
||||
import me.jellysquid.mods.sodium.client.gui.SodiumGameOptions;
|
||||
|
||||
import java.io.IOException;
|
||||
@@ -9,7 +9,7 @@ public class SodiumOptionsStorage implements OptionStorage<SodiumGameOptions> {
|
||||
private final SodiumGameOptions options;
|
||||
|
||||
public SodiumOptionsStorage() {
|
||||
this.options = SodiumClientMod.options();
|
||||
this.options = AngelicaMod.options();
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -25,6 +25,6 @@ public class SodiumOptionsStorage implements OptionStorage<SodiumGameOptions> {
|
||||
throw new RuntimeException("Couldn't save configuration changes", e);
|
||||
}
|
||||
|
||||
SodiumClientMod.logger().info("Flushed changes to Angelica configuration");
|
||||
AngelicaMod.LOGGER.info("Flushed changes to Angelica configuration");
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
package me.jellysquid.mods.sodium.client.gui.utils;
|
||||
|
||||
import me.jellysquid.mods.sodium.client.SodiumClientMod;
|
||||
import com.gtnewhorizons.angelica.AngelicaMod;
|
||||
import net.minecraft.util.Util;
|
||||
|
||||
import java.io.IOException;
|
||||
@@ -19,7 +19,7 @@ public class URLUtils {
|
||||
try {
|
||||
Runtime.getRuntime().exec(getURLOpenCommand(url));
|
||||
} catch (IOException exception) {
|
||||
SodiumClientMod.logger().error("Couldn't open url '{}'", url, exception);
|
||||
AngelicaMod.LOGGER.error("Couldn't open url '{}'", url, exception);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -1,56 +0,0 @@
|
||||
package me.jellysquid.mods.sodium.proxy;
|
||||
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import cpw.mods.fml.common.event.FMLInitializationEvent;
|
||||
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
|
||||
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
|
||||
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
|
||||
import jss.notfine.gui.GuiCustomMenu;
|
||||
import jss.notfine.gui.NotFineGameOptionPages;
|
||||
import me.flashyreese.mods.reeses_sodium_options.client.gui.ReeseSodiumVideoOptionsScreen;
|
||||
import me.jellysquid.mods.sodium.client.gui.SodiumOptionsGUI;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.gui.GuiScreen;
|
||||
import net.minecraft.client.gui.GuiVideoSettings;
|
||||
import net.minecraftforge.client.event.GuiScreenEvent;
|
||||
import net.minecraftforge.common.MinecraftForge;
|
||||
|
||||
public class ClientProxy extends CommonProxy {
|
||||
|
||||
@Override
|
||||
public void preInit(FMLPreInitializationEvent event) {
|
||||
// FMLCommonHandler.instance().bus().register(this);
|
||||
MinecraftForge.EVENT_BUS.register(this);
|
||||
}
|
||||
|
||||
@SubscribeEvent
|
||||
public void onGui(GuiScreenEvent.InitGuiEvent.Pre event) {
|
||||
if(event.gui instanceof GuiVideoSettings eventGui) {
|
||||
event.setCanceled(true);
|
||||
if(AngelicaConfig.enableNotFineOptions || GuiScreen.isShiftKeyDown()) {
|
||||
Minecraft.getMinecraft().displayGuiScreen(new GuiCustomMenu(eventGui.parentGuiScreen,
|
||||
NotFineGameOptionPages.general(),
|
||||
NotFineGameOptionPages.detail(), NotFineGameOptionPages.atmosphere(),
|
||||
NotFineGameOptionPages.particles(), NotFineGameOptionPages.other()
|
||||
));
|
||||
} else if(!AngelicaConfig.enableReesesSodiumOptions || GuiScreen.isCtrlKeyDown()) {
|
||||
Minecraft.getMinecraft().displayGuiScreen(new SodiumOptionsGUI(eventGui.parentGuiScreen));
|
||||
} else {
|
||||
Minecraft.getMinecraft().displayGuiScreen(new ReeseSodiumVideoOptionsScreen(eventGui.parentGuiScreen));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void init(FMLInitializationEvent event) {
|
||||
// Nothing to do here (yet)
|
||||
}
|
||||
|
||||
@Override
|
||||
public void postInit(FMLPostInitializationEvent event) {
|
||||
// Nothing to do here (yet)
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
package me.jellysquid.mods.sodium.proxy;
|
||||
|
||||
import cpw.mods.fml.common.event.FMLInitializationEvent;
|
||||
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
|
||||
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
|
||||
|
||||
public class CommonProxy {
|
||||
|
||||
public void preInit(FMLPreInitializationEvent event) {
|
||||
|
||||
}
|
||||
|
||||
public void init(FMLInitializationEvent event) {}
|
||||
|
||||
public void postInit(FMLPostInitializationEvent event) {}
|
||||
}
|
||||
@@ -390,6 +390,9 @@ public class Iris {
|
||||
// Warm up the threadpool so shader transformations are faster when we need them
|
||||
ShaderTransformExecutor.warmup();
|
||||
|
||||
// Initialize version hoisting pattern based on GL capabilities
|
||||
ShaderTransformer.init();
|
||||
|
||||
PBRTextureManager.INSTANCE.init();
|
||||
|
||||
// Only load the shader pack when we can access OpenGL
|
||||
|
||||
@@ -12,8 +12,10 @@ import net.coderbot.iris.gl.program.ProgramUniforms;
|
||||
import net.coderbot.iris.pipeline.PatchedShaderPrinter;
|
||||
import net.coderbot.iris.pipeline.transform.PatchShaderType;
|
||||
import net.coderbot.iris.rendertarget.RenderTargets;
|
||||
import net.coderbot.iris.gl.state.FogMode;
|
||||
import net.coderbot.iris.uniforms.CommonUniforms;
|
||||
import net.coderbot.iris.uniforms.builtin.BuiltinReplacementUniforms;
|
||||
import net.coderbot.iris.shaderpack.ProgramSource;
|
||||
import net.coderbot.iris.uniforms.custom.CustomUniforms;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
@@ -60,124 +62,82 @@ public class CeleritasTerrainPipeline {
|
||||
IntFunction<ProgramImages> createTerrainImages,
|
||||
IntFunction<ProgramImages> createShadowImages,
|
||||
CustomUniforms customUniforms,
|
||||
String terrainSourceName,
|
||||
String translucentSourceName,
|
||||
String shadowSourceName,
|
||||
Optional<ProgramSource> terrainSource,
|
||||
Optional<ProgramSource> translucentSource,
|
||||
Optional<ProgramSource> shadowSource,
|
||||
CompletableFuture<Map<PatchShaderType, String>> terrainFuture,
|
||||
CompletableFuture<Map<PatchShaderType, String>> translucentFuture,
|
||||
CompletableFuture<Map<PatchShaderType, String>> shadowFuture,
|
||||
RenderTargets renderTargets,
|
||||
ImmutableSet<Integer> flippedAfterPrepare,
|
||||
ImmutableSet<Integer> flippedAfterTranslucent,
|
||||
@Nullable GlFramebuffer shadowFramebuffer,
|
||||
int[] terrainDrawBuffers
|
||||
@Nullable GlFramebuffer shadowFramebuffer
|
||||
) {
|
||||
this.customUniforms = customUniforms;
|
||||
|
||||
// Initialize PassInfo for each pass
|
||||
for (IrisTerrainPass pass : IrisTerrainPass.VALUES) {
|
||||
passInfoMap.put(pass, new PassInfo());
|
||||
}
|
||||
|
||||
// Process terrain shaders (used for GBUFFER_SOLID and GBUFFER_CUTOUT)
|
||||
if (terrainFuture != null) {
|
||||
try {
|
||||
final Map<PatchShaderType, String> result = terrainFuture.join();
|
||||
final PassInfo solidInfo = passInfoMap.get(IrisTerrainPass.GBUFFER_SOLID);
|
||||
final PassInfo cutoutInfo = passInfoMap.get(IrisTerrainPass.GBUFFER_CUTOUT);
|
||||
|
||||
solidInfo.setSource(PatchShaderType.VERTEX, result.get(PatchShaderType.VERTEX));
|
||||
solidInfo.setSource(PatchShaderType.GEOMETRY, result.get(PatchShaderType.GEOMETRY));
|
||||
solidInfo.setSource(PatchShaderType.FRAGMENT, result.get(PatchShaderType.FRAGMENT));
|
||||
|
||||
cutoutInfo.setSource(PatchShaderType.VERTEX, result.get(PatchShaderType.VERTEX));
|
||||
cutoutInfo.setSource(PatchShaderType.GEOMETRY, result.get(PatchShaderType.GEOMETRY));
|
||||
cutoutInfo.setSource(PatchShaderType.FRAGMENT, result.get(PatchShaderType.FRAGMENT));
|
||||
|
||||
PatchedShaderPrinter.debugPatchedShaders(terrainSourceName + "_celeritas",
|
||||
result.get(PatchShaderType.VERTEX), result.get(PatchShaderType.GEOMETRY), result.get(PatchShaderType.FRAGMENT));
|
||||
} catch (Exception e) {
|
||||
Iris.logger.error("Failed to transform terrain shader for Celeritas: {}", terrainSourceName, e);
|
||||
throw new RuntimeException("Shader transformation failed for " + terrainSourceName, e);
|
||||
}
|
||||
}
|
||||
|
||||
// Process translucent shaders (used for GBUFFER_TRANSLUCENT)
|
||||
if (translucentFuture != null) {
|
||||
try {
|
||||
final Map<PatchShaderType, String> result = translucentFuture.join();
|
||||
final PassInfo translucentInfo = passInfoMap.get(IrisTerrainPass.GBUFFER_TRANSLUCENT);
|
||||
|
||||
translucentInfo.setSource(PatchShaderType.VERTEX, result.get(PatchShaderType.VERTEX));
|
||||
translucentInfo.setSource(PatchShaderType.GEOMETRY, result.get(PatchShaderType.GEOMETRY));
|
||||
translucentInfo.setSource(PatchShaderType.FRAGMENT, result.get(PatchShaderType.FRAGMENT));
|
||||
|
||||
PatchedShaderPrinter.debugPatchedShaders(translucentSourceName + "_celeritas",
|
||||
result.get(PatchShaderType.VERTEX), result.get(PatchShaderType.GEOMETRY), result.get(PatchShaderType.FRAGMENT));
|
||||
} catch (Exception e) {
|
||||
Iris.logger.error("Failed to transform translucent shader for Celeritas: {}", translucentSourceName, e);
|
||||
throw new RuntimeException("Shader transformation failed for " + translucentSourceName, e);
|
||||
}
|
||||
}
|
||||
|
||||
// Process shadow shaders (used for SHADOW and SHADOW_CUTOUT)
|
||||
if (shadowFuture != null) {
|
||||
try {
|
||||
final Map<PatchShaderType, String> result = shadowFuture.join();
|
||||
final PassInfo shadowInfo = passInfoMap.get(IrisTerrainPass.SHADOW);
|
||||
final PassInfo shadowCutoutInfo = passInfoMap.get(IrisTerrainPass.SHADOW_CUTOUT);
|
||||
|
||||
shadowInfo.setSource(PatchShaderType.VERTEX, result.get(PatchShaderType.VERTEX));
|
||||
shadowInfo.setSource(PatchShaderType.GEOMETRY, result.get(PatchShaderType.GEOMETRY));
|
||||
shadowInfo.setSource(PatchShaderType.FRAGMENT, result.get(PatchShaderType.FRAGMENT));
|
||||
|
||||
shadowCutoutInfo.setSource(PatchShaderType.VERTEX, result.get(PatchShaderType.VERTEX));
|
||||
shadowCutoutInfo.setSource(PatchShaderType.GEOMETRY, result.get(PatchShaderType.GEOMETRY));
|
||||
shadowCutoutInfo.setSource(PatchShaderType.FRAGMENT, result.get(PatchShaderType.FRAGMENT));
|
||||
|
||||
PatchedShaderPrinter.debugPatchedShaders(shadowSourceName + "_celeritas",
|
||||
result.get(PatchShaderType.VERTEX), result.get(PatchShaderType.GEOMETRY), result.get(PatchShaderType.FRAGMENT));
|
||||
} catch (Exception e) {
|
||||
Iris.logger.error("Failed to transform shadow shader for Celeritas: {}", shadowSourceName, e);
|
||||
throw new RuntimeException("Shader transformation failed for " + shadowSourceName, e);
|
||||
}
|
||||
}
|
||||
|
||||
// Set up framebuffers for each pass
|
||||
// Shadow passes use the shadow framebuffer
|
||||
if (shadowFramebuffer != null) {
|
||||
passInfoMap.get(IrisTerrainPass.SHADOW).framebuffer = shadowFramebuffer;
|
||||
passInfoMap.get(IrisTerrainPass.SHADOW_CUTOUT).framebuffer = shadowFramebuffer;
|
||||
}
|
||||
|
||||
// GBuffer passes use render target framebuffers
|
||||
if (renderTargets != null && terrainDrawBuffers != null) {
|
||||
final GlFramebuffer solidFb = renderTargets.createGbufferFramebuffer(flippedAfterPrepare, terrainDrawBuffers);
|
||||
final GlFramebuffer translucentFb = renderTargets.createGbufferFramebuffer(flippedAfterTranslucent, terrainDrawBuffers);
|
||||
|
||||
passInfoMap.get(IrisTerrainPass.GBUFFER_SOLID).framebuffer = solidFb;
|
||||
passInfoMap.get(IrisTerrainPass.GBUFFER_CUTOUT).framebuffer = solidFb;
|
||||
passInfoMap.get(IrisTerrainPass.GBUFFER_TRANSLUCENT).framebuffer = translucentFb;
|
||||
}
|
||||
|
||||
// Set blend mode overrides
|
||||
passInfoMap.get(IrisTerrainPass.GBUFFER_SOLID).blendModeOverride = BlendModeOverride.OFF;
|
||||
passInfoMap.get(IrisTerrainPass.GBUFFER_CUTOUT).blendModeOverride = BlendModeOverride.OFF;
|
||||
passInfoMap.get(IrisTerrainPass.GBUFFER_TRANSLUCENT).blendModeOverride = null; // Default blending
|
||||
passInfoMap.get(IrisTerrainPass.SHADOW).blendModeOverride = BlendModeOverride.OFF;
|
||||
passInfoMap.get(IrisTerrainPass.SHADOW_CUTOUT).blendModeOverride = BlendModeOverride.OFF;
|
||||
|
||||
// Set alpha references
|
||||
passInfoMap.get(IrisTerrainPass.GBUFFER_SOLID).alphaReference = 0.0f;
|
||||
passInfoMap.get(IrisTerrainPass.GBUFFER_CUTOUT).alphaReference = 0.1f;
|
||||
passInfoMap.get(IrisTerrainPass.GBUFFER_TRANSLUCENT).alphaReference = 0.0f;
|
||||
passInfoMap.get(IrisTerrainPass.SHADOW).alphaReference = 0.0f;
|
||||
passInfoMap.get(IrisTerrainPass.SHADOW_CUTOUT).alphaReference = 0.1f;
|
||||
|
||||
this.createTerrainSamplers = createTerrainSamplers;
|
||||
this.createShadowSamplers = createShadowSamplers;
|
||||
this.createTerrainImages = createTerrainImages;
|
||||
this.createShadowImages = createShadowImages;
|
||||
|
||||
// Build program source map (local - only needed during construction)
|
||||
final EnumMap<IrisTerrainPass, Optional<ProgramSource>> gbufferProgramSource = new EnumMap<>(IrisTerrainPass.class);
|
||||
gbufferProgramSource.put(IrisTerrainPass.GBUFFER_SOLID, terrainSource);
|
||||
gbufferProgramSource.put(IrisTerrainPass.GBUFFER_CUTOUT, terrainSource);
|
||||
gbufferProgramSource.put(IrisTerrainPass.GBUFFER_TRANSLUCENT, translucentSource.isPresent() ? translucentSource : terrainSource);
|
||||
gbufferProgramSource.put(IrisTerrainPass.SHADOW, shadowSource);
|
||||
|
||||
// Initialize PassInfo, framebuffers, blend modes, and alpha in single pass
|
||||
for (IrisTerrainPass pass : IrisTerrainPass.VALUES) {
|
||||
PassInfo passInfo = new PassInfo();
|
||||
passInfoMap.put(pass, passInfo);
|
||||
|
||||
// Set up framebuffer
|
||||
if (pass == IrisTerrainPass.SHADOW || pass == IrisTerrainPass.SHADOW_CUTOUT) {
|
||||
passInfo.framebuffer = shadowFramebuffer;
|
||||
} else if (renderTargets != null) {
|
||||
ImmutableSet<Integer> flipped = pass == IrisTerrainPass.GBUFFER_TRANSLUCENT ? flippedAfterTranslucent : flippedAfterPrepare;
|
||||
|
||||
Optional<ProgramSource> programSource = gbufferProgramSource.get(pass);
|
||||
programSource.ifPresentOrElse(source -> passInfo.framebuffer = renderTargets.createGbufferFramebuffer(flipped, source.getDirectives().getDrawBuffers()), () -> passInfo.framebuffer = renderTargets.createGbufferFramebuffer(flipped, new int[] {0}));
|
||||
}
|
||||
|
||||
// Set blend mode override
|
||||
passInfo.blendModeOverride = switch (pass) {
|
||||
case GBUFFER_TRANSLUCENT -> null; // Default blending
|
||||
default -> BlendModeOverride.OFF;
|
||||
};
|
||||
|
||||
// Set alpha reference
|
||||
passInfo.alphaReference = switch (pass) {
|
||||
case GBUFFER_CUTOUT, SHADOW_CUTOUT -> 0.1f;
|
||||
default -> 0.0f;
|
||||
};
|
||||
}
|
||||
|
||||
// Process and apply shader sources
|
||||
processShaderFuture(terrainFuture, terrainSource, passInfoMap.get(IrisTerrainPass.GBUFFER_SOLID), passInfoMap.get(IrisTerrainPass.GBUFFER_CUTOUT));
|
||||
processShaderFuture(translucentFuture, translucentSource, passInfoMap.get(IrisTerrainPass.GBUFFER_TRANSLUCENT));
|
||||
processShaderFuture(shadowFuture, shadowSource, passInfoMap.get(IrisTerrainPass.SHADOW), passInfoMap.get(IrisTerrainPass.SHADOW_CUTOUT));
|
||||
}
|
||||
|
||||
private void processShaderFuture(@Nullable CompletableFuture<Map<PatchShaderType, String>> future, Optional<ProgramSource> source, PassInfo... targets) {
|
||||
if (future == null || source.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
final String sourceName = source.get().getName();
|
||||
try {
|
||||
final Map<PatchShaderType, String> result = future.join();
|
||||
for (PassInfo target : targets) {
|
||||
target.setSource(PatchShaderType.VERTEX, result.get(PatchShaderType.VERTEX));
|
||||
target.setSource(PatchShaderType.GEOMETRY, result.get(PatchShaderType.GEOMETRY));
|
||||
target.setSource(PatchShaderType.FRAGMENT, result.get(PatchShaderType.FRAGMENT));
|
||||
}
|
||||
PatchedShaderPrinter.debugPatchedShaders(sourceName + "_celeritas",
|
||||
result.get(PatchShaderType.VERTEX), result.get(PatchShaderType.GEOMETRY), result.get(PatchShaderType.FRAGMENT));
|
||||
} catch (Exception e) {
|
||||
Iris.logger.error("Failed to transform shader for Celeritas: {}", sourceName, e);
|
||||
throw new RuntimeException("Shader transformation failed for " + sourceName, e);
|
||||
}
|
||||
}
|
||||
|
||||
public PassInfo getPassInfo(IrisTerrainPass pass) {
|
||||
@@ -187,7 +147,7 @@ public class CeleritasTerrainPipeline {
|
||||
public ProgramUniforms.Builder initUniforms(int programId) {
|
||||
final ProgramUniforms.Builder uniforms = ProgramUniforms.builder("<celeritas shaders>", programId);
|
||||
|
||||
CommonUniforms.addDynamicUniforms(uniforms);
|
||||
CommonUniforms.addDynamicUniforms(uniforms, FogMode.PER_VERTEX);
|
||||
customUniforms.assignTo(uniforms);
|
||||
|
||||
BuiltinReplacementUniforms.addBuiltinReplacementUniforms(uniforms);
|
||||
|
||||
Loaded 100 of 210 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user