Compare commits

...
Author SHA1 Message Date
Tomasz Sobczyk df8784536e Use separate queue and workers for chunk renders that can block and wait for the main thread. Increase number of renders done on main thread to 16. (#1084) 2025-11-07 15:11:24 -08:00
KotmatrossandJason Mitchell c8991d810c Port FIX_BLOCK_CRACK from FalseTweaks 2 (#1023)
Co-authored-by: Jason Mitchell <[email protected]>
2025-11-07 15:07:04 -08:00
Alexdoru e3b02642ac split AngelicaRedirector from SodiumBlockTransform (#1018) 2025-11-07 14:49:46 -08:00
ALongStringOfNumbers 2759dd6689 Increase Scroll Speed in Settings GUIs (#1106) 2025-11-07 14:48:09 -08:00
Kotmatross 996dbaef2c [Shaders] Basic compatibility with NTM:Space skybox & more (#1096) 2025-11-07 14:44:38 -08:00
Jason Mitchell 72ca675c93 Uniform Additions and fixes (#1102) 2025-11-07 14:39:10 -08:00
sisyphussy e6e230e270 Add more VAO tests (#1093) 2025-11-07 19:42:05 +00:00
ALongStringOfNumbers 43d7282ba5 Set maxShiftBy to fix some log warnings (#1105) 2025-11-07 17:47:16 +00:00
ah-OOG-ah 4b2d57a32d Update model API (#842)
* Bump GTNHLib

* Change test block's properties

This makes it easier to test the block overlay

* Update VanillaModels.java

# Conflicts:
#	src/main/java/com/gtnewhorizons/angelica/models/VanillaModels.java

* Revert rename

* Rename models

* Sledgehammer out removed abstractions

* Switch to ModelISBRH

* Replace old models

With a single new and interesting model!

* Adapt to GTNHLib

* Remove dead code

* Fix JSON model detection + remove dead code

* Remove direct model renderer

* yet more yote

* Remove ColorABGR

* Remove unused line methods

* Yeet color fully

* publicize nextLong

Technically you don't *need* this on Java 8, but it silences a warning and doesn't break anything so 🤷

* yoten

* Register Angelica for automatic texture loading

* Remove TX-Loader dep

* Make the list mutable

* Remove rebase mistake

* Bump BS + deps
2025-11-06 17:40:45 +00:00
Darren Eberly 06bf71126f Add several missing built-in uniforms (#1101) 2025-11-05 15:38:57 -08:00
Darren Eberly 4c0f2f2685 Disable hardcoded custom uniforms by default 2025-11-05 12:25:18 -08:00
Jason Mitchell 78334717e7 Fix TAA:
* Return an immutable view of the underlying camera position to avoid mutating it
* Update Camera Uniforms to utilize the view instead of mutating in place
2025-11-05 09:59:47 -08:00
MalTeeez a77765a2c9 Allow avoiding other mods spash screen handlers (#1080) 2025-10-31 16:06:28 -07:00
sisyphussy 1a9fe45ee9 Add VAO test (#1089) 2025-10-31 10:10:01 -07:00
123 changed files with 2567 additions and 1947 deletions

No files matched your search

+10 -9
View File
@@ -49,19 +49,16 @@ configurations {
}
dependencies {
compileOnly("com.github.GTNewHorizons:Hodgepodge:2.6.107")
compileOnly("com.github.GTNewHorizons:Hodgepodge:2.7.11")
compileOnly("com.gtnewhorizons.retrofuturabootstrap:RetroFuturaBootstrap:1.0.7") { transitive = false }
compileOnly("org.projectlombok:lombok:1.18.34") { transitive = false }
annotationProcessor("org.projectlombok:lombok:1.18.34")
// Use modern models+textures to inject QuadProviders
devOnlyNonPublishable('com.github.GTNewHorizons:TX-Loader:1.8.5:dev')
// Iris Shaders
compileOnly('org.jetbrains:annotations:26.0.2')
api("com.github.GTNewHorizons:GTNHLib:0.6.40:dev")
api("com.github.GTNewHorizons:GTNHLib:0.8.0:dev")
shadowImplementation("org.anarres:jcpp:1.4.14") // Apache 2.0
shadowImplementation("org.taumc:glsl-transformation-lib:0.2.0-4.g6b42bca") {
exclude module: "antlr4" // we only want to shadow the runtime module
@@ -70,18 +67,18 @@ dependencies {
compileOnly "org.apache.ant:ant:1.8.2"
// Because who doesn't want NEI
devOnlyNonPublishable('com.github.GTNewHorizons:NotEnoughItems:2.7.90-GTNH:dev')
devOnlyNonPublishable('com.github.GTNewHorizons:NotEnoughItems:2.8.31-GTNH:dev')
devOnlyNonPublishable('com.github.GTNewHorizons:CodeChickenCore:1.4.7:dev')
// Notfine Deps
compileOnly("thaumcraft:Thaumcraft:1.7.10-4.2.3.5:dev")
devOnlyNonPublishable("com.github.GTNewHorizons:Baubles-Expanded:2.1.15-GTNH:dev")
devOnlyNonPublishable("com.github.GTNewHorizons:Baubles-Expanded:2.2.2-GTNH:dev")
compileOnly("com.github.GTNewHorizons:twilightforest:2.7.13:dev") { transitive = false }
compileOnly(rfg.deobf('curse.maven:witchery-69673:2234410'))
compileOnly("com.github.GTNewHorizons:TinkersConstruct:1.13.54-GTNH:dev") { transitive = false }
compileOnly("com.github.GTNewHorizons:TinkersConstruct:1.14.6-GTNH:dev") { transitive = false }
compileOnly("com.github.GTNewHorizons:Natura:2.8.9:dev")
compileOnly("com.github.GTNewHorizons:ThaumicHorizons:1.7.8:dev")
compileOnly("com.github.GTNewHorizons:ThaumicHorizons:1.8.4:dev")
compileOnly("com.github.GTNewHorizons:Battlegear2:1.4.3:dev") { transitive = false }
@@ -96,11 +93,15 @@ dependencies {
compileOnly("com.github.GTNewHorizons:NotEnoughIds:2.1.10:dev") // Mixin Version
compileOnly("com.github.GTNewHorizons:NotEnoughIds-Legacy:1.4.7:dev") // ASM Version
compileOnly(rfg.deobf("curse.maven:ntm-space-1121235:6974420"))
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"))
runtimeOnlyNonPublishable(rfg.deobf("CoreTweaks:CoreTweaks:0.3.3.2"))
// For testing alternative splash screens, can be sourced from https://github.com/MalTeeez/ModernSplash/releases
//runtimeOnly(rfg.deobf(files("dependencies/modernsplash-1.7.10-1.2.2-dev.jar")))
// Hodgepodge
transformedMod("net.industrial-craft:industrialcraft-2:2.2.828-experimental:dev")
+9 -1
View File
@@ -96,7 +96,9 @@ usesMixinDebug = false
# Specify the location of your implementation of IMixinConfigPlugin. Leave it empty otherwise.
mixinPlugin =
# Specify the package that contains all of your Mixins. You may only place Mixins in this package or the build will fail!
# Specify the package that contains all of your Mixins. The package must exist or
# the build will fail. If you have a package property defined in your mixins.<modid>.json,
# it must match with this or the build will fail.
mixinsPackage = mixins
# Specify the core mod entry class if you use a core mod. This class must implement IFMLLoadingPlugin!
@@ -172,6 +174,12 @@ curseForgeRelations = requiredDependency\:gtnhlib
# projects. New projects should not use this parameter.
# customArchiveBaseName =
# Optional parameter to customize the default working directory used by the runClient* tasks. Relative to the project directory.
# runClientWorkingDirectory = run/client
# Optional parameter to customize the default working directory used by the runServer* tasks. Relative to the project directory.
# runServerWorkingDirectory = run/server
# Optional parameter to have the build automatically fail if an illegal version is used.
# This can be useful if you e.g. only want to allow versions in the form of '1.1.xxx'.
# The check is ONLY performed if the version is a git tag.
+1 -1
View File
@@ -1,6 +1,6 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
+1 -1
View File
@@ -16,5 +16,5 @@ pluginManagement {
}
plugins {
id 'com.gtnewhorizons.gtnhsettingsconvention' version '1.0.41'
id 'com.gtnewhorizons.gtnhsettingsconvention' version '1.0.48'
}
@@ -1,5 +1,7 @@
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.proxy.CommonProxy;
@@ -12,7 +14,7 @@ import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
@Mod(
modid = "angelica",
modid = MOD_ID,
name = "Angelica",
version = Tags.VERSION,
dependencies = """
@@ -26,6 +28,8 @@ import cpw.mods.fml.common.event.FMLPreInitializationEvent;
acceptableRemoteVersions = "*",
guiFactory = "com.gtnewhorizons.angelica.config.AngelicaGuiConfigFactory")
public class AngelicaMod {
public static final String MOD_ID = "angelica";
@SidedProxy(clientSide = "com.gtnewhorizons.angelica.proxy.ClientProxy", serverSide = "com.gtnewhorizons.angelica.proxy.CommonProxy")
public static CommonProxy proxy;
@@ -87,8 +87,7 @@ public class BatchingFontRenderer {
}
this.isSGA = Objects.equals(this.locationFontTexture.getResourcePath(), "textures/font/ascii_sga.png");
// noinspection deprecation
this.isSplash = underlying instanceof SplashProgress.SplashFontRenderer;
this.isSplash = FontStrategist.isSplashFontRendererActive(underlying);
FontProviderMC.get(this.isSGA).charWidth = this.charWidth;
FontProviderMC.get(this.isSGA).locationFontTexture = this.locationFontTexture;
@@ -3,8 +3,10 @@ package com.gtnewhorizons.angelica.client.font;
import com.google.common.collect.HashMultiset;
import com.gtnewhorizons.angelica.config.FontConfig;
import com.gtnewhorizons.angelica.mixins.interfaces.ResourceAccessor;
import cpw.mods.fml.client.SplashProgress;
import lombok.Getter;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.resources.DefaultResourcePack;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@@ -125,4 +127,17 @@ public class FontStrategist {
}
customFontInUse = (FontConfig.enableCustomFont && (primaryFontFound || fallbackFontFound));
}
public static boolean isSplashFontRendererActive(FontRenderer fontRenderer) {
// noinspection deprecation
boolean active = fontRenderer instanceof SplashProgress.SplashFontRenderer;
try {
Class<?> customSplashClass = Class.forName("gkappa.modernsplash.CustomSplash$SplashFontRenderer");
active = active || customSplashClass.isInstance(fontRenderer);
} catch (ClassNotFoundException ignored) {
}
return active;
}
}
@@ -1,34 +1,20 @@
package com.gtnewhorizons.angelica.common;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadProvider;
import com.gtnewhorizon.gtnhlib.client.renderer.util.DirectionUtil;
import com.gtnewhorizons.angelica.mixins.interfaces.ModeledBlock;
import com.gtnewhorizons.angelica.utils.AssetLoader;
import lombok.Getter;
import lombok.Setter;
import static com.gtnewhorizon.gtnhlib.client.model.ModelISBRH.JSON_ISBRH_ID;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import org.jetbrains.annotations.NotNull;
import static com.gtnewhorizons.angelica.models.VanillaModels.LECTERN;
public class BlockTest extends Block implements ModeledBlock {
@Getter
@Setter
private QuadProvider model;
/// Unline {@link BlockError}, this *is* registered on both sides. It's intended to test functionality in a SP
/// development environment.
public class BlockTest extends Block {
public BlockTest() {
super(Material.rock);
this.setBlockTextureName("missingno");
this.setModel((world, pos, block, meta, dir, random, color, quadPool) -> {
if (meta < 2 || meta > 5) meta = 2;
return LECTERN.models[meta - 2].getQuads(world, pos, block, meta, dir, random, color, quadPool);
});
super(Material.wood);
setHardness(0.7f);
}
@Override
@@ -36,13 +22,6 @@ public class BlockTest extends Block implements ModeledBlock {
return false;
}
@Override
public void registerBlockIcons(IIconRegister reg) {
for (String s : AssetLoader.testTexs) {
reg.registerIcon(s);
}
}
/**
* Called when a block is placed using its ItemBlock. Args: World, X, Y, Z, side, hitX, hitY, hitZ, block metadata
*/
@@ -50,11 +29,16 @@ public class BlockTest extends Block implements ModeledBlock {
public int onBlockPlaced(@NotNull World worldIn, int x, int y, int z, int side, float subX, float subY, float subZ, int meta) {
// Face NORTH if placed up or down
final ForgeDirection s = DirectionUtil.ALL_DIRECTIONS[side];
final var s = ForgeDirection.getOrientation(side);
if (s == ForgeDirection.UP || s == ForgeDirection.DOWN)
return 2;
// Face the placed side
return side;
}
@Override
public int getRenderType() {
return JSON_ISBRH_ID;
}
}
@@ -0,0 +1,17 @@
package com.gtnewhorizons.angelica.compat.iris;
/**
* Interface implemented by BiomeGenBase via mixin to cache biome category.
* This avoids recomputing the category every frame for shader uniforms.
*/
public interface BiomeCategoryCache {
/**
* Gets the cached biome category ordinal, or -1 if not yet computed.
*/
int iris$getCachedCategory();
/**
* Sets the cached biome category ordinal.
*/
void iris$setCachedCategory(int category);
}
@@ -0,0 +1,102 @@
package com.gtnewhorizons.angelica.compat.iris;
import net.coderbot.iris.parsing.BiomeCategories;
import net.minecraft.world.biome.BiomeGenBase;
import java.util.LinkedHashMap;
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)
*/
public class ModdedBiomeDetector {
private static boolean initialized = false;
// BiomesOPlenty (BOP) cache - dimension-specific base classes
// BOP 1.7.10 hierarchy: BOPBiome -> BOPEndBiome/BOPNetherBiome/BOPOverworldBiome -> specific biomes
private static Class<?> bopEndBiomeClass = null;
private static Class<?> bopNetherBiomeClass = null;
private static Class<?> bopOceanBiomeClass = null;
// Realistic World Gen (RWG) cache - base biome classes that extend BiomeGenBase
// LinkedHashMap maintains insertion order for deterministic behavior
private static final Map<Class<?>, BiomeCategories> rwgClassMap = new LinkedHashMap<>();
private static synchronized void initialize() {
if (initialized) return;
initialized = true;
initializeBOP();
initializeRWG();
}
private static void initializeBOP() {
try {
bopEndBiomeClass = Class.forName("biomesoplenty.common.biome.BOPEndBiome");
bopNetherBiomeClass = Class.forName("biomesoplenty.common.biome.BOPNetherBiome");
bopOceanBiomeClass = Class.forName("biomesoplenty.common.biome.BOPOceanBiome");
} catch (ClassNotFoundException ignored) {
// BOP not installed
}
}
private static void initializeRWG() {
// RWG adds actual BiomeGenBase subclasses in rwg.biomes.base package
tryAddRWGClass("rwg.biomes.base.BaseBiomeOcean", BiomeCategories.OCEAN);
tryAddRWGClass("rwg.biomes.base.BaseBiomeRiver", BiomeCategories.RIVER);
tryAddRWGClass("rwg.biomes.base.BaseBiomePlains", BiomeCategories.PLAINS);
tryAddRWGClass("rwg.biomes.base.BaseBiomeColdPlains", BiomeCategories.PLAINS);
tryAddRWGClass("rwg.biomes.base.BaseBiomeHotPlains", BiomeCategories.PLAINS);
tryAddRWGClass("rwg.biomes.base.BaseBiomeHotDesert", BiomeCategories.DESERT);
tryAddRWGClass("rwg.biomes.base.BaseBiomeSnowDesert", BiomeCategories.DESERT); // Cold desert, but still desert
tryAddRWGClass("rwg.biomes.base.BaseBiomeJungle", BiomeCategories.JUNGLE);
tryAddRWGClass("rwg.biomes.base.BaseBiomeTropicalIsland", BiomeCategories.JUNGLE); // Tropical islands are jungle-like
tryAddRWGClass("rwg.biomes.base.BaseBiomeRedwood", BiomeCategories.FOREST); // Redwood/Sequoia forests
tryAddRWGClass("rwg.biomes.base.BaseBiomeTemperateForest", BiomeCategories.FOREST);
tryAddRWGClass("rwg.biomes.base.BaseBiomeColdForest", BiomeCategories.TAIGA); // Cold forests are taiga-like
tryAddRWGClass("rwg.biomes.base.BaseBiomeHotForest", BiomeCategories.FOREST);
tryAddRWGClass("rwg.biomes.base.BaseBiomeSnowForest", BiomeCategories.TAIGA); // Snow forests are taiga
}
private static void tryAddRWGClass(String className, BiomeCategories category) {
try {
final Class<?> clazz = Class.forName(className);
rwgClassMap.put(clazz, category);
} catch (ClassNotFoundException ignored) {
// Class not available, RWG not installed or different version
}
}
/**
* Attempts to detect the biome category for modded biomes.
* Returns null if no modded biome detection applies.
*/
public static BiomeCategories detectModdedBiome(BiomeGenBase biome) {
if (!initialized) {
initialize();
}
// BiomesOPlenty detection - dimension-specific classes give us clear categories
if (bopEndBiomeClass != null && bopEndBiomeClass.isInstance(biome)) {
return BiomeCategories.THE_END;
}
if (bopNetherBiomeClass != null && bopNetherBiomeClass.isInstance(biome)) {
return BiomeCategories.NETHER;
}
if (bopOceanBiomeClass != null && bopOceanBiomeClass.isInstance(biome)) {
return BiomeCategories.OCEAN;
}
// For other BOP overworld biomes (e.g., Alps, Arctic, BambooForest),
// 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();
}
}
return null;
}
}
@@ -9,35 +9,62 @@ import net.minecraft.util.MathHelper;
import org.joml.Matrix4f;
import org.joml.Vector3d;
import org.joml.Vector4f;
import org.joml.Vector3f;
/**
* Singleton camera instance that tracks the current camera position and orientation.
*/
@Getter
public class Camera {
final Vector3d pos = new Vector3d();
final BlockPos blockPos = new BlockPos();
float pitch;
float yaw;
EntityLivingBase entity;
boolean thirdPerson;
final float partialTicks;
public static final Camera INSTANCE = new Camera();
public Camera(EntityLivingBase entity, float partialTicks) {
private final Vector3d pos = new Vector3d();
private final BlockPos blockPos = new BlockPos();
private final Vector3f offset = new Vector3f();
private final Matrix4f inverseModelView = new Matrix4f();
private float pitch;
private float yaw;
private EntityLivingBase entity;
private boolean thirdPerson;
private float partialTicks;
private Camera() {
}
/**
* Updates the camera position and orientation based on the current entity and partial ticks.
*
* @param entity The entity to track (usually the render view entity)
* @param partialTicks The partial tick time for interpolation
*/
public void update(EntityLivingBase entity, float partialTicks) {
this.partialTicks = partialTicks;
final Vector4f offset = new Vector4f(); // third person offset
final Matrix4f inverseModelView = new Matrix4f(RenderingState.INSTANCE.getModelViewMatrix()).invert();
inverseModelView.transform(offset);
final double camX = entity.lastTickPosX + (entity.posX - entity.lastTickPosX) * partialTicks + offset.x;
final double camY = entity.lastTickPosY + (entity.posY - entity.lastTickPosY) * partialTicks + offset.y;
final double camZ = entity.lastTickPosZ + (entity.posZ - entity.lastTickPosZ) * partialTicks + offset.z;
this.entity = entity;
// Entity position (interpolated, at feet 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();
thirdPerson = Minecraft.getMinecraft().gameSettings.thirdPersonView > 0;
final double camX, camY, camZ;
offset.set(0, 0, 0);
if (thirdPerson) {
// Third person: use inverse modelview to find camera offset
inverseModelView.set(RenderingState.INSTANCE.getModelViewMatrix()).invert();
inverseModelView.transformPosition(offset);
}
camX = entityX + offset.x;
camY = entityY + eyeHeight + offset.y;
camZ = entityZ + offset.z;
pos.set(camX, camY, camZ);
blockPos.set(MathHelper.floor_double(camX), MathHelper.floor_double(camY), MathHelper.floor_double(camZ));
pitch = entity.cameraPitch;
yaw = entity.rotationYaw;
thirdPerson = Minecraft.getMinecraft().gameSettings.thirdPersonView == 1;
}
}
@@ -0,0 +1,17 @@
package com.gtnewhorizons.angelica.compat.mojang;
import net.minecraft.client.Minecraft;
import net.minecraft.client.multiplayer.PlayerControllerMP;
public final class GameModeUtil {
private GameModeUtil() {
}
public static boolean isSpectator() {
final PlayerControllerMP controller = Minecraft.getMinecraft().playerController;
if (controller == null) {
return false;
}
return controller.currentGameType.getID() == 3;
}
}
@@ -1,63 +0,0 @@
package com.gtnewhorizons.angelica.compat.nd;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.ShortBuffer;
public class BufferWriter {
// Adapted from Neodymium
private final ByteBuffer buf;
private final FloatBuffer floatBuffer;
private final ShortBuffer shortBuffer;
private final IntBuffer intBuffer;
public BufferWriter(ByteBuffer buf) {
this.buf = buf;
this.floatBuffer = buf.asFloatBuffer();
this.shortBuffer = buf.asShortBuffer();
this.intBuffer = buf.asIntBuffer();
}
private void incrementPosition(int add) {
buf.position(buf.position() + add);
floatBuffer.position(buf.position() / 4);
shortBuffer.position(buf.position() / 2);
intBuffer.position(buf.position() / 4);
}
public void writeFloat(float x) {
try {
floatBuffer.put(x);
incrementPosition(4);
} catch(Exception e){
e.printStackTrace();
}
}
public void writeInt(int x) {
intBuffer.put(x);
incrementPosition(4);
}
public void writeByte(byte x) {
buf.put(x); // this increments the buffer position by 1
incrementPosition(0);
}
public int position() {
return buf.position();
}
public void writeShort(short s) {
shortBuffer.put(s);
incrementPosition(2);
}
}
@@ -1,47 +0,0 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.writers.IWriteQuads;
import java.nio.ByteBuffer;
public class ItemVBOQuadWriter implements IWriteQuads {
private boolean direct;
public ItemVBOQuadWriter() {
init(false);
}
public void init(boolean direct) {
// This would need to be re-initialized if the direct vs indirect changes
this.direct = direct;
}
@Override
public void writeQuad(QuadView quad, ByteBuffer buf) {
if(direct) {
writeQuadDirect(quad, buf);
} else {
writeQuadIndirect(quad, buf);
}
}
protected void writeQuadDirect(QuadView quad, ByteBuffer buf) {
throw new UnsupportedOperationException("Direct mode not supported yet");
}
protected void writeQuadIndirect(QuadView quad, ByteBuffer buf) {
for(int idx = 0; idx < 4; ++idx) {
// Position
buf.putFloat(quad.getX(idx));
buf.putFloat(quad.getY(idx));
buf.putFloat(quad.getZ(idx));
// Texture
buf.putFloat(quad.getTexU(idx));
buf.putFloat(quad.getTexV(idx));
// Normals + Padding
buf.putInt(quad.getNormal(idx));
}
}
}
@@ -1,47 +0,0 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.writers.IWriteQuads;
import java.nio.ByteBuffer;
public class PositionColorTextureQuadWriter implements IWriteQuads {
private boolean direct;
public PositionColorTextureQuadWriter() {
init(false);
}
public void init(boolean direct) {
// This would need to be re-initialized if the direct vs indirect changes
this.direct = direct;
}
@Override
public void writeQuad(QuadView quad, ByteBuffer buf) {
if(direct) {
writeQuadDirect(quad, buf);
} else {
writeQuadIndirect(quad, buf);
}
}
protected void writeQuadDirect(QuadView quad, ByteBuffer buf) {
throw new UnsupportedOperationException("Direct mode not supported yet");
}
protected void writeQuadIndirect(QuadView quad, ByteBuffer buf) {
for(int idx = 0; idx < 4; ++idx) {
// Position
buf.putFloat(quad.getX(idx));
buf.putFloat(quad.getY(idx));
buf.putFloat(quad.getZ(idx));
// Color
buf.putInt(quad.getColor(idx));
// Texture
buf.putFloat(quad.getTexU(idx));
buf.putFloat(quad.getTexV(idx));
}
}
}
@@ -1,40 +0,0 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.writers.IWriteQuads;
import java.nio.ByteBuffer;
public class PositionQuadWriter implements IWriteQuads {
private boolean direct;
public PositionQuadWriter() {
init(false);
}
public void init(boolean direct) {
// This would need to be re-initialized if the direct vs indirect changes
this.direct = direct;
}
@Override
public void writeQuad(QuadView quad, ByteBuffer buf) {
if(direct) {
writeQuadDirect(quad, buf);
} else {
writeQuadIndirect(quad, buf);
}
}
protected void writeQuadDirect(QuadView quad, ByteBuffer buf) {
throw new UnsupportedOperationException("Direct mode not supported yet");
}
protected void writeQuadIndirect(QuadView quad, ByteBuffer buf) {
for(int idx = 0; idx < 4; ++idx) {
// Position
buf.putFloat(quad.getX(idx));
buf.putFloat(quad.getY(idx));
buf.putFloat(quad.getZ(idx));
}
}
}
@@ -1,49 +0,0 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.writers.IWriteQuads;
import java.nio.ByteBuffer;
public class PositionTextureColorQuadWriter implements IWriteQuads {
private boolean direct;
public PositionTextureColorQuadWriter() {
init(false);
}
public void init(boolean direct) {
// This would need to be re-initialized if the direct vs indirect changes
this.direct = direct;
}
@Override
public void writeQuad(QuadView quad, ByteBuffer buf) {
if(direct) {
writeQuadDirect(quad, buf);
} else {
writeQuadIndirect(quad, buf);
}
}
protected void writeQuadDirect(QuadView quad, ByteBuffer buf) {
throw new UnsupportedOperationException("Direct mode not supported yet");
}
protected void writeQuadIndirect(QuadView quad, ByteBuffer buf) {
for(int idx = 0; idx < 4; ++idx) {
// Position
buf.putFloat(quad.getX(idx));
buf.putFloat(quad.getY(idx));
buf.putFloat(quad.getZ(idx));
// Texture
buf.putFloat(quad.getTexU(idx));
buf.putFloat(quad.getTexV(idx));
// Color
buf.putInt(quad.getColor(idx));
}
}
}
@@ -1,44 +0,0 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.writers.IWriteQuads;
import java.nio.ByteBuffer;
public class PositionTextureQuadWriter implements IWriteQuads {
private boolean direct;
public PositionTextureQuadWriter() {
init(false);
}
public void init(boolean direct) {
// This would need to be re-initialized if the direct vs indirect changes
this.direct = direct;
}
@Override
public void writeQuad(QuadView quad, ByteBuffer buf) {
if(direct) {
writeQuadDirect(quad, buf);
} else {
writeQuadIndirect(quad, buf);
}
}
protected void writeQuadDirect(QuadView quad, ByteBuffer buf) {
throw new UnsupportedOperationException("Direct mode not supported yet");
}
protected void writeQuadIndirect(QuadView quad, ByteBuffer buf) {
for(int idx = 0; idx < 4; ++idx) {
// Position
buf.putFloat(quad.getX(idx));
buf.putFloat(quad.getY(idx));
buf.putFloat(quad.getZ(idx));
// Texture
buf.putFloat(quad.getTexU(idx));
buf.putFloat(quad.getTexV(idx));
}
}
}
@@ -22,7 +22,7 @@ public class AngelicaConfig {
@Config.RequiresMcRestart
public static boolean enableSodiumFluidRendering;
@Config.Comment("Inject QuadProvider rendering into some vanilla blocks")
@Config.Comment("Inject BakedModel rendering into some vanilla blocks")
@Config.DefaultBoolean(false)
@Config.RequiresMcRestart
public static boolean injectQPRendering;
@@ -166,4 +166,42 @@ public class AngelicaConfig {
@Config.Comment("Allows unicode languages to use an odd gui scale")
@Config.DefaultBoolean(true)
public static boolean removeUnicodeEvenScaling;
@Config.Comment({"Block corners and edges between chunks might have \"cracks\" (various lines/dots) in them.",
"While using \"Compact Vertex Format\" makes the situation even worse.",
"This option fixes it.",
"Requires texture reloading (F3 + T) after changing this option to take effect"})
@Config.DefaultBoolean(true)
public static boolean fixBlockCrack;
@Config.Comment({
"The \"epsilon\" value for the fixBlockCrack option. ",
"Set this a bit higher if you can still see lines/dots between solid blocks in dark areas.",
"May cause intense flickering (z-fighting) between blocks if the value is too high"
})
@Config.RangeDouble(min = 0, max = 0.005)
@Config.DefaultDouble(0.001)
public static double blockCrackFixEpsilon;
@Config.Comment("Block classes that have bugs when rendering with the fixBlockCrack can be put here to avoid manipulating them")
@Config.DefaultStringList({
"net.minecraft.block.BlockCauldron",
"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"
})
@Config.DefaultStringList({
"gregtech.common.blocks.BlockOres",
"shukaro.artifice.block.world.BlockOre",
"bartworks.system.material.BWMetaGeneratedOres",
"gtPlusPlus.core.block.base.BlockBaseOre",
})
public static String[] blockCrackFixRenderPassWhitelist;
@Config.Comment("Register HardcodedCustomUniforms in Iris Shaders. May help with compatibility in certain shader packs")
@Config.DefaultBoolean(false)
public static boolean enableHardcodedCustomUniforms;
}
@@ -11,6 +11,7 @@ public class AngelicaGuiConfig extends SimpleGuiConfig {
"Angelica",
true,
AngelicaConfig.class,
CompatConfig.class,
FontConfig.class
);
}
@@ -2,7 +2,7 @@ package com.gtnewhorizons.angelica.config;
import com.gtnewhorizon.gtnhlib.config.Config;
@Config(modid = "angelica", filename = "angelica-compat")
@Config(modid = "angelica", filename = "angelica-compat", category = "compat")
public class CompatConfig {
@Config.Comment("Apply fixes to the LOTR mod")
@@ -44,4 +44,24 @@ public class CompatConfig {
@Config.DefaultBoolean(true)
@Config.RequiresMcRestart
public static boolean fixSecurityCraft;
@Config.Comment("Apply tweaks to NTM:Space")
@Config.DefaultBoolean(true)
@Config.RequiresMcRestart
public static boolean tweakNTMSpace;
@Config.Comment("Apply fixes to NTM:Space")
@Config.DefaultBoolean(true)
@Config.RequiresMcRestart
public static boolean fixNTMSpace;
@Config.Comment("Disables rendering of the planet below the player at high altitudes [Requires tweakNTMSpace]")
@Config.DefaultEnum("ShadersOnly")
public static altitudePlanetRendererState NTMSpace_disableAltitudePlanetRenderer;
public enum altitudePlanetRendererState {
Always,
ShadersOnly,
Never
}
}
@@ -125,9 +125,9 @@ public class AngelicaTweaker implements IFMLLoadingPlugin, IEarlyMixinLoader {
boolean rfbLoaded = Launch.blackboard.getOrDefault("angelica.rfbPluginLoaded", Boolean.FALSE) == Boolean.TRUE;
if (!rfbLoaded) {
tweaks.add("com.gtnewhorizons.angelica.loading.fml.tweakers.AngelicaLateTweaker");
}
if (AngelicaConfig.enableSodium) {
tweaks.add("com.gtnewhorizons.angelica.loading.fml.tweakers.SodiumLateTweaker");
if (AngelicaConfig.enableSodium) {
tweaks.add("com.gtnewhorizons.angelica.loading.fml.tweakers.SodiumLateTweaker");
}
}
}
}
@@ -15,7 +15,7 @@ public class AngelicaRedirectorTransformer implements IClassTransformer {
private final String[] exclusions;
public AngelicaRedirectorTransformer() {
inner = new AngelicaRedirector(AngelicaTweaker.isObfEnv());
inner = new AngelicaRedirector();
exclusions = inner.getTransformerExclusions();
}
@@ -1,26 +1,24 @@
package com.gtnewhorizons.angelica.loading.fml.transformers;
import com.google.common.collect.ImmutableList;
import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
import com.gtnewhorizons.angelica.loading.shared.AngelicaClassDump;
import com.gtnewhorizons.angelica.loading.shared.transformers.AngelicaRedirector;
import com.gtnewhorizons.angelica.loading.shared.transformers.SodiumBlockTransform;
import net.minecraft.launchwrapper.IClassTransformer;
import org.apache.commons.lang3.tuple.Pair;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.tree.ClassNode;
import java.util.List;
public class SodiumBlockTransformer implements IClassTransformer {
private static final List<Pair<String, String>> BlockBoundsFields = ImmutableList.of(
Pair.of("minX", "field_149759_B"),
Pair.of("minY", "field_149760_C"),
Pair.of("minZ", "field_149754_D"),
Pair.of("maxX", "field_149755_E"),
Pair.of("maxY", "field_149756_F"),
Pair.of("maxZ", "field_149757_G")
);
private final SodiumBlockTransform inner;
private final String[] exclusions;
public SodiumBlockTransformer() {
this.inner = new SodiumBlockTransform(AngelicaTweaker.isObfEnv());
this.exclusions = inner.getTransformerExclusions();
this.inner.setSodiumSetting();
}
/**
* Delete the global vanilla bounding box fields off the Block object. {@link AngelicaRedirector}
@@ -29,12 +27,20 @@ public class SodiumBlockTransformer implements IClassTransformer {
@Override
public byte[] transform(String name, String transformedName, byte[] basicClass) {
if (basicClass == null) return null;
if ("net.minecraft.block.Block".equals(transformedName)) {
final ClassReader cr = new ClassReader(basicClass);
final ClassNode cn = new ClassNode();
cr.accept(cn, 0);
cn.fields.removeIf(field -> BlockBoundsFields.stream().anyMatch(pair -> field.name.equals(pair.getLeft()) || field.name.equals(pair.getRight())));
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
for (String exclusion : exclusions) {
if (transformedName.startsWith(exclusion)) return basicClass;
}
if (!inner.shouldTransform(basicClass)) {
return basicClass;
}
final ClassReader cr = new ClassReader(basicClass);
final ClassNode cn = new ClassNode();
cr.accept(cn, 0);
final boolean changed = inner.transformClassNode(transformedName, cn);
if (changed) {
final ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
cn.accept(cw);
final byte[] bytes = cw.toByteArray();
AngelicaClassDump.dumpClass(transformedName, basicClass, bytes, this);
@@ -1,6 +1,7 @@
package com.gtnewhorizons.angelica.loading.rfb;
import com.gtnewhorizons.angelica.loading.rfb.transformers.RFBAngelicaRedirector;
import com.gtnewhorizons.angelica.loading.rfb.transformers.RFBSodiumBlockTransformer;
import com.gtnewhorizons.retrofuturabootstrap.api.PluginContext;
import com.gtnewhorizons.retrofuturabootstrap.api.RetroFuturaBootstrap;
import com.gtnewhorizons.retrofuturabootstrap.api.RfbClassTransformer;
@@ -25,7 +26,8 @@ public class AngelicaRfbPlugin implements RfbPlugin {
final boolean isObf = RetroFuturaBootstrap.API.launchClassLoader().findClassMetadata("net.minecraft.world.World") == null;
return new RfbClassTransformer[] {
new RFBAngelicaRedirector(isObf)
new RFBAngelicaRedirector(),
new RFBSodiumBlockTransformer(isObf)
};
}
}
@@ -16,8 +16,8 @@ public class RFBAngelicaRedirector implements RfbClassTransformer {
private final AngelicaRedirector inner;
public RFBAngelicaRedirector(boolean isObf) {
inner = new AngelicaRedirector(isObf);
public RFBAngelicaRedirector() {
inner = new AngelicaRedirector();
}
@Pattern("[a-z0-9-]+")
@@ -0,0 +1,66 @@
package com.gtnewhorizons.angelica.loading.rfb.transformers;
import com.gtnewhorizons.angelica.loading.shared.AngelicaClassDump;
import com.gtnewhorizons.angelica.loading.shared.transformers.SodiumBlockTransform;
import com.gtnewhorizons.retrofuturabootstrap.api.ClassNodeHandle;
import com.gtnewhorizons.retrofuturabootstrap.api.ExtensibleClassLoader;
import com.gtnewhorizons.retrofuturabootstrap.api.RfbClassTransformer;
import org.intellij.lang.annotations.Pattern;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.jar.Manifest;
public class RFBSodiumBlockTransformer implements RfbClassTransformer {
private final SodiumBlockTransform inner;
public RFBSodiumBlockTransformer(boolean isObf) {
inner = new SodiumBlockTransform(isObf);
}
@Pattern("[a-z0-9-]+")
@Override
public @NotNull String id() {
return "sodiumblocktransform";
}
@Override
public @NotNull String @Nullable [] sortAfter() {
return new String[]{"*", "mixin:mixin"};
}
@Override
public @NotNull String @Nullable [] sortBefore() {
return new String[]{"lwjgl3ify:redirect"};
}
@Override
public @NotNull String @Nullable [] additionalExclusions() {
return inner.getTransformerExclusions();
}
@Override
public boolean shouldTransformClass(@NotNull ExtensibleClassLoader classLoader,
@NotNull RfbClassTransformer.Context context, @Nullable Manifest manifest, @NotNull String className,
@NotNull ClassNodeHandle classNode) {
if (!classNode.isPresent()) {
return false;
}
if (!classNode.isOriginal()) {
// If a class is already a transformed ClassNode, conservatively continue processing.
return true;
}
return inner.shouldTransform(classNode.getOriginalBytes());
}
@Override
public void transformClass(@NotNull ExtensibleClassLoader classLoader, @NotNull RfbClassTransformer.Context context,
@Nullable Manifest manifest, @NotNull String className, @NotNull ClassNodeHandle classNode) {
final boolean changed = inner.transformClassNode(className, classNode.getNode());
if (changed) {
classNode.computeMaxs();
AngelicaClassDump.dumpRFBClass(className, classNode, this);
}
}
}
@@ -26,7 +26,6 @@ import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
/**
* This transformer redirects many GL calls to our custom GLStateManager
@@ -35,16 +34,6 @@ import java.util.stream.Collectors;
* IT SHOULD NOT CALL ANY CODE FROM THE MAIN MOD
*/
public final class AngelicaRedirector {
// TODO(Alexdoru) properly split this class in two because currently this class is doing
// two very different things :
// - redirect the GL calls to our GL manager class
// - replace the block fields with a thread safe replacement (only if Sodium is enabled)
public AngelicaRedirector(boolean isObf) {
IS_OBF = isObf;
}
private final boolean IS_OBF;
private static final boolean ASSERT_MAIN_THREAD = Boolean.getBoolean("angelica.assertMainThread");
private static final boolean LOG_SPAM = Boolean.getBoolean("angelica.redirectorLogspam");
@@ -56,48 +45,20 @@ public final class AngelicaRedirector {
private static final String GL14 = "org/lwjgl/opengl/GL14";
private static final String GL20 = "org/lwjgl/opengl/GL20";
private static final String Project = "org/lwjgl/util/glu/Project";
private static final String BlockClass = "net/minecraft/block/Block";
private static final String BlockPackage = "net/minecraft/block/Block";
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";
private static final String MinecraftClient = "net.minecraft.client";
private static final String SplashProgress = "cpw.mods.fml.client.SplashProgress";
private static final String ThreadedBlockData = "com/gtnewhorizons/angelica/glsm/ThreadedBlockData";
private static final Set<String> ExcludedMinecraftMainThreadChecks = ImmutableSet.of(
"startGame", "func_71384_a",
"initializeTextures", "func_77474_a"
);
private static final List<Pair<String, String>> BlockBoundsFields = ImmutableList.of(
Pair.of("minX", "field_149759_B"),
Pair.of("minY", "field_149760_C"),
Pair.of("minZ", "field_149754_D"),
Pair.of("maxX", "field_149755_E"),
Pair.of("maxY", "field_149756_F"),
Pair.of("maxZ", "field_149757_G")
);
/** All classes in <tt>net.minecraft.block.*</tt> are the block subclasses save for these. */
private static final String[] VanillaBlockExclusions = {
"net/minecraft/block/IGrowable",
"net/minecraft/block/ITileEntityProvider",
"net/minecraft/block/BlockEventData",
"net/minecraft/block/BlockSourceImpl",
"net/minecraft/block/material/"
};
private static final ClassConstantPoolParser cstPoolParser = new ClassConstantPoolParser(GL11, GL13, GL14, GL20, OpenGlHelper, EXTBlendFunc, ARBMultiTexture, BlockPackage, Project);
private static final ClassConstantPoolParser cstPoolParser = new ClassConstantPoolParser(GL11, GL13, GL14, GL20, OpenGlHelper, EXTBlendFunc, ARBMultiTexture, Project);
private static final Map<String, Map<String, String>> methodRedirects = new HashMap<>();
private static final Map<Integer, String> glCapRedirects = new HashMap<>();
private static final Set<String> moddedBlockSubclasses = Collections.newSetFromMap(new ConcurrentHashMap<>());
// Block owners we *shouldn't* redirect because they shadow one of our fields
private static final Set<String> blockOwnerExclusions = Collections.newSetFromMap(new ConcurrentHashMap<>());
// Needed because the config is loaded in LaunchClassLoader, but we need to access it in the parent system loader.
private static final MethodHandle angelicaConfigSodiumEnabledGetter;
static {
glCapRedirects.put(org.lwjgl.opengl.GL11.GL_ALPHA_TEST, "AlphaTest");
glCapRedirects.put(org.lwjgl.opengl.GL11.GL_BLEND, "Blend");
@@ -220,41 +181,6 @@ public final class AngelicaRedirector {
methodRedirects.put(EXTBlendFunc, RedirectMap.newMap().add("glBlendFuncSeparateEXT", "tryBlendFuncSeparate"));
methodRedirects.put(ARBMultiTexture, RedirectMap.newMap().add("glActiveTextureARB"));
methodRedirects.put(Project, RedirectMap.newMap().add("gluPerspective"));
try {
final Class<?> angelicaConfig = Class.forName("com.gtnewhorizons.angelica.config.AngelicaConfig", true, Launch.classLoader);
angelicaConfigSodiumEnabledGetter = MethodHandles.lookup().findStaticGetter(angelicaConfig, "enableSodium", boolean.class);
} catch (ReflectiveOperationException e) {
throw new RuntimeException(e);
}
}
private static boolean isSodiumEnabled() {
try {
return (boolean) angelicaConfigSodiumEnabledGetter.invokeExact();
} catch (Throwable e) {
throw new RuntimeException(e);
}
}
private boolean isVanillaBlockSubclass(String className) {
if (className.startsWith(BlockPackage)) {
for (String exclusion : VanillaBlockExclusions) {
if (className.startsWith(exclusion)) {
return false;
}
}
return true;
}
return false;
}
private boolean isBlockSubclass(String className) {
return isVanillaBlockSubclass(className) || moddedBlockSubclasses.contains(className);
}
private String getFieldName(Pair<String, String> fieldPair) {
return IS_OBF ? fieldPair.getRight() : fieldPair.getLeft();
}
public String[] getTransformerExclusions() {
@@ -276,30 +202,6 @@ public final class AngelicaRedirector {
return false;
}
// Track subclasses of Block
if (!isVanillaBlockSubclass(cn.name) && isBlockSubclass(cn.superName)) {
moddedBlockSubclasses.add(cn.name);
cstPoolParser.addString(cn.name);
}
// Check if this class shadows any fields of the parent class
if (moddedBlockSubclasses.contains(cn.name)) {
// If a superclass shadows, then so do we, because JVM will resolve a reference on our class to that
// superclass
boolean doWeShadow;
if (blockOwnerExclusions.contains(cn.superName)) {
doWeShadow = true;
} else {
// Check if we declare any known field names
doWeShadow = BlockBoundsFields.stream().anyMatch(pair ->
cn.fields.stream().anyMatch(field -> field.name.equals(getFieldName(pair))));
}
if (doWeShadow) {
LOGGER.info("Class '{}' shadows one or more block bounds fields, these accesses won't be redirected!", cn.name);
blockOwnerExclusions.add(cn.name);
}
}
boolean changed = false;
for (MethodNode mn : cn.methods) {
if (transformedName.equals("net.minecraft.client.renderer.OpenGlHelper") && (mn.name.equals("glBlendFunc") || mn.name.equals("func_148821_a"))) {
@@ -360,42 +262,6 @@ public final class AngelicaRedirector {
redirectInMethod = true;
}
}
} else if ((node.getOpcode() == Opcodes.GETFIELD || node.getOpcode() == Opcodes.PUTFIELD) && node instanceof FieldInsnNode fNode) {
if (!blockOwnerExclusions.contains(fNode.owner) && isBlockSubclass(fNode.owner) && isSodiumEnabled()) {
Pair<String, String> fieldToRedirect = BlockBoundsFields.stream()
.filter(pair -> fNode.name.equals(getFieldName(pair)))
.findFirst()
.orElse(null);
if (fieldToRedirect != null) {
if (LOG_SPAM) {
LOGGER.info("Redirecting Block.{} in {} to thread-safe wrapper", fNode.name, transformedName);
}
// Perform the redirect
fNode.name = fieldToRedirect.getLeft(); // use unobfuscated name
fNode.owner = ThreadedBlockData;
// Inject getter before the field access, to turn Block -> ThreadedBlockData
final MethodInsnNode getter = new MethodInsnNode(Opcodes.INVOKESTATIC, ThreadedBlockData, "get", "(L" + BlockClass + ";)L" + ThreadedBlockData + ";", false);
if (node.getOpcode() == Opcodes.GETFIELD) {
mn.instructions.insertBefore(fNode, getter);
} else if (node.getOpcode() == Opcodes.PUTFIELD) {
// FIXME: this code assumes doubles
// Stack: Block, double
final InsnList beforePut = new InsnList();
beforePut.add(new InsnNode(Opcodes.DUP2_X1));
// Stack: double, Block, double
beforePut.add(new InsnNode(Opcodes.POP2));
// Stack: double, Block
beforePut.add(getter);
// Stack: double, ThreadedBlockData
beforePut.add(new InsnNode(Opcodes.DUP_X2));
// Stack: ThreadedBlockData, double, ThreadedBlockData
beforePut.add(new InsnNode(Opcodes.POP));
// Stack: ThreadedBlockData, double
mn.instructions.insertBefore(fNode, beforePut);
}
changed = true;
}
}
}
}
if (ASSERT_MAIN_THREAD && redirectInMethod && !transformedName.startsWith(SplashProgress) && !(transformedName.startsWith(MinecraftClient) && ExcludedMinecraftMainThreadChecks.contains(mn.name))) {
@@ -0,0 +1,211 @@
package com.gtnewhorizons.angelica.loading.shared.transformers;
import com.google.common.collect.ImmutableList;
import com.gtnewhorizon.gtnhlib.asm.ClassConstantPoolParser;
import net.minecraft.launchwrapper.Launch;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.FieldInsnNode;
import org.objectweb.asm.tree.FieldNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.InsnNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
public class SodiumBlockTransform {
public SodiumBlockTransform(boolean isObf) {
this.IS_OBF = isObf;
}
private final boolean IS_OBF;
private static final boolean LOG_SPAM = Boolean.getBoolean("angelica.redirectorLogspam");
private static final Logger LOGGER = LogManager.getLogger("SodiumBlockTransformer");
private static final String BlockClass = "net/minecraft/block/Block";
private static final String BlockPackage = "net/minecraft/block/Block";
private static final String ThreadedBlockData = "com/gtnewhorizons/angelica/glsm/ThreadedBlockData";
private static final List<Pair<String, String>> BlockBoundsFields = ImmutableList.of(
Pair.of("minX", "field_149759_B"),
Pair.of("minY", "field_149760_C"),
Pair.of("minZ", "field_149754_D"),
Pair.of("maxX", "field_149755_E"),
Pair.of("maxY", "field_149756_F"),
Pair.of("maxZ", "field_149757_G")
);
/** All classes in <tt>net.minecraft.block.*</tt> are the block subclasses save for these. */
private static final String[] VanillaBlockExclusions = {
"net/minecraft/block/IGrowable",
"net/minecraft/block/ITileEntityProvider",
"net/minecraft/block/BlockEventData",
"net/minecraft/block/BlockSourceImpl",
"net/minecraft/block/material/"
};
private static final ClassConstantPoolParser cstPoolParser = new ClassConstantPoolParser(BlockPackage);
private static final Set<String> moddedBlockSubclasses = Collections.newSetFromMap(new ConcurrentHashMap<>());
// Block owners we *shouldn't* redirect because they shadow one of our fields
private static final Set<String> blockOwnerExclusions = Collections.newSetFromMap(new ConcurrentHashMap<>());
// Needed because the config is loaded in LaunchClassLoader, but we need to access it in the parent system loader.
private static final MethodHandle angelicaConfigSodiumEnabledGetter;
private static boolean isSodiumEnabled;
static {
try {
final Class<?> angelicaConfig = Class.forName("com.gtnewhorizons.angelica.config.AngelicaConfig", true, Launch.classLoader);
angelicaConfigSodiumEnabledGetter = MethodHandles.lookup().findStaticGetter(angelicaConfig, "enableSodium", boolean.class);
} catch (ReflectiveOperationException e) {
throw new RuntimeException(e);
}
}
private static boolean isSodiumEnabled() {
if (isSodiumEnabled) return true;
try {
return (boolean) angelicaConfigSodiumEnabledGetter.invokeExact();
} catch (Throwable e) {
throw new RuntimeException(e);
}
}
private boolean isVanillaBlockSubclass(String className) {
if (className.startsWith(BlockPackage)) {
for (String exclusion : VanillaBlockExclusions) {
if (className.startsWith(exclusion)) {
return false;
}
}
return true;
}
return false;
}
private boolean isBlockSubclass(String className) {
return isVanillaBlockSubclass(className) || moddedBlockSubclasses.contains(className);
}
private String getFieldName(Pair<String, String> fieldPair) {
return IS_OBF ? fieldPair.getRight() : fieldPair.getLeft();
}
public String[] getTransformerExclusions() {
return new String[]{
"org.lwjgl",
"com.gtnewhorizons.angelica.glsm.",
"com.gtnewhorizons.angelica.transform",
"me.eigenraven.lwjgl3ify"
};
}
public boolean shouldTransform(byte[] basicClass) {
return cstPoolParser.find(basicClass, true);
}
/** @return Was the class changed? */
public boolean transformClassNode(String transformedName, ClassNode cn) {
if (cn == null) {
return false;
}
if ("net.minecraft.block.Block".equals(transformedName) && isSodiumEnabled()) {
cn.fields.removeIf(field -> BlockBoundsFields.stream().anyMatch(pair -> field.name.equals(pair.getLeft()) || field.name.equals(pair.getRight())));
}
// Track subclasses of Block
if (!isVanillaBlockSubclass(cn.name) && isBlockSubclass(cn.superName)) {
moddedBlockSubclasses.add(cn.name);
cstPoolParser.addString(cn.name);
}
// Check if this class shadows any fields of the parent class
if (moddedBlockSubclasses.contains(cn.name)) {
// If a superclass shadows, then so do we, because JVM will resolve a reference on our class to that
// superclass
boolean doWeShadow;
if (blockOwnerExclusions.contains(cn.superName)) {
doWeShadow = true;
} else {
// Check if we declare any known field names
boolean b = false;
for (Pair<String, String> pair : BlockBoundsFields) {
boolean result = false;
for (FieldNode field : cn.fields) {
if (field.name.equals(getFieldName(pair))) {
result = true;
break;
}
}
if (result) {
b = true;
break;
}
}
doWeShadow = b;
}
if (doWeShadow) {
LOGGER.info("Class '{}' shadows one or more block bounds fields, these accesses won't be redirected!", cn.name);
blockOwnerExclusions.add(cn.name);
}
}
boolean changed = false;
for (MethodNode mn : cn.methods) {
for (AbstractInsnNode node : mn.instructions.toArray()) {
if ((node.getOpcode() == Opcodes.GETFIELD || node.getOpcode() == Opcodes.PUTFIELD) && node instanceof FieldInsnNode fNode) {
if (!blockOwnerExclusions.contains(fNode.owner) && isBlockSubclass(fNode.owner) && isSodiumEnabled()) {
Pair<String, String> fieldToRedirect = BlockBoundsFields.stream()
.filter(pair -> fNode.name.equals(getFieldName(pair)))
.findFirst()
.orElse(null);
if (fieldToRedirect != null) {
if (LOG_SPAM) {
LOGGER.info("Redirecting Block.{} in {} to thread-safe wrapper", fNode.name, transformedName);
}
// Perform the redirect
fNode.name = fieldToRedirect.getLeft(); // use unobfuscated name
fNode.owner = ThreadedBlockData;
// Inject getter before the field access, to turn Block -> ThreadedBlockData
final MethodInsnNode getter = new MethodInsnNode(Opcodes.INVOKESTATIC, ThreadedBlockData, "get", "(L" + BlockClass + ";)L" + ThreadedBlockData + ";", false);
if (node.getOpcode() == Opcodes.GETFIELD) {
mn.instructions.insertBefore(fNode, getter);
} else if (node.getOpcode() == Opcodes.PUTFIELD) {
// FIXME: this code assumes doubles
// Stack: Block, double
final InsnList beforePut = new InsnList();
beforePut.add(new InsnNode(Opcodes.DUP2_X1));
// Stack: double, Block, double
beforePut.add(new InsnNode(Opcodes.POP2));
// Stack: double, Block
beforePut.add(getter);
// Stack: double, ThreadedBlockData
beforePut.add(new InsnNode(Opcodes.DUP_X2));
// Stack: ThreadedBlockData, double, ThreadedBlockData
beforePut.add(new InsnNode(Opcodes.POP));
// Stack: ThreadedBlockData, double
mn.instructions.insertBefore(fNode, beforePut);
}
changed = true;
}
}
}
}
}
return changed;
}
public void setSodiumSetting() {
isSodiumEnabled = true;
}
}
@@ -77,7 +77,14 @@ public enum Mixins implements IMixins {
, "angelica.dynamiclights.MixinItemRenderer"
)
),
ANGELICA_FIX_BLOCK_CRACK(
new MixinBuilder("Block corners and edges between chunks might have \"cracks\" in them. This option fixes it")
.setPhase(Phase.EARLY)
.addClientMixins("angelica.bugfixes.MixinRenderBlocks_CrackFix")
.addExcludedMod(TargetedMod.FALSETWEAKS)
.setApplyIf(() -> AngelicaConfig.fixBlockCrack)),
ANGELICA_FIX_FLUID_RENDERER_CHECKING_BLOCK_AGAIN(
new MixinBuilder("Fix RenderBlockFluid reading the block type from the world access multiple times")
.setPhase(Phase.EARLY)
@@ -276,6 +283,17 @@ public enum Mixins implements IMixins {
.addRequiredMod(TargetedMod.MINEFACTORY_RELOADED)
.setApplyIf(() -> CompatConfig.fixMinefactoryReloaded)
.addClientMixins("client.minefactoryreloaded.MixinRedNetCableRenderer")),
NTM_SPACE_TWEAKS(new MixinBuilder("Support for 'Disable Horizon' & 'disableAltitudePlanetRenderer' options in NTM:Space")
.setPhase(Phase.LATE)
.addRequiredMod(TargetedMod.NTM_SPACE)
.setApplyIf(() -> CompatConfig.tweakNTMSpace)
.addClientMixins("client.ntmSpace.MixinSkyProviderCelestial_Tweaks")),
NTM_SPACE_SHADER_COMPAT(new MixinBuilder("Multiple shader fixes for NTM:Space")
.setPhase(Phase.LATE)
.addRequiredMod(TargetedMod.NTM_SPACE)
.setApplyIf(() -> CompatConfig.fixNTMSpace && AngelicaConfig.enableIris)
.addClientMixins("client.ntmSpace.MixinSkyProviderCelestial_ShaderCompat")),
SPEEDUP_CAMPFIRE_BACKPORT_ANIMATIONS(new MixinBuilder("Add animation speedup support to Campfire Backport")
.setPhase(Phase.LATE)
@@ -575,13 +593,6 @@ public enum Mixins implements IMixins {
.addClientMixins("mcpatcherforge.ctm_cc.MixinTextureMap")
),
//End from NotFine
QPR(new MixinBuilder("Adds a QuadProvider field to blocks without populating it")
.setPhase(Phase.EARLY)
.addClientMixins(
"angelica.models.MixinBlock",
"angelica.models.MixinBlockOldLeaf")),
;
private final MixinBuilder builder;
@@ -14,7 +14,9 @@ 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"),
EXTRAUTILS(null, "ExtraUtilities"),
FALSETWEAKS("com.falsepattern.falsetweaks.asm.CoreLoadingPlugin", "falsetweaks"),
MINEFACTORY_RELOADED(null, "MineFactoryReloaded"),
NTM_SPACE("com.hbm.dim.SolarSystem"),
IC2("ic2.core.coremod.IC2core", "IC2"),
NATURA(null, "Natura"),
SECURITYCRAFT(null, "securitycraft"),
@@ -24,7 +26,10 @@ public enum TargetedMod implements ITargetMod {
WITCHERY(null, "witchery");
private final TargetModBuilder builder;
TargetedMod(String targetClass) {
this.builder = new TargetModBuilder().setTargetClass(targetClass);
}
TargetedMod(String coreModClass, String modId) {
this.builder = new TargetModBuilder().setCoreModClass(coreModClass).setModId(modId);
}
@@ -1,9 +0,0 @@
package com.gtnewhorizons.angelica.mixins.interfaces;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadProvider;
public interface ModeledBlock {
QuadProvider getModel();
void setModel(QuadProvider model);
}
@@ -1,191 +0,0 @@
package com.gtnewhorizons.angelica.models;
import com.gtnewhorizon.gtnhlib.blockpos.IBlockPos;
import com.gtnewhorizon.gtnhlib.client.model.ModelLoader;
import com.gtnewhorizon.gtnhlib.client.model.Variant;
import com.gtnewhorizon.gtnhlib.client.model.json.ModelLocation;
import com.gtnewhorizon.gtnhlib.client.model.template.BlockColoredCube;
import com.gtnewhorizon.gtnhlib.client.model.template.BlockStaticCube;
import com.gtnewhorizon.gtnhlib.client.model.template.Column3Rot;
import com.gtnewhorizon.gtnhlib.client.model.template.Model4Rot;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadProvider;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadView;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import net.minecraft.block.Block;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
public class VanillaModels {
private static boolean init = false;
public static final BlockStaticCube STONE = new BlockStaticCube("stone");
public static final BlockStaticCube GLASS = new BlockStaticCube("glass");
public static BlockColoredCube OAK_LEAVES;
public static BlockColoredCube SPRUCE_LEAVES;
public static BlockColoredCube BIRCH_LEAVES;
public static BlockColoredCube JUNGLE_LEAVES;
public static QuadProvider OLD_LEAF = new QuadProvider() {
@Override
public int getColor(IBlockAccess world, IBlockPos pos, Block block, int meta, Random random) {
return QuadProvider.getDefaultColor(world, pos, block);
}
@Override
public List<QuadView> getQuads(IBlockAccess world, IBlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
return (switch (meta % 4) {
case 0 -> OAK_LEAVES;
case 1 -> SPRUCE_LEAVES;
case 2 -> BIRCH_LEAVES;
case 3 -> JUNGLE_LEAVES;
default -> throw new IllegalStateException("Unexpected value: " + meta);
}).getQuads(world, pos, block, meta, dir, random, color, quadPool);
}
};
public static BlockColoredCube ACACIA_LEAVES;
public static BlockColoredCube DARK_OAK_LEAVES;
public static QuadProvider NEW_LEAF = new QuadProvider() {
@Override
public int getColor(IBlockAccess world, IBlockPos pos, Block block, int meta, Random random) {
return QuadProvider.getDefaultColor(world, pos, block);
}
@Override
public List<QuadView> getQuads(IBlockAccess world, IBlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
return (switch (meta % 2) {
case 0 -> ACACIA_LEAVES;
case 1 -> DARK_OAK_LEAVES;
default -> throw new IllegalStateException("Unexpected value: " + meta);
}).getQuads(world, pos, block, meta, dir, random, color, quadPool);
}
};
public static Column3Rot OAK_LOG;
public static Column3Rot SPRUCE_LOG;
public static Column3Rot BIRCH_LOG;
public static Column3Rot JUNGLE_LOG;
public static BlockStaticCube OAK_WOOD;
public static BlockStaticCube BIRCH_WOOD;
public static BlockStaticCube SPRUCE_WOOD;
public static BlockStaticCube JUNGLE_WOOD;
public static QuadProvider OLD_LOG = new QuadProvider() {
@Override
public List<QuadView> getQuads(IBlockAccess world, IBlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
if (meta > 11) {
return (switch (meta) {
case 12 -> OAK_WOOD;
case 13 -> SPRUCE_WOOD;
case 14 -> BIRCH_WOOD;
case 15 -> JUNGLE_WOOD;
default -> throw new IllegalStateException("Unexpected value: " + meta);
}).getQuads(world, pos, block, meta, dir, random, color, quadPool);
}
Column3Rot ret = switch (meta % 4) {
case 0 -> OAK_LOG;
case 1 -> SPRUCE_LOG;
case 2 -> BIRCH_LOG;
case 3 -> JUNGLE_LOG;
default -> throw new IllegalStateException("Unexpected value: " + meta);
};
return (switch (meta / 4) {
case 0 -> ret.updown();
case 1 -> ret.eastwest();
case 2 -> ret.northsouth();
default -> throw new IllegalStateException("Unexpected value: " + meta);
}).getQuads(world, pos, block, meta, dir, random, color, quadPool);
}
};
public static Column3Rot ACACIA_LOG;
public static Column3Rot DARK_OAK_LOG;
public static BlockStaticCube ACACIA_WOOD;
public static BlockStaticCube DARK_OAK_WOOD;
public static QuadProvider NEW_LOG = new QuadProvider() {
@Override
public List<QuadView> getQuads(IBlockAccess world, IBlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
if (meta > 11) {
return (switch (meta) {
case 12 -> ACACIA_WOOD;
case 13 -> DARK_OAK_WOOD;
default -> throw new IllegalStateException("Unexpected value: " + meta);
}).getQuads(world, pos, block, meta, dir, random, color, quadPool);
}
Column3Rot ret = switch (meta % 4) {
case 0 -> ACACIA_LOG;
case 1 -> DARK_OAK_LOG;
default -> throw new IllegalStateException("Unexpected value: " + meta);
};
return (switch (meta / 4) {
case 0 -> ret.updown();
case 1 -> ret.eastwest();
case 2 -> ret.northsouth();
default -> throw new IllegalStateException("Unexpected value: " + meta);
}).getQuads(world, pos, block, meta, dir, random, color, quadPool);
}
};
public static final Variant workbench = new Variant(
new ModelLocation("block/crafting_table"),
0,
0,
true
);
public static QuadProvider WORKBENCH;
public static Model4Rot LECTERN;
public static void init() {
if (init) {
throw new RuntimeException("Vanilla models were baked twice!");
}
if (AngelicaConfig.injectQPRendering) {
ACACIA_LEAVES = new BlockColoredCube("leaves_acacia");
BIRCH_LEAVES = new BlockColoredCube("leaves_birch");
DARK_OAK_LEAVES = new BlockColoredCube("leaves_big_oak");
JUNGLE_LEAVES = new BlockColoredCube("leaves_jungle");
OAK_LEAVES = new BlockColoredCube("leaves_oak");
SPRUCE_LEAVES = new BlockColoredCube("leaves_spruce");
ACACIA_LOG = new Column3Rot(new ModelLocation("block/acacia_log"));
BIRCH_LOG = new Column3Rot(new ModelLocation("block/birch_log"));
DARK_OAK_LOG = new Column3Rot(new ModelLocation("block/dark_oak_log"));
JUNGLE_LOG = new Column3Rot(new ModelLocation("block/jungle_log"));
OAK_LOG = new Column3Rot(new ModelLocation("block/oak_log"));
SPRUCE_LOG = new Column3Rot(new ModelLocation("block/spruce_log"));
ACACIA_WOOD = new BlockStaticCube("log_acacia");
BIRCH_WOOD = new BlockStaticCube("log_birch");
DARK_OAK_WOOD = new BlockStaticCube("log_big_oak");
JUNGLE_WOOD = new BlockStaticCube("log_jungle");
OAK_WOOD = new BlockStaticCube("log_oak");
SPRUCE_WOOD = new BlockStaticCube("log_spruce");
ModelLoader.registerModels(VanillaModels::loadModels,
workbench);
}
if (AngelicaConfig.enableTestBlocks)
LECTERN = new Model4Rot(new ModelLocation("block/lectern"));
init = true;
}
public static void loadModels() {
WORKBENCH = ModelLoader.getModel(workbench);
}
}
@@ -1,8 +1,10 @@
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.vertex.DefaultVertexFormat;
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat;
import com.gtnewhorizons.angelica.compat.ModStatus;
@@ -12,15 +14,13 @@ import com.gtnewhorizons.angelica.config.CompatConfig;
import com.gtnewhorizons.angelica.debug.F3Direction;
import com.gtnewhorizons.angelica.debug.FrametimeGraph;
import com.gtnewhorizons.angelica.debug.TPSGraph;
import com.gtnewhorizons.angelica.mixins.interfaces.IGameSettingsExt;
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
import com.gtnewhorizons.angelica.glsm.debug.OpenGLDebugging;
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
import com.gtnewhorizons.angelica.models.VanillaModels;
import com.gtnewhorizons.angelica.mixins.interfaces.IGameSettingsExt;
import com.gtnewhorizons.angelica.render.CloudRenderer;
import com.gtnewhorizons.angelica.rendering.AngelicaBlockSafetyRegistry;
import com.gtnewhorizons.angelica.utils.AssetLoader;
import com.gtnewhorizons.angelica.zoom.Zoom;
import cpw.mods.fml.client.registry.ClientRegistry;
import cpw.mods.fml.common.FMLCommonHandler;
@@ -76,7 +76,7 @@ public class ClientProxy extends CommonProxy {
FMLCommonHandler.instance().bus().register(this);
MinecraftForge.EVENT_BUS.register(this);
AssetLoader.load();
ModelRegistry.registerModid(MOD_ID);
}
@SubscribeEvent
@@ -139,8 +139,6 @@ public class ClientProxy extends CommonProxy {
glsmKeyBinding = new KeyBinding("Print GLSM Debug", Keyboard.KEY_NONE, "Angelica");
ClientRegistry.registerKeyBinding(glsmKeyBinding);
VanillaModels.init();
if (ModStatus.isBetterCrashesLoaded) {
BetterCrashesCompat.init();
}
@@ -27,21 +27,18 @@ package com.gtnewhorizons.angelica.rendering;
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadView;
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;
import java.nio.ByteBuffer;
import java.util.List;
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);
@@ -100,7 +97,7 @@ public class ItemRenderListManager {
}
public static void post(CapturingTessellator tessellator, VertexBuffer vbo) {
final List<QuadView> quads = TessellatorManager.stopCapturingToPooledQuads();
final var quads = TessellatorManager.stopCapturingToPooledQuads();
final int size = quads.size();
final int needed = (DefaultVertexFormat.POSITION_TEXTURE_NORMAL.getVertexSize() * size) << 2;
@@ -1,111 +0,0 @@
package com.gtnewhorizons.angelica.utils;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import glowredman.txloader.Asset;
import glowredman.txloader.TXLoaderCore;
public class AssetLoader {
// Texture paths from modern, starting with "minecraft/textures/"
public static final String[] injectTexs = {
"block/stone",
"block/crafting_table_front",
"block/crafting_table_side",
"block/crafting_table_top",
"block/oak_planks",
"block/acacia_log_top",
"block/acacia_log",
"block/birch_log_top",
"block/birch_log",
"block/dark_oak_log_top",
"block/dark_oak_log",
"block/jungle_log_top",
"block/jungle_log",
"block/oak_log_top",
"block/oak_log",
"block/spruce_log_top",
"block/spruce_log"
};
// Any equivalents from 7.10, starting with "minecraft/"
// This can't be automatic because some of them are inconsistent
public static final String[] oldInjectTexs = {
"blocks/stone",
"blocks/crafting_table_front",
"blocks/crafting_table_side",
"blocks/crafting_table_top",
"blocks/planks_oak",
"blocks/log_acacia_top",
"blocks/log_acacia",
"blocks/log_birch_top",
"blocks/log_birch",
"blocks/log_big_oak_top",
"blocks/log_big_oak",
"blocks/log_jungle_top",
"blocks/log_jungle",
"blocks/log_oak_top",
"blocks/log_oak",
"blocks/log_spruce_top",
"blocks/log_spruce"
};
public static final String[] testTexs = {
"block/lectern_base",
"block/lectern_front",
"block/lectern_base",
"block/lectern_sides",
"block/lectern_top",
"block/oak_planks"
};
public static void load() {
if (AngelicaConfig.injectQPRendering || AngelicaConfig.enableTestBlocks) {
addModelAssets(
"block/block",
"block/cube",
"block/cube_all",
"block/cube_column"
);
}
// For textures, we first clone old assets to their locations in modern, then copy any modern textures we don't
// have equivalents for (only the lectern rn). Models are always downloaded, 7.10 doesn't have any.
if (AngelicaConfig.injectQPRendering) {
addModelAssets(
"block/stone",
"block/crafting_table",
"block/acacia_log",
"block/birch_log",
"block/dark_oak_log",
"block/jungle_log",
"block/oak_log",
"block/spruce_log");
addTexAssets(oldInjectTexs, injectTexs, "1.7.10");
}
if (AngelicaConfig.enableTestBlocks) {
addModelAssets("block/lectern");
addTexAssets(testTexs, testTexs, "1.20.4");
}
}
private static void addModelAssets(String... resourcePaths) {
for (String path : resourcePaths) {
TXLoaderCore.getAssetBuilder("minecraft/models/" + path + ".json")
.setVersion("1.20.4")
.setSource(Asset.Source.CLIENT)
.add();
}
}
private static void addTexAssets(String[] resourcePaths, String[] destPaths, String version) {
for (int i = 0; i < resourcePaths.length; ++i) {
TXLoaderCore.getAssetBuilder("minecraft/textures/" + resourcePaths[i] + ".png")
.setOverride("minecraft/textures/blocks/" + destPaths[i] + ".png")
.setVersion(version)
.setSource(Asset.Source.CLIENT)
.add();
}
}
}
@@ -1,25 +0,0 @@
package com.gtnewhorizons.angelica.utils;
import java.util.ArrayList;
import java.util.function.Supplier;
public class ObjectPooler<T> {
private final Supplier<T> instanceSupplier;
private final ArrayList<T> availableInstances;
public ObjectPooler(Supplier<T> instanceSupplier) {
this.instanceSupplier = instanceSupplier;
this.availableInstances = new ArrayList<>();
}
public T getInstance() {
if(this.availableInstances.isEmpty()) {
return this.instanceSupplier.get();
}
return this.availableInstances.remove(this.availableInstances.size() - 1);
}
public void releaseInstance(T instance) {
this.availableInstances.add(instance);
}
}
@@ -60,6 +60,7 @@ public enum Settings {
DynamicLights.ShaderForce = (boolean) this.option.getStore();
}
},
HORIZON_DISABLE(new NotFineOptionTickBox(true, OptionImpact.LOW)),
FOG_DISABLE(new NotFineOptionTickBox(false, OptionImpact.LOW)),
FOG_NEAR_DISTANCE(new NotFineOptionSliderPercentage(75, 1, 100, 1, OptionImpact.LOW)),
GUI_BACKGROUND(new NotFineOptionCycling<>(BackgroundSelect.DEFAULT, null)) {
@@ -213,6 +213,7 @@ public class NotFineGameOptionPages {
.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)
.build());
@@ -16,7 +16,8 @@ public abstract class Type {
public static final Primitive[] AllPrimitives = {Type.Boolean, Type.Int, Type.Float};
public static UniformType convert(Type type) {
if (type == Type.Int || type == Type.Boolean) return UniformType.INT;
if (type == Type.Int) return UniformType.INT;
else if (type == Type.Boolean) return UniformType.INT;
else if (type == Type.Float) return UniformType.FLOAT;
else if (type == VectorType.VEC2) return UniformType.VEC2;
else if (type == VectorType.VEC3) return UniformType.VEC3;
@@ -9,7 +9,7 @@ import java.util.function.Consumer;
public class ScrollBarComponent extends AbstractWidget {
protected static final int SCROLL_OFFSET = 6;
protected static final int SCROLL_OFFSET = 15;
protected final Dim2i dim;
@@ -89,6 +89,7 @@ public class SodiumGameOptionPages {
.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);
@@ -1,9 +1,9 @@
package me.jellysquid.mods.sodium.client.model.light;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.ModelQuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import me.jellysquid.mods.sodium.client.model.light.data.QuadLightData;
import net.minecraftforge.common.util.ForgeDirection;
/**
* Light pipelines allow model quads for any location in the world to be lit using various backends, including fluids
@@ -18,5 +18,5 @@ public interface LightPipeline {
* @param face The pre-computed facing vector of the quad
* @param shade True if the block is shaded by ambient occlusion
*/
void calculate(ModelQuadView quad, BlockPos pos, QuadLightData out, ForgeDirection cullFace, ForgeDirection face, boolean shade);
void calculate(ModelQuadView quad, BlockPos pos, QuadLightData out, ModelQuadFacing cullFace, ModelQuadFacing face, boolean shade);
}
@@ -1,11 +1,11 @@
package me.jellysquid.mods.sodium.client.model.light.data;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
import me.jellysquid.mods.sodium.client.util.StateUtil;
import me.jellysquid.mods.sodium.client.world.WorldSlice;
import net.minecraft.block.Block;
import net.minecraftforge.common.util.ForgeDirection;
/**
* The light data cache is used to make accessing the light data and occlusion properties of blocks cheaper. The data
@@ -26,15 +26,15 @@ public abstract class LightDataAccess {
public static final ThreadLocal<BlockPos> DynamicLightsPos = ThreadLocal.withInitial(BlockPos::new);
protected WorldSlice world;
public long get(int x, int y, int z, ForgeDirection d1, ForgeDirection d2) {
return this.get(x + d1.offsetX + d2.offsetX, y + d1.offsetY + d2.offsetY, z + d1.offsetZ + d2.offsetZ);
public long get(int x, int y, int z, ModelQuadFacing d1, ModelQuadFacing d2) {
return this.get(x + d1.getStepX() + d2.getStepX(), y + d1.getStepY() + d2.getStepY(), z + d1.getStepZ() + d2.getStepZ());
}
public long get(int x, int y, int z, ForgeDirection dir) {
return this.get(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ);
public long get(int x, int y, int z, ModelQuadFacing dir) {
return this.get(x + dir.getStepX(), y + dir.getStepY(), z + dir.getStepZ());
}
public long get(BlockPos pos, ForgeDirection dir) {
public long get(BlockPos pos, ModelQuadFacing dir) {
return this.get(pos.x, pos.y, pos.z, dir);
}
@@ -1,17 +1,17 @@
package me.jellysquid.mods.sodium.client.model.light.flat;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.ModelQuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFlags;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFlags;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import java.util.Arrays;
import me.jellysquid.mods.sodium.client.model.light.LightPipeline;
import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess;
import me.jellysquid.mods.sodium.client.model.light.data.QuadLightData;
import net.coderbot.iris.block_rendering.BlockRenderingSettings;
import net.minecraftforge.common.util.ForgeDirection;
import java.util.Arrays;
/**
* A light pipeline which implements "classic-style" lighting through simply using the light value of the adjacent
* block to a face.
@@ -27,7 +27,7 @@ public class FlatLightPipeline implements LightPipeline {
}
@Override
public void calculate(ModelQuadView quad, BlockPos pos, QuadLightData out, ForgeDirection cullFace, ForgeDirection face, boolean shade) {
public void calculate(ModelQuadView quad, BlockPos pos, QuadLightData out, ModelQuadFacing cullFace, ModelQuadFacing face, boolean shade) {
int lightmap;
// To match vanilla behavior, use the cull face if it exists/is available
@@ -57,7 +57,7 @@ public class FlatLightPipeline implements LightPipeline {
* behind tinted glass. {@link LightDataAccess} cannot efficiently store lightmaps computed with
* inconsistent values so this method exists to mirror vanilla behavior as closely as possible.
*/
private int getOffsetLightmap(BlockPos pos, ForgeDirection face) {
private int getOffsetLightmap(BlockPos pos, ModelQuadFacing face) {
int lightmap = LightDataAccess.getLightMap(this.lightCache.get(pos, face));
// If the block light is not 15 (max)...
if ((lightmap & 0xF0) != 0xF0) {
@@ -1,13 +1,13 @@
package me.jellysquid.mods.sodium.client.model.light.smooth;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess;
import net.minecraftforge.common.util.ForgeDirection;
import static me.jellysquid.mods.sodium.client.model.light.cache.ArrayLightDataCache.getLightMap;
import static me.jellysquid.mods.sodium.client.model.light.cache.ArrayLightDataCache.unpackAO;
import static me.jellysquid.mods.sodium.client.model.light.cache.ArrayLightDataCache.unpackFO;
import static me.jellysquid.mods.sodium.client.model.light.cache.ArrayLightDataCache.unpackOP;
import static me.jellysquid.mods.sodium.client.model.light.cache.ArrayLightDataCache.getLightMap;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess;
class AoFaceData {
public final int[] lm = new int[4];
@@ -18,7 +18,7 @@ class AoFaceData {
private int flags;
public void initLightData(LightDataAccess cache, BlockPos pos, ForgeDirection direction, boolean offset) {
public void initLightData(LightDataAccess cache, BlockPos pos, ModelQuadFacing direction, boolean offset) {
final int x = pos.x;
final int y = pos.y;
final int z = pos.z;
@@ -28,9 +28,9 @@ class AoFaceData {
final int adjZ;
if (offset) {
adjX = x + direction.offsetX;
adjY = y + direction.offsetY;
adjZ = z + direction.offsetZ;
adjX = x + direction.getStepX();
adjY = y + direction.getStepY();
adjZ = z + direction.getStepZ();
} else {
adjX = x;
adjY = y;
@@ -50,7 +50,7 @@ class AoFaceData {
final float caao = unpackAO(adjWord);
ForgeDirection[] faces = AoNeighborInfo.get(direction).faces;
var faces = AoNeighborInfo.get(direction).faces;
final long e0 = cache.get(adjX, adjY, adjZ, faces[0]);
final int e0lm = getLightMap(e0);
@@ -1,17 +1,25 @@
package me.jellysquid.mods.sodium.client.model.light.smooth;
import net.minecraftforge.common.util.ForgeDirection;
import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.NEG_X;
import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.NEG_Y;
import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.NEG_Z;
import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.POS_X;
import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.POS_Y;
import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.POS_Z;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import org.jetbrains.annotations.NotNull;
/**
* The neighbor information for each face of a block, used when performing smooth lighting in order to calculate
* the occlusion of each corner.
*/
enum AoNeighborInfo {
DOWN(new ForgeDirection[] { ForgeDirection.WEST, ForgeDirection.EAST, ForgeDirection.NORTH, ForgeDirection.SOUTH }, 0.5F) {
EAST(new ModelQuadFacing[] { NEG_Y, POS_Y, NEG_Z, POS_Z }, 0.6F) {
@Override
public void calculateCornerWeights(float x, float y, float z, float[] out) {
final float u = z;
final float v = 1.0f - x;
final float v = 1.0f - y;
out[0] = v * u;
out[1] = v * (1.0f - u);
@@ -21,23 +29,23 @@ enum AoNeighborInfo {
@Override
public void mapCorners(int[] lm0, float[] ao0, int[] lm1, float[] ao1) {
lm1[0] = lm0[0];
lm1[1] = lm0[1];
lm1[2] = lm0[2];
lm1[3] = lm0[3];
lm1[1] = lm0[0];
lm1[2] = lm0[1];
lm1[3] = lm0[2];
lm1[0] = lm0[3];
ao1[0] = ao0[0];
ao1[1] = ao0[1];
ao1[2] = ao0[2];
ao1[3] = ao0[3];
ao1[1] = ao0[0];
ao1[2] = ao0[1];
ao1[3] = ao0[2];
ao1[0] = ao0[3];
}
@Override
public float getDepth(float x, float y, float z) {
return y;
return 1.0f - x;
}
},
UP(new ForgeDirection[] { ForgeDirection.EAST, ForgeDirection.WEST, ForgeDirection.NORTH, ForgeDirection.SOUTH }, 1.0F) {
UP(new ModelQuadFacing[] { POS_X, NEG_X, NEG_Z, POS_Z }, 1.0F) {
@Override
public void calculateCornerWeights(float x, float y, float z, float[] out) {
final float u = z;
@@ -67,37 +75,7 @@ enum AoNeighborInfo {
return 1.0f - y;
}
},
NORTH(new ForgeDirection[] { ForgeDirection.UP, ForgeDirection.DOWN, ForgeDirection.EAST, ForgeDirection.WEST }, 0.8F) {
@Override
public void calculateCornerWeights(float x, float y, float z, float[] out) {
final float u = 1.0f - x;
final float v = y;
out[0] = v * u;
out[1] = v * (1.0f - u);
out[2] = (1.0f - v) * (1.0f - u);
out[3] = (1.0f - v) * u;
}
@Override
public void mapCorners(int[] lm0, float[] ao0, int[] lm1, float[] ao1) {
lm1[3] = lm0[0];
lm1[0] = lm0[1];
lm1[1] = lm0[2];
lm1[2] = lm0[3];
ao1[3] = ao0[0];
ao1[0] = ao0[1];
ao1[1] = ao0[2];
ao1[2] = ao0[3];
}
@Override
public float getDepth(float x, float y, float z) {
return z;
}
},
SOUTH(new ForgeDirection[] { ForgeDirection.WEST, ForgeDirection.EAST, ForgeDirection.DOWN, ForgeDirection.UP }, 0.8F) {
SOUTH(new ModelQuadFacing[] { NEG_X, POS_X, NEG_Y, POS_Y }, 0.8F) {
@Override
public void calculateCornerWeights(float x, float y, float z, float[] out) {
final float u = y;
@@ -127,7 +105,7 @@ enum AoNeighborInfo {
return 1.0f - z;
}
},
WEST(new ForgeDirection[] { ForgeDirection.UP, ForgeDirection.DOWN, ForgeDirection.NORTH, ForgeDirection.SOUTH }, 0.6F) {
WEST(new ModelQuadFacing[] { POS_Y, NEG_Y, NEG_Z, POS_Z }, 0.6F) {
@Override
public void calculateCornerWeights(float x, float y, float z, float[] out) {
final float u = z;
@@ -157,11 +135,11 @@ enum AoNeighborInfo {
return x;
}
},
EAST(new ForgeDirection[] { ForgeDirection.DOWN, ForgeDirection.UP, ForgeDirection.NORTH, ForgeDirection.SOUTH }, 0.6F) {
DOWN(new ModelQuadFacing[] { NEG_X, POS_X, NEG_Z, POS_Z }, 0.5F) {
@Override
public void calculateCornerWeights(float x, float y, float z, float[] out) {
final float u = z;
final float v = 1.0f - y;
final float v = 1.0f - x;
out[0] = v * u;
out[1] = v * (1.0f - u);
@@ -171,20 +149,50 @@ enum AoNeighborInfo {
@Override
public void mapCorners(int[] lm0, float[] ao0, int[] lm1, float[] ao1) {
lm1[1] = lm0[0];
lm1[2] = lm0[1];
lm1[3] = lm0[2];
lm1[0] = lm0[3];
lm1[0] = lm0[0];
lm1[1] = lm0[1];
lm1[2] = lm0[2];
lm1[3] = lm0[3];
ao1[1] = ao0[0];
ao1[2] = ao0[1];
ao1[3] = ao0[2];
ao1[0] = ao0[3];
ao1[0] = ao0[0];
ao1[1] = ao0[1];
ao1[2] = ao0[2];
ao1[3] = ao0[3];
}
@Override
public float getDepth(float x, float y, float z) {
return 1.0f - x;
return y;
}
},
NORTH(new ModelQuadFacing[] { POS_Y, NEG_Y, POS_X, NEG_X }, 0.8F) {
@Override
public void calculateCornerWeights(float x, float y, float z, float[] out) {
final float u = 1.0f - x;
final float v = y;
out[0] = v * u;
out[1] = v * (1.0f - u);
out[2] = (1.0f - v) * (1.0f - u);
out[3] = (1.0f - v) * u;
}
@Override
public void mapCorners(int[] lm0, float[] ao0, int[] lm1, float[] ao1) {
lm1[3] = lm0[0];
lm1[0] = lm0[1];
lm1[1] = lm0[2];
lm1[2] = lm0[3];
ao1[3] = ao0[0];
ao1[0] = ao0[1];
ao1[1] = ao0[2];
ao1[2] = ao0[3];
}
@Override
public float getDepth(float x, float y, float z) {
return z;
}
};
@@ -192,7 +200,7 @@ enum AoNeighborInfo {
* The direction of each corner block from this face, which can be retrieved by offsetting the position of the origin
* block by the direction vector.
*/
public final ForgeDirection[] faces;
public final ModelQuadFacing[] faces;
/**
* The constant brightness modifier for this face. This data exists to emulate the results of the OpenGL lighting
@@ -200,7 +208,7 @@ enum AoNeighborInfo {
*/
public final float strength;
AoNeighborInfo(ForgeDirection[] directions, float strength) {
AoNeighborInfo(ModelQuadFacing[] directions, float strength) {
this.faces = directions;
this.strength = strength;
}
@@ -243,7 +251,7 @@ enum AoNeighborInfo {
/**
* @return Returns the {@link AoNeighborInfo} which corresponds with the specified direction
*/
public static AoNeighborInfo get(ForgeDirection direction) {
public static AoNeighborInfo get(@NotNull ModelQuadFacing direction) {
return VALUES[direction.ordinal()];
}
}
@@ -2,14 +2,14 @@ package me.jellysquid.mods.sodium.client.model.light.smooth;
import com.google.common.math.DoubleMath;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.ModelQuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFlags;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFlags;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import me.jellysquid.mods.sodium.client.model.light.LightPipeline;
import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess;
import me.jellysquid.mods.sodium.client.model.light.data.QuadLightData;
import net.coderbot.iris.block_rendering.BlockRenderingSettings;
import net.minecraftforge.common.util.ForgeDirection;
/**
@@ -71,7 +71,7 @@ public class SmoothLightPipeline implements LightPipeline {
}
@Override
public void calculate(ModelQuadView quad, BlockPos pos, QuadLightData out, ForgeDirection cullFace, ForgeDirection face, boolean shade) {
public void calculate(ModelQuadView quad, BlockPos pos, QuadLightData out, ModelQuadFacing cullFace, ModelQuadFacing face, boolean shade) {
this.updateCachedData(pos.asLong());
final int flags = quad.getFlags();
@@ -107,7 +107,7 @@ public class SmoothLightPipeline implements LightPipeline {
* have two contributing sides.
* Flags: IS_ALIGNED, !IS_PARTIAL
*/
private void applyAlignedFullFace(AoNeighborInfo neighborInfo, BlockPos pos, ForgeDirection dir, QuadLightData out) {
private void applyAlignedFullFace(AoNeighborInfo neighborInfo, BlockPos pos, ModelQuadFacing dir, QuadLightData out) {
final AoFaceData faceData = this.getCachedFaceData(pos, dir, true);
neighborInfo.mapCorners(faceData.lm, faceData.ao, out.lm, out.br);
}
@@ -116,7 +116,7 @@ public class SmoothLightPipeline implements LightPipeline {
* Calculates the light data for a grid-aligned quad that does not cover the entire block volume's face.
* Flags: IS_ALIGNED, IS_PARTIAL
*/
private void applyAlignedPartialFace(AoNeighborInfo neighborInfo, ModelQuadView quad, BlockPos pos, ForgeDirection dir, QuadLightData out) {
private void applyAlignedPartialFace(AoNeighborInfo neighborInfo, ModelQuadView quad, BlockPos pos, ModelQuadFacing dir, QuadLightData out) {
for (int i = 0; i < 4; i++) {
// Clamp the vertex positions to the block's boundaries to prevent weird errors in lighting
final float cx = clamp(quad.getX(i));
@@ -130,13 +130,13 @@ public class SmoothLightPipeline implements LightPipeline {
}
/**
* This method is the same as {@link #applyNonParallelFace(AoNeighborInfo, ModelQuadView, BlockPos, ForgeDirection,
* This method is the same as {@link #applyNonParallelFace(AoNeighborInfo, ModelQuadView, BlockPos, ModelQuadFacing,
* QuadLightData)} but with the check for a depth of approximately 0 removed. If the quad is parallel but not
* aligned, all of its vertices will have the same depth and this depth must be approximately greater than 0,
* meaning the check for 0 will always return false.
* Flags: !IS_ALIGNED, IS_PARALLEL
*/
private void applyParallelFace(AoNeighborInfo neighborInfo, ModelQuadView quad, BlockPos pos, ForgeDirection dir, QuadLightData out) {
private void applyParallelFace(AoNeighborInfo neighborInfo, ModelQuadView quad, BlockPos pos, ModelQuadFacing dir, QuadLightData out) {
for (int i = 0; i < 4; i++) {
// Clamp the vertex positions to the block's boundaries to prevent weird errors in lighting
final float cx = clamp(quad.getX(i));
@@ -163,7 +163,7 @@ public class SmoothLightPipeline implements LightPipeline {
/**
* Flags: !IS_ALIGNED, !IS_PARALLEL
*/
private void applyNonParallelFace(AoNeighborInfo neighborInfo, ModelQuadView quad, BlockPos pos, ForgeDirection dir, QuadLightData out) {
private void applyNonParallelFace(AoNeighborInfo neighborInfo, ModelQuadView quad, BlockPos pos, ModelQuadFacing dir, QuadLightData out) {
for (int i = 0; i < 4; i++) {
// Clamp the vertex positions to the block's boundaries to prevent weird errors in lighting
final float cx = clamp(quad.getX(i));
@@ -188,7 +188,7 @@ public class SmoothLightPipeline implements LightPipeline {
}
}
private void applyAlignedPartialFaceVertex(BlockPos pos, ForgeDirection dir, float[] w, int i, QuadLightData out, boolean offset) {
private void applyAlignedPartialFaceVertex(BlockPos pos, ModelQuadFacing dir, float[] w, int i, QuadLightData out, boolean offset) {
final AoFaceData faceData = this.getCachedFaceData(pos, dir, offset);
if (!faceData.hasUnpackedLightData()) {
@@ -203,7 +203,7 @@ public class SmoothLightPipeline implements LightPipeline {
out.lm[i] = getLightMapCoord(sl, bl);
}
private void applyInsetPartialFaceVertex(BlockPos pos, ForgeDirection dir, float n1d, float n2d, float[] w, int i, QuadLightData out) {
private void applyInsetPartialFaceVertex(BlockPos pos, ModelQuadFacing dir, float n1d, float n2d, float[] w, int i, QuadLightData out) {
final AoFaceData n1 = this.getCachedFaceData(pos, dir, false);
if (!n1.hasUnpackedLightData()) {
@@ -225,7 +225,7 @@ public class SmoothLightPipeline implements LightPipeline {
out.lm[i] = getLightMapCoord(sl, bl);
}
private void applySidedBrightness(QuadLightData out, ForgeDirection face, boolean shade) {
private void applySidedBrightness(QuadLightData out, ModelQuadFacing face, boolean shade) {
if(AngelicaConfig.enableIris && BlockRenderingSettings.INSTANCE.shouldDisableDirectionalShading()) {
return;
}
@@ -241,7 +241,7 @@ public class SmoothLightPipeline implements LightPipeline {
/**
* Returns the cached data for a given facing or calculates it if it hasn't been cached.
*/
private AoFaceData getCachedFaceData(BlockPos pos, ForgeDirection face, boolean offset) {
private AoFaceData getCachedFaceData(BlockPos pos, ModelQuadFacing face, boolean offset) {
final AoFaceData data = this.cachedFaceData[offset ? face.ordinal() : face.ordinal() + 6];
@@ -1,9 +1,9 @@
package me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.writer;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.ColorABGR;
import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer;
import me.jellysquid.mods.sodium.client.model.vertex.fallback.VertexWriterFallback;
import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.GlyphVertexSink;
import me.jellysquid.mods.sodium.client.util.color.ColorABGR;
public class GlyphVertexWriterFallback extends VertexWriterFallback implements GlyphVertexSink {
@@ -3,35 +3,8 @@ package me.jellysquid.mods.sodium.client.model.vertex.formats.line;
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat;
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat;
import me.jellysquid.mods.sodium.client.model.vertex.VertexSink;
import me.jellysquid.mods.sodium.client.util.color.ColorABGR;
public interface LineVertexSink extends VertexSink {
VertexFormat VERTEX_FORMAT = DefaultVertexFormat.POSITION_COLOR;
/**
* Writes a line vertex to the sink.
*
* @param x The x-position of the vertex
* @param y The y-position of the vertex
* @param z The z-position of the vertex
* @param color The ABGR-packed color of the vertex
*/
void vertexLine(float x, float y, float z, int color);
/**
* Writes a line vertex to the sink using unpacked normalized colors. This is slower than
* {@link LineVertexSink#vertexLine(float, float, float, int)} as it needs to pack the colors
* each call.
*
* @param x The x-position of the vertex
* @param y The y-position of the vertex
* @param z The z-position of the vertex
* @param r The normalized red component of the vertex's color
* @param g The normalized green component of the vertex's color
* @param b The normalized blue component of the vertex's color
* @param a The normalized alpha component of the vertex's color
*/
default void vertexLine(float x, float y, float z, float r, float g, float b, float a) {
this.vertexLine(x, y, z, ColorABGR.pack(r, g, b, a));
}
}
@@ -5,23 +5,9 @@ import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView;
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterNio;
import me.jellysquid.mods.sodium.client.model.vertex.formats.line.LineVertexSink;
import java.nio.ByteBuffer;
public class LineVertexBufferWriterNio extends VertexBufferWriterNio implements LineVertexSink {
public LineVertexBufferWriterNio(VertexBufferView backingBuffer) {
super(backingBuffer, VanillaVertexTypes.LINES);
}
@Override
public void vertexLine(float x, float y, float z, int color) {
int i = this.writeOffset;
ByteBuffer buffer = this.byteBuffer;
buffer.putFloat(i, x);
buffer.putFloat(i + 4, y);
buffer.putFloat(i + 8, z);
buffer.putInt(i + 12, color);
this.advance();
}
}
@@ -1,7 +1,5 @@
package me.jellysquid.mods.sodium.client.model.vertex.formats.line.writer;
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*;
import me.jellysquid.mods.sodium.client.model.vertex.VanillaVertexTypes;
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView;
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterUnsafe;
@@ -12,15 +10,4 @@ public class LineVertexBufferWriterUnsafe extends VertexBufferWriterUnsafe imple
super(backingBuffer, VanillaVertexTypes.LINES);
}
@Override
public void vertexLine(float x, float y, float z, int color) {
long i = this.writePointer;
memPutFloat(i, x);
memPutFloat(i + 4, y);
memPutFloat(i + 8, z);
memPutInt(i + 12, color);
this.advance();
}
}
@@ -3,7 +3,6 @@ package me.jellysquid.mods.sodium.client.model.vertex.formats.line.writer;
import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer;
import me.jellysquid.mods.sodium.client.model.vertex.fallback.VertexWriterFallback;
import me.jellysquid.mods.sodium.client.model.vertex.formats.line.LineVertexSink;
import me.jellysquid.mods.sodium.client.util.color.ColorABGR;
public class LineVertexWriterFallback extends VertexWriterFallback implements LineVertexSink {
@@ -11,11 +10,4 @@ public class LineVertexWriterFallback extends VertexWriterFallback implements Li
super(consumer);
}
@Override
public void vertexLine(float x, float y, float z, int color) {
VertexConsumer consumer = this.consumer;
consumer.vertex(x, y, z);
consumer.color(ColorABGR.unpackRed(color), ColorABGR.unpackGreen(color), ColorABGR.unpackBlue(color), ColorABGR.unpackAlpha(color));
consumer.next();
}
}
@@ -1,9 +1,9 @@
package me.jellysquid.mods.sodium.client.model.vertex.formats.particle.writer;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.ColorABGR;
import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer;
import me.jellysquid.mods.sodium.client.model.vertex.fallback.VertexWriterFallback;
import me.jellysquid.mods.sodium.client.model.vertex.formats.particle.ParticleVertexSink;
import me.jellysquid.mods.sodium.client.util.color.ColorABGR;
public class ParticleVertexWriterFallback extends VertexWriterFallback implements ParticleVertexSink {
@@ -1,10 +1,10 @@
package me.jellysquid.mods.sodium.client.model.vertex.formats.quad.writer;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.ColorABGR;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.NormI8;
import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer;
import me.jellysquid.mods.sodium.client.model.vertex.fallback.VertexWriterFallback;
import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.QuadVertexSink;
import me.jellysquid.mods.sodium.client.util.Norm3b;
import me.jellysquid.mods.sodium.client.util.color.ColorABGR;
public class QuadVertexWriterFallback extends VertexWriterFallback implements QuadVertexSink {
@@ -20,7 +20,7 @@ public class QuadVertexWriterFallback extends VertexWriterFallback implements Qu
consumer.texture(u, v);
consumer.overlay(overlay);
consumer.light(light);
consumer.normal(Norm3b.unpackX(normal), Norm3b.unpackY(normal), Norm3b.unpackZ(normal));
consumer.normal(NormI8.unpackX(normal), NormI8.unpackY(normal), NormI8.unpackZ(normal));
consumer.next();
}
}
@@ -1,9 +1,9 @@
package me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad.writer;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.ColorABGR;
import com.gtnewhorizons.angelica.compat.toremove.VertexConsumer;
import me.jellysquid.mods.sodium.client.model.vertex.fallback.VertexWriterFallback;
import me.jellysquid.mods.sodium.client.model.vertex.formats.screen_quad.BasicScreenQuadVertexSink;
import me.jellysquid.mods.sodium.client.util.color.ColorABGR;
public class BasicScreenQuadVertexWriterFallback extends VertexWriterFallback implements BasicScreenQuadVertexSink {
@@ -1,6 +1,11 @@
package me.jellysquid.mods.sodium.client.render.chunk;
import com.gtnewhorizon.gtnhlib.client.renderer.util.DirectionUtil;
import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.HORIZONTAL_DIRECTIONS;
import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.NEG_X;
import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.NEG_Z;
import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.POS_X;
import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.POS_Z;
import net.minecraftforge.common.util.ForgeDirection;
public class ChunkRenderColumn<T extends ChunkGraphicsState> {
@@ -48,7 +53,7 @@ public class ChunkRenderColumn<T extends ChunkGraphicsState> {
}
public boolean areNeighborsPresent() {
for (ForgeDirection dir : DirectionUtil.HORIZONTAL_DIRECTIONS) {
for (var dir : HORIZONTAL_DIRECTIONS) {
ChunkRenderColumn<T> adj = this.adjacent[dir.ordinal()];
if (adj == null) {
@@ -58,13 +63,13 @@ public class ChunkRenderColumn<T extends ChunkGraphicsState> {
ForgeDirection corner;
// Access the adjacent corner chunk from the neighbor in this direction
if (dir == ForgeDirection.NORTH) {
if (dir == NEG_Z) {
corner = ForgeDirection.EAST;
} else if (dir == ForgeDirection.SOUTH) {
} else if (dir == POS_Z) {
corner = ForgeDirection.WEST;
} else if (dir == ForgeDirection.WEST) {
} else if (dir == NEG_X) {
corner = ForgeDirection.NORTH;
} else if (dir == ForgeDirection.EAST) {
} else if (dir == POS_X) {
corner = ForgeDirection.SOUTH;
} else {
continue;
@@ -1,9 +1,17 @@
package me.jellysquid.mods.sodium.client.render.chunk.backends.multidraw;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import it.unimi.dsi.fastutil.objects.ObjectArrayFIFOQueue;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import lombok.Setter;
import me.jellysquid.mods.sodium.client.gl.arena.GlBufferArena;
import me.jellysquid.mods.sodium.client.gl.arena.GlBufferSegment;
@@ -42,15 +50,6 @@ import net.minecraft.util.EnumChatFormatting;
import net.minecraft.util.Util;
import org.lwjgl.opengl.GL11;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Shader-based chunk renderer which makes use of a custom memory allocator on top of large buffer objects to allow
* for draw call batching without buffer switching.
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.render.chunk.backends.multidraw;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import me.jellysquid.mods.sodium.client.gl.arena.GlBufferSegment;
import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexFormat;
import me.jellysquid.mods.sodium.client.gl.device.CommandList;
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.render.chunk.backends.oneshot;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexAttributeBinding;
import me.jellysquid.mods.sodium.client.gl.attribute.GlVertexFormat;
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.render.chunk.backends.oneshot;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import me.jellysquid.mods.sodium.client.gl.device.CommandList;
import me.jellysquid.mods.sodium.client.gl.device.DrawCommandList;
import me.jellysquid.mods.sodium.client.gl.device.RenderDevice;
@@ -1,8 +1,10 @@
package me.jellysquid.mods.sodium.client.render.chunk.compile;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import it.unimi.dsi.fastutil.objects.Object2IntMap;
import java.nio.ByteBuffer;
import java.util.Map;
import lombok.Getter;
import me.jellysquid.mods.sodium.client.SodiumClientMod;
import me.jellysquid.mods.sodium.client.gl.buffer.VertexData;
@@ -24,9 +26,6 @@ import net.coderbot.iris.sodium.block_context.ContextAwareVertexWriter;
import net.minecraft.block.Block;
import org.lwjgl.BufferUtils;
import java.nio.ByteBuffer;
import java.util.Map;
/**
* A collection of temporary buffers for each worker thread which will be used to build chunk meshes for given render
* passes. This makes a best-effort attempt to pick a suitable size for each scratch buffer, but will never try to
@@ -46,10 +46,13 @@ public class ChunkBuilder<T extends ChunkGraphicsState> {
private static final Logger LOGGER = LogManager.getLogger("ChunkBuilder");
private final Deque<WrappedTask<T>> buildQueue = new ConcurrentLinkedDeque<>();
// special queue for tasks that will block until the main thread finalizes them
private final Deque<WrappedTask<T>> buildQueueKnownBlocking = new ConcurrentLinkedDeque<>();
private final Deque<ChunkBuildResult<T>> uploadQueue = new ConcurrentLinkedDeque<>();
private final Deque<Throwable> failureQueue = new ConcurrentLinkedDeque<>();
private final Object jobNotifier = new Object();
private final Object jobNotifierKnownBlocking = new Object();
private final AtomicBoolean running = new AtomicBoolean(false);
private final List<Thread> threads = new ArrayList<>();
@@ -60,6 +63,7 @@ public class ChunkBuilder<T extends ChunkGraphicsState> {
private Vector3d cameraPosition = new Vector3d();
private final int limitThreads;
private final int limitThreadsBlocking;
private final ChunkVertexType vertexType;
private final ChunkRenderBackend<T> backend;
@@ -67,6 +71,7 @@ public class ChunkBuilder<T extends ChunkGraphicsState> {
this.vertexType = vertexType;
this.backend = backend;
this.limitThreads = getThreadCount();
this.limitThreadsBlocking = this.limitThreads;
}
/**
@@ -74,7 +79,7 @@ public class ChunkBuilder<T extends ChunkGraphicsState> {
* spawn more tasks than the budget allows, it will block until resources become available.
*/
public int getSchedulingBudget() {
return Math.max(0, (this.limitThreads * TASK_QUEUE_LIMIT_PER_WORKER) - this.buildQueue.size());
return Math.max(0, (this.limitThreads * TASK_QUEUE_LIMIT_PER_WORKER) - this.buildQueue.size() - this.buildQueueKnownBlocking.size());
}
/**
@@ -96,7 +101,7 @@ public class ChunkBuilder<T extends ChunkGraphicsState> {
ChunkBuildBuffers buffers = new ChunkBuildBuffers(this.vertexType);
ChunkRenderCacheLocal pipeline = new ChunkRenderCacheLocal(client, this.world);
WorkerRunnable worker = new WorkerRunnable(buffers, pipeline);
WorkerRunnable worker = new WorkerRunnable(i, buffers, pipeline, this.world, false);
Thread thread = new Thread(worker, "Chunk Render Task Executor #" + i);
thread.setPriority(Math.max(0, Thread.NORM_PRIORITY - 2));
@@ -105,6 +110,19 @@ public class ChunkBuilder<T extends ChunkGraphicsState> {
this.threads.add(thread);
}
for (int i = 0; i < this.limitThreadsBlocking; i++) {
ChunkBuildBuffers buffers = new ChunkBuildBuffers(this.vertexType);
ChunkRenderCacheLocal pipeline = new ChunkRenderCacheLocal(client, this.world);
WorkerRunnable worker = new WorkerRunnable(this.limitThreads + i, buffers, pipeline, this.world, true);
Thread thread = new Thread(worker, "Chunk Render Blocking Task Executor #" + i);
thread.setPriority(Math.max(0, Thread.NORM_PRIORITY - 2));
thread.start();
this.threads.add(thread);
}
LOGGER.info("Started {} worker threads", this.threads.size());
}
@@ -137,6 +155,9 @@ public class ChunkBuilder<T extends ChunkGraphicsState> {
synchronized (this.jobNotifier) {
this.jobNotifier.notifyAll();
}
synchronized (this.jobNotifierKnownBlocking) {
this.jobNotifierKnownBlocking.notifyAll();
}
// Keep processing the main thread tasks so the workers don't block forever
AngelicaRenderQueue.managedBlock(() -> !workersAlive());
@@ -159,7 +180,12 @@ public class ChunkBuilder<T extends ChunkGraphicsState> {
job.future.cancel(true);
}
for (WrappedTask<?> job : this.buildQueueKnownBlocking) {
job.future.cancel(true);
}
this.buildQueue.clear();
this.buildQueueKnownBlocking.clear();
this.world = null;
this.sectionCache = null;
@@ -200,7 +226,7 @@ public class ChunkBuilder<T extends ChunkGraphicsState> {
if (this.uploadQueue.isEmpty()) {
return false;
}
this.backend.upload(RenderDevice.INSTANCE.createCommandList(), filterChunkBuilds(new DequeDrain<>(this.uploadQueue)));
return true;
@@ -256,7 +282,7 @@ public class ChunkBuilder<T extends ChunkGraphicsState> {
* @return True if the build queue is empty
*/
public boolean isBuildQueueEmpty() {
return this.buildQueue.isEmpty();
return this.buildQueue.isEmpty() && this.buildQueueKnownBlocking.isEmpty();
}
/**
@@ -388,9 +414,18 @@ public class ChunkBuilder<T extends ChunkGraphicsState> {
// caches between different CPU cores
private final ChunkRenderCacheLocal cache;
public WorkerRunnable(ChunkBuildBuffers bufferCache, ChunkRenderCacheLocal cache) {
private final WorldClient world;
private final int i;
private final boolean allowBlocking;
public WorkerRunnable(int i, ChunkBuildBuffers bufferCache, ChunkRenderCacheLocal cache, WorldClient world, boolean allowBlocking) {
this.i = i;
this.bufferCache = bufferCache;
this.cache = cache;
this.world = world;
this.allowBlocking = allowBlocking;
}
@Override
@@ -404,6 +439,15 @@ public class ChunkBuilder<T extends ChunkGraphicsState> {
continue;
}
// Relegate tasks that can block for an extended period of time to a separate threadpool.
if (!this.allowBlocking && job.task.willRenderInMainThread(this.cache)) {
ChunkBuilder.this.buildQueueKnownBlocking.add(job);
synchronized (ChunkBuilder.this.jobNotifierKnownBlocking) {
ChunkBuilder.this.jobNotifierKnownBlocking.notify();
}
continue;
}
ChunkBuildResult<T> result;
try {
@@ -435,18 +479,33 @@ public class ChunkBuilder<T extends ChunkGraphicsState> {
* currently available, it will wait on {@link ChunkBuilder#jobNotifier} field until notified.
*/
private WrappedTask<T> getNextJob() {
WrappedTask<T> job = ChunkBuilder.this.buildQueue.poll();
if (this.allowBlocking) {
WrappedTask<T> job = ChunkBuilder.this.buildQueueKnownBlocking.poll();
if (job == null) {
synchronized (ChunkBuilder.this.jobNotifier) {
try {
ChunkBuilder.this.jobNotifier.wait();
} catch (InterruptedException ignored) {
if (job == null) {
synchronized (ChunkBuilder.this.jobNotifierKnownBlocking) {
try {
ChunkBuilder.this.jobNotifierKnownBlocking.wait();
} catch (InterruptedException ignored) {
}
}
}
}
return job;
return job;
} else {
WrappedTask<T> job = ChunkBuilder.this.buildQueue.poll();
if (job == null) {
synchronized (ChunkBuilder.this.jobNotifier) {
try {
ChunkBuilder.this.jobNotifier.wait();
} catch (InterruptedException ignored) {
}
}
}
return job;
}
}
}
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.render.chunk.compile.buffers;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData;
import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink;
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.render.chunk.compile.buffers;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData;
import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink;
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.render.chunk.compile.buffers;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData;
import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink;
@@ -1,14 +1,14 @@
package me.jellysquid.mods.sodium.client.render.chunk.cull;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
public class ChunkFaceFlags {
public static final int UP = of(ModelQuadFacing.UP);
public static final int DOWN = of(ModelQuadFacing.DOWN);
public static final int WEST = of(ModelQuadFacing.WEST);
public static final int EAST = of(ModelQuadFacing.EAST);
public static final int NORTH = of(ModelQuadFacing.NORTH);
public static final int SOUTH = of(ModelQuadFacing.SOUTH);
public static final int UP = of(ModelQuadFacing.POS_Y);
public static final int DOWN = of(ModelQuadFacing.NEG_Y);
public static final int WEST = of(ModelQuadFacing.NEG_X);
public static final int EAST = of(ModelQuadFacing.POS_X);
public static final int NORTH = of(ModelQuadFacing.NEG_Z);
public static final int SOUTH = of(ModelQuadFacing.POS_Z);
public static final int UNASSIGNED = of(ModelQuadFacing.UNASSIGNED);
public static final int ALL = all();
@@ -1,11 +1,10 @@
package me.jellysquid.mods.sodium.client.render.chunk.data;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFacing;
import me.jellysquid.mods.sodium.client.gl.buffer.VertexData;
import me.jellysquid.mods.sodium.client.gl.util.BufferSlice;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import java.util.EnumMap;
import java.util.Map;
import me.jellysquid.mods.sodium.client.gl.buffer.VertexData;
import me.jellysquid.mods.sodium.client.gl.util.BufferSlice;
public class ChunkMeshData {
public static final ChunkMeshData EMPTY = new ChunkMeshData();
@@ -1,17 +1,10 @@
package me.jellysquid.mods.sodium.client.render.chunk.data;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import com.gtnewhorizons.angelica.compat.mojang.ChunkOcclusionData;
import com.gtnewhorizons.angelica.mixins.interfaces.ISpriteExt;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
import lombok.Getter;
import me.jellysquid.mods.sodium.client.gl.util.BufferSlice;
import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.EnumMap;
@@ -19,6 +12,12 @@ import java.util.EnumSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import lombok.Getter;
import me.jellysquid.mods.sodium.client.gl.util.BufferSlice;
import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;
/**
* The render data for a chunk render container containing all the information about which meshes are attached, the
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.render.chunk.region;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import me.jellysquid.mods.sodium.client.gl.arena.GlBufferArena;
import me.jellysquid.mods.sodium.client.gl.device.CommandList;
@@ -32,6 +32,7 @@ public abstract class ChunkRenderBuildTask<T extends ChunkGraphicsState> {
public abstract ChunkBuildResult<T> performBuild(ChunkRenderCacheLocal cache, ChunkBuildBuffers buffers,
CancellationSource cancellationSource);
public boolean willRenderInMainThread(ChunkRenderCacheLocal cache) { return false; };
/**
* Called on the main render thread when the task's execution returns. The implementation should release any
* resources it's still holding onto at this point.
@@ -1,7 +1,6 @@
package me.jellysquid.mods.sodium.client.render.chunk.tasks;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import com.gtnewhorizon.gtnhlib.client.renderer.util.WorldUtil;
import com.gtnewhorizons.angelica.compat.ModStatus;
import com.gtnewhorizons.angelica.compat.mojang.ChunkOcclusionDataBuilder;
import com.gtnewhorizons.angelica.compat.toremove.RenderLayer;
@@ -11,6 +10,9 @@ import com.gtnewhorizons.angelica.rendering.AngelicaBlockSafetyRegistry;
import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue;
import com.gtnewhorizons.angelica.utils.AnimationsRenderUtils;
import it.unimi.dsi.fastutil.longs.LongArrayFIFOQueue;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import me.jellysquid.mods.sodium.client.SodiumClientMod;
import me.jellysquid.mods.sodium.client.render.chunk.ChunkGraphicsState;
import me.jellysquid.mods.sodium.client.render.chunk.ChunkRenderContainer;
@@ -21,6 +23,7 @@ import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkMeshData;
import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderBounds;
import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData;
import me.jellysquid.mods.sodium.client.render.chunk.passes.BlockRenderPass;
import me.jellysquid.mods.sodium.client.render.pipeline.WorldUtil;
import me.jellysquid.mods.sodium.client.render.pipeline.context.ChunkRenderCacheLocal;
import me.jellysquid.mods.sodium.client.util.MathUtil;
import me.jellysquid.mods.sodium.client.util.task.CancellationSource;
@@ -40,10 +43,6 @@ import net.minecraft.util.IIcon;
import net.minecraftforge.fluids.Fluid;
import org.joml.Vector3d;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
/**
* Rebuilds all the meshes of a chunk for each given render pass with non-occluded blocks. The result is then uploaded
* to graphics memory on the main thread.
@@ -62,13 +61,15 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
private final boolean translucencySorting;
private boolean hasMainThreadBlocks = false;
private boolean hasMainThreadBlocksComputed = false;
public ChunkRenderRebuildTask(ChunkRenderContainer<T> render, ChunkRenderContext context, BlockPos offset) {
this.render = render;
this.offset = offset;
this.context = context;
this.camera = new Vector3d();
this.translucencySorting = SodiumClientMod.options().advanced.translucencySorting;
}
public ChunkRenderRebuildTask<T> withCameraPosition(Vector3d camera) {
@@ -123,6 +124,48 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
return canRender;
}
public boolean willRenderInMainThread(ChunkRenderCacheLocal cache) {
if (hasMainThreadBlocksComputed)
return hasMainThreadBlocks;
final ChunkRenderData.Builder renderData = new ChunkRenderData.Builder();
final ChunkOcclusionDataBuilder occluder = new ChunkOcclusionDataBuilder();
final ChunkRenderBounds.Builder bounds = new ChunkRenderBounds.Builder();
cache.init(this.context);
final WorldSlice slice = cache.getWorldSlice();
final int baseX = this.render.getOriginX();
final int baseY = this.render.getOriginY();
final int baseZ = this.render.getOriginZ();
final BlockPos pos = new BlockPos();
outer:
for (int relY = 0; relY < 16; relY++) {
for (int relZ = 0; relZ < 16; relZ++) {
for (int relX = 0; relX < 16; relX++) {
final Block block = slice.getBlockRelative(relX + 16, relY + 16, relZ + 16);
// If the block is vanilla air, assume it renders nothing. Don't use isAir because mods
// can abuse it for all sorts of things
if (block.getMaterial() == Material.air) {
continue;
}
if (!rendersOffThread(block)) {
hasMainThreadBlocks = true;
break outer;
}
}
}
}
hasMainThreadBlocksComputed = true;
return hasMainThreadBlocks;
}
@Override
public ChunkBuildResult<T> performBuild(ChunkRenderCacheLocal cache, ChunkBuildBuffers buffers, CancellationSource cancellationSource) {
final ChunkRenderData.Builder renderData = new ChunkRenderData.Builder();
@@ -148,7 +191,6 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
final BlockPos renderOffset = this.offset;
final LongArrayFIFOQueue mainThreadBlocks = new LongArrayFIFOQueue();
boolean hasMainThreadBlocks = false;
for (int relY = 0; relY < 16; relY++) {
if (cancellationSource.isCancelled()) {
@@ -186,7 +228,7 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
ChunkRenderManager.setWorldRenderPass(pass);
if(AngelicaConfig.enableIris) buffers.iris$setMaterialId(fluid.getBlock(), ExtendedDataHelper.FLUID_RENDER_TYPE);
cache.getBlockRenderer().renderFluidLogged(fluid, renderBlocks, pos, buffers.get(pass), seed);
cache.getBlockRenderer().renderFluidLogged(cache.getWorldSlice(), fluid, renderBlocks, pos, buffers.get(pass), seed);
}
}
if (canRenderInPass(block, pass) && !shouldUseSodiumFluidRendering(block)) {
@@ -243,6 +285,7 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
handleRenderBlocksTextures(renderBlocks, renderData);
hasMainThreadBlocksComputed = true;
if(hasMainThreadBlocks) {
// Render the other blocks on the main thread
var future = CompletableFuture.runAsync(() -> this.performMainBuild(cache, buffers, cancellationSource, bounds, renderData, mainThreadBlocks), AngelicaRenderQueue.executor());
@@ -351,6 +394,8 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
+ camera
+ ", translucencySorting="
+ translucencySorting
+ ", hasMainThreadBlocks="
+ hasMainThreadBlocks
+ '}';
}
@@ -1,7 +1,7 @@
package me.jellysquid.mods.sodium.client.render.chunk.tasks;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import me.jellysquid.mods.sodium.client.gl.buffer.VertexData;
import me.jellysquid.mods.sodium.client.gl.util.BufferSlice;
import me.jellysquid.mods.sodium.client.render.chunk.ChunkGraphicsState;
@@ -1,10 +1,10 @@
package me.jellysquid.mods.sodium.client.render.occlusion;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import it.unimi.dsi.fastutil.objects.Object2ByteLinkedOpenHashMap;
import net.minecraft.block.Block;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
public class BlockOcclusionCache {
private static final byte UNCACHED_VALUE = (byte) 127;
@@ -25,12 +25,12 @@ public class BlockOcclusionCache {
* @param facing The facing direction of the side to check
* @return True if the block side facing {@param dir} is not occluded, otherwise false
*/
public boolean shouldDrawSide(Block block, int meta, IBlockAccess view, BlockPos pos, ForgeDirection facing) {
if (facing == ForgeDirection.UNKNOWN)
public boolean shouldDrawSide(Block block, int meta, IBlockAccess view, BlockPos pos, ModelQuadFacing facing) {
if (facing == ModelQuadFacing.UNASSIGNED)
return true;
final BlockPos adjPos = this.cpos;
adjPos.set(pos.getX() + facing.offsetX, pos.getY() + facing.offsetY, pos.getZ() + facing.offsetZ);
adjPos.set(pos.getX() + facing.getStepX(), pos.getY() + facing.getStepY(), pos.getZ() + facing.getStepZ());
final Block adjState = view.getBlock(adjPos.x, adjPos.y, adjPos.z);
@@ -3,27 +3,23 @@ package me.jellysquid.mods.sodium.client.render.pipeline;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import com.gtnewhorizon.gtnhlib.client.renderer.CapturingTessellator;
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadProvider;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.QuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadOrientation;
import com.gtnewhorizon.gtnhlib.client.renderer.util.DirectionUtil;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.ColorMixer;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadViewMutable;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadOrientation;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.util.ModelQuadUtil;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.mixins.interfaces.ModeledBlock;
import com.gtnewhorizons.angelica.utils.ObjectPooler;
import java.util.List;
import java.util.Random;
import me.jellysquid.mods.sodium.client.SodiumClientMod;
import me.jellysquid.mods.sodium.client.model.light.LightMode;
import me.jellysquid.mods.sodium.client.model.light.LightPipeline;
import me.jellysquid.mods.sodium.client.model.light.LightPipelineProvider;
import me.jellysquid.mods.sodium.client.model.light.data.QuadLightData;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.Quad;
import me.jellysquid.mods.sodium.client.render.chunk.compile.buffers.ChunkModelBuffers;
import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData;
import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink;
import me.jellysquid.mods.sodium.client.render.occlusion.BlockOcclusionCache;
import me.jellysquid.mods.sodium.client.util.ModelQuadUtil;
import me.jellysquid.mods.sodium.client.util.color.ColorABGR;
import me.jellysquid.mods.sodium.client.util.rand.XoRoShiRoRandom;
import net.coderbot.iris.block_rendering.BlockRenderingSettings;
import net.minecraft.block.Block;
@@ -31,12 +27,8 @@ import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import java.util.List;
import java.util.Random;
public class BlockRenderer {
private static final BlockPos POS_ZERO = new BlockPos(0, 0, 0);
@@ -49,10 +41,6 @@ public class BlockRenderer {
private boolean useSeparateAo;
private final LightPipelineProvider lighters;
private final BlockOcclusionCache occlusionCache;
private final ObjectPooler<QuadView> quadPool = new ObjectPooler<>(Quad::new);
// TODO: Use modern model API, and store them here
public BlockRenderer(LightPipelineProvider lighters) {
@@ -60,10 +48,9 @@ public class BlockRenderer {
// TODO: Sodium - AO Setting
this.useAmbientOcclusion = Minecraft.getMinecraft().gameSettings.ambientOcclusion > 0;
this.useSodiumAO = SodiumClientMod.options().quality.useSodiumAO;
this.occlusionCache = new BlockOcclusionCache();
}
public boolean renderFluidLogged(Fluid fluid, RenderBlocks renderBlocks, BlockPos pos, ChunkModelBuffers buffers, long seed) {
public boolean renderFluidLogged(IBlockAccess world, Fluid fluid, RenderBlocks renderBlocks, BlockPos pos, ChunkModelBuffers buffers, long seed) {
if (fluid == null) {
return false;
}
@@ -73,6 +60,7 @@ public class BlockRenderer {
}
boolean rendered = false;
final int emitted = block.getLightValue(world, pos.x, pos.y, pos.z);
try {
final LightMode mode = LightMode.SMOOTH; // TODO: this.getLightingMode(block); is what was previously used. The flat pipeline is busted and was only an optimization for very few blocks.
@@ -86,12 +74,12 @@ public class BlockRenderer {
tess.setOffset(POS_ZERO);
tess.setTranslation(-pos.x, -pos.y, -pos.z);
renderBlocks.renderBlockByRenderType(block, pos.x, pos.y, pos.z);
final List<QuadView> quads = TessellatorManager.stopCapturingToPooledQuads();
final var quads = TessellatorManager.stopCapturingToPooledQuads();
tess.resetOffset();
for (ModelQuadFacing facing : ModelQuadFacing.VALUES) {
this.random.setSeed(seed);
this.renderQuadList(pos, lighter, buffers, quads, facing, (this.useAmbientOcclusion && this.useSodiumAO));
this.renderQuadList(pos, lighter, emitted, buffers, quads, facing, (this.useAmbientOcclusion && this.useSodiumAO));
}
if (!quads.isEmpty()) rendered = true;
@@ -110,60 +98,34 @@ public class BlockRenderer {
boolean rendered = false;
this.useSeparateAo = AngelicaConfig.enableIris && BlockRenderingSettings.INSTANCE.shouldUseSeparateAo();
final int emitted = block.getLightValue(world, pos.x, pos.y, pos.z);
final QuadProvider model = ((ModeledBlock) block).getModel();
if (model != null) {
final int color = model.getColor(world, pos, block, meta, random);
for (ForgeDirection dir : DirectionUtil.ALL_DIRECTIONS) {
try {
TessellatorManager.startCapturing();
final CapturingTessellator tess = (CapturingTessellator) TessellatorManager.get();
tess.startDrawingQuads();
// Use setTranslation rather than setOffset so that the float data written to the internal buffer
// is done in subchunk-relative coordinates
tess.setOffset(POS_ZERO);
tess.setTranslation(-pos.x, -pos.y, -pos.z);
renderBlocks.renderBlockByRenderType(block, pos.x, pos.y, pos.z);
final var quads = TessellatorManager.stopCapturingToPooledQuads();
tess.resetOffset();
for (ModelQuadFacing facing : ModelQuadFacing.VALUES) {
this.random.setSeed(seed);
List<QuadView> quads;
if (!cull || this.occlusionCache.shouldDrawSide(block, meta, world, pos, dir)) {
quads = model.getQuads(world, pos, block, meta, dir, random, color, this.quadPool::getInstance);
if (quads.isEmpty()) continue;
this.renderQuadList(pos, lighter, buffers, quads, ModelQuadFacing.fromDirection(dir), true);
rendered = true;
if (model.isDynamic())
for (QuadView q : quads) this.quadPool.releaseInstance(q);
}
this.renderQuadList(pos, lighter, emitted, buffers, quads, facing, (this.useAmbientOcclusion && this.useSodiumAO));
}
} else {
try {
TessellatorManager.startCapturing();
final CapturingTessellator tess = (CapturingTessellator) TessellatorManager.get();
tess.startDrawingQuads();
// Use setTranslation rather than setOffset so that the float data written to the internal buffer
// is done in subchunk-relative coordinates
tess.setOffset(POS_ZERO);
tess.setTranslation(-pos.x, -pos.y, -pos.z);
renderBlocks.renderBlockByRenderType(block, pos.x, pos.y, pos.z);
final List<QuadView> quads = TessellatorManager.stopCapturingToPooledQuads();
tess.resetOffset();
for (ModelQuadFacing facing : ModelQuadFacing.VALUES) {
this.random.setSeed(seed);
this.renderQuadList(pos, lighter, buffers, quads, facing, (this.useAmbientOcclusion && this.useSodiumAO));
}
if (!quads.isEmpty()) rendered = true;
} finally {
TessellatorManager.cleanup();
}
if (!quads.isEmpty()) rendered = true;
} finally {
TessellatorManager.cleanup();
}
return rendered;
}
private void renderQuadList(BlockPos pos, LightPipeline lighter, ChunkModelBuffers buffers, List<QuadView> quads, ModelQuadFacing facing, boolean useSodiumLight) {
final ForgeDirection cullFace = ModelQuadFacing.toDirection(facing);
private void renderQuadList(BlockPos pos, LightPipeline lighter, int emitted, ChunkModelBuffers buffers, List<ModelQuadViewMutable> quads, ModelQuadFacing facing, boolean useSodiumLight) {
final ModelVertexSink sink = buffers.getSink(facing);
sink.ensureCapacity(quads.size() * 4);
@@ -172,25 +134,25 @@ public class BlockRenderer {
// This is a very hot allocation, iterate over it manually
// noinspection ForLoopReplaceableByForEach
for (int i = 0, quadsSize = quads.size(); i < quadsSize; i++) {
final QuadView quad = quads.get(i);
final var quad = quads.get(i);
final QuadLightData light = this.cachedQuadLightData;
if (quad.getFace() != cullFace)
if (quad.getNormalFace() != facing)
continue;
if (useSodiumLight || this.useSeparateAo)
lighter.calculate(quad, pos, light, cullFace, quad.getLightFace(), quad.isShade());
lighter.calculate(quad, pos, light, facing, quad.getLightFace(), quad.hasAmbientOcclusion());
this.renderQuad(sink, quad, light, renderData, useSodiumLight);
this.renderQuad(sink, quad, emitted, light, renderData, useSodiumLight);
}
sink.flush();
}
private void renderQuad(ModelVertexSink sink, QuadView quad, QuadLightData light, ChunkRenderData.Builder renderData, boolean useSodiumLight) {
private void renderQuad(ModelVertexSink sink, ModelQuadView quad, int emitted, QuadLightData light, ChunkRenderData.Builder renderData, boolean useSodiumLight) {
final ModelQuadOrientation order = (useSodiumLight || this.useSeparateAo) ? ModelQuadOrientation.orient(light.br) : ModelQuadOrientation.NORMAL;
final ModelQuadOrientation order = (useSodiumLight || this.useSeparateAo) ? ModelQuadOrientation.orientByBrightness(light.br, light.lm) : ModelQuadOrientation.NORMAL;
int shaderBlockId = quad.getShaderBlockId();
for (int dstIndex = 0; dstIndex < 4; dstIndex++) {
@@ -207,60 +169,23 @@ public class BlockRenderer {
color |= ((int) (ao * 255.0f)) << 24;
} else {
color = (useSodiumLight) ? ColorABGR.mul(quad.getColor(srcIndex), light.br[srcIndex]) : quad.getColor(srcIndex);
color = (useSodiumLight) ? ColorMixer.mulSingleWithoutAlpha(quad.getColor(srcIndex), (int)(light.br[srcIndex] * 255)) : quad.getColor(srcIndex);
}
final float u = quad.getTexU(srcIndex);
final float v = quad.getTexV(srcIndex);
final int lm = (useSeparateAo) ? ModelQuadUtil.mergeBakedLight(quad.getLight(srcIndex), light.lm[srcIndex]) :
final int lm = (useSeparateAo) ? ModelQuadUtil.mergeBakedLight(quad.getLight(srcIndex), emitted, light.lm[srcIndex]) :
(useSodiumLight) ? light.lm[srcIndex] : quad.getLight(srcIndex);
sink.writeQuad(x, y, z, color, u, v, lm, shaderBlockId);
}
final TextureAtlasSprite sprite = quad.rubidium$getSprite();
final TextureAtlasSprite sprite = (TextureAtlasSprite) quad.celeritas$getSprite();
if (sprite != null) {
renderData.addSprite(sprite);
}
}
public static class Flags {
boolean hasTexture;
public boolean hasBrightness;
public boolean hasColor;
public boolean hasNormals;
public Flags(byte flags) {
hasTexture = (flags & 1) != 0;
hasBrightness = (flags & 2) != 0;
hasColor = (flags & 4) != 0;
hasNormals = (flags & 8) != 0;
}
public Flags(boolean hasTexture, boolean hasBrightness, boolean hasColor, boolean hasNormals) {
this.hasTexture = hasTexture;
this.hasBrightness = hasBrightness;
this.hasColor = hasColor;
this.hasNormals = hasNormals;
}
public byte toByte() {
byte flags = 0;
if(hasTexture) {
flags |= 1;
}
if(hasBrightness) {
flags |= 2;
}
if(hasColor) {
flags |= 4;
}
if(hasNormals) {
flags |= 8;
}
return flags;
}
}
}
@@ -1,23 +1,27 @@
package me.jellysquid.mods.sodium.client.render.pipeline;
import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.HORIZONTAL_DIRECTIONS;
import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.NEG_Y;
import static com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing.POS_Y;
import static org.joml.Math.lerp;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.ModelQuad;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.ModelQuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.ModelQuadViewMutable;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.quad.properties.ModelQuadFlags;
import com.gtnewhorizon.gtnhlib.client.renderer.util.DirectionUtil;
import com.gtnewhorizon.gtnhlib.client.renderer.util.WorldUtil;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.ColorARGB;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.ColorMixer;
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.ModelQuadView;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.ModelQuadViewMutable;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFlags;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import java.util.Arrays;
import me.jellysquid.mods.sodium.client.model.light.LightMode;
import me.jellysquid.mods.sodium.client.model.light.LightPipeline;
import me.jellysquid.mods.sodium.client.model.light.LightPipelineProvider;
import me.jellysquid.mods.sodium.client.model.light.data.QuadLightData;
import me.jellysquid.mods.sodium.client.render.chunk.compile.buffers.ChunkModelBuffers;
import me.jellysquid.mods.sodium.client.render.chunk.format.ModelVertexSink;
import me.jellysquid.mods.sodium.client.util.Norm3b;
import me.jellysquid.mods.sodium.client.util.color.ColorABGR;
import me.jellysquid.mods.sodium.client.util.color.ColorARGB;
import me.jellysquid.mods.sodium.client.world.WorldSlice;
import net.coderbot.iris.block_rendering.BlockRenderingSettings;
import net.minecraft.block.Block;
@@ -29,10 +33,6 @@ import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import org.joml.Vector3d;
import java.util.Arrays;
import static org.joml.Math.lerp;
public class FluidRenderer {
private static final float EPSILON = 0.001f;
private final LightPipelineProvider lpp;
@@ -48,10 +48,10 @@ public class FluidRenderer {
private final TextureAtlasSprite missingTex = Minecraft.getMinecraft().getTextureMapBlocks().getAtlasSprite("minecraft:missing");
public FluidRenderer(LightPipelineProvider lpp) {
int normal = Norm3b.pack(0.0f, 1.0f, 0.0f);
int normal = NormI8.pack(0.0f, 1.0f, 0.0f);
for (int i = 0; i < 4; i++) {
this.quad.setNormal(i, normal);
this.quad.setForgeNormal(i, normal);
}
this.lpp = lpp;
@@ -69,8 +69,8 @@ public class FluidRenderer {
return tmp;
}
private boolean isSideExposed(IBlockAccess world, int x, int y, int z, ForgeDirection dir, float height) {
BlockPos pos = this.scratchPos.set(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ);
private boolean isSideExposed(IBlockAccess world, int x, int y, int z, ModelQuadFacing dir, float height) {
BlockPos pos = this.scratchPos.set(x + dir.getStepX(), y + dir.getStepY(), z + dir.getStepZ());
Block block = world.getBlock(pos.x, pos.y, pos.z);
if (block.getMaterial().isOpaque()) {
@@ -79,7 +79,7 @@ public class FluidRenderer {
// Hoist these checks to avoid allocating the shape below
if (renderAsFullCube) {
// The top face always be inset, so if the shape above is a full cube it can't possibly occlude
return dir == ForgeDirection.UP;
return dir == POS_Y;
} else {
return true;
}
@@ -102,7 +102,7 @@ public class FluidRenderer {
// Check for occluded sides; if everything is occluded, don't render
boolean sfUp = this.isFluidOccluded(world, posX, posY, posZ, ForgeDirection.UP, fluid);
boolean sfDown = this.isFluidOccluded(world, posX, posY, posZ, ForgeDirection.DOWN, fluid) ||
!this.isSideExposed(world, posX, posY, posZ, ForgeDirection.DOWN, 0.8888889F);
!this.isSideExposed(world, posX, posY, posZ, NEG_Y, 0.8888889F);
boolean sfNorth = this.isFluidOccluded(world, posX, posY, posZ, ForgeDirection.NORTH, fluid);
boolean sfSouth = this.isFluidOccluded(world, posX, posY, posZ, ForgeDirection.SOUTH, fluid);
boolean sfWest = this.isFluidOccluded(world, posX, posY, posZ, ForgeDirection.WEST, fluid);
@@ -142,7 +142,7 @@ public class FluidRenderer {
quad.setFlags(0);
if (!sfUp && this.isSideExposed(world, posX, posY, posZ, ForgeDirection.UP, Math.min(Math.min(h1, h2), Math.min(h3, h4)))) {
if (!sfUp && this.isSideExposed(world, posX, posY, posZ, POS_Y, Math.min(Math.min(h1, h2), Math.min(h3, h4)))) {
h1 -= 0.001F;
h2 -= 0.001F;
h3 -= 0.001F;
@@ -157,7 +157,7 @@ public class FluidRenderer {
if (velocity.x == 0.0D && velocity.z == 0.0D) {
sprite = sprites[0];
facing = ModelQuadFacing.UP;
facing = ModelQuadFacing.POS_Y;
u1 = sprite.getInterpolatedU(0.0D);
v1 = sprite.getInterpolatedV(0.0D);
u2 = u1;
@@ -204,7 +204,7 @@ public class FluidRenderer {
this.setVertex(quad, 2, 1.0F, h3, 1.0F, u3, v3);
this.setVertex(quad, 3, 1.0F, h4, 0.0f, u4, v4);
this.calculateQuadColors(quad, pos, lighter, ForgeDirection.UP, 1.0F, hc, slice);
this.calculateQuadColors(quad, pos, lighter, POS_Y, 1.0F, hc, slice);
this.flushQuad(buffers, quad, facing, false);
if (WorldUtil.method_15756(slice, this.scratchPos.set(posX, posY + 1, posZ), fluid)) {
@@ -213,7 +213,7 @@ public class FluidRenderer {
this.setVertex(quad, 1, 1.0F, h3, 1.0F, u3, v3);
this.setVertex(quad, 0, 1.0F, h4, 0.0f, u4, v4);
this.flushQuad(buffers, quad, ModelQuadFacing.DOWN, true);
this.flushQuad(buffers, quad, ModelQuadFacing.NEG_Y, true);
}
rendered = true;
@@ -233,15 +233,15 @@ public class FluidRenderer {
this.setVertex(quad, 2, 1.0F, yOffset, 0.0f, maxU, minV);
this.setVertex(quad, 3, 1.0F, yOffset, 1.0F, maxU, maxV);
this.calculateQuadColors(quad, pos, lighter, ForgeDirection.DOWN, 1.0F, hc, slice);
this.flushQuad(buffers, quad, ModelQuadFacing.DOWN, false);
this.calculateQuadColors(quad, pos, lighter, NEG_Y, 1.0F, hc, slice);
this.flushQuad(buffers, quad, ModelQuadFacing.NEG_Y, false);
rendered = true;
}
quad.setFlags(ModelQuadFlags.IS_ALIGNED);
for (ForgeDirection dir : DirectionUtil.HORIZONTAL_DIRECTIONS) {
for (var facing : HORIZONTAL_DIRECTIONS) {
float c1;
float c2;
float x1;
@@ -249,8 +249,8 @@ public class FluidRenderer {
float x2;
float z2;
switch (dir) {
case NORTH:
switch (facing) {
case NEG_Z:
if (sfNorth) {
continue;
}
@@ -262,7 +262,7 @@ public class FluidRenderer {
z1 = 0.001f;
z2 = z1;
break;
case SOUTH:
case POS_Z:
if (sfSouth) {
continue;
}
@@ -274,7 +274,7 @@ public class FluidRenderer {
z1 = 0.999f;
z2 = z1;
break;
case WEST:
case NEG_X:
if (sfWest) {
continue;
}
@@ -286,7 +286,7 @@ public class FluidRenderer {
z1 = 1.0F;
z2 = 0.0f;
break;
case EAST:
case POS_X:
if (sfEast) {
continue;
}
@@ -302,10 +302,10 @@ public class FluidRenderer {
continue;
}
if (this.isSideExposed(world, posX, posY, posZ, dir, Math.max(c1, c2))) {
int adjX = posX + dir.offsetX;
int adjY = posY + dir.offsetY;
int adjZ = posZ + dir.offsetZ;
if (this.isSideExposed(world, posX, posY, posZ, facing, Math.max(c1, c2))) {
int adjX = posX + facing.getStepX();
int adjY = posY + facing.getStepY();
int adjZ = posZ + facing.getStepZ();
TextureAtlasSprite sprite = sprites[1];
TextureAtlasSprite oSprite = sprites[2];
@@ -333,11 +333,9 @@ public class FluidRenderer {
this.setVertex(quad, 2, x1, yOffset, z1, u1, v3);
this.setVertex(quad, 3, x1, c1, z1, u1, v1);
float br = dir.offsetZ != 0 ? 0.8F : 0.6F;
float br = facing.getStepZ() != 0 ? 0.8F : 0.6F;
ModelQuadFacing facing = ModelQuadFacing.fromDirection(dir);
this.calculateQuadColors(quad, pos, lighter, dir, br, hc, slice);
this.calculateQuadColors(quad, pos, lighter, facing, br, hc, slice);
this.flushQuad(buffers, quad, facing, false);
if (sprite != oSprite) {
@@ -356,7 +354,7 @@ public class FluidRenderer {
return rendered;
}
private void calculateQuadColors(ModelQuadView quad, BlockPos pos, LightPipeline lighter, ForgeDirection dir, float brightness, boolean colorized, WorldSlice slice) {
private void calculateQuadColors(ModelQuadView quad, BlockPos pos, LightPipeline lighter, ModelQuadFacing dir, float brightness, boolean colorized, WorldSlice slice) {
QuadLightData light = this.quadLightData;
lighter.calculate(quad, pos, light, null, dir, false);
@@ -372,7 +370,7 @@ public class FluidRenderer {
color &= 0x00FFFFFF;
color |= ((int) (ao * 255.0f)) << 24;
} else {
color = ColorABGR.mul(color, ao);
color = ColorMixer.mulSingleWithoutAlpha(color, (int)(ao * 255));
}
this.quadColors[i] = color;
}
@@ -410,7 +408,7 @@ public class FluidRenderer {
vertexIdx += lightOrder;
}
TextureAtlasSprite sprite = quad.rubidium$getSprite();
TextureAtlasSprite sprite = (TextureAtlasSprite) quad.celeritas$getSprite();
if (sprite != null) {
buffers.getRenderData().addSprite(sprite);
@@ -0,0 +1,149 @@
package me.jellysquid.mods.sodium.client.render.pipeline;
import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import net.minecraft.block.Block;
import net.minecraft.block.BlockLiquid;
import net.minecraft.block.material.Material;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidRegistry;
import net.minecraftforge.fluids.IFluidBlock;
import org.joml.Vector3d;
/**
* Contains methods stripped from BlockState or FluidState that didn't actually need to be there. Technically these
* could be a mixin to Block or Fluid, but that's annoying while not actually providing any benefit.
*/
public class WorldUtil {
public static Vector3d getVelocity(IBlockAccess world, int x, int y, int z, Block thizz) {
Vector3d velocity = new Vector3d();
int decay = getEffectiveFlowDecay(world, x, y, z, thizz);
for (var dire : ModelQuadFacing.HORIZONTAL_DIRECTIONS) {
int adjX = x + dire.getStepX();
int adjZ = z + dire.getStepZ();
int adjDecay = getEffectiveFlowDecay(world, adjX, y, adjZ, thizz);
if (adjDecay < 0) {
if (!world.getBlock(adjX, y, adjZ).getMaterial().blocksMovement()) {
adjDecay = getEffectiveFlowDecay(world, adjX, y - 1, adjZ, thizz);
if (adjDecay >= 0) {
adjDecay -= (decay - 8);
velocity = velocity.add((adjX - x) * adjDecay, 0, (adjZ - z) * adjDecay);
}
}
} else {
adjDecay -= decay;
velocity = velocity.add((adjX - x) * adjDecay, 0, (adjZ - z) * adjDecay);
}
}
if (world.getBlockMetadata(x, y, z) >= 8) {
if (thizz.isBlockSolid(world, x, y, z - 1, 2) || thizz.isBlockSolid(world, x, y, z + 1, 3)
|| thizz.isBlockSolid(world, x - 1, y, z, 4)
|| thizz.isBlockSolid(world, x + 1, y, z, 5)
|| thizz.isBlockSolid(world, x, y + 1, z - 1, 2)
|| thizz.isBlockSolid(world, x, y + 1, z + 1, 3)
|| thizz.isBlockSolid(world, x - 1, y + 1, z, 4)
|| thizz.isBlockSolid(world, x + 1, y + 1, z, 5)) {
velocity = velocity.normalize().add(0.0D, -6.0D, 0.0D);
}
}
if (velocity.x == 0 && velocity.y == 0 && velocity.z == 0) return velocity.zero();
return velocity.normalize();
}
/**
* Returns true if any block in a 3x3x3 cube is not the same fluid and not an opaque full cube. Equivalent to
* FluidState::method_15756 in modern.
*/
public static boolean method_15756(IBlockAccess world, BlockPos pos, Fluid fluid) {
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
Block block = world.getBlock(pos.x, pos.y, pos.z);
if (!block.isOpaqueCube() && getFluid(block) != fluid) {
return true;
}
}
}
return false;
}
/**
* Returns fluid height as a percentage of the block; 0 is none and 1 is full.
*/
public static float getFluidHeight(Fluid fluid, int meta) {
return fluid == null ? 0 : 1 - BlockLiquid.getLiquidHeightPercent(meta);
}
/**
* Returns the flow decay but converts values indicating falling liquid (values >=8) to their effective source block
* value of zero
*/
public static int getEffectiveFlowDecay(IBlockAccess world, int x, int y, int z, Block thiz) {
if (world.getBlock(x, y, z).getMaterial() != thiz.getMaterial()) {
return -1;
} else {
int decay = world.getBlockMetadata(x, y, z);
return decay >= 8 ? 0 : decay;
}
}
// I believe forge mappings in modern say BreakableBlock, while yarn says TransparentBlock.
// I have a sneaking suspicion isOpaque is neither, but it works for now
public static boolean shouldDisplayFluidOverlay(Block block) {
return !block.getMaterial().isOpaque() || block.getMaterial() == Material.leaves;
}
public static boolean isFluidBlock(Block block) {
return block instanceof IFluidBlock || block instanceof BlockLiquid;
}
public static Fluid getFluid(Block b) {
if (b instanceof IFluidBlock fluidBlock) return fluidBlock.getFluid();
if (b instanceof BlockLiquid) {
if (b.getMaterial() == Material.water) return FluidRegistry.WATER;
if (b.getMaterial() == Material.lava) return FluidRegistry.LAVA;
}
return null;
}
/**
* Equivalent to method_15748 in 1.16.5
*/
public static boolean isEmptyOrSame(Fluid fluid, Fluid otherFluid) {
return otherFluid == null || fluid == otherFluid;
}
/**
* Equivalent to method_15749 in 1.16.5
*/
public static boolean method_15749(IBlockAccess world, Fluid thiz, BlockPos pos, ForgeDirection dir) {
Block b = world.getBlock(pos.x, pos.y, pos.z);
Fluid f = getFluid(b);
if (f == thiz) {
return false;
}
if (dir == ForgeDirection.UP) {
return true;
}
return b.getMaterial() != Material.ice && b.isSideSolid(world, pos.x, pos.y, pos.z, dir);
}
}
@@ -24,7 +24,4 @@ public class MathUtil {
return (a + b + 1) * (a + b) / 2 + b;
}
public static boolean fuzzy_eq(float a, float b) {
return Math.abs(a - b) < 1e-5;
}
}
@@ -1,79 +0,0 @@
package me.jellysquid.mods.sodium.client.util;
import net.minecraftforge.common.util.ForgeDirection;
/**
* Provides some utilities and constants for interacting with vanilla's model quad vertex format.
*
* This is the current vertex format used by Minecraft for chunk meshes and model quads. Internally, it uses integer
* arrays for store baked quad data, and as such the following table provides both the byte and int indices.
*
* Byte Index Integer Index Name Format Fields
* 0 ..11 0..2 Position 3 floats x, y, z
* 12..15 3 Color 4 unsigned bytes a, r, g, b
* 16..23 4..5 Block Texture 2 floats u, v
* 24..27 6 Light Texture 2 shorts u, v
* 28..30 7 Normal 3 unsigned bytes x, y, z
* 31 Padding 1 byte
*/
public class ModelQuadUtil {
// Integer indices for vertex attributes, useful for accessing baked quad data
public static final int POSITION_INDEX = 0,
COLOR_INDEX = 3,
TEXTURE_INDEX = 4,
LIGHT_INDEX = 6,
NORMAL_INDEX = 7;
// Size of vertex format in 4-byte integers
public static final int VERTEX_SIZE = 8;
public static final int VERTEX_SIZE_BYTES = VERTEX_SIZE * 4;
// Cached array of normals for every facing to avoid expensive computation
static final int[] NORMALS = new int[ForgeDirection.VALID_DIRECTIONS.length];
static {
for (int i = 0; i < NORMALS.length; i++) {
final ForgeDirection dir = ForgeDirection.VALID_DIRECTIONS[i];
NORMALS[i] = Norm3b.pack(dir.offsetX, dir.offsetY, dir.offsetZ);
}
}
/**
* Returns the normal vector for a model quad with the given {@param facing}.
*/
public static int getFacingNormal(ForgeDirection facing) {
return NORMALS[facing.ordinal()];
}
public static int getFacingNormal(ForgeDirection facing, int bakedNormal) {
if(!hasNormal(bakedNormal))
return NORMALS[facing.ordinal()];
return bakedNormal;
}
public static boolean hasNormal(int n) {
return (n & 0xFFFFFF) != 0;
}
/**
* @param vertexIndex The index of the vertex to access
* @return The starting offset of the vertex's attributes
*/
public static int vertexOffset(int vertexIndex) {
return vertexIndex * VERTEX_SIZE;
}
public static int mergeBakedLight(int packedLight, int calcLight) {
// bail early in most cases
if (packedLight == 0)
return calcLight;
final int psl = (packedLight >> 16) & 0xFF;
final int csl = (calcLight >> 16) & 0xFF;
final int pbl = (packedLight) & 0xFF;
final int cbl = (calcLight) & 0xFF;
final int bl = Math.max(pbl, cbl);
final int sl = Math.max(psl, csl);
return (sl << 16) | bl;
}
}
@@ -1,82 +0,0 @@
package me.jellysquid.mods.sodium.client.util;
import net.minecraft.util.MathHelper;
import org.joml.Vector3f;
import org.joml.Vector3i;
/**
* Provides some utilities for working with packed normal vectors. Each getNormal component provides 8 bits of
* precision in the range of [-1.0,1.0].
*
* | 32 | 24 | 16 | 8 |
* | 0000 0000 | 0110 1100 | 0110 1100 | 0110 1100 |
* | Padding | X | Y | Z |
*/
public class Norm3b {
/**
* The maximum value of a getNormal's vector component.
*/
private static final float COMPONENT_RANGE = 127.0f;
/**
* Constant value which can be multiplied with a floating-point vector component to get the normalized value. The
* multiplication is slightly faster than a floating point division, and this code is a hot path which justifies it.
*/
private static final float NORM = 1.0f / COMPONENT_RANGE;
static int pack(Vector3i norm) {
return pack(norm.x, norm.y, norm.z);
}
public static int pack(Vector3f dir) {
return pack(dir.x, dir.y, dir.z);
}
/**
* Packs the specified vector components into a 32-bit integer in XYZ ordering with the 8 bits of padding at the
* end.
* @param x The x component of the getNormal's vector
* @param y The y component of the getNormal's vector
* @param z The z component of the getNormal's vector
*/
public static int pack(float x, float y, float z) {
int normX = encode(x);
int normY = encode(y);
int normZ = encode(z);
return (normZ << 16) | (normY << 8) | normX;
}
/**
* Encodes a float in the range of -1.0..1.0 to a normalized unsigned integer in the range of 0..255 which can then
* be passed to graphics memory.
*/
private static int encode(float comp) {
// TODO: is the clamp necessary here? our inputs should always be normalized vector components
return ((int) (MathHelper.clamp_float(comp, -1.0F, 1.0F) * COMPONENT_RANGE) & 255);
}
/**
* Unpacks the x-component of the packed getNormal, denormalizing it to a float in the range of -1.0..1.0.
* @param norm The packed getNormal
*/
public static float unpackX(int norm) {
return ((byte) (norm & 0xFF)) * NORM;
}
/**
* Unpacks the y-component of the packed getNormal, denormalizing it to a float in the range of -1.0..1.0.
* @param norm The packed getNormal
*/
public static float unpackY(int norm) {
return ((byte) ((norm >> 8) & 0xFF)) * NORM;
}
/**
* Unpacks the z-component of the packed getNormal, denormalizing it to a float in the range of -1.0..1.0.
* @param norm The packed getNormal
*/
public static float unpackZ(int norm) {
return ((byte) ((norm >> 16) & 0xFF)) * NORM;
}
}
@@ -1,84 +0,0 @@
package me.jellysquid.mods.sodium.client.util.color;
/**
* Provides some utilities for packing and unpacking color components from packed integer colors in ABGR format, which
* is used by OpenGL for color vectors.
*
* | 32 | 24 | 16 | 8 |
* | 0110 1100 | 0110 1100 | 0110 1100 | 0110 1100 |
* | Alpha | Blue | Green | Red |
*/
public class ColorABGR implements ColorU8 {
/**
* Packs the specified color components into ABGR format.
* @param r The red component of the color
* @param g The green component of the color
* @param b The blue component of the color
* @param a The alpha component of the color
*/
public static int pack(int r, int g, int b, int a) {
return (a & 0xFF) << 24 | (b & 0xFF) << 16 | (g & 0xFF) << 8 | (r & 0xFF);
}
/**
* @see ColorABGR#pack(int, int, int, int)
*/
public static int pack(float r, float g, float b, float a) {
return pack((int) (r * COMPONENT_RANGE), (int) (g * COMPONENT_RANGE), (int) (b * COMPONENT_RANGE), (int) (a * COMPONENT_RANGE));
}
/**
* Multiplies the RGB components of the packed ABGR color using the given scale factors.
* @param color The ABGR packed color to be multiplied
* @param rw The red component scale factor
* @param gw The green component scale factor
* @param bw The blue component scale factor
*/
public static int mul(int color, float rw, float gw, float bw) {
float r = unpackRed(color) * rw;
float g = unpackGreen(color) * gw;
float b = unpackBlue(color) * bw;
return pack((int) r, (int) g, (int) b, 0xFF);
}
public static int mul(int color, float w) {
return mul(color, w, w, w);
}
/**
* @param color The packed 32-bit ABGR color to unpack
* @return The red color component in the range of 0..255
*/
public static int unpackRed(int color) {
return color & 0xFF;
}
/**
* @param color The packed 32-bit ABGR color to unpack
* @return The green color component in the range of 0..255
*/
public static int unpackGreen(int color) {
return color >> 8 & 0xFF;
}
/**
* @param color The packed 32-bit ABGR color to unpack
* @return The blue color component in the range of 0..255
*/
public static int unpackBlue(int color) {
return color >> 16 & 0xFF;
}
/**
* @param color The packed 32-bit ABGR color to unpack
* @return The red color component in the range of 0..255
*/
public static int unpackAlpha(int color) {
return color >> 24 & 0xFF;
}
public static int pack(float r, float g, float b) {
return pack(r, g, b, 255);
}
}
@@ -1,66 +0,0 @@
package me.jellysquid.mods.sodium.client.util.color;
/**
* Provides some utilities for packing and unpacking color components from packed integer colors in ARGB format. This
* packed format is used by most of Minecraft, but special care must be taken to pack it into ABGR format before passing
* it to OpenGL attributes.
*
* | 32 | 24 | 16 | 8 |
* | 0110 1100 | 0110 1100 | 0110 1100 | 0110 1100 |
* | Alpha | Red | Green | Blue |
*/
public class ColorARGB implements ColorU8 {
/**
* Packs the specified color components into big-endian format for consumption by OpenGL.
* @param r The red component of the color
* @param g The green component of the color
* @param b The blue component of the color
* @param a The alpha component of the color
*/
public static int pack(int r, int g, int b, int a) {
return (a & 0xFF) << 24 | (r & 0xFF) << 16 | (g & 0xFF) << 8 | (b & 0xFF);
}
/**
* @param color The packed 32-bit ARGB color to unpack
* @return The red color component in the range of 0..255
*/
public static int unpackAlpha(int color) {
return color >> 24 & 0xFF;
}
/**
* @param color The packed 32-bit ARGB color to unpack
* @return The red color component in the range of 0..255
*/
public static int unpackRed(int color) {
return color >> 16 & 0xFF;
}
/**
* @param color The packed 32-bit ARGB color to unpack
* @return The green color component in the range of 0..255
*/
public static int unpackGreen(int color) {
return color >> 8 & 0xFF;
}
/**
* @param color The packed 32-bit ARGB color to unpack
* @return The blue color component in the range of 0..255
*/
public static int unpackBlue(int color) {
return color & 0xFF;
}
/**
* Re-packs the ARGB color into a aBGR color with the specified alpha component.
*/
public static int toABGR(int color, int alpha) {
return Integer.reverseBytes(color << 8 | alpha);
}
public static int toABGR(int color) {
return Integer.reverseBytes(color << 8);
}
}
@@ -1,40 +0,0 @@
package me.jellysquid.mods.sodium.client.util.color;
public class ColorMixer {
private static final long MASK1 = 0x00FF00FF;
private static final long MASK2 = 0xFF00FF00;
/**
* Mixes two ARGB colors using the given ratios. Use {@link ColorMixer#getStartRatio(float)} and
* {@link ColorMixer#getEndRatio(float)} to convert a floating-point ratio into a integer ratio.
*
* This method takes 64-bit inputs to avoid overflows when mixing the alpha channel. The helper method
* {@link ColorMixer#mixARGB(int, int, int, int)} can be used with 32-bit inputs.
*
* @param c1 The first (starting) color to blend with in ARGB format
* @param c2 The second (ending) color to blend with in ARGB format
* @param f1 The ratio of the color {@param c1} as calculated by {@link ColorMixer#getStartRatio(float)}
* @param f2 The ratio of the color {@param c2} as calculated by {@link ColorMixer#getEndRatio(float)}
* @return The result of ((c1 * f1) + (c2 * f2) as an ARGB-encoded color
*/
public static long mixARGB(long c1, long c2, int f1, int f2) {
return ((((((c1 & MASK1) * f1) + ((c2 & MASK1) * f2)) >> 8) & MASK1) |
(((((c1 & MASK2) * f1) + ((c2 & MASK2) * f2)) >> 8) & MASK2));
}
/**
* Helper method to convert 32-bit integers to 64-bit integers and back.
* @see ColorMixer#mixARGB(long, long, int, int)
*/
public static int mixARGB(int c1, int c2, int f1, int f2) {
return (int) mixARGB(Integer.toUnsignedLong(c1), Integer.toUnsignedLong(c2), f1, f2);
}
public static int getStartRatio(float frac) {
return (int) (256 * frac);
}
public static int getEndRatio(float frac) {
return 256 - getStartRatio(frac);
}
}
@@ -1,21 +0,0 @@
package me.jellysquid.mods.sodium.client.util.color;
public interface ColorU8 {
/**
* The maximum value of a color component.
*/
float COMPONENT_RANGE = 255.0f;
/**
* Constant value which can be multiplied with a floating-point color component to get the normalized value. The
* multiplication is slightly faster than a floating point division, and this code is a hot path which justifies it.
*/
float NORM = 1.0f / COMPONENT_RANGE;
/**
* Normalizes a color component to the range of 0..1.
*/
static float normalize(float v) {
return v * NORM;
}
}
@@ -1,94 +0,0 @@
package me.jellysquid.mods.sodium.client.util.color;
import net.minecraft.util.MathHelper;
import org.joml.Vector3d;
import java.util.function.Function;
import static org.joml.Math.lerp;
public class FastCubicSampler {
private static final double[] DENSITY_CURVE = new double[] { 0.0D, 1.0D, 4.0D, 6.0D, 4.0D, 1.0D, 0.0D };
private static final int DIAMETER = 6;
private static Vector3d unpackRgb(int rgb) {
return new Vector3d((rgb >> 16 & 255) / 255.0, (rgb >> 8 & 255) / 255.0, (rgb & 255) / 255.0);
}
public static Vector3d sampleColor(Vector3d pos, ColorFetcher colorFetcher, Function<Vector3d, Vector3d> transformer) {
int intX = MathHelper.floor_double(pos.x);
int intY = MathHelper.floor_double(pos.y);
int intZ = MathHelper.floor_double(pos.z);
int[] values = new int[DIAMETER * DIAMETER * DIAMETER];
for(int x = 0; x < DIAMETER; ++x) {
int blockX = (intX - 2) + x;
for(int y = 0; y < DIAMETER; ++y) {
int blockY = (intY - 2) + y;
for(int z = 0; z < DIAMETER; ++z) {
int blockZ = (intZ - 2) + z;
values[index(x, y, z)] = colorFetcher.fetch(blockX, blockY, blockZ);
}
}
}
// Fast path! Skip blending the colors if all inputs are the same
if (isHomogenousArray(values)) {
// Take the first color if it's homogenous (all elements are the same...)
return transformer.apply(unpackRgb(values[0]));
}
double deltaX = pos.x - (double)intX;
double deltaY = pos.y - (double)intY;
double deltaZ = pos.z - (double)intZ;
Vector3d sum = new Vector3d();
double totalFactor = 0.0D;
for(int x = 0; x < DIAMETER; ++x) {
double densityX = lerp(DENSITY_CURVE[x + 1], DENSITY_CURVE[x], deltaX);
for(int y = 0; y < DIAMETER; ++y) {
double densityY = lerp(DENSITY_CURVE[y + 1], DENSITY_CURVE[y], deltaY);
for(int z = 0; z < DIAMETER; ++z) {
double densityZ = lerp(DENSITY_CURVE[z + 1], DENSITY_CURVE[z], deltaZ);
double factor = densityX * densityY * densityZ;
totalFactor += factor;
Vector3d color = transformer.apply(unpackRgb(values[index(x, y, z)]));
sum.add(color.mul(factor));
}
}
}
sum.mul(1.0D / totalFactor);
return sum;
}
private static int index(int x, int y, int z) {
return (DIAMETER * DIAMETER * z) + (DIAMETER * y) + x;
}
public interface ColorFetcher {
int fetch(int x, int y, int z);
}
private static boolean isHomogenousArray(int[] arr) {
int val = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] != val) {
return false;
}
}
return true;
}
}
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.util.math;
import me.jellysquid.mods.sodium.client.util.Norm3b;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.NormI8;
import net.minecraftforge.common.util.ForgeDirection;
import org.joml.Matrix3f;
import org.joml.Matrix4f;
@@ -21,14 +21,14 @@ public class MatrixUtil {
public static int transformPackedNormal(int norm, Matrix3f matrix) {
Matrix3fExtended mat = MatrixUtil.getExtendedMatrix(matrix);
float normX1 = Norm3b.unpackX(norm);
float normY1 = Norm3b.unpackY(norm);
float normZ1 = Norm3b.unpackZ(norm);
float normX1 = NormI8.unpackX(norm);
float normY1 = NormI8.unpackY(norm);
float normZ1 = NormI8.unpackZ(norm);
float normX2 = mat.transformVecX(normX1, normY1, normZ1);
float normY2 = mat.transformVecY(normX1, normY1, normZ1);
float normZ2 = mat.transformVecZ(normX1, normY1, normZ1);
return Norm3b.pack(normX2, normY2, normZ2);
return NormI8.pack(normX2, normY2, normZ2);
}
}
@@ -61,7 +61,7 @@ public class XoRoShiRoRandom extends Random {
return (int) this.nextLong(n);
}
private long nextLong(final long n) {
public long nextLong(final long n) {
if (n <= 0) {
throw new IllegalArgumentException("illegal bound " + n + " (must be positive)");
}
@@ -147,4 +147,4 @@ public class XoRoShiRoRandom extends Random {
return this;
}
}
}
@@ -1,13 +1,13 @@
package me.jellysquid.mods.sodium.client.world;
import java.util.Arrays;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.model.quad.properties.ModelQuadFacing;
import com.gtnewhorizons.angelica.api.IBlockAccessExtended;
import com.gtnewhorizons.angelica.compat.ModStatus;
import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos;
import com.gtnewhorizons.angelica.compat.mojang.CompatMathHelper;
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
import cpw.mods.fml.common.Optional;
import java.util.Arrays;
import lombok.Getter;
import me.jellysquid.mods.sodium.client.world.cloned.ChunkRenderContext;
import me.jellysquid.mods.sodium.client.world.cloned.ClonedChunkSection;
@@ -19,7 +19,6 @@ import net.minecraft.init.Blocks;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.MathHelper;
import net.minecraft.world.EnumSkyBlock;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.chunk.Chunk;
@@ -464,17 +463,17 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess {
return z << TABLE_BITS | x;
}
// Modern checks if the sky is darkened, which only happens in the nether. However, I think 1.7.10's hasNoSky is
// close enough.
public float getBrightness(ForgeDirection direction, boolean shaded) {
/// Modern checks if the sky is darkened, which only happens in the nether. However, I think 1.7.10's hasNoSky is
/// close enough.
public float getBrightness(ModelQuadFacing direction, boolean shaded) {
if (!shaded) {
return world.provider.hasNoSky ? 0.9f : 1.0f;
}
return switch (direction) {
case DOWN -> 0.5f;
case UP -> 1.0f;
case NORTH, SOUTH -> 0.8f;
case NEG_Y -> 0.5f;
case POS_Y -> 1.0f;
case NEG_Z, POS_Z -> 0.8f;
default -> 0.6f;
};
}
@@ -203,43 +203,45 @@ public class ProgramUniforms {
final int size = sizeType.get(0);
final int type = sizeType.get(1);
UniformType provided = uniformNames.get(name);
final UniformType provided = uniformNames.get(name);
final UniformType expected = getExpectedType(type);
if (provided == null && !name.startsWith("gl_")) {
final String typeName = getTypeName(type);
if(AngelicaConfig.enableHardcodedCustomUniforms) {
// Legacy Checks from hardcoded custom uniforms
if (provided == null && !name.startsWith("gl_")) {
final String typeName = getTypeName(type);
if (isSampler(type) || isImage(type)) {
// don't print a warning, samplers and images are managed elsewhere.
// TODO: Detect unsupported samplers/images?
continue;
}
if (isSampler(type) || isImage(type)) {
// don't print a warning, samplers and images are managed elsewhere.
continue;
}
final UniformType externalProvided = externalUniformNames.get(name);
final UniformType externalProvided = externalUniformNames.get(name);
if (externalProvided != null) {
if (externalProvided != expected) {
String expectedName;
if (externalProvided != null) {
if (externalProvided != expected) {
final String expectedName;
if (expected != null) {
expectedName = expected.toString();
} else {
expectedName = "(unsupported type: " + getTypeName(type) + ")";
if (expected != null) {
expectedName = expected.toString();
} else {
expectedName = "(unsupported type: " + getTypeName(type) + ")";
}
Iris.logger.error("[" + this.name + "] Wrong uniform type for externally-managed uniform " + name + ": " + externalProvided + " is provided but the program expects " + expectedName + ".");
}
Iris.logger.error("[" + this.name + "] Wrong uniform type for externally-managed uniform " + name + ": " + externalProvided + " is provided but the program expects " + expectedName + ".");
continue;
}
if (size == 1) {
Iris.logger.warn("[" + this.name + "] Unsupported uniform: " + typeName + " " + name);
} else {
Iris.logger.warn("[" + this.name + "] Unsupported uniform: " + name + " of size " + size + " and type " + typeName);
}
continue;
}
if (size == 1) {
Iris.logger.warn("[" + this.name + "] Unsupported uniform: " + typeName + " " + name);
} else {
Iris.logger.warn("[" + this.name + "] Unsupported uniform: " + name + " of size " + size + " and type " + typeName);
}
continue;
}
if (provided != null && provided != expected) {
@@ -291,6 +293,7 @@ public class ProgramUniforms {
return switch(type) {
case GL11.GL_FLOAT -> "float";
case GL11.GL_INT -> "int";
case GL20.GL_BOOL -> "bool";
case GL20.GL_FLOAT_MAT4 -> "mat4";
case GL20.GL_FLOAT_VEC4 -> "vec4";
case GL20.GL_FLOAT_MAT3 -> "mat3";
@@ -316,12 +319,13 @@ public class ProgramUniforms {
return switch (type) {
case GL11.GL_FLOAT -> UniformType.FLOAT;
case GL11.GL_INT -> UniformType.INT;
case GL20.GL_BOOL -> UniformType.INT;
case GL20.GL_FLOAT_MAT4 -> UniformType.MAT4;
case GL20.GL_FLOAT_VEC4 -> UniformType.VEC4;
case GL20.GL_INT_VEC4 -> UniformType.VEC4I;
case GL20.GL_FLOAT_VEC3 -> UniformType.VEC3;
case GL20.GL_FLOAT_MAT3 -> null;
case GL20.GL_INT_VEC3 -> null;
case GL20.GL_FLOAT_MAT3 -> UniformType.MAT3;
case GL20.GL_INT_VEC3 -> UniformType.VEC3I;
case GL20.GL_FLOAT_MAT2 -> null;
case GL20.GL_FLOAT_VEC2 -> UniformType.VEC2;
case GL20.GL_INT_VEC2 -> UniformType.VEC2I;
@@ -3,11 +3,13 @@ package net.coderbot.iris.gl.shader;
import com.google.common.collect.ImmutableList;
import com.gtnewhorizons.angelica.Tags;
import cpw.mods.fml.common.Loader;
import net.coderbot.iris.parsing.BiomeCategories;
import net.coderbot.iris.pipeline.HandRenderer;
import net.coderbot.iris.pipeline.WorldRenderingPhase;
import net.coderbot.iris.shaderpack.StringPair;
import net.coderbot.iris.texture.format.TextureFormat;
import net.coderbot.iris.texture.format.TextureFormatLoader;
import net.coderbot.iris.uniforms.VanillaBiomeList;
import org.lwjgl.LWJGLUtil;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL20;
@@ -88,6 +90,9 @@ public class StandardMacros {
define(standardDefines, irisDefine);
}
getBiomeCategoryDefines().forEach((category, ordinal) -> define(standardDefines, category, ordinal));
getVanillaBiomeDefines().forEach((biome, id) -> define(standardDefines, biome, id));
return ImmutableList.copyOf(standardDefines);
}
@@ -98,7 +103,7 @@ public class StandardMacros {
* @see <a href="https://github.com/sp614x/optifine/blob/9c6a5b5326558ccc57c6490b66b3be3b2dc8cbef/OptiFineDoc/doc/shaders.txt#L696-L699">Optifine Doc</a>
*/
public static String getMcVersion() {
final String version = Loader.MC_VERSION;;
final String version = Loader.MC_VERSION;
String[] splitVersion = version.split("\\.");
@@ -117,10 +122,10 @@ public class StandardMacros {
}
if (minor.length() == 1) {
minor = 0 + minor;
minor = "0" + minor;
}
if (bugfix.length() == 1) {
bugfix = 0 + bugfix;
bugfix = "0" + bugfix;
}
return major + minor + bugfix;
@@ -283,4 +288,47 @@ public class StandardMacros {
return defines;
}
/**
* Returns biome category defines for use in shaders.
* Generates #define CAT_<CATEGORY_NAME> <ordinal> for each BiomeCategories enum value.
*
* @return Map of biome category defines and their ordinal values
*/
public static Map<String, String> getBiomeCategoryDefines() {
Map<String, String> defines = new HashMap<>();
for (BiomeCategories category : BiomeCategories.values()) {
defines.put("CAT_" + category.name(), String.valueOf(category.ordinal()));
}
return defines;
}
/**
* Returns vanilla biome ID defines for use in shaders.
* Generates #define BIOME_<BIOME_NAME> <biomeID> for all vanilla biomes.
*
* @return Map of vanilla biome defines and their IDs
*/
public static Map<String, String> getVanillaBiomeDefines() {
final Map<String, String> defines = new HashMap<>();
for (VanillaBiomeList.BiomeEntry entry : VanillaBiomeList.getVanillaBiomes()) {
if (entry.biome != null) {
defines.put("BIOME_" + entry.name, String.valueOf(entry.biome.biomeID));
}
}
// Modern biomes that don't exist in 1.7.10 - add dummy IDs that will never match
// This allows shader expressions to parse without errors while always evaluating to false/0
// Using negative IDs to avoid conflicts with actual biome IDs
defines.put("BIOME_NETHER_WASTES", "-1000");
defines.put("BIOME_SOUL_SAND_VALLEY", "-1001");
defines.put("BIOME_CRIMSON_FOREST", "-1002");
defines.put("BIOME_WARPED_FOREST", "-1003");
defines.put("BIOME_BASALT_DELTAS", "-1004");
defines.put("BIOME_LUSH_CAVES", "-1005");
defines.put("BIOME_PALE_GARDEN", "-1006");
return defines;
}
}
@@ -2,7 +2,9 @@ package net.coderbot.iris.gl.uniform;
public enum UniformType {
INT,
BOOL,
FLOAT,
MAT3,
MAT4,
VEC2,
VEC2I,
@@ -1,6 +1,7 @@
package net.coderbot.iris.pipeline;
import com.gtnewhorizons.angelica.compat.mojang.Camera;
import com.gtnewhorizons.angelica.compat.mojang.GameModeUtil;
import com.gtnewhorizons.angelica.compat.mojang.InteractionHand;
import com.gtnewhorizons.angelica.compat.toremove.RenderLayer;
import com.gtnewhorizons.angelica.glsm.GLStateManager;
@@ -26,7 +27,7 @@ public class HandRenderer {
public static final float DEPTH = 0.125F;
private void setupGlState(RenderGlobal gameRenderer, Camera camera, float tickDelta) {
Minecraft mc = Minecraft.getMinecraft();
final Minecraft mc = Minecraft.getMinecraft();
GL11.glMatrixMode(GL11.GL_PROJECTION);
GL11.glLoadIdentity();
@@ -72,8 +73,7 @@ public class HandRenderer {
mc.gameSettings.thirdPersonView == 0 &&
!camera.getEntity().isPlayerSleeping() &&
!mc.gameSettings.hideGUI &&
// TODO: SPECTATOR
// mc.playerController.currentGameType
!GameModeUtil.isSpectator() &&
!mc.playerController.enableEverythingIsScrewedUpMode();
}
@@ -44,7 +44,7 @@ import net.minecraft.entity.Entity;
import net.minecraft.profiler.Profiler;
import net.minecraft.tileentity.TileEntity;
import org.joml.Matrix4f;
import org.joml.Vector3d;
import org.joml.Vector3dc;
import org.joml.Vector3f;
import org.joml.Vector4f;
import org.lwjgl.BufferUtils;
@@ -141,11 +141,11 @@ public class ShadowRenderer {
public static MatrixStack createShadowModelView(float sunPathRotation, float intervalSize) {
// Determine the camera position
final Vector3d cameraPos = CameraUniforms.getUnshiftedCameraPosition();
final Vector3dc cameraPos = CameraUniforms.getUnshiftedCameraPosition();
final double cameraX = cameraPos.x;
final double cameraY = cameraPos.y;
final double cameraZ = cameraPos.z;
final double cameraX = cameraPos.x();
final double cameraY = cameraPos.y();
final double cameraZ = cameraPos.z();
// Set up our modelview matrix stack
final MatrixStack modelView = new MatrixStack();
@@ -461,7 +461,7 @@ public class ShadowRenderer {
MODELVIEW_BUFFER.clear().rewind();
modelView.peek().getModel().get(MODELVIEW_BUFFER);
GL11.glLoadMatrix(MODELVIEW_BUFFER);
for (TileEntity tileEntity : visibleTileEntities) {
if (hasEntityFrustum && (culler.isCulled(tileEntity.xCoord - 1, tileEntity.yCoord - 1, tileEntity.zCoord - 1, tileEntity.xCoord + 1, tileEntity.yCoord + 1, tileEntity.zCoord + 1))) {
continue;
@@ -475,10 +475,10 @@ public class ShadowRenderer {
continue;
}
renderTileEntity(tileEntity, cameraX, cameraY, cameraZ, partialTicks);
shadowTileEntities++;
}
GLStateManager.glPopMatrix();
renderedShadowTileEntities = shadowTileEntities;
@@ -530,7 +530,7 @@ public class ShadowRenderer {
terrainFrustumHolder = createShadowFrustum(renderDistanceMultiplier, terrainFrustumHolder);
// Determine the player camera position
final Vector3d cameraPos = CameraUniforms.getUnshiftedCameraPosition();
final Vector3dc cameraPos = CameraUniforms.getUnshiftedCameraPosition();
final double cameraX = cameraPos.x();
final double cameraY = cameraPos.y();
@@ -9,6 +9,7 @@ import net.coderbot.iris.pipeline.transform.TransformPatcher;
import net.coderbot.iris.shaderpack.ProgramSet;
import net.coderbot.iris.shaderpack.ProgramSource;
import net.coderbot.iris.uniforms.CommonUniforms;
import net.coderbot.iris.uniforms.ExternallyManagedUniforms;
import net.coderbot.iris.uniforms.builtin.BuiltinReplacementUniforms;
import net.coderbot.iris.uniforms.custom.CustomUniforms;
@@ -143,6 +144,8 @@ public class SodiumTerrainPipeline {
CommonUniforms.addDynamicUniforms(uniforms);
customUniforms.assignTo(uniforms);
ExternallyManagedUniforms.addExternallyManagedUniforms116(uniforms);
BuiltinReplacementUniforms.addBuiltinReplacementUniforms(uniforms);
return uniforms;
}
@@ -18,13 +18,17 @@ import net.coderbot.iris.gl.blending.BlendModeFunction;
import net.coderbot.iris.gl.blending.BlendModeOverride;
import net.coderbot.iris.gl.blending.BufferBlendInformation;
import net.coderbot.iris.gl.texture.TextureScaleOverride;
import net.coderbot.iris.pipeline.PatchedShaderPrinter;
import net.coderbot.iris.shaderpack.option.ShaderPackOptions;
import net.coderbot.iris.shaderpack.preprocessor.PropertiesPreprocessor;
import net.coderbot.iris.shaderpack.texture.TextureStage;
import net.coderbot.iris.uniforms.custom.CustomUniforms;
import net.minecraft.client.Minecraft;
import java.io.IOException;
import java.io.StringReader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.EnumMap;
@@ -98,6 +102,15 @@ public class ShaderProperties {
public ShaderProperties(String contents, ShaderPackOptions shaderPackOptions, Iterable<StringPair> environmentDefines) {
final String preprocessedContents = PropertiesPreprocessor.preprocessSource(contents, shaderPackOptions, environmentDefines);
if (PatchedShaderPrinter.prettyPrintShaders) {
try {
Files.write(Minecraft.getMinecraft().mcDataDir.toPath().resolve("preprocessed.properties"), preprocessedContents.getBytes(StandardCharsets.UTF_8));
Files.write(Minecraft.getMinecraft().mcDataDir.toPath().resolve("original.properties"), contents.getBytes(StandardCharsets.UTF_8));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
final Properties preprocessed = new OrderBackedProperties();
final Properties original = new OrderBackedProperties();
try {
@@ -181,7 +194,7 @@ public class ShaderProperties {
});
handlePassDirective("alphaTest.", key, value, pass -> {
if ("off".equals(value)) {
if ("off".equals(value) || "false".equals(value)) {
alphaTestOverrides.put(pass, AlphaTestOverride.OFF);
return;
}
@@ -6,6 +6,7 @@ import net.coderbot.iris.shaderpack.option.ShaderPackOptions;
import org.anarres.cpp.Feature;
import org.anarres.cpp.LexerException;
import org.anarres.cpp.Preprocessor;
import org.anarres.cpp.PreprocessorCommand;
import org.anarres.cpp.StringLexerSource;
import org.anarres.cpp.Token;
@@ -14,18 +15,19 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.stream.Collectors;
public class PropertiesPreprocessor {
// Derived from ShaderProcessor.glslPreprocessSource, which is derived from GlShader from Canvas, licenced under LGPL
public static String preprocessSource(String source, ShaderPackOptions shaderPackOptions, Iterable<StringPair> environmentDefines) {
if (source.contains(PropertyCollectingListener.PROPERTY_MARKER)) {
if (source.contains(PropertyCollectingListener.PROPERTY_MARKER) || source.contains("IRIS_PASSTHROUGHBACKSLASH")) {
throw new RuntimeException("Some shader author is trying to exploit internal Iris implementation details, stop!");
}
List<String> booleanValues = getBooleanValues(shaderPackOptions);
Map<String, String> stringValues = getStringValues(shaderPackOptions);
final List<String> booleanValues = getBooleanValues(shaderPackOptions);
final Map<String, String> stringValues = getStringValues(shaderPackOptions);
try (Preprocessor pp = new Preprocessor()) {
for (String value : booleanValues) {
@@ -57,7 +59,7 @@ public class PropertiesPreprocessor {
throw new RuntimeException("Some shader author is trying to exploit internal Iris implementation details, stop!");
}
Preprocessor preprocessor = new Preprocessor();
final Preprocessor preprocessor = new Preprocessor();
try {
for (StringPair envDefine : environmentDefines) {
@@ -78,19 +80,23 @@ public class PropertiesPreprocessor {
// Not super efficient, but this removes trailing whitespace on lines, fixing an issue with whitespace after
// line continuations (see PreprocessorTest#testWeirdPropertiesLineContinuation)
// Required for Voyager Shader
source = Arrays.stream(source.split("\\R")).map(String::trim)
source = Arrays.stream(source.split("\\R")).map(String::trim).filter(s -> !s.isEmpty())
.map(line -> {
if (line.startsWith("#")) {
// In PropertyCollectingListener we suppress "unknown preprocessor directive errors" and
// assume the line to be a comment, since in .properties files `#` also functions as a comment
// marker.
return line;
} else {
// This is a hack to ensure that non-macro lines don't have any preprocessing applied...
// In properties files, we don't substitute #define values except on macro lines.
return "#warning IRIS_PASSTHROUGH " + line;
for (PreprocessorCommand command : PreprocessorCommand.values()) {
if (line.startsWith("#" + (command.name().replace("PP_", "").toLowerCase(Locale.ROOT)))) {
return line;
}
}
return "";
}
// In PropertyCollectingListener we suppress "unknown preprocessor directive errors" and
// assume the line to be a comment, since in .properties files `#` also functions as a comment
// marker.
return line.replace("#", "");
}).collect(Collectors.joining("\n")) + "\n";
// TODO: This is a horrible fix to trick the preprocessor into not seeing the backslashes during processing. We need a better way to do this.
source = source.replace("\\", "IRIS_PASSTHROUGHBACKSLASH");
preprocessor.addInput(new StringLexerSource(source, true));
preprocessor.addFeature(Feature.KEEPCOMMENTS);
@@ -110,7 +116,7 @@ public class PropertiesPreprocessor {
source = builder.toString();
return listener.collectLines() + source;
return (listener.collectLines() + source).replace("IRIS_PASSTHROUGHBACKSLASH", "\\");
}
private static List<String> getBooleanValues(ShaderPackOptions shaderPackOptions) {
@@ -1,16 +1,15 @@
package net.coderbot.iris.sodium.vertex_format.entity_xhfp;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.NormI8;
import java.nio.ByteBuffer;
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView;
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterNio;
import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.GlyphVertexSink;
import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.QuadVertexSink;
import me.jellysquid.mods.sodium.client.util.Norm3b;
import net.coderbot.iris.vertices.IrisVertexFormats;
import net.coderbot.iris.vertices.NormalHelper;
import org.joml.Vector3f;
import java.nio.ByteBuffer;
public class EntityVertexBufferWriterNio extends VertexBufferWriterNio implements QuadVertexSink, GlyphVertexSink {
private static final int STRIDE = IrisVertexFormats.ENTITY.getVertexSize();
@@ -75,9 +74,9 @@ public class EntityVertexBufferWriterNio extends VertexBufferWriterNio implement
normalZ = saveNormal.z;
normal = NormalHelper.packNormal(saveNormal, 0.0F);
} else {
normalX = Norm3b.unpackX(normal);
normalY = Norm3b.unpackY(normal);
normalZ = Norm3b.unpackZ(normal);
normalX = NormI8.unpackX(normal);
normalY = NormI8.unpackY(normal);
normalZ = NormI8.unpackZ(normal);
}
int tangent = NormalHelper.computeTangent(normalX, normalY, normalZ, quad);
@@ -1,12 +1,13 @@
package net.coderbot.iris.sodium.vertex_format.entity_xhfp;
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*;
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memPutFloat;
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memPutInt;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.NormI8;
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView;
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterUnsafe;
import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.GlyphVertexSink;
import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.QuadVertexSink;
import me.jellysquid.mods.sodium.client.util.Norm3b;
import net.coderbot.iris.vertices.IrisVertexFormats;
import net.coderbot.iris.vertices.NormalHelper;
import org.joml.Vector3f;
@@ -73,9 +74,9 @@ public class EntityVertexBufferWriterUnsafe extends VertexBufferWriterUnsafe imp
normalZ = saveNormal.z;
normal = NormalHelper.packNormal(saveNormal, 0.0F);
} else {
normalX = Norm3b.unpackX(normal);
normalY = Norm3b.unpackY(normal);
normalZ = Norm3b.unpackZ(normal);
normalX = NormI8.unpackX(normal);
normalY = NormI8.unpackY(normal);
normalZ = NormI8.unpackZ(normal);
}
int tangent = NormalHelper.computeTangent(normalX, normalY, normalZ, quad);
@@ -1,16 +1,15 @@
package net.coderbot.iris.sodium.vertex_format.entity_xhfp;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.NormI8;
import java.nio.ByteBuffer;
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView;
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterNio;
import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.GlyphVertexSink;
import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.QuadVertexSink;
import me.jellysquid.mods.sodium.client.util.Norm3b;
import net.coderbot.iris.vertices.IrisVertexFormats;
import net.coderbot.iris.vertices.NormalHelper;
import org.joml.Vector3f;
import java.nio.ByteBuffer;
public class GlyphVertexBufferWriterNio extends VertexBufferWriterNio implements QuadVertexSink, GlyphVertexSink {
private static final int STRIDE = IrisVertexFormats.TERRAIN.getVertexSize();
@@ -74,9 +73,9 @@ public class GlyphVertexBufferWriterNio extends VertexBufferWriterNio implements
normalZ = saveNormal.z;
normal = NormalHelper.packNormal(saveNormal, 0.0F);
} else {
normalX = Norm3b.unpackX(normal);
normalY = Norm3b.unpackY(normal);
normalZ = Norm3b.unpackZ(normal);
normalX = NormI8.unpackX(normal);
normalY = NormI8.unpackY(normal);
normalZ = NormI8.unpackZ(normal);
}
int tangent = NormalHelper.computeTangent(normalX, normalY, normalZ, quad);
@@ -1,12 +1,13 @@
package net.coderbot.iris.sodium.vertex_format.entity_xhfp;
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*;
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memPutFloat;
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memPutInt;
import com.gtnewhorizon.gtnhlib.client.renderer.cel.api.util.NormI8;
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferView;
import me.jellysquid.mods.sodium.client.model.vertex.buffer.VertexBufferWriterUnsafe;
import me.jellysquid.mods.sodium.client.model.vertex.formats.glyph.GlyphVertexSink;
import me.jellysquid.mods.sodium.client.model.vertex.formats.quad.QuadVertexSink;
import me.jellysquid.mods.sodium.client.util.Norm3b;
import net.coderbot.iris.vertices.IrisVertexFormats;
import net.coderbot.iris.vertices.NormalHelper;
import org.joml.Vector3f;
@@ -72,9 +73,9 @@ public class GlyphVertexBufferWriterUnsafe extends VertexBufferWriterUnsafe impl
normalZ = saveNormal.z;
normal = NormalHelper.packNormal(saveNormal, 0.0F);
} else {
normalX = Norm3b.unpackX(normal);
normalY = Norm3b.unpackY(normal);
normalZ = Norm3b.unpackZ(normal);
normalX = NormI8.unpackX(normal);
normalY = NormI8.unpackY(normal);
normalZ = NormI8.unpackZ(normal);
}
int tangent = NormalHelper.computeTangent(normalX, normalY, normalZ, quad);
Loaded 100 of 123 files, more files were not shown because too many files have changed in this diff. Show more